QMP: Remove duplicate TPM type from query-tpm
[qemu/ar7.git] / block.c
blob16a92a4e088b266655d0763e7c6fa1ccc6315f54
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 discard mode
586 * Return 0 on success, -1 if the discard mode was invalid.
588 int bdrv_parse_discard_flags(const char *mode, int *flags)
590 *flags &= ~BDRV_O_UNMAP;
592 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
593 /* do nothing */
594 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
595 *flags |= BDRV_O_UNMAP;
596 } else {
597 return -1;
600 return 0;
604 * Set open flags for a given cache mode
606 * Return 0 on success, -1 if the cache mode was invalid.
608 int bdrv_parse_cache_flags(const char *mode, int *flags)
610 *flags &= ~BDRV_O_CACHE_MASK;
612 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
613 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
614 } else if (!strcmp(mode, "directsync")) {
615 *flags |= BDRV_O_NOCACHE;
616 } else if (!strcmp(mode, "writeback")) {
617 *flags |= BDRV_O_CACHE_WB;
618 } else if (!strcmp(mode, "unsafe")) {
619 *flags |= BDRV_O_CACHE_WB;
620 *flags |= BDRV_O_NO_FLUSH;
621 } else if (!strcmp(mode, "writethrough")) {
622 /* this is the default */
623 } else {
624 return -1;
627 return 0;
631 * The copy-on-read flag is actually a reference count so multiple users may
632 * use the feature without worrying about clobbering its previous state.
633 * Copy-on-read stays enabled until all users have called to disable it.
635 void bdrv_enable_copy_on_read(BlockDriverState *bs)
637 bs->copy_on_read++;
640 void bdrv_disable_copy_on_read(BlockDriverState *bs)
642 assert(bs->copy_on_read > 0);
643 bs->copy_on_read--;
646 static int bdrv_open_flags(BlockDriverState *bs, int flags)
648 int open_flags = flags | BDRV_O_CACHE_WB;
651 * Clear flags that are internal to the block layer before opening the
652 * image.
654 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
657 * Snapshots should be writable.
659 if (bs->is_temporary) {
660 open_flags |= BDRV_O_RDWR;
663 return open_flags;
667 * Common part for opening disk images and files
669 * Removes all processed options from *options.
671 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
672 const char *filename, QDict *options,
673 int flags, BlockDriver *drv)
675 int ret, open_flags;
677 assert(drv != NULL);
678 assert(bs->file == NULL);
679 assert(options != NULL && bs->options != options);
681 trace_bdrv_open_common(bs, filename, flags, drv->format_name);
683 bs->open_flags = flags;
684 bs->buffer_alignment = 512;
686 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
687 if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {
688 bdrv_enable_copy_on_read(bs);
691 if (filename != NULL) {
692 pstrcpy(bs->filename, sizeof(bs->filename), filename);
693 } else {
694 bs->filename[0] = '\0';
697 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
698 return -ENOTSUP;
701 bs->drv = drv;
702 bs->opaque = g_malloc0(drv->instance_size);
704 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
705 open_flags = bdrv_open_flags(bs, flags);
707 bs->read_only = !(open_flags & BDRV_O_RDWR);
709 /* Open the image, either directly or using a protocol */
710 if (drv->bdrv_file_open) {
711 if (file != NULL) {
712 bdrv_swap(file, bs);
713 ret = 0;
714 } else {
715 assert(drv->bdrv_parse_filename || filename != NULL);
716 ret = drv->bdrv_file_open(bs, filename, options, open_flags);
718 } else {
719 assert(file != NULL);
720 bs->file = file;
721 ret = drv->bdrv_open(bs, options, open_flags);
724 if (ret < 0) {
725 goto free_and_fail;
728 ret = refresh_total_sectors(bs, bs->total_sectors);
729 if (ret < 0) {
730 goto free_and_fail;
733 #ifndef _WIN32
734 if (bs->is_temporary) {
735 assert(filename != NULL);
736 unlink(filename);
738 #endif
739 return 0;
741 free_and_fail:
742 bs->file = NULL;
743 g_free(bs->opaque);
744 bs->opaque = NULL;
745 bs->drv = NULL;
746 return ret;
750 * Opens a file using a protocol (file, host_device, nbd, ...)
752 * options is a QDict of options to pass to the block drivers, or NULL for an
753 * empty set of options. The reference to the QDict belongs to the block layer
754 * after the call (even on failure), so if the caller intends to reuse the
755 * dictionary, it needs to use QINCREF() before calling bdrv_file_open.
757 int bdrv_file_open(BlockDriverState **pbs, const char *filename,
758 QDict *options, int flags)
760 BlockDriverState *bs;
761 BlockDriver *drv;
762 const char *drvname;
763 int ret;
765 /* NULL means an empty set of options */
766 if (options == NULL) {
767 options = qdict_new();
770 bs = bdrv_new("");
771 bs->options = options;
772 options = qdict_clone_shallow(options);
774 /* Find the right block driver */
775 drvname = qdict_get_try_str(options, "driver");
776 if (drvname) {
777 drv = bdrv_find_whitelisted_format(drvname);
778 qdict_del(options, "driver");
779 } else if (filename) {
780 drv = bdrv_find_protocol(filename);
781 } else {
782 qerror_report(ERROR_CLASS_GENERIC_ERROR,
783 "Must specify either driver or file");
784 drv = NULL;
787 if (!drv) {
788 ret = -ENOENT;
789 goto fail;
792 /* Parse the filename and open it */
793 if (drv->bdrv_parse_filename && filename) {
794 Error *local_err = NULL;
795 drv->bdrv_parse_filename(filename, options, &local_err);
796 if (error_is_set(&local_err)) {
797 qerror_report_err(local_err);
798 error_free(local_err);
799 ret = -EINVAL;
800 goto fail;
802 } else if (!drv->bdrv_parse_filename && !filename) {
803 qerror_report(ERROR_CLASS_GENERIC_ERROR,
804 "The '%s' block driver requires a file name",
805 drv->format_name);
806 ret = -EINVAL;
807 goto fail;
810 ret = bdrv_open_common(bs, NULL, filename, options, flags, drv);
811 if (ret < 0) {
812 goto fail;
815 /* Check if any unknown options were used */
816 if (qdict_size(options) != 0) {
817 const QDictEntry *entry = qdict_first(options);
818 qerror_report(ERROR_CLASS_GENERIC_ERROR, "Block protocol '%s' doesn't "
819 "support the option '%s'",
820 drv->format_name, entry->key);
821 ret = -EINVAL;
822 goto fail;
824 QDECREF(options);
826 bs->growable = 1;
827 *pbs = bs;
828 return 0;
830 fail:
831 QDECREF(options);
832 if (!bs->drv) {
833 QDECREF(bs->options);
835 bdrv_delete(bs);
836 return ret;
839 int bdrv_open_backing_file(BlockDriverState *bs)
841 char backing_filename[PATH_MAX];
842 int back_flags, ret;
843 BlockDriver *back_drv = NULL;
845 if (bs->backing_hd != NULL) {
846 return 0;
849 bs->open_flags &= ~BDRV_O_NO_BACKING;
850 if (bs->backing_file[0] == '\0') {
851 return 0;
854 bs->backing_hd = bdrv_new("");
855 bdrv_get_full_backing_filename(bs, backing_filename,
856 sizeof(backing_filename));
858 if (bs->backing_format[0] != '\0') {
859 back_drv = bdrv_find_format(bs->backing_format);
862 /* backing files always opened read-only */
863 back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT);
865 ret = bdrv_open(bs->backing_hd, backing_filename, NULL,
866 back_flags, back_drv);
867 if (ret < 0) {
868 bdrv_delete(bs->backing_hd);
869 bs->backing_hd = NULL;
870 bs->open_flags |= BDRV_O_NO_BACKING;
871 return ret;
873 return 0;
876 static void extract_subqdict(QDict *src, QDict **dst, const char *start)
878 const QDictEntry *entry, *next;
879 const char *p;
881 *dst = qdict_new();
882 entry = qdict_first(src);
884 while (entry != NULL) {
885 next = qdict_next(src, entry);
886 if (strstart(entry->key, start, &p)) {
887 qobject_incref(entry->value);
888 qdict_put_obj(*dst, p, entry->value);
889 qdict_del(src, entry->key);
891 entry = next;
896 * Opens a disk image (raw, qcow2, vmdk, ...)
898 * options is a QDict of options to pass to the block drivers, or NULL for an
899 * empty set of options. The reference to the QDict belongs to the block layer
900 * after the call (even on failure), so if the caller intends to reuse the
901 * dictionary, it needs to use QINCREF() before calling bdrv_open.
903 int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
904 int flags, BlockDriver *drv)
906 int ret;
907 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
908 char tmp_filename[PATH_MAX + 1];
909 BlockDriverState *file = NULL;
910 QDict *file_options = NULL;
912 /* NULL means an empty set of options */
913 if (options == NULL) {
914 options = qdict_new();
917 bs->options = options;
918 options = qdict_clone_shallow(options);
920 /* For snapshot=on, create a temporary qcow2 overlay */
921 if (flags & BDRV_O_SNAPSHOT) {
922 BlockDriverState *bs1;
923 int64_t total_size;
924 BlockDriver *bdrv_qcow2;
925 QEMUOptionParameter *create_options;
926 char backing_filename[PATH_MAX];
928 if (qdict_size(options) != 0) {
929 error_report("Can't use snapshot=on with driver-specific options");
930 ret = -EINVAL;
931 goto fail;
933 assert(filename != NULL);
935 /* if snapshot, we create a temporary backing file and open it
936 instead of opening 'filename' directly */
938 /* if there is a backing file, use it */
939 bs1 = bdrv_new("");
940 ret = bdrv_open(bs1, filename, NULL, 0, drv);
941 if (ret < 0) {
942 bdrv_delete(bs1);
943 goto fail;
945 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
947 bdrv_delete(bs1);
949 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
950 if (ret < 0) {
951 goto fail;
954 /* Real path is meaningless for protocols */
955 if (path_has_protocol(filename)) {
956 snprintf(backing_filename, sizeof(backing_filename),
957 "%s", filename);
958 } else if (!realpath(filename, backing_filename)) {
959 ret = -errno;
960 goto fail;
963 bdrv_qcow2 = bdrv_find_format("qcow2");
964 create_options = parse_option_parameters("", bdrv_qcow2->create_options,
965 NULL);
967 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
968 set_option_parameter(create_options, BLOCK_OPT_BACKING_FILE,
969 backing_filename);
970 if (drv) {
971 set_option_parameter(create_options, BLOCK_OPT_BACKING_FMT,
972 drv->format_name);
975 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options);
976 free_option_parameters(create_options);
977 if (ret < 0) {
978 goto fail;
981 filename = tmp_filename;
982 drv = bdrv_qcow2;
983 bs->is_temporary = 1;
986 /* Open image file without format layer */
987 if (flags & BDRV_O_RDWR) {
988 flags |= BDRV_O_ALLOW_RDWR;
991 extract_subqdict(options, &file_options, "file.");
993 ret = bdrv_file_open(&file, filename, file_options,
994 bdrv_open_flags(bs, flags));
995 if (ret < 0) {
996 goto fail;
999 /* Find the right image format driver */
1000 if (!drv) {
1001 ret = find_image_format(file, filename, &drv);
1004 if (!drv) {
1005 goto unlink_and_fail;
1008 /* Open the image */
1009 ret = bdrv_open_common(bs, file, filename, options, flags, drv);
1010 if (ret < 0) {
1011 goto unlink_and_fail;
1014 if (bs->file != file) {
1015 bdrv_delete(file);
1016 file = NULL;
1019 /* If there is a backing file, use it */
1020 if ((flags & BDRV_O_NO_BACKING) == 0) {
1021 ret = bdrv_open_backing_file(bs);
1022 if (ret < 0) {
1023 goto close_and_fail;
1027 /* Check if any unknown options were used */
1028 if (qdict_size(options) != 0) {
1029 const QDictEntry *entry = qdict_first(options);
1030 qerror_report(ERROR_CLASS_GENERIC_ERROR, "Block format '%s' used by "
1031 "device '%s' doesn't support the option '%s'",
1032 drv->format_name, bs->device_name, entry->key);
1034 ret = -EINVAL;
1035 goto close_and_fail;
1037 QDECREF(options);
1039 if (!bdrv_key_required(bs)) {
1040 bdrv_dev_change_media_cb(bs, true);
1043 /* throttling disk I/O limits */
1044 if (bs->io_limits_enabled) {
1045 bdrv_io_limits_enable(bs);
1048 return 0;
1050 unlink_and_fail:
1051 if (file != NULL) {
1052 bdrv_delete(file);
1054 if (bs->is_temporary) {
1055 unlink(filename);
1057 fail:
1058 QDECREF(bs->options);
1059 QDECREF(options);
1060 bs->options = NULL;
1061 return ret;
1063 close_and_fail:
1064 bdrv_close(bs);
1065 QDECREF(options);
1066 return ret;
1069 typedef struct BlockReopenQueueEntry {
1070 bool prepared;
1071 BDRVReopenState state;
1072 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1073 } BlockReopenQueueEntry;
1076 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1077 * reopen of multiple devices.
1079 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1080 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1081 * be created and initialized. This newly created BlockReopenQueue should be
1082 * passed back in for subsequent calls that are intended to be of the same
1083 * atomic 'set'.
1085 * bs is the BlockDriverState to add to the reopen queue.
1087 * flags contains the open flags for the associated bs
1089 * returns a pointer to bs_queue, which is either the newly allocated
1090 * bs_queue, or the existing bs_queue being used.
1093 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1094 BlockDriverState *bs, int flags)
1096 assert(bs != NULL);
1098 BlockReopenQueueEntry *bs_entry;
1099 if (bs_queue == NULL) {
1100 bs_queue = g_new0(BlockReopenQueue, 1);
1101 QSIMPLEQ_INIT(bs_queue);
1104 if (bs->file) {
1105 bdrv_reopen_queue(bs_queue, bs->file, flags);
1108 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1109 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1111 bs_entry->state.bs = bs;
1112 bs_entry->state.flags = flags;
1114 return bs_queue;
1118 * Reopen multiple BlockDriverStates atomically & transactionally.
1120 * The queue passed in (bs_queue) must have been built up previous
1121 * via bdrv_reopen_queue().
1123 * Reopens all BDS specified in the queue, with the appropriate
1124 * flags. All devices are prepared for reopen, and failure of any
1125 * device will cause all device changes to be abandonded, and intermediate
1126 * data cleaned up.
1128 * If all devices prepare successfully, then the changes are committed
1129 * to all devices.
1132 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1134 int ret = -1;
1135 BlockReopenQueueEntry *bs_entry, *next;
1136 Error *local_err = NULL;
1138 assert(bs_queue != NULL);
1140 bdrv_drain_all();
1142 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1143 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1144 error_propagate(errp, local_err);
1145 goto cleanup;
1147 bs_entry->prepared = true;
1150 /* If we reach this point, we have success and just need to apply the
1151 * changes
1153 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1154 bdrv_reopen_commit(&bs_entry->state);
1157 ret = 0;
1159 cleanup:
1160 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1161 if (ret && bs_entry->prepared) {
1162 bdrv_reopen_abort(&bs_entry->state);
1164 g_free(bs_entry);
1166 g_free(bs_queue);
1167 return ret;
1171 /* Reopen a single BlockDriverState with the specified flags. */
1172 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1174 int ret = -1;
1175 Error *local_err = NULL;
1176 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1178 ret = bdrv_reopen_multiple(queue, &local_err);
1179 if (local_err != NULL) {
1180 error_propagate(errp, local_err);
1182 return ret;
1187 * Prepares a BlockDriverState for reopen. All changes are staged in the
1188 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1189 * the block driver layer .bdrv_reopen_prepare()
1191 * bs is the BlockDriverState to reopen
1192 * flags are the new open flags
1193 * queue is the reopen queue
1195 * Returns 0 on success, non-zero on error. On error errp will be set
1196 * as well.
1198 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1199 * It is the responsibility of the caller to then call the abort() or
1200 * commit() for any other BDS that have been left in a prepare() state
1203 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1204 Error **errp)
1206 int ret = -1;
1207 Error *local_err = NULL;
1208 BlockDriver *drv;
1210 assert(reopen_state != NULL);
1211 assert(reopen_state->bs->drv != NULL);
1212 drv = reopen_state->bs->drv;
1214 /* if we are to stay read-only, do not allow permission change
1215 * to r/w */
1216 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1217 reopen_state->flags & BDRV_O_RDWR) {
1218 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1219 reopen_state->bs->device_name);
1220 goto error;
1224 ret = bdrv_flush(reopen_state->bs);
1225 if (ret) {
1226 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1227 strerror(-ret));
1228 goto error;
1231 if (drv->bdrv_reopen_prepare) {
1232 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1233 if (ret) {
1234 if (local_err != NULL) {
1235 error_propagate(errp, local_err);
1236 } else {
1237 error_set(errp, QERR_OPEN_FILE_FAILED,
1238 reopen_state->bs->filename);
1240 goto error;
1242 } else {
1243 /* It is currently mandatory to have a bdrv_reopen_prepare()
1244 * handler for each supported drv. */
1245 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1246 drv->format_name, reopen_state->bs->device_name,
1247 "reopening of file");
1248 ret = -1;
1249 goto error;
1252 ret = 0;
1254 error:
1255 return ret;
1259 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1260 * makes them final by swapping the staging BlockDriverState contents into
1261 * the active BlockDriverState contents.
1263 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1265 BlockDriver *drv;
1267 assert(reopen_state != NULL);
1268 drv = reopen_state->bs->drv;
1269 assert(drv != NULL);
1271 /* If there are any driver level actions to take */
1272 if (drv->bdrv_reopen_commit) {
1273 drv->bdrv_reopen_commit(reopen_state);
1276 /* set BDS specific flags now */
1277 reopen_state->bs->open_flags = reopen_state->flags;
1278 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1279 BDRV_O_CACHE_WB);
1280 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1284 * Abort the reopen, and delete and free the staged changes in
1285 * reopen_state
1287 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1289 BlockDriver *drv;
1291 assert(reopen_state != NULL);
1292 drv = reopen_state->bs->drv;
1293 assert(drv != NULL);
1295 if (drv->bdrv_reopen_abort) {
1296 drv->bdrv_reopen_abort(reopen_state);
1301 void bdrv_close(BlockDriverState *bs)
1303 bdrv_flush(bs);
1304 if (bs->job) {
1305 block_job_cancel_sync(bs->job);
1307 bdrv_drain_all();
1308 notifier_list_notify(&bs->close_notifiers, bs);
1310 if (bs->drv) {
1311 if (bs == bs_snapshots) {
1312 bs_snapshots = NULL;
1314 if (bs->backing_hd) {
1315 bdrv_delete(bs->backing_hd);
1316 bs->backing_hd = NULL;
1318 bs->drv->bdrv_close(bs);
1319 g_free(bs->opaque);
1320 #ifdef _WIN32
1321 if (bs->is_temporary) {
1322 unlink(bs->filename);
1324 #endif
1325 bs->opaque = NULL;
1326 bs->drv = NULL;
1327 bs->copy_on_read = 0;
1328 bs->backing_file[0] = '\0';
1329 bs->backing_format[0] = '\0';
1330 bs->total_sectors = 0;
1331 bs->encrypted = 0;
1332 bs->valid_key = 0;
1333 bs->sg = 0;
1334 bs->growable = 0;
1335 QDECREF(bs->options);
1336 bs->options = NULL;
1338 if (bs->file != NULL) {
1339 bdrv_delete(bs->file);
1340 bs->file = NULL;
1344 bdrv_dev_change_media_cb(bs, false);
1346 /*throttling disk I/O limits*/
1347 if (bs->io_limits_enabled) {
1348 bdrv_io_limits_disable(bs);
1352 void bdrv_close_all(void)
1354 BlockDriverState *bs;
1356 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1357 bdrv_close(bs);
1362 * Wait for pending requests to complete across all BlockDriverStates
1364 * This function does not flush data to disk, use bdrv_flush_all() for that
1365 * after calling this function.
1367 * Note that completion of an asynchronous I/O operation can trigger any
1368 * number of other I/O operations on other devices---for example a coroutine
1369 * can be arbitrarily complex and a constant flow of I/O can come until the
1370 * coroutine is complete. Because of this, it is not possible to have a
1371 * function to drain a single device's I/O queue.
1373 void bdrv_drain_all(void)
1375 BlockDriverState *bs;
1376 bool busy;
1378 do {
1379 busy = qemu_aio_wait();
1381 /* FIXME: We do not have timer support here, so this is effectively
1382 * a busy wait.
1384 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1385 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
1386 qemu_co_queue_restart_all(&bs->throttled_reqs);
1387 busy = true;
1390 } while (busy);
1392 /* If requests are still pending there is a bug somewhere */
1393 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1394 assert(QLIST_EMPTY(&bs->tracked_requests));
1395 assert(qemu_co_queue_empty(&bs->throttled_reqs));
1399 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1400 Also, NULL terminate the device_name to prevent double remove */
1401 void bdrv_make_anon(BlockDriverState *bs)
1403 if (bs->device_name[0] != '\0') {
1404 QTAILQ_REMOVE(&bdrv_states, bs, list);
1406 bs->device_name[0] = '\0';
1409 static void bdrv_rebind(BlockDriverState *bs)
1411 if (bs->drv && bs->drv->bdrv_rebind) {
1412 bs->drv->bdrv_rebind(bs);
1416 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1417 BlockDriverState *bs_src)
1419 /* move some fields that need to stay attached to the device */
1420 bs_dest->open_flags = bs_src->open_flags;
1422 /* dev info */
1423 bs_dest->dev_ops = bs_src->dev_ops;
1424 bs_dest->dev_opaque = bs_src->dev_opaque;
1425 bs_dest->dev = bs_src->dev;
1426 bs_dest->buffer_alignment = bs_src->buffer_alignment;
1427 bs_dest->copy_on_read = bs_src->copy_on_read;
1429 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1431 /* i/o timing parameters */
1432 bs_dest->slice_time = bs_src->slice_time;
1433 bs_dest->slice_start = bs_src->slice_start;
1434 bs_dest->slice_end = bs_src->slice_end;
1435 bs_dest->io_limits = bs_src->io_limits;
1436 bs_dest->io_base = bs_src->io_base;
1437 bs_dest->throttled_reqs = bs_src->throttled_reqs;
1438 bs_dest->block_timer = bs_src->block_timer;
1439 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1441 /* r/w error */
1442 bs_dest->on_read_error = bs_src->on_read_error;
1443 bs_dest->on_write_error = bs_src->on_write_error;
1445 /* i/o status */
1446 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1447 bs_dest->iostatus = bs_src->iostatus;
1449 /* dirty bitmap */
1450 bs_dest->dirty_bitmap = bs_src->dirty_bitmap;
1452 /* job */
1453 bs_dest->in_use = bs_src->in_use;
1454 bs_dest->job = bs_src->job;
1456 /* keep the same entry in bdrv_states */
1457 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1458 bs_src->device_name);
1459 bs_dest->list = bs_src->list;
1463 * Swap bs contents for two image chains while they are live,
1464 * while keeping required fields on the BlockDriverState that is
1465 * actually attached to a device.
1467 * This will modify the BlockDriverState fields, and swap contents
1468 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1470 * bs_new is required to be anonymous.
1472 * This function does not create any image files.
1474 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1476 BlockDriverState tmp;
1478 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1479 assert(bs_new->device_name[0] == '\0');
1480 assert(bs_new->dirty_bitmap == NULL);
1481 assert(bs_new->job == NULL);
1482 assert(bs_new->dev == NULL);
1483 assert(bs_new->in_use == 0);
1484 assert(bs_new->io_limits_enabled == false);
1485 assert(bs_new->block_timer == NULL);
1487 tmp = *bs_new;
1488 *bs_new = *bs_old;
1489 *bs_old = tmp;
1491 /* there are some fields that should not be swapped, move them back */
1492 bdrv_move_feature_fields(&tmp, bs_old);
1493 bdrv_move_feature_fields(bs_old, bs_new);
1494 bdrv_move_feature_fields(bs_new, &tmp);
1496 /* bs_new shouldn't be in bdrv_states even after the swap! */
1497 assert(bs_new->device_name[0] == '\0');
1499 /* Check a few fields that should remain attached to the device */
1500 assert(bs_new->dev == NULL);
1501 assert(bs_new->job == NULL);
1502 assert(bs_new->in_use == 0);
1503 assert(bs_new->io_limits_enabled == false);
1504 assert(bs_new->block_timer == NULL);
1506 bdrv_rebind(bs_new);
1507 bdrv_rebind(bs_old);
1511 * Add new bs contents at the top of an image chain while the chain is
1512 * live, while keeping required fields on the top layer.
1514 * This will modify the BlockDriverState fields, and swap contents
1515 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1517 * bs_new is required to be anonymous.
1519 * This function does not create any image files.
1521 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1523 bdrv_swap(bs_new, bs_top);
1525 /* The contents of 'tmp' will become bs_top, as we are
1526 * swapping bs_new and bs_top contents. */
1527 bs_top->backing_hd = bs_new;
1528 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1529 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1530 bs_new->filename);
1531 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1532 bs_new->drv ? bs_new->drv->format_name : "");
1535 void bdrv_delete(BlockDriverState *bs)
1537 assert(!bs->dev);
1538 assert(!bs->job);
1539 assert(!bs->in_use);
1541 /* remove from list, if necessary */
1542 bdrv_make_anon(bs);
1544 bdrv_close(bs);
1546 assert(bs != bs_snapshots);
1547 g_free(bs);
1550 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1551 /* TODO change to DeviceState *dev when all users are qdevified */
1553 if (bs->dev) {
1554 return -EBUSY;
1556 bs->dev = dev;
1557 bdrv_iostatus_reset(bs);
1558 return 0;
1561 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1562 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
1564 if (bdrv_attach_dev(bs, dev) < 0) {
1565 abort();
1569 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1570 /* TODO change to DeviceState *dev when all users are qdevified */
1572 assert(bs->dev == dev);
1573 bs->dev = NULL;
1574 bs->dev_ops = NULL;
1575 bs->dev_opaque = NULL;
1576 bs->buffer_alignment = 512;
1579 /* TODO change to return DeviceState * when all users are qdevified */
1580 void *bdrv_get_attached_dev(BlockDriverState *bs)
1582 return bs->dev;
1585 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1586 void *opaque)
1588 bs->dev_ops = ops;
1589 bs->dev_opaque = opaque;
1590 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
1591 bs_snapshots = NULL;
1595 void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1596 enum MonitorEvent ev,
1597 BlockErrorAction action, bool is_read)
1599 QObject *data;
1600 const char *action_str;
1602 switch (action) {
1603 case BDRV_ACTION_REPORT:
1604 action_str = "report";
1605 break;
1606 case BDRV_ACTION_IGNORE:
1607 action_str = "ignore";
1608 break;
1609 case BDRV_ACTION_STOP:
1610 action_str = "stop";
1611 break;
1612 default:
1613 abort();
1616 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1617 bdrv->device_name,
1618 action_str,
1619 is_read ? "read" : "write");
1620 monitor_protocol_event(ev, data);
1622 qobject_decref(data);
1625 static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1627 QObject *data;
1629 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1630 bdrv_get_device_name(bs), ejected);
1631 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1633 qobject_decref(data);
1636 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
1638 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
1639 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
1640 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
1641 if (tray_was_closed) {
1642 /* tray open */
1643 bdrv_emit_qmp_eject_event(bs, true);
1645 if (load) {
1646 /* tray close */
1647 bdrv_emit_qmp_eject_event(bs, false);
1652 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1654 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1657 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1659 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1660 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1664 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1666 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1667 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1669 return false;
1672 static void bdrv_dev_resize_cb(BlockDriverState *bs)
1674 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1675 bs->dev_ops->resize_cb(bs->dev_opaque);
1679 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1681 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1682 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1684 return false;
1688 * Run consistency checks on an image
1690 * Returns 0 if the check could be completed (it doesn't mean that the image is
1691 * free of errors) or -errno when an internal error occurred. The results of the
1692 * check are stored in res.
1694 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
1696 if (bs->drv->bdrv_check == NULL) {
1697 return -ENOTSUP;
1700 memset(res, 0, sizeof(*res));
1701 return bs->drv->bdrv_check(bs, res, fix);
1704 #define COMMIT_BUF_SECTORS 2048
1706 /* commit COW file into the raw image */
1707 int bdrv_commit(BlockDriverState *bs)
1709 BlockDriver *drv = bs->drv;
1710 int64_t sector, total_sectors;
1711 int n, ro, open_flags;
1712 int ret = 0;
1713 uint8_t *buf;
1714 char filename[PATH_MAX];
1716 if (!drv)
1717 return -ENOMEDIUM;
1719 if (!bs->backing_hd) {
1720 return -ENOTSUP;
1723 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1724 return -EBUSY;
1727 ro = bs->backing_hd->read_only;
1728 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1729 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
1730 open_flags = bs->backing_hd->open_flags;
1732 if (ro) {
1733 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
1734 return -EACCES;
1738 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1739 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
1741 for (sector = 0; sector < total_sectors; sector += n) {
1742 if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
1744 if (bdrv_read(bs, sector, buf, n) != 0) {
1745 ret = -EIO;
1746 goto ro_cleanup;
1749 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1750 ret = -EIO;
1751 goto ro_cleanup;
1756 if (drv->bdrv_make_empty) {
1757 ret = drv->bdrv_make_empty(bs);
1758 bdrv_flush(bs);
1762 * Make sure all data we wrote to the backing device is actually
1763 * stable on disk.
1765 if (bs->backing_hd)
1766 bdrv_flush(bs->backing_hd);
1768 ro_cleanup:
1769 g_free(buf);
1771 if (ro) {
1772 /* ignoring error return here */
1773 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
1776 return ret;
1779 int bdrv_commit_all(void)
1781 BlockDriverState *bs;
1783 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1784 if (bs->drv && bs->backing_hd) {
1785 int ret = bdrv_commit(bs);
1786 if (ret < 0) {
1787 return ret;
1791 return 0;
1794 struct BdrvTrackedRequest {
1795 BlockDriverState *bs;
1796 int64_t sector_num;
1797 int nb_sectors;
1798 bool is_write;
1799 QLIST_ENTRY(BdrvTrackedRequest) list;
1800 Coroutine *co; /* owner, used for deadlock detection */
1801 CoQueue wait_queue; /* coroutines blocked on this request */
1805 * Remove an active request from the tracked requests list
1807 * This function should be called when a tracked request is completing.
1809 static void tracked_request_end(BdrvTrackedRequest *req)
1811 QLIST_REMOVE(req, list);
1812 qemu_co_queue_restart_all(&req->wait_queue);
1816 * Add an active request to the tracked requests list
1818 static void tracked_request_begin(BdrvTrackedRequest *req,
1819 BlockDriverState *bs,
1820 int64_t sector_num,
1821 int nb_sectors, bool is_write)
1823 *req = (BdrvTrackedRequest){
1824 .bs = bs,
1825 .sector_num = sector_num,
1826 .nb_sectors = nb_sectors,
1827 .is_write = is_write,
1828 .co = qemu_coroutine_self(),
1831 qemu_co_queue_init(&req->wait_queue);
1833 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
1837 * Round a region to cluster boundaries
1839 void bdrv_round_to_clusters(BlockDriverState *bs,
1840 int64_t sector_num, int nb_sectors,
1841 int64_t *cluster_sector_num,
1842 int *cluster_nb_sectors)
1844 BlockDriverInfo bdi;
1846 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
1847 *cluster_sector_num = sector_num;
1848 *cluster_nb_sectors = nb_sectors;
1849 } else {
1850 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
1851 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
1852 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
1853 nb_sectors, c);
1857 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
1858 int64_t sector_num, int nb_sectors) {
1859 /* aaaa bbbb */
1860 if (sector_num >= req->sector_num + req->nb_sectors) {
1861 return false;
1863 /* bbbb aaaa */
1864 if (req->sector_num >= sector_num + nb_sectors) {
1865 return false;
1867 return true;
1870 static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
1871 int64_t sector_num, int nb_sectors)
1873 BdrvTrackedRequest *req;
1874 int64_t cluster_sector_num;
1875 int cluster_nb_sectors;
1876 bool retry;
1878 /* If we touch the same cluster it counts as an overlap. This guarantees
1879 * that allocating writes will be serialized and not race with each other
1880 * for the same cluster. For example, in copy-on-read it ensures that the
1881 * CoR read and write operations are atomic and guest writes cannot
1882 * interleave between them.
1884 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
1885 &cluster_sector_num, &cluster_nb_sectors);
1887 do {
1888 retry = false;
1889 QLIST_FOREACH(req, &bs->tracked_requests, list) {
1890 if (tracked_request_overlaps(req, cluster_sector_num,
1891 cluster_nb_sectors)) {
1892 /* Hitting this means there was a reentrant request, for
1893 * example, a block driver issuing nested requests. This must
1894 * never happen since it means deadlock.
1896 assert(qemu_coroutine_self() != req->co);
1898 qemu_co_queue_wait(&req->wait_queue);
1899 retry = true;
1900 break;
1903 } while (retry);
1907 * Return values:
1908 * 0 - success
1909 * -EINVAL - backing format specified, but no file
1910 * -ENOSPC - can't update the backing file because no space is left in the
1911 * image file header
1912 * -ENOTSUP - format driver doesn't support changing the backing file
1914 int bdrv_change_backing_file(BlockDriverState *bs,
1915 const char *backing_file, const char *backing_fmt)
1917 BlockDriver *drv = bs->drv;
1918 int ret;
1920 /* Backing file format doesn't make sense without a backing file */
1921 if (backing_fmt && !backing_file) {
1922 return -EINVAL;
1925 if (drv->bdrv_change_backing_file != NULL) {
1926 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
1927 } else {
1928 ret = -ENOTSUP;
1931 if (ret == 0) {
1932 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
1933 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
1935 return ret;
1939 * Finds the image layer in the chain that has 'bs' as its backing file.
1941 * active is the current topmost image.
1943 * Returns NULL if bs is not found in active's image chain,
1944 * or if active == bs.
1946 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
1947 BlockDriverState *bs)
1949 BlockDriverState *overlay = NULL;
1950 BlockDriverState *intermediate;
1952 assert(active != NULL);
1953 assert(bs != NULL);
1955 /* if bs is the same as active, then by definition it has no overlay
1957 if (active == bs) {
1958 return NULL;
1961 intermediate = active;
1962 while (intermediate->backing_hd) {
1963 if (intermediate->backing_hd == bs) {
1964 overlay = intermediate;
1965 break;
1967 intermediate = intermediate->backing_hd;
1970 return overlay;
1973 typedef struct BlkIntermediateStates {
1974 BlockDriverState *bs;
1975 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
1976 } BlkIntermediateStates;
1980 * Drops images above 'base' up to and including 'top', and sets the image
1981 * above 'top' to have base as its backing file.
1983 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1984 * information in 'bs' can be properly updated.
1986 * E.g., this will convert the following chain:
1987 * bottom <- base <- intermediate <- top <- active
1989 * to
1991 * bottom <- base <- active
1993 * It is allowed for bottom==base, in which case it converts:
1995 * base <- intermediate <- top <- active
1997 * to
1999 * base <- active
2001 * Error conditions:
2002 * if active == top, that is considered an error
2005 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2006 BlockDriverState *base)
2008 BlockDriverState *intermediate;
2009 BlockDriverState *base_bs = NULL;
2010 BlockDriverState *new_top_bs = NULL;
2011 BlkIntermediateStates *intermediate_state, *next;
2012 int ret = -EIO;
2014 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2015 QSIMPLEQ_INIT(&states_to_delete);
2017 if (!top->drv || !base->drv) {
2018 goto exit;
2021 new_top_bs = bdrv_find_overlay(active, top);
2023 if (new_top_bs == NULL) {
2024 /* we could not find the image above 'top', this is an error */
2025 goto exit;
2028 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2029 * to do, no intermediate images */
2030 if (new_top_bs->backing_hd == base) {
2031 ret = 0;
2032 goto exit;
2035 intermediate = top;
2037 /* now we will go down through the list, and add each BDS we find
2038 * into our deletion queue, until we hit the 'base'
2040 while (intermediate) {
2041 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2042 intermediate_state->bs = intermediate;
2043 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2045 if (intermediate->backing_hd == base) {
2046 base_bs = intermediate->backing_hd;
2047 break;
2049 intermediate = intermediate->backing_hd;
2051 if (base_bs == NULL) {
2052 /* something went wrong, we did not end at the base. safely
2053 * unravel everything, and exit with error */
2054 goto exit;
2057 /* success - we can delete the intermediate states, and link top->base */
2058 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2059 base_bs->drv ? base_bs->drv->format_name : "");
2060 if (ret) {
2061 goto exit;
2063 new_top_bs->backing_hd = base_bs;
2066 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2067 /* so that bdrv_close() does not recursively close the chain */
2068 intermediate_state->bs->backing_hd = NULL;
2069 bdrv_delete(intermediate_state->bs);
2071 ret = 0;
2073 exit:
2074 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2075 g_free(intermediate_state);
2077 return ret;
2081 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2082 size_t size)
2084 int64_t len;
2086 if (!bdrv_is_inserted(bs))
2087 return -ENOMEDIUM;
2089 if (bs->growable)
2090 return 0;
2092 len = bdrv_getlength(bs);
2094 if (offset < 0)
2095 return -EIO;
2097 if ((offset > len) || (len - offset < size))
2098 return -EIO;
2100 return 0;
2103 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2104 int nb_sectors)
2106 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2107 nb_sectors * BDRV_SECTOR_SIZE);
2110 typedef struct RwCo {
2111 BlockDriverState *bs;
2112 int64_t sector_num;
2113 int nb_sectors;
2114 QEMUIOVector *qiov;
2115 bool is_write;
2116 int ret;
2117 } RwCo;
2119 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2121 RwCo *rwco = opaque;
2123 if (!rwco->is_write) {
2124 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
2125 rwco->nb_sectors, rwco->qiov, 0);
2126 } else {
2127 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
2128 rwco->nb_sectors, rwco->qiov, 0);
2133 * Process a synchronous request using coroutines
2135 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2136 int nb_sectors, bool is_write)
2138 QEMUIOVector qiov;
2139 struct iovec iov = {
2140 .iov_base = (void *)buf,
2141 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2143 Coroutine *co;
2144 RwCo rwco = {
2145 .bs = bs,
2146 .sector_num = sector_num,
2147 .nb_sectors = nb_sectors,
2148 .qiov = &qiov,
2149 .is_write = is_write,
2150 .ret = NOT_DONE,
2153 qemu_iovec_init_external(&qiov, &iov, 1);
2156 * In sync call context, when the vcpu is blocked, this throttling timer
2157 * will not fire; so the I/O throttling function has to be disabled here
2158 * if it has been enabled.
2160 if (bs->io_limits_enabled) {
2161 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2162 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2163 bdrv_io_limits_disable(bs);
2166 if (qemu_in_coroutine()) {
2167 /* Fast-path if already in coroutine context */
2168 bdrv_rw_co_entry(&rwco);
2169 } else {
2170 co = qemu_coroutine_create(bdrv_rw_co_entry);
2171 qemu_coroutine_enter(co, &rwco);
2172 while (rwco.ret == NOT_DONE) {
2173 qemu_aio_wait();
2176 return rwco.ret;
2179 /* return < 0 if error. See bdrv_write() for the return codes */
2180 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2181 uint8_t *buf, int nb_sectors)
2183 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
2186 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2187 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2188 uint8_t *buf, int nb_sectors)
2190 bool enabled;
2191 int ret;
2193 enabled = bs->io_limits_enabled;
2194 bs->io_limits_enabled = false;
2195 ret = bdrv_read(bs, 0, buf, 1);
2196 bs->io_limits_enabled = enabled;
2197 return ret;
2200 /* Return < 0 if error. Important errors are:
2201 -EIO generic I/O error (may happen for all errors)
2202 -ENOMEDIUM No media inserted.
2203 -EINVAL Invalid sector number or nb_sectors
2204 -EACCES Trying to write a read-only device
2206 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2207 const uint8_t *buf, int nb_sectors)
2209 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
2212 int bdrv_pread(BlockDriverState *bs, int64_t offset,
2213 void *buf, int count1)
2215 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
2216 int len, nb_sectors, count;
2217 int64_t sector_num;
2218 int ret;
2220 count = count1;
2221 /* first read to align to sector start */
2222 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
2223 if (len > count)
2224 len = count;
2225 sector_num = offset >> BDRV_SECTOR_BITS;
2226 if (len > 0) {
2227 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2228 return ret;
2229 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
2230 count -= len;
2231 if (count == 0)
2232 return count1;
2233 sector_num++;
2234 buf += len;
2237 /* read the sectors "in place" */
2238 nb_sectors = count >> BDRV_SECTOR_BITS;
2239 if (nb_sectors > 0) {
2240 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2241 return ret;
2242 sector_num += nb_sectors;
2243 len = nb_sectors << BDRV_SECTOR_BITS;
2244 buf += len;
2245 count -= len;
2248 /* add data from the last sector */
2249 if (count > 0) {
2250 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2251 return ret;
2252 memcpy(buf, tmp_buf, count);
2254 return count1;
2257 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2258 const void *buf, int count1)
2260 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
2261 int len, nb_sectors, count;
2262 int64_t sector_num;
2263 int ret;
2265 count = count1;
2266 /* first write to align to sector start */
2267 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
2268 if (len > count)
2269 len = count;
2270 sector_num = offset >> BDRV_SECTOR_BITS;
2271 if (len > 0) {
2272 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2273 return ret;
2274 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
2275 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2276 return ret;
2277 count -= len;
2278 if (count == 0)
2279 return count1;
2280 sector_num++;
2281 buf += len;
2284 /* write the sectors "in place" */
2285 nb_sectors = count >> BDRV_SECTOR_BITS;
2286 if (nb_sectors > 0) {
2287 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
2288 return ret;
2289 sector_num += nb_sectors;
2290 len = nb_sectors << BDRV_SECTOR_BITS;
2291 buf += len;
2292 count -= len;
2295 /* add data from the last sector */
2296 if (count > 0) {
2297 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2298 return ret;
2299 memcpy(tmp_buf, buf, count);
2300 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2301 return ret;
2303 return count1;
2307 * Writes to the file and ensures that no writes are reordered across this
2308 * request (acts as a barrier)
2310 * Returns 0 on success, -errno in error cases.
2312 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2313 const void *buf, int count)
2315 int ret;
2317 ret = bdrv_pwrite(bs, offset, buf, count);
2318 if (ret < 0) {
2319 return ret;
2322 /* No flush needed for cache modes that already do it */
2323 if (bs->enable_write_cache) {
2324 bdrv_flush(bs);
2327 return 0;
2330 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2331 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2333 /* Perform I/O through a temporary buffer so that users who scribble over
2334 * their read buffer while the operation is in progress do not end up
2335 * modifying the image file. This is critical for zero-copy guest I/O
2336 * where anything might happen inside guest memory.
2338 void *bounce_buffer;
2340 BlockDriver *drv = bs->drv;
2341 struct iovec iov;
2342 QEMUIOVector bounce_qiov;
2343 int64_t cluster_sector_num;
2344 int cluster_nb_sectors;
2345 size_t skip_bytes;
2346 int ret;
2348 /* Cover entire cluster so no additional backing file I/O is required when
2349 * allocating cluster in the image file.
2351 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2352 &cluster_sector_num, &cluster_nb_sectors);
2354 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2355 cluster_sector_num, cluster_nb_sectors);
2357 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2358 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2359 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2361 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2362 &bounce_qiov);
2363 if (ret < 0) {
2364 goto err;
2367 if (drv->bdrv_co_write_zeroes &&
2368 buffer_is_zero(bounce_buffer, iov.iov_len)) {
2369 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2370 cluster_nb_sectors);
2371 } else {
2372 /* This does not change the data on the disk, it is not necessary
2373 * to flush even in cache=writethrough mode.
2375 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
2376 &bounce_qiov);
2379 if (ret < 0) {
2380 /* It might be okay to ignore write errors for guest requests. If this
2381 * is a deliberate copy-on-read then we don't want to ignore the error.
2382 * Simply report it in all cases.
2384 goto err;
2387 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
2388 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2389 nb_sectors * BDRV_SECTOR_SIZE);
2391 err:
2392 qemu_vfree(bounce_buffer);
2393 return ret;
2397 * Handle a read request in coroutine context
2399 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
2400 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2401 BdrvRequestFlags flags)
2403 BlockDriver *drv = bs->drv;
2404 BdrvTrackedRequest req;
2405 int ret;
2407 if (!drv) {
2408 return -ENOMEDIUM;
2410 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2411 return -EIO;
2414 /* throttling disk read I/O */
2415 if (bs->io_limits_enabled) {
2416 bdrv_io_limits_intercept(bs, false, nb_sectors);
2419 if (bs->copy_on_read) {
2420 flags |= BDRV_REQ_COPY_ON_READ;
2422 if (flags & BDRV_REQ_COPY_ON_READ) {
2423 bs->copy_on_read_in_flight++;
2426 if (bs->copy_on_read_in_flight) {
2427 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2430 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
2432 if (flags & BDRV_REQ_COPY_ON_READ) {
2433 int pnum;
2435 ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum);
2436 if (ret < 0) {
2437 goto out;
2440 if (!ret || pnum != nb_sectors) {
2441 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
2442 goto out;
2446 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
2448 out:
2449 tracked_request_end(&req);
2451 if (flags & BDRV_REQ_COPY_ON_READ) {
2452 bs->copy_on_read_in_flight--;
2455 return ret;
2458 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
2459 int nb_sectors, QEMUIOVector *qiov)
2461 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
2463 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
2466 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
2467 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2469 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
2471 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
2472 BDRV_REQ_COPY_ON_READ);
2475 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
2476 int64_t sector_num, int nb_sectors)
2478 BlockDriver *drv = bs->drv;
2479 QEMUIOVector qiov;
2480 struct iovec iov;
2481 int ret;
2483 /* TODO Emulate only part of misaligned requests instead of letting block
2484 * drivers return -ENOTSUP and emulate everything */
2486 /* First try the efficient write zeroes operation */
2487 if (drv->bdrv_co_write_zeroes) {
2488 ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2489 if (ret != -ENOTSUP) {
2490 return ret;
2494 /* Fall back to bounce buffer if write zeroes is unsupported */
2495 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2496 iov.iov_base = qemu_blockalign(bs, iov.iov_len);
2497 memset(iov.iov_base, 0, iov.iov_len);
2498 qemu_iovec_init_external(&qiov, &iov, 1);
2500 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
2502 qemu_vfree(iov.iov_base);
2503 return ret;
2507 * Handle a write request in coroutine context
2509 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
2510 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2511 BdrvRequestFlags flags)
2513 BlockDriver *drv = bs->drv;
2514 BdrvTrackedRequest req;
2515 int ret;
2517 if (!bs->drv) {
2518 return -ENOMEDIUM;
2520 if (bs->read_only) {
2521 return -EACCES;
2523 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2524 return -EIO;
2527 /* throttling disk write I/O */
2528 if (bs->io_limits_enabled) {
2529 bdrv_io_limits_intercept(bs, true, nb_sectors);
2532 if (bs->copy_on_read_in_flight) {
2533 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2536 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
2538 if (flags & BDRV_REQ_ZERO_WRITE) {
2539 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors);
2540 } else {
2541 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
2544 if (ret == 0 && !bs->enable_write_cache) {
2545 ret = bdrv_co_flush(bs);
2548 if (bs->dirty_bitmap) {
2549 bdrv_set_dirty(bs, sector_num, nb_sectors);
2552 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2553 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2556 tracked_request_end(&req);
2558 return ret;
2561 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
2562 int nb_sectors, QEMUIOVector *qiov)
2564 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
2566 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
2569 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
2570 int64_t sector_num, int nb_sectors)
2572 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2574 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
2575 BDRV_REQ_ZERO_WRITE);
2579 * Truncate file to 'offset' bytes (needed only for file protocols)
2581 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2583 BlockDriver *drv = bs->drv;
2584 int ret;
2585 if (!drv)
2586 return -ENOMEDIUM;
2587 if (!drv->bdrv_truncate)
2588 return -ENOTSUP;
2589 if (bs->read_only)
2590 return -EACCES;
2591 if (bdrv_in_use(bs))
2592 return -EBUSY;
2593 ret = drv->bdrv_truncate(bs, offset);
2594 if (ret == 0) {
2595 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2596 bdrv_dev_resize_cb(bs);
2598 return ret;
2602 * Length of a allocated file in bytes. Sparse files are counted by actual
2603 * allocated space. Return < 0 if error or unknown.
2605 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2607 BlockDriver *drv = bs->drv;
2608 if (!drv) {
2609 return -ENOMEDIUM;
2611 if (drv->bdrv_get_allocated_file_size) {
2612 return drv->bdrv_get_allocated_file_size(bs);
2614 if (bs->file) {
2615 return bdrv_get_allocated_file_size(bs->file);
2617 return -ENOTSUP;
2621 * Length of a file in bytes. Return < 0 if error or unknown.
2623 int64_t bdrv_getlength(BlockDriverState *bs)
2625 BlockDriver *drv = bs->drv;
2626 if (!drv)
2627 return -ENOMEDIUM;
2629 if (bs->growable || bdrv_dev_has_removable_media(bs)) {
2630 if (drv->bdrv_getlength) {
2631 return drv->bdrv_getlength(bs);
2634 return bs->total_sectors * BDRV_SECTOR_SIZE;
2637 /* return 0 as number of sectors if no device present or error */
2638 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2640 int64_t length;
2641 length = bdrv_getlength(bs);
2642 if (length < 0)
2643 length = 0;
2644 else
2645 length = length >> BDRV_SECTOR_BITS;
2646 *nb_sectors_ptr = length;
2649 /* throttling disk io limits */
2650 void bdrv_set_io_limits(BlockDriverState *bs,
2651 BlockIOLimit *io_limits)
2653 bs->io_limits = *io_limits;
2654 bs->io_limits_enabled = bdrv_io_limits_enabled(bs);
2657 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2658 BlockdevOnError on_write_error)
2660 bs->on_read_error = on_read_error;
2661 bs->on_write_error = on_write_error;
2664 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2666 return is_read ? bs->on_read_error : bs->on_write_error;
2669 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2671 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2673 switch (on_err) {
2674 case BLOCKDEV_ON_ERROR_ENOSPC:
2675 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
2676 case BLOCKDEV_ON_ERROR_STOP:
2677 return BDRV_ACTION_STOP;
2678 case BLOCKDEV_ON_ERROR_REPORT:
2679 return BDRV_ACTION_REPORT;
2680 case BLOCKDEV_ON_ERROR_IGNORE:
2681 return BDRV_ACTION_IGNORE;
2682 default:
2683 abort();
2687 /* This is done by device models because, while the block layer knows
2688 * about the error, it does not know whether an operation comes from
2689 * the device or the block layer (from a job, for example).
2691 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2692 bool is_read, int error)
2694 assert(error >= 0);
2695 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
2696 if (action == BDRV_ACTION_STOP) {
2697 vm_stop(RUN_STATE_IO_ERROR);
2698 bdrv_iostatus_set_err(bs, error);
2702 int bdrv_is_read_only(BlockDriverState *bs)
2704 return bs->read_only;
2707 int bdrv_is_sg(BlockDriverState *bs)
2709 return bs->sg;
2712 int bdrv_enable_write_cache(BlockDriverState *bs)
2714 return bs->enable_write_cache;
2717 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2719 bs->enable_write_cache = wce;
2721 /* so a reopen() will preserve wce */
2722 if (wce) {
2723 bs->open_flags |= BDRV_O_CACHE_WB;
2724 } else {
2725 bs->open_flags &= ~BDRV_O_CACHE_WB;
2729 int bdrv_is_encrypted(BlockDriverState *bs)
2731 if (bs->backing_hd && bs->backing_hd->encrypted)
2732 return 1;
2733 return bs->encrypted;
2736 int bdrv_key_required(BlockDriverState *bs)
2738 BlockDriverState *backing_hd = bs->backing_hd;
2740 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2741 return 1;
2742 return (bs->encrypted && !bs->valid_key);
2745 int bdrv_set_key(BlockDriverState *bs, const char *key)
2747 int ret;
2748 if (bs->backing_hd && bs->backing_hd->encrypted) {
2749 ret = bdrv_set_key(bs->backing_hd, key);
2750 if (ret < 0)
2751 return ret;
2752 if (!bs->encrypted)
2753 return 0;
2755 if (!bs->encrypted) {
2756 return -EINVAL;
2757 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2758 return -ENOMEDIUM;
2760 ret = bs->drv->bdrv_set_key(bs, key);
2761 if (ret < 0) {
2762 bs->valid_key = 0;
2763 } else if (!bs->valid_key) {
2764 bs->valid_key = 1;
2765 /* call the change callback now, we skipped it on open */
2766 bdrv_dev_change_media_cb(bs, true);
2768 return ret;
2771 const char *bdrv_get_format_name(BlockDriverState *bs)
2773 return bs->drv ? bs->drv->format_name : NULL;
2776 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2777 void *opaque)
2779 BlockDriver *drv;
2781 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2782 it(opaque, drv->format_name);
2786 BlockDriverState *bdrv_find(const char *name)
2788 BlockDriverState *bs;
2790 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2791 if (!strcmp(name, bs->device_name)) {
2792 return bs;
2795 return NULL;
2798 BlockDriverState *bdrv_next(BlockDriverState *bs)
2800 if (!bs) {
2801 return QTAILQ_FIRST(&bdrv_states);
2803 return QTAILQ_NEXT(bs, list);
2806 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
2808 BlockDriverState *bs;
2810 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2811 it(opaque, bs);
2815 const char *bdrv_get_device_name(BlockDriverState *bs)
2817 return bs->device_name;
2820 int bdrv_get_flags(BlockDriverState *bs)
2822 return bs->open_flags;
2825 void bdrv_flush_all(void)
2827 BlockDriverState *bs;
2829 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2830 bdrv_flush(bs);
2834 int bdrv_has_zero_init(BlockDriverState *bs)
2836 assert(bs->drv);
2838 if (bs->drv->bdrv_has_zero_init) {
2839 return bs->drv->bdrv_has_zero_init(bs);
2842 return 1;
2845 typedef struct BdrvCoIsAllocatedData {
2846 BlockDriverState *bs;
2847 BlockDriverState *base;
2848 int64_t sector_num;
2849 int nb_sectors;
2850 int *pnum;
2851 int ret;
2852 bool done;
2853 } BdrvCoIsAllocatedData;
2856 * Returns true iff the specified sector is present in the disk image. Drivers
2857 * not implementing the functionality are assumed to not support backing files,
2858 * hence all their sectors are reported as allocated.
2860 * If 'sector_num' is beyond the end of the disk image the return value is 0
2861 * and 'pnum' is set to 0.
2863 * 'pnum' is set to the number of sectors (including and immediately following
2864 * the specified sector) that are known to be in the same
2865 * allocated/unallocated state.
2867 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2868 * beyond the end of the disk image it will be clamped.
2870 int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
2871 int nb_sectors, int *pnum)
2873 int64_t n;
2875 if (sector_num >= bs->total_sectors) {
2876 *pnum = 0;
2877 return 0;
2880 n = bs->total_sectors - sector_num;
2881 if (n < nb_sectors) {
2882 nb_sectors = n;
2885 if (!bs->drv->bdrv_co_is_allocated) {
2886 *pnum = nb_sectors;
2887 return 1;
2890 return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum);
2893 /* Coroutine wrapper for bdrv_is_allocated() */
2894 static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque)
2896 BdrvCoIsAllocatedData *data = opaque;
2897 BlockDriverState *bs = data->bs;
2899 data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors,
2900 data->pnum);
2901 data->done = true;
2905 * Synchronous wrapper around bdrv_co_is_allocated().
2907 * See bdrv_co_is_allocated() for details.
2909 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2910 int *pnum)
2912 Coroutine *co;
2913 BdrvCoIsAllocatedData data = {
2914 .bs = bs,
2915 .sector_num = sector_num,
2916 .nb_sectors = nb_sectors,
2917 .pnum = pnum,
2918 .done = false,
2921 co = qemu_coroutine_create(bdrv_is_allocated_co_entry);
2922 qemu_coroutine_enter(co, &data);
2923 while (!data.done) {
2924 qemu_aio_wait();
2926 return data.ret;
2930 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2932 * Return true if the given sector is allocated in any image between
2933 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2934 * sector is allocated in any image of the chain. Return false otherwise.
2936 * 'pnum' is set to the number of sectors (including and immediately following
2937 * the specified sector) that are known to be in the same
2938 * allocated/unallocated state.
2941 int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
2942 BlockDriverState *base,
2943 int64_t sector_num,
2944 int nb_sectors, int *pnum)
2946 BlockDriverState *intermediate;
2947 int ret, n = nb_sectors;
2949 intermediate = top;
2950 while (intermediate && intermediate != base) {
2951 int pnum_inter;
2952 ret = bdrv_co_is_allocated(intermediate, sector_num, nb_sectors,
2953 &pnum_inter);
2954 if (ret < 0) {
2955 return ret;
2956 } else if (ret) {
2957 *pnum = pnum_inter;
2958 return 1;
2962 * [sector_num, nb_sectors] is unallocated on top but intermediate
2963 * might have
2965 * [sector_num+x, nr_sectors] allocated.
2967 if (n > pnum_inter &&
2968 (intermediate == top ||
2969 sector_num + pnum_inter < intermediate->total_sectors)) {
2970 n = pnum_inter;
2973 intermediate = intermediate->backing_hd;
2976 *pnum = n;
2977 return 0;
2980 /* Coroutine wrapper for bdrv_is_allocated_above() */
2981 static void coroutine_fn bdrv_is_allocated_above_co_entry(void *opaque)
2983 BdrvCoIsAllocatedData *data = opaque;
2984 BlockDriverState *top = data->bs;
2985 BlockDriverState *base = data->base;
2987 data->ret = bdrv_co_is_allocated_above(top, base, data->sector_num,
2988 data->nb_sectors, data->pnum);
2989 data->done = true;
2993 * Synchronous wrapper around bdrv_co_is_allocated_above().
2995 * See bdrv_co_is_allocated_above() for details.
2997 int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
2998 int64_t sector_num, int nb_sectors, int *pnum)
3000 Coroutine *co;
3001 BdrvCoIsAllocatedData data = {
3002 .bs = top,
3003 .base = base,
3004 .sector_num = sector_num,
3005 .nb_sectors = nb_sectors,
3006 .pnum = pnum,
3007 .done = false,
3010 co = qemu_coroutine_create(bdrv_is_allocated_above_co_entry);
3011 qemu_coroutine_enter(co, &data);
3012 while (!data.done) {
3013 qemu_aio_wait();
3015 return data.ret;
3018 BlockInfo *bdrv_query_info(BlockDriverState *bs)
3020 BlockInfo *info = g_malloc0(sizeof(*info));
3021 info->device = g_strdup(bs->device_name);
3022 info->type = g_strdup("unknown");
3023 info->locked = bdrv_dev_is_medium_locked(bs);
3024 info->removable = bdrv_dev_has_removable_media(bs);
3026 if (bdrv_dev_has_removable_media(bs)) {
3027 info->has_tray_open = true;
3028 info->tray_open = bdrv_dev_is_tray_open(bs);
3031 if (bdrv_iostatus_is_enabled(bs)) {
3032 info->has_io_status = true;
3033 info->io_status = bs->iostatus;
3036 if (bs->dirty_bitmap) {
3037 info->has_dirty = true;
3038 info->dirty = g_malloc0(sizeof(*info->dirty));
3039 info->dirty->count = bdrv_get_dirty_count(bs) * BDRV_SECTOR_SIZE;
3040 info->dirty->granularity =
3041 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bs->dirty_bitmap));
3044 if (bs->drv) {
3045 info->has_inserted = true;
3046 info->inserted = g_malloc0(sizeof(*info->inserted));
3047 info->inserted->file = g_strdup(bs->filename);
3048 info->inserted->ro = bs->read_only;
3049 info->inserted->drv = g_strdup(bs->drv->format_name);
3050 info->inserted->encrypted = bs->encrypted;
3051 info->inserted->encryption_key_missing = bdrv_key_required(bs);
3053 if (bs->backing_file[0]) {
3054 info->inserted->has_backing_file = true;
3055 info->inserted->backing_file = g_strdup(bs->backing_file);
3058 info->inserted->backing_file_depth = bdrv_get_backing_file_depth(bs);
3060 if (bs->io_limits_enabled) {
3061 info->inserted->bps =
3062 bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
3063 info->inserted->bps_rd =
3064 bs->io_limits.bps[BLOCK_IO_LIMIT_READ];
3065 info->inserted->bps_wr =
3066 bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];
3067 info->inserted->iops =
3068 bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
3069 info->inserted->iops_rd =
3070 bs->io_limits.iops[BLOCK_IO_LIMIT_READ];
3071 info->inserted->iops_wr =
3072 bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];
3075 return info;
3078 BlockInfoList *qmp_query_block(Error **errp)
3080 BlockInfoList *head = NULL, **p_next = &head;
3081 BlockDriverState *bs;
3083 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3084 BlockInfoList *info = g_malloc0(sizeof(*info));
3085 info->value = bdrv_query_info(bs);
3087 *p_next = info;
3088 p_next = &info->next;
3091 return head;
3094 BlockStats *bdrv_query_stats(const BlockDriverState *bs)
3096 BlockStats *s;
3098 s = g_malloc0(sizeof(*s));
3100 if (bs->device_name[0]) {
3101 s->has_device = true;
3102 s->device = g_strdup(bs->device_name);
3105 s->stats = g_malloc0(sizeof(*s->stats));
3106 s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];
3107 s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];
3108 s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];
3109 s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];
3110 s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;
3111 s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];
3112 s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];
3113 s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];
3114 s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];
3116 if (bs->file) {
3117 s->has_parent = true;
3118 s->parent = bdrv_query_stats(bs->file);
3121 return s;
3124 BlockStatsList *qmp_query_blockstats(Error **errp)
3126 BlockStatsList *head = NULL, **p_next = &head;
3127 BlockDriverState *bs;
3129 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3130 BlockStatsList *info = g_malloc0(sizeof(*info));
3131 info->value = bdrv_query_stats(bs);
3133 *p_next = info;
3134 p_next = &info->next;
3137 return head;
3140 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3142 if (bs->backing_hd && bs->backing_hd->encrypted)
3143 return bs->backing_file;
3144 else if (bs->encrypted)
3145 return bs->filename;
3146 else
3147 return NULL;
3150 void bdrv_get_backing_filename(BlockDriverState *bs,
3151 char *filename, int filename_size)
3153 pstrcpy(filename, filename_size, bs->backing_file);
3156 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
3157 const uint8_t *buf, int nb_sectors)
3159 BlockDriver *drv = bs->drv;
3160 if (!drv)
3161 return -ENOMEDIUM;
3162 if (!drv->bdrv_write_compressed)
3163 return -ENOTSUP;
3164 if (bdrv_check_request(bs, sector_num, nb_sectors))
3165 return -EIO;
3167 assert(!bs->dirty_bitmap);
3169 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
3172 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3174 BlockDriver *drv = bs->drv;
3175 if (!drv)
3176 return -ENOMEDIUM;
3177 if (!drv->bdrv_get_info)
3178 return -ENOTSUP;
3179 memset(bdi, 0, sizeof(*bdi));
3180 return drv->bdrv_get_info(bs, bdi);
3183 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
3184 int64_t pos, int size)
3186 BlockDriver *drv = bs->drv;
3187 if (!drv)
3188 return -ENOMEDIUM;
3189 if (drv->bdrv_save_vmstate)
3190 return drv->bdrv_save_vmstate(bs, buf, pos, size);
3191 if (bs->file)
3192 return bdrv_save_vmstate(bs->file, buf, pos, size);
3193 return -ENOTSUP;
3196 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
3197 int64_t pos, int size)
3199 BlockDriver *drv = bs->drv;
3200 if (!drv)
3201 return -ENOMEDIUM;
3202 if (drv->bdrv_load_vmstate)
3203 return drv->bdrv_load_vmstate(bs, buf, pos, size);
3204 if (bs->file)
3205 return bdrv_load_vmstate(bs->file, buf, pos, size);
3206 return -ENOTSUP;
3209 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3211 BlockDriver *drv = bs->drv;
3213 if (!drv || !drv->bdrv_debug_event) {
3214 return;
3217 drv->bdrv_debug_event(bs, event);
3220 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3221 const char *tag)
3223 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3224 bs = bs->file;
3227 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3228 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3231 return -ENOTSUP;
3234 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3236 while (bs && bs->drv && !bs->drv->bdrv_debug_resume) {
3237 bs = bs->file;
3240 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3241 return bs->drv->bdrv_debug_resume(bs, tag);
3244 return -ENOTSUP;
3247 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3249 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3250 bs = bs->file;
3253 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3254 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3257 return false;
3260 /**************************************************************/
3261 /* handling of snapshots */
3263 int bdrv_can_snapshot(BlockDriverState *bs)
3265 BlockDriver *drv = bs->drv;
3266 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
3267 return 0;
3270 if (!drv->bdrv_snapshot_create) {
3271 if (bs->file != NULL) {
3272 return bdrv_can_snapshot(bs->file);
3274 return 0;
3277 return 1;
3280 int bdrv_is_snapshot(BlockDriverState *bs)
3282 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3285 BlockDriverState *bdrv_snapshots(void)
3287 BlockDriverState *bs;
3289 if (bs_snapshots) {
3290 return bs_snapshots;
3293 bs = NULL;
3294 while ((bs = bdrv_next(bs))) {
3295 if (bdrv_can_snapshot(bs)) {
3296 bs_snapshots = bs;
3297 return bs;
3300 return NULL;
3303 int bdrv_snapshot_create(BlockDriverState *bs,
3304 QEMUSnapshotInfo *sn_info)
3306 BlockDriver *drv = bs->drv;
3307 if (!drv)
3308 return -ENOMEDIUM;
3309 if (drv->bdrv_snapshot_create)
3310 return drv->bdrv_snapshot_create(bs, sn_info);
3311 if (bs->file)
3312 return bdrv_snapshot_create(bs->file, sn_info);
3313 return -ENOTSUP;
3316 int bdrv_snapshot_goto(BlockDriverState *bs,
3317 const char *snapshot_id)
3319 BlockDriver *drv = bs->drv;
3320 int ret, open_ret;
3322 if (!drv)
3323 return -ENOMEDIUM;
3324 if (drv->bdrv_snapshot_goto)
3325 return drv->bdrv_snapshot_goto(bs, snapshot_id);
3327 if (bs->file) {
3328 drv->bdrv_close(bs);
3329 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
3330 open_ret = drv->bdrv_open(bs, NULL, bs->open_flags);
3331 if (open_ret < 0) {
3332 bdrv_delete(bs->file);
3333 bs->drv = NULL;
3334 return open_ret;
3336 return ret;
3339 return -ENOTSUP;
3342 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
3344 BlockDriver *drv = bs->drv;
3345 if (!drv)
3346 return -ENOMEDIUM;
3347 if (drv->bdrv_snapshot_delete)
3348 return drv->bdrv_snapshot_delete(bs, snapshot_id);
3349 if (bs->file)
3350 return bdrv_snapshot_delete(bs->file, snapshot_id);
3351 return -ENOTSUP;
3354 int bdrv_snapshot_list(BlockDriverState *bs,
3355 QEMUSnapshotInfo **psn_info)
3357 BlockDriver *drv = bs->drv;
3358 if (!drv)
3359 return -ENOMEDIUM;
3360 if (drv->bdrv_snapshot_list)
3361 return drv->bdrv_snapshot_list(bs, psn_info);
3362 if (bs->file)
3363 return bdrv_snapshot_list(bs->file, psn_info);
3364 return -ENOTSUP;
3367 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
3368 const char *snapshot_name)
3370 BlockDriver *drv = bs->drv;
3371 if (!drv) {
3372 return -ENOMEDIUM;
3374 if (!bs->read_only) {
3375 return -EINVAL;
3377 if (drv->bdrv_snapshot_load_tmp) {
3378 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
3380 return -ENOTSUP;
3383 /* backing_file can either be relative, or absolute, or a protocol. If it is
3384 * relative, it must be relative to the chain. So, passing in bs->filename
3385 * from a BDS as backing_file should not be done, as that may be relative to
3386 * the CWD rather than the chain. */
3387 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3388 const char *backing_file)
3390 char *filename_full = NULL;
3391 char *backing_file_full = NULL;
3392 char *filename_tmp = NULL;
3393 int is_protocol = 0;
3394 BlockDriverState *curr_bs = NULL;
3395 BlockDriverState *retval = NULL;
3397 if (!bs || !bs->drv || !backing_file) {
3398 return NULL;
3401 filename_full = g_malloc(PATH_MAX);
3402 backing_file_full = g_malloc(PATH_MAX);
3403 filename_tmp = g_malloc(PATH_MAX);
3405 is_protocol = path_has_protocol(backing_file);
3407 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3409 /* If either of the filename paths is actually a protocol, then
3410 * compare unmodified paths; otherwise make paths relative */
3411 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3412 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3413 retval = curr_bs->backing_hd;
3414 break;
3416 } else {
3417 /* If not an absolute filename path, make it relative to the current
3418 * image's filename path */
3419 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3420 backing_file);
3422 /* We are going to compare absolute pathnames */
3423 if (!realpath(filename_tmp, filename_full)) {
3424 continue;
3427 /* We need to make sure the backing filename we are comparing against
3428 * is relative to the current image filename (or absolute) */
3429 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3430 curr_bs->backing_file);
3432 if (!realpath(filename_tmp, backing_file_full)) {
3433 continue;
3436 if (strcmp(backing_file_full, filename_full) == 0) {
3437 retval = curr_bs->backing_hd;
3438 break;
3443 g_free(filename_full);
3444 g_free(backing_file_full);
3445 g_free(filename_tmp);
3446 return retval;
3449 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3451 if (!bs->drv) {
3452 return 0;
3455 if (!bs->backing_hd) {
3456 return 0;
3459 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3462 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3464 BlockDriverState *curr_bs = NULL;
3466 if (!bs) {
3467 return NULL;
3470 curr_bs = bs;
3472 while (curr_bs->backing_hd) {
3473 curr_bs = curr_bs->backing_hd;
3475 return curr_bs;
3478 #define NB_SUFFIXES 4
3480 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
3482 static const char suffixes[NB_SUFFIXES] = "KMGT";
3483 int64_t base;
3484 int i;
3486 if (size <= 999) {
3487 snprintf(buf, buf_size, "%" PRId64, size);
3488 } else {
3489 base = 1024;
3490 for(i = 0; i < NB_SUFFIXES; i++) {
3491 if (size < (10 * base)) {
3492 snprintf(buf, buf_size, "%0.1f%c",
3493 (double)size / base,
3494 suffixes[i]);
3495 break;
3496 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
3497 snprintf(buf, buf_size, "%" PRId64 "%c",
3498 ((size + (base >> 1)) / base),
3499 suffixes[i]);
3500 break;
3502 base = base * 1024;
3505 return buf;
3508 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
3510 char buf1[128], date_buf[128], clock_buf[128];
3511 struct tm tm;
3512 time_t ti;
3513 int64_t secs;
3515 if (!sn) {
3516 snprintf(buf, buf_size,
3517 "%-10s%-20s%7s%20s%15s",
3518 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3519 } else {
3520 ti = sn->date_sec;
3521 localtime_r(&ti, &tm);
3522 strftime(date_buf, sizeof(date_buf),
3523 "%Y-%m-%d %H:%M:%S", &tm);
3524 secs = sn->vm_clock_nsec / 1000000000;
3525 snprintf(clock_buf, sizeof(clock_buf),
3526 "%02d:%02d:%02d.%03d",
3527 (int)(secs / 3600),
3528 (int)((secs / 60) % 60),
3529 (int)(secs % 60),
3530 (int)((sn->vm_clock_nsec / 1000000) % 1000));
3531 snprintf(buf, buf_size,
3532 "%-10s%-20s%7s%20s%15s",
3533 sn->id_str, sn->name,
3534 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
3535 date_buf,
3536 clock_buf);
3538 return buf;
3541 /**************************************************************/
3542 /* async I/Os */
3544 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
3545 QEMUIOVector *qiov, int nb_sectors,
3546 BlockDriverCompletionFunc *cb, void *opaque)
3548 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
3550 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
3551 cb, opaque, false);
3554 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
3555 QEMUIOVector *qiov, int nb_sectors,
3556 BlockDriverCompletionFunc *cb, void *opaque)
3558 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
3560 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
3561 cb, opaque, true);
3565 typedef struct MultiwriteCB {
3566 int error;
3567 int num_requests;
3568 int num_callbacks;
3569 struct {
3570 BlockDriverCompletionFunc *cb;
3571 void *opaque;
3572 QEMUIOVector *free_qiov;
3573 } callbacks[];
3574 } MultiwriteCB;
3576 static void multiwrite_user_cb(MultiwriteCB *mcb)
3578 int i;
3580 for (i = 0; i < mcb->num_callbacks; i++) {
3581 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
3582 if (mcb->callbacks[i].free_qiov) {
3583 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
3585 g_free(mcb->callbacks[i].free_qiov);
3589 static void multiwrite_cb(void *opaque, int ret)
3591 MultiwriteCB *mcb = opaque;
3593 trace_multiwrite_cb(mcb, ret);
3595 if (ret < 0 && !mcb->error) {
3596 mcb->error = ret;
3599 mcb->num_requests--;
3600 if (mcb->num_requests == 0) {
3601 multiwrite_user_cb(mcb);
3602 g_free(mcb);
3606 static int multiwrite_req_compare(const void *a, const void *b)
3608 const BlockRequest *req1 = a, *req2 = b;
3611 * Note that we can't simply subtract req2->sector from req1->sector
3612 * here as that could overflow the return value.
3614 if (req1->sector > req2->sector) {
3615 return 1;
3616 } else if (req1->sector < req2->sector) {
3617 return -1;
3618 } else {
3619 return 0;
3624 * Takes a bunch of requests and tries to merge them. Returns the number of
3625 * requests that remain after merging.
3627 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
3628 int num_reqs, MultiwriteCB *mcb)
3630 int i, outidx;
3632 // Sort requests by start sector
3633 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
3635 // Check if adjacent requests touch the same clusters. If so, combine them,
3636 // filling up gaps with zero sectors.
3637 outidx = 0;
3638 for (i = 1; i < num_reqs; i++) {
3639 int merge = 0;
3640 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
3642 // Handle exactly sequential writes and overlapping writes.
3643 if (reqs[i].sector <= oldreq_last) {
3644 merge = 1;
3647 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
3648 merge = 0;
3651 if (merge) {
3652 size_t size;
3653 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
3654 qemu_iovec_init(qiov,
3655 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
3657 // Add the first request to the merged one. If the requests are
3658 // overlapping, drop the last sectors of the first request.
3659 size = (reqs[i].sector - reqs[outidx].sector) << 9;
3660 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
3662 // We should need to add any zeros between the two requests
3663 assert (reqs[i].sector <= oldreq_last);
3665 // Add the second request
3666 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
3668 reqs[outidx].nb_sectors = qiov->size >> 9;
3669 reqs[outidx].qiov = qiov;
3671 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
3672 } else {
3673 outidx++;
3674 reqs[outidx].sector = reqs[i].sector;
3675 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
3676 reqs[outidx].qiov = reqs[i].qiov;
3680 return outidx + 1;
3684 * Submit multiple AIO write requests at once.
3686 * On success, the function returns 0 and all requests in the reqs array have
3687 * been submitted. In error case this function returns -1, and any of the
3688 * requests may or may not be submitted yet. In particular, this means that the
3689 * callback will be called for some of the requests, for others it won't. The
3690 * caller must check the error field of the BlockRequest to wait for the right
3691 * callbacks (if error != 0, no callback will be called).
3693 * The implementation may modify the contents of the reqs array, e.g. to merge
3694 * requests. However, the fields opaque and error are left unmodified as they
3695 * are used to signal failure for a single request to the caller.
3697 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3699 MultiwriteCB *mcb;
3700 int i;
3702 /* don't submit writes if we don't have a medium */
3703 if (bs->drv == NULL) {
3704 for (i = 0; i < num_reqs; i++) {
3705 reqs[i].error = -ENOMEDIUM;
3707 return -1;
3710 if (num_reqs == 0) {
3711 return 0;
3714 // Create MultiwriteCB structure
3715 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
3716 mcb->num_requests = 0;
3717 mcb->num_callbacks = num_reqs;
3719 for (i = 0; i < num_reqs; i++) {
3720 mcb->callbacks[i].cb = reqs[i].cb;
3721 mcb->callbacks[i].opaque = reqs[i].opaque;
3724 // Check for mergable requests
3725 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3727 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3729 /* Run the aio requests. */
3730 mcb->num_requests = num_reqs;
3731 for (i = 0; i < num_reqs; i++) {
3732 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
3733 reqs[i].nb_sectors, multiwrite_cb, mcb);
3736 return 0;
3739 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
3741 acb->aiocb_info->cancel(acb);
3744 /* block I/O throttling */
3745 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
3746 bool is_write, double elapsed_time, uint64_t *wait)
3748 uint64_t bps_limit = 0;
3749 double bytes_limit, bytes_base, bytes_res;
3750 double slice_time, wait_time;
3752 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3753 bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
3754 } else if (bs->io_limits.bps[is_write]) {
3755 bps_limit = bs->io_limits.bps[is_write];
3756 } else {
3757 if (wait) {
3758 *wait = 0;
3761 return false;
3764 slice_time = bs->slice_end - bs->slice_start;
3765 slice_time /= (NANOSECONDS_PER_SECOND);
3766 bytes_limit = bps_limit * slice_time;
3767 bytes_base = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write];
3768 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3769 bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write];
3772 /* bytes_base: the bytes of data which have been read/written; and
3773 * it is obtained from the history statistic info.
3774 * bytes_res: the remaining bytes of data which need to be read/written.
3775 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3776 * the total time for completing reading/writting all data.
3778 bytes_res = (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
3780 if (bytes_base + bytes_res <= bytes_limit) {
3781 if (wait) {
3782 *wait = 0;
3785 return false;
3788 /* Calc approx time to dispatch */
3789 wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time;
3791 /* When the I/O rate at runtime exceeds the limits,
3792 * bs->slice_end need to be extended in order that the current statistic
3793 * info can be kept until the timer fire, so it is increased and tuned
3794 * based on the result of experiment.
3796 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3797 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3798 if (wait) {
3799 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3802 return true;
3805 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
3806 double elapsed_time, uint64_t *wait)
3808 uint64_t iops_limit = 0;
3809 double ios_limit, ios_base;
3810 double slice_time, wait_time;
3812 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3813 iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
3814 } else if (bs->io_limits.iops[is_write]) {
3815 iops_limit = bs->io_limits.iops[is_write];
3816 } else {
3817 if (wait) {
3818 *wait = 0;
3821 return false;
3824 slice_time = bs->slice_end - bs->slice_start;
3825 slice_time /= (NANOSECONDS_PER_SECOND);
3826 ios_limit = iops_limit * slice_time;
3827 ios_base = bs->nr_ops[is_write] - bs->io_base.ios[is_write];
3828 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3829 ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write];
3832 if (ios_base + 1 <= ios_limit) {
3833 if (wait) {
3834 *wait = 0;
3837 return false;
3840 /* Calc approx time to dispatch */
3841 wait_time = (ios_base + 1) / iops_limit;
3842 if (wait_time > elapsed_time) {
3843 wait_time = wait_time - elapsed_time;
3844 } else {
3845 wait_time = 0;
3848 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3849 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3850 if (wait) {
3851 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3854 return true;
3857 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
3858 bool is_write, int64_t *wait)
3860 int64_t now, max_wait;
3861 uint64_t bps_wait = 0, iops_wait = 0;
3862 double elapsed_time;
3863 int bps_ret, iops_ret;
3865 now = qemu_get_clock_ns(vm_clock);
3866 if ((bs->slice_start < now)
3867 && (bs->slice_end > now)) {
3868 bs->slice_end = now + bs->slice_time;
3869 } else {
3870 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
3871 bs->slice_start = now;
3872 bs->slice_end = now + bs->slice_time;
3874 bs->io_base.bytes[is_write] = bs->nr_bytes[is_write];
3875 bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write];
3877 bs->io_base.ios[is_write] = bs->nr_ops[is_write];
3878 bs->io_base.ios[!is_write] = bs->nr_ops[!is_write];
3881 elapsed_time = now - bs->slice_start;
3882 elapsed_time /= (NANOSECONDS_PER_SECOND);
3884 bps_ret = bdrv_exceed_bps_limits(bs, nb_sectors,
3885 is_write, elapsed_time, &bps_wait);
3886 iops_ret = bdrv_exceed_iops_limits(bs, is_write,
3887 elapsed_time, &iops_wait);
3888 if (bps_ret || iops_ret) {
3889 max_wait = bps_wait > iops_wait ? bps_wait : iops_wait;
3890 if (wait) {
3891 *wait = max_wait;
3894 now = qemu_get_clock_ns(vm_clock);
3895 if (bs->slice_end < now + max_wait) {
3896 bs->slice_end = now + max_wait;
3899 return true;
3902 if (wait) {
3903 *wait = 0;
3906 return false;
3909 /**************************************************************/
3910 /* async block device emulation */
3912 typedef struct BlockDriverAIOCBSync {
3913 BlockDriverAIOCB common;
3914 QEMUBH *bh;
3915 int ret;
3916 /* vector translation state */
3917 QEMUIOVector *qiov;
3918 uint8_t *bounce;
3919 int is_write;
3920 } BlockDriverAIOCBSync;
3922 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3924 BlockDriverAIOCBSync *acb =
3925 container_of(blockacb, BlockDriverAIOCBSync, common);
3926 qemu_bh_delete(acb->bh);
3927 acb->bh = NULL;
3928 qemu_aio_release(acb);
3931 static const AIOCBInfo bdrv_em_aiocb_info = {
3932 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3933 .cancel = bdrv_aio_cancel_em,
3936 static void bdrv_aio_bh_cb(void *opaque)
3938 BlockDriverAIOCBSync *acb = opaque;
3940 if (!acb->is_write)
3941 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
3942 qemu_vfree(acb->bounce);
3943 acb->common.cb(acb->common.opaque, acb->ret);
3944 qemu_bh_delete(acb->bh);
3945 acb->bh = NULL;
3946 qemu_aio_release(acb);
3949 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3950 int64_t sector_num,
3951 QEMUIOVector *qiov,
3952 int nb_sectors,
3953 BlockDriverCompletionFunc *cb,
3954 void *opaque,
3955 int is_write)
3958 BlockDriverAIOCBSync *acb;
3960 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
3961 acb->is_write = is_write;
3962 acb->qiov = qiov;
3963 acb->bounce = qemu_blockalign(bs, qiov->size);
3964 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
3966 if (is_write) {
3967 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
3968 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
3969 } else {
3970 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
3973 qemu_bh_schedule(acb->bh);
3975 return &acb->common;
3978 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3979 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3980 BlockDriverCompletionFunc *cb, void *opaque)
3982 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
3985 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3986 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3987 BlockDriverCompletionFunc *cb, void *opaque)
3989 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3993 typedef struct BlockDriverAIOCBCoroutine {
3994 BlockDriverAIOCB common;
3995 BlockRequest req;
3996 bool is_write;
3997 bool *done;
3998 QEMUBH* bh;
3999 } BlockDriverAIOCBCoroutine;
4001 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4003 BlockDriverAIOCBCoroutine *acb =
4004 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4005 bool done = false;
4007 acb->done = &done;
4008 while (!done) {
4009 qemu_aio_wait();
4013 static const AIOCBInfo bdrv_em_co_aiocb_info = {
4014 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4015 .cancel = bdrv_aio_co_cancel_em,
4018 static void bdrv_co_em_bh(void *opaque)
4020 BlockDriverAIOCBCoroutine *acb = opaque;
4022 acb->common.cb(acb->common.opaque, acb->req.error);
4024 if (acb->done) {
4025 *acb->done = true;
4028 qemu_bh_delete(acb->bh);
4029 qemu_aio_release(acb);
4032 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4033 static void coroutine_fn bdrv_co_do_rw(void *opaque)
4035 BlockDriverAIOCBCoroutine *acb = opaque;
4036 BlockDriverState *bs = acb->common.bs;
4038 if (!acb->is_write) {
4039 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
4040 acb->req.nb_sectors, acb->req.qiov, 0);
4041 } else {
4042 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
4043 acb->req.nb_sectors, acb->req.qiov, 0);
4046 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4047 qemu_bh_schedule(acb->bh);
4050 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4051 int64_t sector_num,
4052 QEMUIOVector *qiov,
4053 int nb_sectors,
4054 BlockDriverCompletionFunc *cb,
4055 void *opaque,
4056 bool is_write)
4058 Coroutine *co;
4059 BlockDriverAIOCBCoroutine *acb;
4061 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4062 acb->req.sector = sector_num;
4063 acb->req.nb_sectors = nb_sectors;
4064 acb->req.qiov = qiov;
4065 acb->is_write = is_write;
4066 acb->done = NULL;
4068 co = qemu_coroutine_create(bdrv_co_do_rw);
4069 qemu_coroutine_enter(co, acb);
4071 return &acb->common;
4074 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4076 BlockDriverAIOCBCoroutine *acb = opaque;
4077 BlockDriverState *bs = acb->common.bs;
4079 acb->req.error = bdrv_co_flush(bs);
4080 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4081 qemu_bh_schedule(acb->bh);
4084 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4085 BlockDriverCompletionFunc *cb, void *opaque)
4087 trace_bdrv_aio_flush(bs, opaque);
4089 Coroutine *co;
4090 BlockDriverAIOCBCoroutine *acb;
4092 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4093 acb->done = NULL;
4095 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4096 qemu_coroutine_enter(co, acb);
4098 return &acb->common;
4101 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4103 BlockDriverAIOCBCoroutine *acb = opaque;
4104 BlockDriverState *bs = acb->common.bs;
4106 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4107 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4108 qemu_bh_schedule(acb->bh);
4111 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4112 int64_t sector_num, int nb_sectors,
4113 BlockDriverCompletionFunc *cb, void *opaque)
4115 Coroutine *co;
4116 BlockDriverAIOCBCoroutine *acb;
4118 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4120 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4121 acb->req.sector = sector_num;
4122 acb->req.nb_sectors = nb_sectors;
4123 acb->done = NULL;
4124 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4125 qemu_coroutine_enter(co, acb);
4127 return &acb->common;
4130 void bdrv_init(void)
4132 module_call_init(MODULE_INIT_BLOCK);
4135 void bdrv_init_with_whitelist(void)
4137 use_bdrv_whitelist = 1;
4138 bdrv_init();
4141 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4142 BlockDriverCompletionFunc *cb, void *opaque)
4144 BlockDriverAIOCB *acb;
4146 acb = g_slice_alloc(aiocb_info->aiocb_size);
4147 acb->aiocb_info = aiocb_info;
4148 acb->bs = bs;
4149 acb->cb = cb;
4150 acb->opaque = opaque;
4151 return acb;
4154 void qemu_aio_release(void *p)
4156 BlockDriverAIOCB *acb = p;
4157 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4160 /**************************************************************/
4161 /* Coroutine block device emulation */
4163 typedef struct CoroutineIOCompletion {
4164 Coroutine *coroutine;
4165 int ret;
4166 } CoroutineIOCompletion;
4168 static void bdrv_co_io_em_complete(void *opaque, int ret)
4170 CoroutineIOCompletion *co = opaque;
4172 co->ret = ret;
4173 qemu_coroutine_enter(co->coroutine, NULL);
4176 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4177 int nb_sectors, QEMUIOVector *iov,
4178 bool is_write)
4180 CoroutineIOCompletion co = {
4181 .coroutine = qemu_coroutine_self(),
4183 BlockDriverAIOCB *acb;
4185 if (is_write) {
4186 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4187 bdrv_co_io_em_complete, &co);
4188 } else {
4189 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4190 bdrv_co_io_em_complete, &co);
4193 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4194 if (!acb) {
4195 return -EIO;
4197 qemu_coroutine_yield();
4199 return co.ret;
4202 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4203 int64_t sector_num, int nb_sectors,
4204 QEMUIOVector *iov)
4206 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4209 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4210 int64_t sector_num, int nb_sectors,
4211 QEMUIOVector *iov)
4213 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4216 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4218 RwCo *rwco = opaque;
4220 rwco->ret = bdrv_co_flush(rwco->bs);
4223 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4225 int ret;
4227 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4228 return 0;
4231 /* Write back cached data to the OS even with cache=unsafe */
4232 if (bs->drv->bdrv_co_flush_to_os) {
4233 ret = bs->drv->bdrv_co_flush_to_os(bs);
4234 if (ret < 0) {
4235 return ret;
4239 /* But don't actually force it to the disk with cache=unsafe */
4240 if (bs->open_flags & BDRV_O_NO_FLUSH) {
4241 goto flush_parent;
4244 if (bs->drv->bdrv_co_flush_to_disk) {
4245 ret = bs->drv->bdrv_co_flush_to_disk(bs);
4246 } else if (bs->drv->bdrv_aio_flush) {
4247 BlockDriverAIOCB *acb;
4248 CoroutineIOCompletion co = {
4249 .coroutine = qemu_coroutine_self(),
4252 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4253 if (acb == NULL) {
4254 ret = -EIO;
4255 } else {
4256 qemu_coroutine_yield();
4257 ret = co.ret;
4259 } else {
4261 * Some block drivers always operate in either writethrough or unsafe
4262 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4263 * know how the server works (because the behaviour is hardcoded or
4264 * depends on server-side configuration), so we can't ensure that
4265 * everything is safe on disk. Returning an error doesn't work because
4266 * that would break guests even if the server operates in writethrough
4267 * mode.
4269 * Let's hope the user knows what he's doing.
4271 ret = 0;
4273 if (ret < 0) {
4274 return ret;
4277 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4278 * in the case of cache=unsafe, so there are no useless flushes.
4280 flush_parent:
4281 return bdrv_co_flush(bs->file);
4284 void bdrv_invalidate_cache(BlockDriverState *bs)
4286 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
4287 bs->drv->bdrv_invalidate_cache(bs);
4291 void bdrv_invalidate_cache_all(void)
4293 BlockDriverState *bs;
4295 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4296 bdrv_invalidate_cache(bs);
4300 void bdrv_clear_incoming_migration_all(void)
4302 BlockDriverState *bs;
4304 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4305 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4309 int bdrv_flush(BlockDriverState *bs)
4311 Coroutine *co;
4312 RwCo rwco = {
4313 .bs = bs,
4314 .ret = NOT_DONE,
4317 if (qemu_in_coroutine()) {
4318 /* Fast-path if already in coroutine context */
4319 bdrv_flush_co_entry(&rwco);
4320 } else {
4321 co = qemu_coroutine_create(bdrv_flush_co_entry);
4322 qemu_coroutine_enter(co, &rwco);
4323 while (rwco.ret == NOT_DONE) {
4324 qemu_aio_wait();
4328 return rwco.ret;
4331 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4333 RwCo *rwco = opaque;
4335 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4338 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4339 int nb_sectors)
4341 if (!bs->drv) {
4342 return -ENOMEDIUM;
4343 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4344 return -EIO;
4345 } else if (bs->read_only) {
4346 return -EROFS;
4349 if (bs->dirty_bitmap) {
4350 bdrv_reset_dirty(bs, sector_num, nb_sectors);
4353 /* Do nothing if disabled. */
4354 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4355 return 0;
4358 if (bs->drv->bdrv_co_discard) {
4359 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
4360 } else if (bs->drv->bdrv_aio_discard) {
4361 BlockDriverAIOCB *acb;
4362 CoroutineIOCompletion co = {
4363 .coroutine = qemu_coroutine_self(),
4366 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4367 bdrv_co_io_em_complete, &co);
4368 if (acb == NULL) {
4369 return -EIO;
4370 } else {
4371 qemu_coroutine_yield();
4372 return co.ret;
4374 } else {
4375 return 0;
4379 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
4381 Coroutine *co;
4382 RwCo rwco = {
4383 .bs = bs,
4384 .sector_num = sector_num,
4385 .nb_sectors = nb_sectors,
4386 .ret = NOT_DONE,
4389 if (qemu_in_coroutine()) {
4390 /* Fast-path if already in coroutine context */
4391 bdrv_discard_co_entry(&rwco);
4392 } else {
4393 co = qemu_coroutine_create(bdrv_discard_co_entry);
4394 qemu_coroutine_enter(co, &rwco);
4395 while (rwco.ret == NOT_DONE) {
4396 qemu_aio_wait();
4400 return rwco.ret;
4403 /**************************************************************/
4404 /* removable device support */
4407 * Return TRUE if the media is present
4409 int bdrv_is_inserted(BlockDriverState *bs)
4411 BlockDriver *drv = bs->drv;
4413 if (!drv)
4414 return 0;
4415 if (!drv->bdrv_is_inserted)
4416 return 1;
4417 return drv->bdrv_is_inserted(bs);
4421 * Return whether the media changed since the last call to this
4422 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4424 int bdrv_media_changed(BlockDriverState *bs)
4426 BlockDriver *drv = bs->drv;
4428 if (drv && drv->bdrv_media_changed) {
4429 return drv->bdrv_media_changed(bs);
4431 return -ENOTSUP;
4435 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4437 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
4439 BlockDriver *drv = bs->drv;
4441 if (drv && drv->bdrv_eject) {
4442 drv->bdrv_eject(bs, eject_flag);
4445 if (bs->device_name[0] != '\0') {
4446 bdrv_emit_qmp_eject_event(bs, eject_flag);
4451 * Lock or unlock the media (if it is locked, the user won't be able
4452 * to eject it manually).
4454 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
4456 BlockDriver *drv = bs->drv;
4458 trace_bdrv_lock_medium(bs, locked);
4460 if (drv && drv->bdrv_lock_medium) {
4461 drv->bdrv_lock_medium(bs, locked);
4465 /* needed for generic scsi interface */
4467 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4469 BlockDriver *drv = bs->drv;
4471 if (drv && drv->bdrv_ioctl)
4472 return drv->bdrv_ioctl(bs, req, buf);
4473 return -ENOTSUP;
4476 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
4477 unsigned long int req, void *buf,
4478 BlockDriverCompletionFunc *cb, void *opaque)
4480 BlockDriver *drv = bs->drv;
4482 if (drv && drv->bdrv_aio_ioctl)
4483 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
4484 return NULL;
4487 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
4489 bs->buffer_alignment = align;
4492 void *qemu_blockalign(BlockDriverState *bs, size_t size)
4494 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
4498 * Check if all memory in this vector is sector aligned.
4500 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
4502 int i;
4504 for (i = 0; i < qiov->niov; i++) {
4505 if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
4506 return false;
4510 return true;
4513 void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity)
4515 int64_t bitmap_size;
4517 assert((granularity & (granularity - 1)) == 0);
4519 if (granularity) {
4520 granularity >>= BDRV_SECTOR_BITS;
4521 assert(!bs->dirty_bitmap);
4522 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
4523 bs->dirty_bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
4524 } else {
4525 if (bs->dirty_bitmap) {
4526 hbitmap_free(bs->dirty_bitmap);
4527 bs->dirty_bitmap = NULL;
4532 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
4534 if (bs->dirty_bitmap) {
4535 return hbitmap_get(bs->dirty_bitmap, sector);
4536 } else {
4537 return 0;
4541 void bdrv_dirty_iter_init(BlockDriverState *bs, HBitmapIter *hbi)
4543 hbitmap_iter_init(hbi, bs->dirty_bitmap, 0);
4546 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
4547 int nr_sectors)
4549 hbitmap_set(bs->dirty_bitmap, cur_sector, nr_sectors);
4552 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
4553 int nr_sectors)
4555 hbitmap_reset(bs->dirty_bitmap, cur_sector, nr_sectors);
4558 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
4560 if (bs->dirty_bitmap) {
4561 return hbitmap_count(bs->dirty_bitmap);
4562 } else {
4563 return 0;
4567 void bdrv_set_in_use(BlockDriverState *bs, int in_use)
4569 assert(bs->in_use != in_use);
4570 bs->in_use = in_use;
4573 int bdrv_in_use(BlockDriverState *bs)
4575 return bs->in_use;
4578 void bdrv_iostatus_enable(BlockDriverState *bs)
4580 bs->iostatus_enabled = true;
4581 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
4584 /* The I/O status is only enabled if the drive explicitly
4585 * enables it _and_ the VM is configured to stop on errors */
4586 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
4588 return (bs->iostatus_enabled &&
4589 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
4590 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
4591 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
4594 void bdrv_iostatus_disable(BlockDriverState *bs)
4596 bs->iostatus_enabled = false;
4599 void bdrv_iostatus_reset(BlockDriverState *bs)
4601 if (bdrv_iostatus_is_enabled(bs)) {
4602 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
4603 if (bs->job) {
4604 block_job_iostatus_reset(bs->job);
4609 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
4611 assert(bdrv_iostatus_is_enabled(bs));
4612 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
4613 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
4614 BLOCK_DEVICE_IO_STATUS_FAILED;
4618 void
4619 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
4620 enum BlockAcctType type)
4622 assert(type < BDRV_MAX_IOTYPE);
4624 cookie->bytes = bytes;
4625 cookie->start_time_ns = get_clock();
4626 cookie->type = type;
4629 void
4630 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
4632 assert(cookie->type < BDRV_MAX_IOTYPE);
4634 bs->nr_bytes[cookie->type] += cookie->bytes;
4635 bs->nr_ops[cookie->type]++;
4636 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
4639 void bdrv_img_create(const char *filename, const char *fmt,
4640 const char *base_filename, const char *base_fmt,
4641 char *options, uint64_t img_size, int flags,
4642 Error **errp, bool quiet)
4644 QEMUOptionParameter *param = NULL, *create_options = NULL;
4645 QEMUOptionParameter *backing_fmt, *backing_file, *size;
4646 BlockDriverState *bs = NULL;
4647 BlockDriver *drv, *proto_drv;
4648 BlockDriver *backing_drv = NULL;
4649 int ret = 0;
4651 /* Find driver and parse its options */
4652 drv = bdrv_find_format(fmt);
4653 if (!drv) {
4654 error_setg(errp, "Unknown file format '%s'", fmt);
4655 return;
4658 proto_drv = bdrv_find_protocol(filename);
4659 if (!proto_drv) {
4660 error_setg(errp, "Unknown protocol '%s'", filename);
4661 return;
4664 create_options = append_option_parameters(create_options,
4665 drv->create_options);
4666 create_options = append_option_parameters(create_options,
4667 proto_drv->create_options);
4669 /* Create parameter list with default values */
4670 param = parse_option_parameters("", create_options, param);
4672 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
4674 /* Parse -o options */
4675 if (options) {
4676 param = parse_option_parameters(options, create_options, param);
4677 if (param == NULL) {
4678 error_setg(errp, "Invalid options for file format '%s'.", fmt);
4679 goto out;
4683 if (base_filename) {
4684 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
4685 base_filename)) {
4686 error_setg(errp, "Backing file not supported for file format '%s'",
4687 fmt);
4688 goto out;
4692 if (base_fmt) {
4693 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
4694 error_setg(errp, "Backing file format not supported for file "
4695 "format '%s'", fmt);
4696 goto out;
4700 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
4701 if (backing_file && backing_file->value.s) {
4702 if (!strcmp(filename, backing_file->value.s)) {
4703 error_setg(errp, "Error: Trying to create an image with the "
4704 "same filename as the backing file");
4705 goto out;
4709 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
4710 if (backing_fmt && backing_fmt->value.s) {
4711 backing_drv = bdrv_find_format(backing_fmt->value.s);
4712 if (!backing_drv) {
4713 error_setg(errp, "Unknown backing file format '%s'",
4714 backing_fmt->value.s);
4715 goto out;
4719 // The size for the image must always be specified, with one exception:
4720 // If we are using a backing file, we can obtain the size from there
4721 size = get_option_parameter(param, BLOCK_OPT_SIZE);
4722 if (size && size->value.n == -1) {
4723 if (backing_file && backing_file->value.s) {
4724 uint64_t size;
4725 char buf[32];
4726 int back_flags;
4728 /* backing files always opened read-only */
4729 back_flags =
4730 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4732 bs = bdrv_new("");
4734 ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
4735 backing_drv);
4736 if (ret < 0) {
4737 error_setg_errno(errp, -ret, "Could not open '%s'",
4738 backing_file->value.s);
4739 goto out;
4741 bdrv_get_geometry(bs, &size);
4742 size *= 512;
4744 snprintf(buf, sizeof(buf), "%" PRId64, size);
4745 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4746 } else {
4747 error_setg(errp, "Image creation needs a size parameter");
4748 goto out;
4752 if (!quiet) {
4753 printf("Formatting '%s', fmt=%s ", filename, fmt);
4754 print_option_parameters(param);
4755 puts("");
4757 ret = bdrv_create(drv, filename, param);
4758 if (ret < 0) {
4759 if (ret == -ENOTSUP) {
4760 error_setg(errp,"Formatting or formatting option not supported for "
4761 "file format '%s'", fmt);
4762 } else if (ret == -EFBIG) {
4763 error_setg(errp, "The image size is too large for file format '%s'",
4764 fmt);
4765 } else {
4766 error_setg(errp, "%s: error while creating %s: %s", filename, fmt,
4767 strerror(-ret));
4771 out:
4772 free_option_parameters(create_options);
4773 free_option_parameters(param);
4775 if (bs) {
4776 bdrv_delete(bs);
4780 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4782 /* Currently BlockDriverState always uses the main loop AioContext */
4783 return qemu_get_aio_context();