usb-ehci: Never follow table entries with the T-bit set
[qemu.git] / block.c
blob52ffe1494a2326549960187021aa5278b5b0313b
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.h"
28 #include "block_int.h"
29 #include "module.h"
30 #include "qjson.h"
31 #include "qemu-coroutine.h"
32 #include "qmp-commands.h"
33 #include "qemu-timer.h"
35 #ifdef CONFIG_BSD
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <sys/ioctl.h>
39 #include <sys/queue.h>
40 #ifndef __DragonFly__
41 #include <sys/disk.h>
42 #endif
43 #endif
45 #ifdef _WIN32
46 #include <windows.h>
47 #endif
49 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
51 typedef enum {
52 BDRV_REQ_COPY_ON_READ = 0x1,
53 BDRV_REQ_ZERO_WRITE = 0x2,
54 } BdrvRequestFlags;
56 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
57 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
58 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
59 BlockDriverCompletionFunc *cb, void *opaque);
60 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
61 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
62 BlockDriverCompletionFunc *cb, void *opaque);
63 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
64 int64_t sector_num, int nb_sectors,
65 QEMUIOVector *iov);
66 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
67 int64_t sector_num, int nb_sectors,
68 QEMUIOVector *iov);
69 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
70 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
71 BdrvRequestFlags flags);
72 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
73 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
74 BdrvRequestFlags flags);
75 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
76 int64_t sector_num,
77 QEMUIOVector *qiov,
78 int nb_sectors,
79 BlockDriverCompletionFunc *cb,
80 void *opaque,
81 bool is_write);
82 static void coroutine_fn bdrv_co_do_rw(void *opaque);
84 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
85 bool is_write, double elapsed_time, uint64_t *wait);
86 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
87 double elapsed_time, uint64_t *wait);
88 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
89 bool is_write, int64_t *wait);
91 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
92 QTAILQ_HEAD_INITIALIZER(bdrv_states);
94 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
95 QLIST_HEAD_INITIALIZER(bdrv_drivers);
97 /* The device to use for VM snapshots */
98 static BlockDriverState *bs_snapshots;
100 /* If non-zero, use only whitelisted block drivers */
101 static int use_bdrv_whitelist;
103 #ifdef _WIN32
104 static int is_windows_drive_prefix(const char *filename)
106 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
107 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
108 filename[1] == ':');
111 int is_windows_drive(const char *filename)
113 if (is_windows_drive_prefix(filename) &&
114 filename[2] == '\0')
115 return 1;
116 if (strstart(filename, "\\\\.\\", NULL) ||
117 strstart(filename, "//./", NULL))
118 return 1;
119 return 0;
121 #endif
123 /* throttling disk I/O limits */
124 void bdrv_io_limits_disable(BlockDriverState *bs)
126 bs->io_limits_enabled = false;
128 while (qemu_co_queue_next(&bs->throttled_reqs));
130 if (bs->block_timer) {
131 qemu_del_timer(bs->block_timer);
132 qemu_free_timer(bs->block_timer);
133 bs->block_timer = NULL;
136 bs->slice_start = 0;
137 bs->slice_end = 0;
138 bs->slice_time = 0;
139 memset(&bs->io_base, 0, sizeof(bs->io_base));
142 static void bdrv_block_timer(void *opaque)
144 BlockDriverState *bs = opaque;
146 qemu_co_queue_next(&bs->throttled_reqs);
149 void bdrv_io_limits_enable(BlockDriverState *bs)
151 qemu_co_queue_init(&bs->throttled_reqs);
152 bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);
153 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
154 bs->slice_start = qemu_get_clock_ns(vm_clock);
155 bs->slice_end = bs->slice_start + bs->slice_time;
156 memset(&bs->io_base, 0, sizeof(bs->io_base));
157 bs->io_limits_enabled = true;
160 bool bdrv_io_limits_enabled(BlockDriverState *bs)
162 BlockIOLimit *io_limits = &bs->io_limits;
163 return io_limits->bps[BLOCK_IO_LIMIT_READ]
164 || io_limits->bps[BLOCK_IO_LIMIT_WRITE]
165 || io_limits->bps[BLOCK_IO_LIMIT_TOTAL]
166 || io_limits->iops[BLOCK_IO_LIMIT_READ]
167 || io_limits->iops[BLOCK_IO_LIMIT_WRITE]
168 || io_limits->iops[BLOCK_IO_LIMIT_TOTAL];
171 static void bdrv_io_limits_intercept(BlockDriverState *bs,
172 bool is_write, int nb_sectors)
174 int64_t wait_time = -1;
176 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
177 qemu_co_queue_wait(&bs->throttled_reqs);
180 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
181 * throttled requests will not be dequeued until the current request is
182 * allowed to be serviced. So if the current request still exceeds the
183 * limits, it will be inserted to the head. All requests followed it will
184 * be still in throttled_reqs queue.
187 while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {
188 qemu_mod_timer(bs->block_timer,
189 wait_time + qemu_get_clock_ns(vm_clock));
190 qemu_co_queue_wait_insert_head(&bs->throttled_reqs);
193 qemu_co_queue_next(&bs->throttled_reqs);
196 /* check if the path starts with "<protocol>:" */
197 static int path_has_protocol(const char *path)
199 #ifdef _WIN32
200 if (is_windows_drive(path) ||
201 is_windows_drive_prefix(path)) {
202 return 0;
204 #endif
206 return strchr(path, ':') != NULL;
209 int path_is_absolute(const char *path)
211 const char *p;
212 #ifdef _WIN32
213 /* specific case for names like: "\\.\d:" */
214 if (*path == '/' || *path == '\\')
215 return 1;
216 #endif
217 p = strchr(path, ':');
218 if (p)
219 p++;
220 else
221 p = path;
222 #ifdef _WIN32
223 return (*p == '/' || *p == '\\');
224 #else
225 return (*p == '/');
226 #endif
229 /* if filename is absolute, just copy it to dest. Otherwise, build a
230 path to it by considering it is relative to base_path. URL are
231 supported. */
232 void path_combine(char *dest, int dest_size,
233 const char *base_path,
234 const char *filename)
236 const char *p, *p1;
237 int len;
239 if (dest_size <= 0)
240 return;
241 if (path_is_absolute(filename)) {
242 pstrcpy(dest, dest_size, filename);
243 } else {
244 p = strchr(base_path, ':');
245 if (p)
246 p++;
247 else
248 p = base_path;
249 p1 = strrchr(base_path, '/');
250 #ifdef _WIN32
252 const char *p2;
253 p2 = strrchr(base_path, '\\');
254 if (!p1 || p2 > p1)
255 p1 = p2;
257 #endif
258 if (p1)
259 p1++;
260 else
261 p1 = base_path;
262 if (p1 > p)
263 p = p1;
264 len = p - base_path;
265 if (len > dest_size - 1)
266 len = dest_size - 1;
267 memcpy(dest, base_path, len);
268 dest[len] = '\0';
269 pstrcat(dest, dest_size, filename);
273 void bdrv_register(BlockDriver *bdrv)
275 /* Block drivers without coroutine functions need emulation */
276 if (!bdrv->bdrv_co_readv) {
277 bdrv->bdrv_co_readv = bdrv_co_readv_em;
278 bdrv->bdrv_co_writev = bdrv_co_writev_em;
280 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
281 * the block driver lacks aio we need to emulate that too.
283 if (!bdrv->bdrv_aio_readv) {
284 /* add AIO emulation layer */
285 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
286 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
290 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
293 /* create a new block device (by default it is empty) */
294 BlockDriverState *bdrv_new(const char *device_name)
296 BlockDriverState *bs;
298 bs = g_malloc0(sizeof(BlockDriverState));
299 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
300 if (device_name[0] != '\0') {
301 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
303 bdrv_iostatus_disable(bs);
304 return bs;
307 BlockDriver *bdrv_find_format(const char *format_name)
309 BlockDriver *drv1;
310 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
311 if (!strcmp(drv1->format_name, format_name)) {
312 return drv1;
315 return NULL;
318 static int bdrv_is_whitelisted(BlockDriver *drv)
320 static const char *whitelist[] = {
321 CONFIG_BDRV_WHITELIST
323 const char **p;
325 if (!whitelist[0])
326 return 1; /* no whitelist, anything goes */
328 for (p = whitelist; *p; p++) {
329 if (!strcmp(drv->format_name, *p)) {
330 return 1;
333 return 0;
336 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
338 BlockDriver *drv = bdrv_find_format(format_name);
339 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
342 int bdrv_create(BlockDriver *drv, const char* filename,
343 QEMUOptionParameter *options)
345 if (!drv->bdrv_create)
346 return -ENOTSUP;
348 return drv->bdrv_create(filename, options);
351 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
353 BlockDriver *drv;
355 drv = bdrv_find_protocol(filename);
356 if (drv == NULL) {
357 return -ENOENT;
360 return bdrv_create(drv, filename, options);
363 #ifdef _WIN32
364 void get_tmp_filename(char *filename, int size)
366 char temp_dir[MAX_PATH];
368 GetTempPath(MAX_PATH, temp_dir);
369 GetTempFileName(temp_dir, "qem", 0, filename);
371 #else
372 void get_tmp_filename(char *filename, int size)
374 int fd;
375 const char *tmpdir;
376 /* XXX: race condition possible */
377 tmpdir = getenv("TMPDIR");
378 if (!tmpdir)
379 tmpdir = "/tmp";
380 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
381 fd = mkstemp(filename);
382 close(fd);
384 #endif
387 * Detect host devices. By convention, /dev/cdrom[N] is always
388 * recognized as a host CDROM.
390 static BlockDriver *find_hdev_driver(const char *filename)
392 int score_max = 0, score;
393 BlockDriver *drv = NULL, *d;
395 QLIST_FOREACH(d, &bdrv_drivers, list) {
396 if (d->bdrv_probe_device) {
397 score = d->bdrv_probe_device(filename);
398 if (score > score_max) {
399 score_max = score;
400 drv = d;
405 return drv;
408 BlockDriver *bdrv_find_protocol(const char *filename)
410 BlockDriver *drv1;
411 char protocol[128];
412 int len;
413 const char *p;
415 /* TODO Drivers without bdrv_file_open must be specified explicitly */
418 * XXX(hch): we really should not let host device detection
419 * override an explicit protocol specification, but moving this
420 * later breaks access to device names with colons in them.
421 * Thanks to the brain-dead persistent naming schemes on udev-
422 * based Linux systems those actually are quite common.
424 drv1 = find_hdev_driver(filename);
425 if (drv1) {
426 return drv1;
429 if (!path_has_protocol(filename)) {
430 return bdrv_find_format("file");
432 p = strchr(filename, ':');
433 assert(p != NULL);
434 len = p - filename;
435 if (len > sizeof(protocol) - 1)
436 len = sizeof(protocol) - 1;
437 memcpy(protocol, filename, len);
438 protocol[len] = '\0';
439 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
440 if (drv1->protocol_name &&
441 !strcmp(drv1->protocol_name, protocol)) {
442 return drv1;
445 return NULL;
448 static int find_image_format(const char *filename, BlockDriver **pdrv)
450 int ret, score, score_max;
451 BlockDriver *drv1, *drv;
452 uint8_t buf[2048];
453 BlockDriverState *bs;
455 ret = bdrv_file_open(&bs, filename, 0);
456 if (ret < 0) {
457 *pdrv = NULL;
458 return ret;
461 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
462 if (bs->sg || !bdrv_is_inserted(bs)) {
463 bdrv_delete(bs);
464 drv = bdrv_find_format("raw");
465 if (!drv) {
466 ret = -ENOENT;
468 *pdrv = drv;
469 return ret;
472 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
473 bdrv_delete(bs);
474 if (ret < 0) {
475 *pdrv = NULL;
476 return ret;
479 score_max = 0;
480 drv = NULL;
481 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
482 if (drv1->bdrv_probe) {
483 score = drv1->bdrv_probe(buf, ret, filename);
484 if (score > score_max) {
485 score_max = score;
486 drv = drv1;
490 if (!drv) {
491 ret = -ENOENT;
493 *pdrv = drv;
494 return ret;
498 * Set the current 'total_sectors' value
500 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
502 BlockDriver *drv = bs->drv;
504 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
505 if (bs->sg)
506 return 0;
508 /* query actual device if possible, otherwise just trust the hint */
509 if (drv->bdrv_getlength) {
510 int64_t length = drv->bdrv_getlength(bs);
511 if (length < 0) {
512 return length;
514 hint = length >> BDRV_SECTOR_BITS;
517 bs->total_sectors = hint;
518 return 0;
522 * Set open flags for a given cache mode
524 * Return 0 on success, -1 if the cache mode was invalid.
526 int bdrv_parse_cache_flags(const char *mode, int *flags)
528 *flags &= ~BDRV_O_CACHE_MASK;
530 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
531 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
532 } else if (!strcmp(mode, "directsync")) {
533 *flags |= BDRV_O_NOCACHE;
534 } else if (!strcmp(mode, "writeback")) {
535 *flags |= BDRV_O_CACHE_WB;
536 } else if (!strcmp(mode, "unsafe")) {
537 *flags |= BDRV_O_CACHE_WB;
538 *flags |= BDRV_O_NO_FLUSH;
539 } else if (!strcmp(mode, "writethrough")) {
540 /* this is the default */
541 } else {
542 return -1;
545 return 0;
549 * The copy-on-read flag is actually a reference count so multiple users may
550 * use the feature without worrying about clobbering its previous state.
551 * Copy-on-read stays enabled until all users have called to disable it.
553 void bdrv_enable_copy_on_read(BlockDriverState *bs)
555 bs->copy_on_read++;
558 void bdrv_disable_copy_on_read(BlockDriverState *bs)
560 assert(bs->copy_on_read > 0);
561 bs->copy_on_read--;
565 * Common part for opening disk images and files
567 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
568 int flags, BlockDriver *drv)
570 int ret, open_flags;
572 assert(drv != NULL);
574 trace_bdrv_open_common(bs, filename, flags, drv->format_name);
576 bs->file = NULL;
577 bs->total_sectors = 0;
578 bs->encrypted = 0;
579 bs->valid_key = 0;
580 bs->sg = 0;
581 bs->open_flags = flags;
582 bs->growable = 0;
583 bs->buffer_alignment = 512;
585 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
586 if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {
587 bdrv_enable_copy_on_read(bs);
590 pstrcpy(bs->filename, sizeof(bs->filename), filename);
591 bs->backing_file[0] = '\0';
593 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
594 return -ENOTSUP;
597 bs->drv = drv;
598 bs->opaque = g_malloc0(drv->instance_size);
600 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
603 * Clear flags that are internal to the block layer before opening the
604 * image.
606 open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
609 * Snapshots should be writable.
611 if (bs->is_temporary) {
612 open_flags |= BDRV_O_RDWR;
615 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
617 /* Open the image, either directly or using a protocol */
618 if (drv->bdrv_file_open) {
619 ret = drv->bdrv_file_open(bs, filename, open_flags);
620 } else {
621 ret = bdrv_file_open(&bs->file, filename, open_flags);
622 if (ret >= 0) {
623 ret = drv->bdrv_open(bs, open_flags);
627 if (ret < 0) {
628 goto free_and_fail;
631 ret = refresh_total_sectors(bs, bs->total_sectors);
632 if (ret < 0) {
633 goto free_and_fail;
636 #ifndef _WIN32
637 if (bs->is_temporary) {
638 unlink(filename);
640 #endif
641 return 0;
643 free_and_fail:
644 if (bs->file) {
645 bdrv_delete(bs->file);
646 bs->file = NULL;
648 g_free(bs->opaque);
649 bs->opaque = NULL;
650 bs->drv = NULL;
651 return ret;
655 * Opens a file using a protocol (file, host_device, nbd, ...)
657 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
659 BlockDriverState *bs;
660 BlockDriver *drv;
661 int ret;
663 drv = bdrv_find_protocol(filename);
664 if (!drv) {
665 return -ENOENT;
668 bs = bdrv_new("");
669 ret = bdrv_open_common(bs, filename, flags, drv);
670 if (ret < 0) {
671 bdrv_delete(bs);
672 return ret;
674 bs->growable = 1;
675 *pbs = bs;
676 return 0;
680 * Opens a disk image (raw, qcow2, vmdk, ...)
682 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
683 BlockDriver *drv)
685 int ret;
686 char tmp_filename[PATH_MAX];
688 if (flags & BDRV_O_SNAPSHOT) {
689 BlockDriverState *bs1;
690 int64_t total_size;
691 int is_protocol = 0;
692 BlockDriver *bdrv_qcow2;
693 QEMUOptionParameter *options;
694 char backing_filename[PATH_MAX];
696 /* if snapshot, we create a temporary backing file and open it
697 instead of opening 'filename' directly */
699 /* if there is a backing file, use it */
700 bs1 = bdrv_new("");
701 ret = bdrv_open(bs1, filename, 0, drv);
702 if (ret < 0) {
703 bdrv_delete(bs1);
704 return ret;
706 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
708 if (bs1->drv && bs1->drv->protocol_name)
709 is_protocol = 1;
711 bdrv_delete(bs1);
713 get_tmp_filename(tmp_filename, sizeof(tmp_filename));
715 /* Real path is meaningless for protocols */
716 if (is_protocol)
717 snprintf(backing_filename, sizeof(backing_filename),
718 "%s", filename);
719 else if (!realpath(filename, backing_filename))
720 return -errno;
722 bdrv_qcow2 = bdrv_find_format("qcow2");
723 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
725 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
726 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
727 if (drv) {
728 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
729 drv->format_name);
732 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
733 free_option_parameters(options);
734 if (ret < 0) {
735 return ret;
738 filename = tmp_filename;
739 drv = bdrv_qcow2;
740 bs->is_temporary = 1;
743 /* Find the right image format driver */
744 if (!drv) {
745 ret = find_image_format(filename, &drv);
748 if (!drv) {
749 goto unlink_and_fail;
752 /* Open the image */
753 ret = bdrv_open_common(bs, filename, flags, drv);
754 if (ret < 0) {
755 goto unlink_and_fail;
758 /* If there is a backing file, use it */
759 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
760 char backing_filename[PATH_MAX];
761 int back_flags;
762 BlockDriver *back_drv = NULL;
764 bs->backing_hd = bdrv_new("");
766 if (path_has_protocol(bs->backing_file)) {
767 pstrcpy(backing_filename, sizeof(backing_filename),
768 bs->backing_file);
769 } else {
770 path_combine(backing_filename, sizeof(backing_filename),
771 filename, bs->backing_file);
774 if (bs->backing_format[0] != '\0') {
775 back_drv = bdrv_find_format(bs->backing_format);
778 /* backing files always opened read-only */
779 back_flags =
780 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
782 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
783 if (ret < 0) {
784 bdrv_close(bs);
785 return ret;
787 if (bs->is_temporary) {
788 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
789 } else {
790 /* base image inherits from "parent" */
791 bs->backing_hd->keep_read_only = bs->keep_read_only;
795 if (!bdrv_key_required(bs)) {
796 bdrv_dev_change_media_cb(bs, true);
799 /* throttling disk I/O limits */
800 if (bs->io_limits_enabled) {
801 bdrv_io_limits_enable(bs);
804 return 0;
806 unlink_and_fail:
807 if (bs->is_temporary) {
808 unlink(filename);
810 return ret;
813 void bdrv_close(BlockDriverState *bs)
815 if (bs->drv) {
816 if (bs == bs_snapshots) {
817 bs_snapshots = NULL;
819 if (bs->backing_hd) {
820 bdrv_delete(bs->backing_hd);
821 bs->backing_hd = NULL;
823 bs->drv->bdrv_close(bs);
824 g_free(bs->opaque);
825 #ifdef _WIN32
826 if (bs->is_temporary) {
827 unlink(bs->filename);
829 #endif
830 bs->opaque = NULL;
831 bs->drv = NULL;
832 bs->copy_on_read = 0;
834 if (bs->file != NULL) {
835 bdrv_close(bs->file);
838 bdrv_dev_change_media_cb(bs, false);
841 /*throttling disk I/O limits*/
842 if (bs->io_limits_enabled) {
843 bdrv_io_limits_disable(bs);
847 void bdrv_close_all(void)
849 BlockDriverState *bs;
851 QTAILQ_FOREACH(bs, &bdrv_states, list) {
852 bdrv_close(bs);
857 * Wait for pending requests to complete across all BlockDriverStates
859 * This function does not flush data to disk, use bdrv_flush_all() for that
860 * after calling this function.
862 void bdrv_drain_all(void)
864 BlockDriverState *bs;
866 qemu_aio_flush();
868 /* If requests are still pending there is a bug somewhere */
869 QTAILQ_FOREACH(bs, &bdrv_states, list) {
870 assert(QLIST_EMPTY(&bs->tracked_requests));
871 assert(qemu_co_queue_empty(&bs->throttled_reqs));
875 /* make a BlockDriverState anonymous by removing from bdrv_state list.
876 Also, NULL terminate the device_name to prevent double remove */
877 void bdrv_make_anon(BlockDriverState *bs)
879 if (bs->device_name[0] != '\0') {
880 QTAILQ_REMOVE(&bdrv_states, bs, list);
882 bs->device_name[0] = '\0';
886 * Add new bs contents at the top of an image chain while the chain is
887 * live, while keeping required fields on the top layer.
889 * This will modify the BlockDriverState fields, and swap contents
890 * between bs_new and bs_top. Both bs_new and bs_top are modified.
892 * This function does not create any image files.
894 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
896 BlockDriverState tmp;
898 /* the new bs must not be in bdrv_states */
899 bdrv_make_anon(bs_new);
901 tmp = *bs_new;
903 /* there are some fields that need to stay on the top layer: */
905 /* dev info */
906 tmp.dev_ops = bs_top->dev_ops;
907 tmp.dev_opaque = bs_top->dev_opaque;
908 tmp.dev = bs_top->dev;
909 tmp.buffer_alignment = bs_top->buffer_alignment;
910 tmp.copy_on_read = bs_top->copy_on_read;
912 /* i/o timing parameters */
913 tmp.slice_time = bs_top->slice_time;
914 tmp.slice_start = bs_top->slice_start;
915 tmp.slice_end = bs_top->slice_end;
916 tmp.io_limits = bs_top->io_limits;
917 tmp.io_base = bs_top->io_base;
918 tmp.throttled_reqs = bs_top->throttled_reqs;
919 tmp.block_timer = bs_top->block_timer;
920 tmp.io_limits_enabled = bs_top->io_limits_enabled;
922 /* geometry */
923 tmp.cyls = bs_top->cyls;
924 tmp.heads = bs_top->heads;
925 tmp.secs = bs_top->secs;
926 tmp.translation = bs_top->translation;
928 /* r/w error */
929 tmp.on_read_error = bs_top->on_read_error;
930 tmp.on_write_error = bs_top->on_write_error;
932 /* i/o status */
933 tmp.iostatus_enabled = bs_top->iostatus_enabled;
934 tmp.iostatus = bs_top->iostatus;
936 /* keep the same entry in bdrv_states */
937 pstrcpy(tmp.device_name, sizeof(tmp.device_name), bs_top->device_name);
938 tmp.list = bs_top->list;
940 /* The contents of 'tmp' will become bs_top, as we are
941 * swapping bs_new and bs_top contents. */
942 tmp.backing_hd = bs_new;
943 pstrcpy(tmp.backing_file, sizeof(tmp.backing_file), bs_top->filename);
945 /* swap contents of the fixed new bs and the current top */
946 *bs_new = *bs_top;
947 *bs_top = tmp;
949 /* clear the copied fields in the new backing file */
950 bdrv_detach_dev(bs_new, bs_new->dev);
952 qemu_co_queue_init(&bs_new->throttled_reqs);
953 memset(&bs_new->io_base, 0, sizeof(bs_new->io_base));
954 memset(&bs_new->io_limits, 0, sizeof(bs_new->io_limits));
955 bdrv_iostatus_disable(bs_new);
957 /* we don't use bdrv_io_limits_disable() for this, because we don't want
958 * to affect or delete the block_timer, as it has been moved to bs_top */
959 bs_new->io_limits_enabled = false;
960 bs_new->block_timer = NULL;
961 bs_new->slice_time = 0;
962 bs_new->slice_start = 0;
963 bs_new->slice_end = 0;
966 void bdrv_delete(BlockDriverState *bs)
968 assert(!bs->dev);
970 /* remove from list, if necessary */
971 bdrv_make_anon(bs);
973 bdrv_close(bs);
974 if (bs->file != NULL) {
975 bdrv_delete(bs->file);
978 assert(bs != bs_snapshots);
979 g_free(bs);
982 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
983 /* TODO change to DeviceState *dev when all users are qdevified */
985 if (bs->dev) {
986 return -EBUSY;
988 bs->dev = dev;
989 bdrv_iostatus_reset(bs);
990 return 0;
993 /* TODO qdevified devices don't use this, remove when devices are qdevified */
994 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
996 if (bdrv_attach_dev(bs, dev) < 0) {
997 abort();
1001 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1002 /* TODO change to DeviceState *dev when all users are qdevified */
1004 assert(bs->dev == dev);
1005 bs->dev = NULL;
1006 bs->dev_ops = NULL;
1007 bs->dev_opaque = NULL;
1008 bs->buffer_alignment = 512;
1011 /* TODO change to return DeviceState * when all users are qdevified */
1012 void *bdrv_get_attached_dev(BlockDriverState *bs)
1014 return bs->dev;
1017 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1018 void *opaque)
1020 bs->dev_ops = ops;
1021 bs->dev_opaque = opaque;
1022 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
1023 bs_snapshots = NULL;
1027 void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1028 BlockQMPEventAction action, int is_read)
1030 QObject *data;
1031 const char *action_str;
1033 switch (action) {
1034 case BDRV_ACTION_REPORT:
1035 action_str = "report";
1036 break;
1037 case BDRV_ACTION_IGNORE:
1038 action_str = "ignore";
1039 break;
1040 case BDRV_ACTION_STOP:
1041 action_str = "stop";
1042 break;
1043 default:
1044 abort();
1047 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1048 bdrv->device_name,
1049 action_str,
1050 is_read ? "read" : "write");
1051 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1053 qobject_decref(data);
1056 static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1058 QObject *data;
1060 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1061 bdrv_get_device_name(bs), ejected);
1062 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1064 qobject_decref(data);
1067 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
1069 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
1070 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
1071 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
1072 if (tray_was_closed) {
1073 /* tray open */
1074 bdrv_emit_qmp_eject_event(bs, true);
1076 if (load) {
1077 /* tray close */
1078 bdrv_emit_qmp_eject_event(bs, false);
1083 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1085 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1088 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1090 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1091 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1095 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1097 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1098 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1100 return false;
1103 static void bdrv_dev_resize_cb(BlockDriverState *bs)
1105 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1106 bs->dev_ops->resize_cb(bs->dev_opaque);
1110 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1112 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1113 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1115 return false;
1119 * Run consistency checks on an image
1121 * Returns 0 if the check could be completed (it doesn't mean that the image is
1122 * free of errors) or -errno when an internal error occurred. The results of the
1123 * check are stored in res.
1125 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
1127 if (bs->drv->bdrv_check == NULL) {
1128 return -ENOTSUP;
1131 memset(res, 0, sizeof(*res));
1132 return bs->drv->bdrv_check(bs, res);
1135 #define COMMIT_BUF_SECTORS 2048
1137 /* commit COW file into the raw image */
1138 int bdrv_commit(BlockDriverState *bs)
1140 BlockDriver *drv = bs->drv;
1141 BlockDriver *backing_drv;
1142 int64_t sector, total_sectors;
1143 int n, ro, open_flags;
1144 int ret = 0, rw_ret = 0;
1145 uint8_t *buf;
1146 char filename[1024];
1147 BlockDriverState *bs_rw, *bs_ro;
1149 if (!drv)
1150 return -ENOMEDIUM;
1152 if (!bs->backing_hd) {
1153 return -ENOTSUP;
1156 if (bs->backing_hd->keep_read_only) {
1157 return -EACCES;
1160 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1161 return -EBUSY;
1164 backing_drv = bs->backing_hd->drv;
1165 ro = bs->backing_hd->read_only;
1166 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
1167 open_flags = bs->backing_hd->open_flags;
1169 if (ro) {
1170 /* re-open as RW */
1171 bdrv_delete(bs->backing_hd);
1172 bs->backing_hd = NULL;
1173 bs_rw = bdrv_new("");
1174 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
1175 backing_drv);
1176 if (rw_ret < 0) {
1177 bdrv_delete(bs_rw);
1178 /* try to re-open read-only */
1179 bs_ro = bdrv_new("");
1180 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
1181 backing_drv);
1182 if (ret < 0) {
1183 bdrv_delete(bs_ro);
1184 /* drive not functional anymore */
1185 bs->drv = NULL;
1186 return ret;
1188 bs->backing_hd = bs_ro;
1189 return rw_ret;
1191 bs->backing_hd = bs_rw;
1194 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1195 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
1197 for (sector = 0; sector < total_sectors; sector += n) {
1198 if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
1200 if (bdrv_read(bs, sector, buf, n) != 0) {
1201 ret = -EIO;
1202 goto ro_cleanup;
1205 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1206 ret = -EIO;
1207 goto ro_cleanup;
1212 if (drv->bdrv_make_empty) {
1213 ret = drv->bdrv_make_empty(bs);
1214 bdrv_flush(bs);
1218 * Make sure all data we wrote to the backing device is actually
1219 * stable on disk.
1221 if (bs->backing_hd)
1222 bdrv_flush(bs->backing_hd);
1224 ro_cleanup:
1225 g_free(buf);
1227 if (ro) {
1228 /* re-open as RO */
1229 bdrv_delete(bs->backing_hd);
1230 bs->backing_hd = NULL;
1231 bs_ro = bdrv_new("");
1232 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
1233 backing_drv);
1234 if (ret < 0) {
1235 bdrv_delete(bs_ro);
1236 /* drive not functional anymore */
1237 bs->drv = NULL;
1238 return ret;
1240 bs->backing_hd = bs_ro;
1241 bs->backing_hd->keep_read_only = 0;
1244 return ret;
1247 void bdrv_commit_all(void)
1249 BlockDriverState *bs;
1251 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1252 bdrv_commit(bs);
1256 struct BdrvTrackedRequest {
1257 BlockDriverState *bs;
1258 int64_t sector_num;
1259 int nb_sectors;
1260 bool is_write;
1261 QLIST_ENTRY(BdrvTrackedRequest) list;
1262 Coroutine *co; /* owner, used for deadlock detection */
1263 CoQueue wait_queue; /* coroutines blocked on this request */
1267 * Remove an active request from the tracked requests list
1269 * This function should be called when a tracked request is completing.
1271 static void tracked_request_end(BdrvTrackedRequest *req)
1273 QLIST_REMOVE(req, list);
1274 qemu_co_queue_restart_all(&req->wait_queue);
1278 * Add an active request to the tracked requests list
1280 static void tracked_request_begin(BdrvTrackedRequest *req,
1281 BlockDriverState *bs,
1282 int64_t sector_num,
1283 int nb_sectors, bool is_write)
1285 *req = (BdrvTrackedRequest){
1286 .bs = bs,
1287 .sector_num = sector_num,
1288 .nb_sectors = nb_sectors,
1289 .is_write = is_write,
1290 .co = qemu_coroutine_self(),
1293 qemu_co_queue_init(&req->wait_queue);
1295 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
1299 * Round a region to cluster boundaries
1301 static void round_to_clusters(BlockDriverState *bs,
1302 int64_t sector_num, int nb_sectors,
1303 int64_t *cluster_sector_num,
1304 int *cluster_nb_sectors)
1306 BlockDriverInfo bdi;
1308 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
1309 *cluster_sector_num = sector_num;
1310 *cluster_nb_sectors = nb_sectors;
1311 } else {
1312 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
1313 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
1314 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
1315 nb_sectors, c);
1319 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
1320 int64_t sector_num, int nb_sectors) {
1321 /* aaaa bbbb */
1322 if (sector_num >= req->sector_num + req->nb_sectors) {
1323 return false;
1325 /* bbbb aaaa */
1326 if (req->sector_num >= sector_num + nb_sectors) {
1327 return false;
1329 return true;
1332 static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
1333 int64_t sector_num, int nb_sectors)
1335 BdrvTrackedRequest *req;
1336 int64_t cluster_sector_num;
1337 int cluster_nb_sectors;
1338 bool retry;
1340 /* If we touch the same cluster it counts as an overlap. This guarantees
1341 * that allocating writes will be serialized and not race with each other
1342 * for the same cluster. For example, in copy-on-read it ensures that the
1343 * CoR read and write operations are atomic and guest writes cannot
1344 * interleave between them.
1346 round_to_clusters(bs, sector_num, nb_sectors,
1347 &cluster_sector_num, &cluster_nb_sectors);
1349 do {
1350 retry = false;
1351 QLIST_FOREACH(req, &bs->tracked_requests, list) {
1352 if (tracked_request_overlaps(req, cluster_sector_num,
1353 cluster_nb_sectors)) {
1354 /* Hitting this means there was a reentrant request, for
1355 * example, a block driver issuing nested requests. This must
1356 * never happen since it means deadlock.
1358 assert(qemu_coroutine_self() != req->co);
1360 qemu_co_queue_wait(&req->wait_queue);
1361 retry = true;
1362 break;
1365 } while (retry);
1369 * Return values:
1370 * 0 - success
1371 * -EINVAL - backing format specified, but no file
1372 * -ENOSPC - can't update the backing file because no space is left in the
1373 * image file header
1374 * -ENOTSUP - format driver doesn't support changing the backing file
1376 int bdrv_change_backing_file(BlockDriverState *bs,
1377 const char *backing_file, const char *backing_fmt)
1379 BlockDriver *drv = bs->drv;
1381 if (drv->bdrv_change_backing_file != NULL) {
1382 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
1383 } else {
1384 return -ENOTSUP;
1388 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
1389 size_t size)
1391 int64_t len;
1393 if (!bdrv_is_inserted(bs))
1394 return -ENOMEDIUM;
1396 if (bs->growable)
1397 return 0;
1399 len = bdrv_getlength(bs);
1401 if (offset < 0)
1402 return -EIO;
1404 if ((offset > len) || (len - offset < size))
1405 return -EIO;
1407 return 0;
1410 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
1411 int nb_sectors)
1413 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
1414 nb_sectors * BDRV_SECTOR_SIZE);
1417 typedef struct RwCo {
1418 BlockDriverState *bs;
1419 int64_t sector_num;
1420 int nb_sectors;
1421 QEMUIOVector *qiov;
1422 bool is_write;
1423 int ret;
1424 } RwCo;
1426 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
1428 RwCo *rwco = opaque;
1430 if (!rwco->is_write) {
1431 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
1432 rwco->nb_sectors, rwco->qiov, 0);
1433 } else {
1434 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
1435 rwco->nb_sectors, rwco->qiov, 0);
1440 * Process a synchronous request using coroutines
1442 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
1443 int nb_sectors, bool is_write)
1445 QEMUIOVector qiov;
1446 struct iovec iov = {
1447 .iov_base = (void *)buf,
1448 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1450 Coroutine *co;
1451 RwCo rwco = {
1452 .bs = bs,
1453 .sector_num = sector_num,
1454 .nb_sectors = nb_sectors,
1455 .qiov = &qiov,
1456 .is_write = is_write,
1457 .ret = NOT_DONE,
1460 qemu_iovec_init_external(&qiov, &iov, 1);
1462 if (qemu_in_coroutine()) {
1463 /* Fast-path if already in coroutine context */
1464 bdrv_rw_co_entry(&rwco);
1465 } else {
1466 co = qemu_coroutine_create(bdrv_rw_co_entry);
1467 qemu_coroutine_enter(co, &rwco);
1468 while (rwco.ret == NOT_DONE) {
1469 qemu_aio_wait();
1472 return rwco.ret;
1475 /* return < 0 if error. See bdrv_write() for the return codes */
1476 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
1477 uint8_t *buf, int nb_sectors)
1479 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
1482 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
1483 int nb_sectors, int dirty)
1485 int64_t start, end;
1486 unsigned long val, idx, bit;
1488 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
1489 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
1491 for (; start <= end; start++) {
1492 idx = start / (sizeof(unsigned long) * 8);
1493 bit = start % (sizeof(unsigned long) * 8);
1494 val = bs->dirty_bitmap[idx];
1495 if (dirty) {
1496 if (!(val & (1UL << bit))) {
1497 bs->dirty_count++;
1498 val |= 1UL << bit;
1500 } else {
1501 if (val & (1UL << bit)) {
1502 bs->dirty_count--;
1503 val &= ~(1UL << bit);
1506 bs->dirty_bitmap[idx] = val;
1510 /* Return < 0 if error. Important errors are:
1511 -EIO generic I/O error (may happen for all errors)
1512 -ENOMEDIUM No media inserted.
1513 -EINVAL Invalid sector number or nb_sectors
1514 -EACCES Trying to write a read-only device
1516 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
1517 const uint8_t *buf, int nb_sectors)
1519 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
1522 int bdrv_pread(BlockDriverState *bs, int64_t offset,
1523 void *buf, int count1)
1525 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1526 int len, nb_sectors, count;
1527 int64_t sector_num;
1528 int ret;
1530 count = count1;
1531 /* first read to align to sector start */
1532 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1533 if (len > count)
1534 len = count;
1535 sector_num = offset >> BDRV_SECTOR_BITS;
1536 if (len > 0) {
1537 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1538 return ret;
1539 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
1540 count -= len;
1541 if (count == 0)
1542 return count1;
1543 sector_num++;
1544 buf += len;
1547 /* read the sectors "in place" */
1548 nb_sectors = count >> BDRV_SECTOR_BITS;
1549 if (nb_sectors > 0) {
1550 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1551 return ret;
1552 sector_num += nb_sectors;
1553 len = nb_sectors << BDRV_SECTOR_BITS;
1554 buf += len;
1555 count -= len;
1558 /* add data from the last sector */
1559 if (count > 0) {
1560 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1561 return ret;
1562 memcpy(buf, tmp_buf, count);
1564 return count1;
1567 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1568 const void *buf, int count1)
1570 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1571 int len, nb_sectors, count;
1572 int64_t sector_num;
1573 int ret;
1575 count = count1;
1576 /* first write to align to sector start */
1577 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1578 if (len > count)
1579 len = count;
1580 sector_num = offset >> BDRV_SECTOR_BITS;
1581 if (len > 0) {
1582 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1583 return ret;
1584 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1585 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1586 return ret;
1587 count -= len;
1588 if (count == 0)
1589 return count1;
1590 sector_num++;
1591 buf += len;
1594 /* write the sectors "in place" */
1595 nb_sectors = count >> BDRV_SECTOR_BITS;
1596 if (nb_sectors > 0) {
1597 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1598 return ret;
1599 sector_num += nb_sectors;
1600 len = nb_sectors << BDRV_SECTOR_BITS;
1601 buf += len;
1602 count -= len;
1605 /* add data from the last sector */
1606 if (count > 0) {
1607 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1608 return ret;
1609 memcpy(tmp_buf, buf, count);
1610 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1611 return ret;
1613 return count1;
1617 * Writes to the file and ensures that no writes are reordered across this
1618 * request (acts as a barrier)
1620 * Returns 0 on success, -errno in error cases.
1622 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1623 const void *buf, int count)
1625 int ret;
1627 ret = bdrv_pwrite(bs, offset, buf, count);
1628 if (ret < 0) {
1629 return ret;
1632 /* No flush needed for cache modes that use O_DSYNC */
1633 if ((bs->open_flags & BDRV_O_CACHE_WB) != 0) {
1634 bdrv_flush(bs);
1637 return 0;
1640 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
1641 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1643 /* Perform I/O through a temporary buffer so that users who scribble over
1644 * their read buffer while the operation is in progress do not end up
1645 * modifying the image file. This is critical for zero-copy guest I/O
1646 * where anything might happen inside guest memory.
1648 void *bounce_buffer;
1650 BlockDriver *drv = bs->drv;
1651 struct iovec iov;
1652 QEMUIOVector bounce_qiov;
1653 int64_t cluster_sector_num;
1654 int cluster_nb_sectors;
1655 size_t skip_bytes;
1656 int ret;
1658 /* Cover entire cluster so no additional backing file I/O is required when
1659 * allocating cluster in the image file.
1661 round_to_clusters(bs, sector_num, nb_sectors,
1662 &cluster_sector_num, &cluster_nb_sectors);
1664 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
1665 cluster_sector_num, cluster_nb_sectors);
1667 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
1668 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
1669 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
1671 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
1672 &bounce_qiov);
1673 if (ret < 0) {
1674 goto err;
1677 if (drv->bdrv_co_write_zeroes &&
1678 buffer_is_zero(bounce_buffer, iov.iov_len)) {
1679 ret = drv->bdrv_co_write_zeroes(bs, cluster_sector_num,
1680 cluster_nb_sectors);
1681 } else {
1682 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
1683 &bounce_qiov);
1686 if (ret < 0) {
1687 /* It might be okay to ignore write errors for guest requests. If this
1688 * is a deliberate copy-on-read then we don't want to ignore the error.
1689 * Simply report it in all cases.
1691 goto err;
1694 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
1695 qemu_iovec_from_buffer(qiov, bounce_buffer + skip_bytes,
1696 nb_sectors * BDRV_SECTOR_SIZE);
1698 err:
1699 qemu_vfree(bounce_buffer);
1700 return ret;
1704 * Handle a read request in coroutine context
1706 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
1707 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
1708 BdrvRequestFlags flags)
1710 BlockDriver *drv = bs->drv;
1711 BdrvTrackedRequest req;
1712 int ret;
1714 if (!drv) {
1715 return -ENOMEDIUM;
1717 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1718 return -EIO;
1721 /* throttling disk read I/O */
1722 if (bs->io_limits_enabled) {
1723 bdrv_io_limits_intercept(bs, false, nb_sectors);
1726 if (bs->copy_on_read) {
1727 flags |= BDRV_REQ_COPY_ON_READ;
1729 if (flags & BDRV_REQ_COPY_ON_READ) {
1730 bs->copy_on_read_in_flight++;
1733 if (bs->copy_on_read_in_flight) {
1734 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
1737 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
1739 if (flags & BDRV_REQ_COPY_ON_READ) {
1740 int pnum;
1742 ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum);
1743 if (ret < 0) {
1744 goto out;
1747 if (!ret || pnum != nb_sectors) {
1748 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
1749 goto out;
1753 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
1755 out:
1756 tracked_request_end(&req);
1758 if (flags & BDRV_REQ_COPY_ON_READ) {
1759 bs->copy_on_read_in_flight--;
1762 return ret;
1765 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
1766 int nb_sectors, QEMUIOVector *qiov)
1768 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
1770 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
1773 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
1774 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1776 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
1778 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
1779 BDRV_REQ_COPY_ON_READ);
1782 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
1783 int64_t sector_num, int nb_sectors)
1785 BlockDriver *drv = bs->drv;
1786 QEMUIOVector qiov;
1787 struct iovec iov;
1788 int ret;
1790 /* First try the efficient write zeroes operation */
1791 if (drv->bdrv_co_write_zeroes) {
1792 return drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
1795 /* Fall back to bounce buffer if write zeroes is unsupported */
1796 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
1797 iov.iov_base = qemu_blockalign(bs, iov.iov_len);
1798 memset(iov.iov_base, 0, iov.iov_len);
1799 qemu_iovec_init_external(&qiov, &iov, 1);
1801 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
1803 qemu_vfree(iov.iov_base);
1804 return ret;
1808 * Handle a write request in coroutine context
1810 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
1811 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
1812 BdrvRequestFlags flags)
1814 BlockDriver *drv = bs->drv;
1815 BdrvTrackedRequest req;
1816 int ret;
1818 if (!bs->drv) {
1819 return -ENOMEDIUM;
1821 if (bs->read_only) {
1822 return -EACCES;
1824 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1825 return -EIO;
1828 /* throttling disk write I/O */
1829 if (bs->io_limits_enabled) {
1830 bdrv_io_limits_intercept(bs, true, nb_sectors);
1833 if (bs->copy_on_read_in_flight) {
1834 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
1837 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
1839 if (flags & BDRV_REQ_ZERO_WRITE) {
1840 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors);
1841 } else {
1842 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
1845 if (bs->dirty_bitmap) {
1846 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1849 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
1850 bs->wr_highest_sector = sector_num + nb_sectors - 1;
1853 tracked_request_end(&req);
1855 return ret;
1858 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
1859 int nb_sectors, QEMUIOVector *qiov)
1861 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
1863 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
1866 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
1867 int64_t sector_num, int nb_sectors)
1869 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
1871 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
1872 BDRV_REQ_ZERO_WRITE);
1876 * Truncate file to 'offset' bytes (needed only for file protocols)
1878 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1880 BlockDriver *drv = bs->drv;
1881 int ret;
1882 if (!drv)
1883 return -ENOMEDIUM;
1884 if (!drv->bdrv_truncate)
1885 return -ENOTSUP;
1886 if (bs->read_only)
1887 return -EACCES;
1888 if (bdrv_in_use(bs))
1889 return -EBUSY;
1890 ret = drv->bdrv_truncate(bs, offset);
1891 if (ret == 0) {
1892 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1893 bdrv_dev_resize_cb(bs);
1895 return ret;
1899 * Length of a allocated file in bytes. Sparse files are counted by actual
1900 * allocated space. Return < 0 if error or unknown.
1902 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
1904 BlockDriver *drv = bs->drv;
1905 if (!drv) {
1906 return -ENOMEDIUM;
1908 if (drv->bdrv_get_allocated_file_size) {
1909 return drv->bdrv_get_allocated_file_size(bs);
1911 if (bs->file) {
1912 return bdrv_get_allocated_file_size(bs->file);
1914 return -ENOTSUP;
1918 * Length of a file in bytes. Return < 0 if error or unknown.
1920 int64_t bdrv_getlength(BlockDriverState *bs)
1922 BlockDriver *drv = bs->drv;
1923 if (!drv)
1924 return -ENOMEDIUM;
1926 if (bs->growable || bdrv_dev_has_removable_media(bs)) {
1927 if (drv->bdrv_getlength) {
1928 return drv->bdrv_getlength(bs);
1931 return bs->total_sectors * BDRV_SECTOR_SIZE;
1934 /* return 0 as number of sectors if no device present or error */
1935 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1937 int64_t length;
1938 length = bdrv_getlength(bs);
1939 if (length < 0)
1940 length = 0;
1941 else
1942 length = length >> BDRV_SECTOR_BITS;
1943 *nb_sectors_ptr = length;
1946 struct partition {
1947 uint8_t boot_ind; /* 0x80 - active */
1948 uint8_t head; /* starting head */
1949 uint8_t sector; /* starting sector */
1950 uint8_t cyl; /* starting cylinder */
1951 uint8_t sys_ind; /* What partition type */
1952 uint8_t end_head; /* end head */
1953 uint8_t end_sector; /* end sector */
1954 uint8_t end_cyl; /* end cylinder */
1955 uint32_t start_sect; /* starting sector counting from 0 */
1956 uint32_t nr_sects; /* nr of sectors in partition */
1957 } QEMU_PACKED;
1959 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1960 static int guess_disk_lchs(BlockDriverState *bs,
1961 int *pcylinders, int *pheads, int *psectors)
1963 uint8_t buf[BDRV_SECTOR_SIZE];
1964 int ret, i, heads, sectors, cylinders;
1965 struct partition *p;
1966 uint32_t nr_sects;
1967 uint64_t nb_sectors;
1969 bdrv_get_geometry(bs, &nb_sectors);
1971 ret = bdrv_read(bs, 0, buf, 1);
1972 if (ret < 0)
1973 return -1;
1974 /* test msdos magic */
1975 if (buf[510] != 0x55 || buf[511] != 0xaa)
1976 return -1;
1977 for(i = 0; i < 4; i++) {
1978 p = ((struct partition *)(buf + 0x1be)) + i;
1979 nr_sects = le32_to_cpu(p->nr_sects);
1980 if (nr_sects && p->end_head) {
1981 /* We make the assumption that the partition terminates on
1982 a cylinder boundary */
1983 heads = p->end_head + 1;
1984 sectors = p->end_sector & 63;
1985 if (sectors == 0)
1986 continue;
1987 cylinders = nb_sectors / (heads * sectors);
1988 if (cylinders < 1 || cylinders > 16383)
1989 continue;
1990 *pheads = heads;
1991 *psectors = sectors;
1992 *pcylinders = cylinders;
1993 #if 0
1994 printf("guessed geometry: LCHS=%d %d %d\n",
1995 cylinders, heads, sectors);
1996 #endif
1997 return 0;
2000 return -1;
2003 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
2005 int translation, lba_detected = 0;
2006 int cylinders, heads, secs;
2007 uint64_t nb_sectors;
2009 /* if a geometry hint is available, use it */
2010 bdrv_get_geometry(bs, &nb_sectors);
2011 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
2012 translation = bdrv_get_translation_hint(bs);
2013 if (cylinders != 0) {
2014 *pcyls = cylinders;
2015 *pheads = heads;
2016 *psecs = secs;
2017 } else {
2018 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
2019 if (heads > 16) {
2020 /* if heads > 16, it means that a BIOS LBA
2021 translation was active, so the default
2022 hardware geometry is OK */
2023 lba_detected = 1;
2024 goto default_geometry;
2025 } else {
2026 *pcyls = cylinders;
2027 *pheads = heads;
2028 *psecs = secs;
2029 /* disable any translation to be in sync with
2030 the logical geometry */
2031 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
2032 bdrv_set_translation_hint(bs,
2033 BIOS_ATA_TRANSLATION_NONE);
2036 } else {
2037 default_geometry:
2038 /* if no geometry, use a standard physical disk geometry */
2039 cylinders = nb_sectors / (16 * 63);
2041 if (cylinders > 16383)
2042 cylinders = 16383;
2043 else if (cylinders < 2)
2044 cylinders = 2;
2045 *pcyls = cylinders;
2046 *pheads = 16;
2047 *psecs = 63;
2048 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
2049 if ((*pcyls * *pheads) <= 131072) {
2050 bdrv_set_translation_hint(bs,
2051 BIOS_ATA_TRANSLATION_LARGE);
2052 } else {
2053 bdrv_set_translation_hint(bs,
2054 BIOS_ATA_TRANSLATION_LBA);
2058 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
2062 void bdrv_set_geometry_hint(BlockDriverState *bs,
2063 int cyls, int heads, int secs)
2065 bs->cyls = cyls;
2066 bs->heads = heads;
2067 bs->secs = secs;
2070 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
2072 bs->translation = translation;
2075 void bdrv_get_geometry_hint(BlockDriverState *bs,
2076 int *pcyls, int *pheads, int *psecs)
2078 *pcyls = bs->cyls;
2079 *pheads = bs->heads;
2080 *psecs = bs->secs;
2083 /* throttling disk io limits */
2084 void bdrv_set_io_limits(BlockDriverState *bs,
2085 BlockIOLimit *io_limits)
2087 bs->io_limits = *io_limits;
2088 bs->io_limits_enabled = bdrv_io_limits_enabled(bs);
2091 /* Recognize floppy formats */
2092 typedef struct FDFormat {
2093 FDriveType drive;
2094 uint8_t last_sect;
2095 uint8_t max_track;
2096 uint8_t max_head;
2097 FDriveRate rate;
2098 } FDFormat;
2100 static const FDFormat fd_formats[] = {
2101 /* First entry is default format */
2102 /* 1.44 MB 3"1/2 floppy disks */
2103 { FDRIVE_DRV_144, 18, 80, 1, FDRIVE_RATE_500K, },
2104 { FDRIVE_DRV_144, 20, 80, 1, FDRIVE_RATE_500K, },
2105 { FDRIVE_DRV_144, 21, 80, 1, FDRIVE_RATE_500K, },
2106 { FDRIVE_DRV_144, 21, 82, 1, FDRIVE_RATE_500K, },
2107 { FDRIVE_DRV_144, 21, 83, 1, FDRIVE_RATE_500K, },
2108 { FDRIVE_DRV_144, 22, 80, 1, FDRIVE_RATE_500K, },
2109 { FDRIVE_DRV_144, 23, 80, 1, FDRIVE_RATE_500K, },
2110 { FDRIVE_DRV_144, 24, 80, 1, FDRIVE_RATE_500K, },
2111 /* 2.88 MB 3"1/2 floppy disks */
2112 { FDRIVE_DRV_288, 36, 80, 1, FDRIVE_RATE_1M, },
2113 { FDRIVE_DRV_288, 39, 80, 1, FDRIVE_RATE_1M, },
2114 { FDRIVE_DRV_288, 40, 80, 1, FDRIVE_RATE_1M, },
2115 { FDRIVE_DRV_288, 44, 80, 1, FDRIVE_RATE_1M, },
2116 { FDRIVE_DRV_288, 48, 80, 1, FDRIVE_RATE_1M, },
2117 /* 720 kB 3"1/2 floppy disks */
2118 { FDRIVE_DRV_144, 9, 80, 1, FDRIVE_RATE_250K, },
2119 { FDRIVE_DRV_144, 10, 80, 1, FDRIVE_RATE_250K, },
2120 { FDRIVE_DRV_144, 10, 82, 1, FDRIVE_RATE_250K, },
2121 { FDRIVE_DRV_144, 10, 83, 1, FDRIVE_RATE_250K, },
2122 { FDRIVE_DRV_144, 13, 80, 1, FDRIVE_RATE_250K, },
2123 { FDRIVE_DRV_144, 14, 80, 1, FDRIVE_RATE_250K, },
2124 /* 1.2 MB 5"1/4 floppy disks */
2125 { FDRIVE_DRV_120, 15, 80, 1, FDRIVE_RATE_500K, },
2126 { FDRIVE_DRV_120, 18, 80, 1, FDRIVE_RATE_500K, },
2127 { FDRIVE_DRV_120, 18, 82, 1, FDRIVE_RATE_500K, },
2128 { FDRIVE_DRV_120, 18, 83, 1, FDRIVE_RATE_500K, },
2129 { FDRIVE_DRV_120, 20, 80, 1, FDRIVE_RATE_500K, },
2130 /* 720 kB 5"1/4 floppy disks */
2131 { FDRIVE_DRV_120, 9, 80, 1, FDRIVE_RATE_250K, },
2132 { FDRIVE_DRV_120, 11, 80, 1, FDRIVE_RATE_250K, },
2133 /* 360 kB 5"1/4 floppy disks */
2134 { FDRIVE_DRV_120, 9, 40, 1, FDRIVE_RATE_300K, },
2135 { FDRIVE_DRV_120, 9, 40, 0, FDRIVE_RATE_300K, },
2136 { FDRIVE_DRV_120, 10, 41, 1, FDRIVE_RATE_300K, },
2137 { FDRIVE_DRV_120, 10, 42, 1, FDRIVE_RATE_300K, },
2138 /* 320 kB 5"1/4 floppy disks */
2139 { FDRIVE_DRV_120, 8, 40, 1, FDRIVE_RATE_250K, },
2140 { FDRIVE_DRV_120, 8, 40, 0, FDRIVE_RATE_250K, },
2141 /* 360 kB must match 5"1/4 better than 3"1/2... */
2142 { FDRIVE_DRV_144, 9, 80, 0, FDRIVE_RATE_250K, },
2143 /* end */
2144 { FDRIVE_DRV_NONE, -1, -1, 0, 0, },
2147 void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
2148 int *max_track, int *last_sect,
2149 FDriveType drive_in, FDriveType *drive,
2150 FDriveRate *rate)
2152 const FDFormat *parse;
2153 uint64_t nb_sectors, size;
2154 int i, first_match, match;
2156 bdrv_get_geometry_hint(bs, nb_heads, max_track, last_sect);
2157 if (*nb_heads != 0 && *max_track != 0 && *last_sect != 0) {
2158 /* User defined disk */
2159 *rate = FDRIVE_RATE_500K;
2160 } else {
2161 bdrv_get_geometry(bs, &nb_sectors);
2162 match = -1;
2163 first_match = -1;
2164 for (i = 0; ; i++) {
2165 parse = &fd_formats[i];
2166 if (parse->drive == FDRIVE_DRV_NONE) {
2167 break;
2169 if (drive_in == parse->drive ||
2170 drive_in == FDRIVE_DRV_NONE) {
2171 size = (parse->max_head + 1) * parse->max_track *
2172 parse->last_sect;
2173 if (nb_sectors == size) {
2174 match = i;
2175 break;
2177 if (first_match == -1) {
2178 first_match = i;
2182 if (match == -1) {
2183 if (first_match == -1) {
2184 match = 1;
2185 } else {
2186 match = first_match;
2188 parse = &fd_formats[match];
2190 *nb_heads = parse->max_head + 1;
2191 *max_track = parse->max_track;
2192 *last_sect = parse->last_sect;
2193 *drive = parse->drive;
2194 *rate = parse->rate;
2198 int bdrv_get_translation_hint(BlockDriverState *bs)
2200 return bs->translation;
2203 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
2204 BlockErrorAction on_write_error)
2206 bs->on_read_error = on_read_error;
2207 bs->on_write_error = on_write_error;
2210 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
2212 return is_read ? bs->on_read_error : bs->on_write_error;
2215 int bdrv_is_read_only(BlockDriverState *bs)
2217 return bs->read_only;
2220 int bdrv_is_sg(BlockDriverState *bs)
2222 return bs->sg;
2225 int bdrv_enable_write_cache(BlockDriverState *bs)
2227 return bs->enable_write_cache;
2230 int bdrv_is_encrypted(BlockDriverState *bs)
2232 if (bs->backing_hd && bs->backing_hd->encrypted)
2233 return 1;
2234 return bs->encrypted;
2237 int bdrv_key_required(BlockDriverState *bs)
2239 BlockDriverState *backing_hd = bs->backing_hd;
2241 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2242 return 1;
2243 return (bs->encrypted && !bs->valid_key);
2246 int bdrv_set_key(BlockDriverState *bs, const char *key)
2248 int ret;
2249 if (bs->backing_hd && bs->backing_hd->encrypted) {
2250 ret = bdrv_set_key(bs->backing_hd, key);
2251 if (ret < 0)
2252 return ret;
2253 if (!bs->encrypted)
2254 return 0;
2256 if (!bs->encrypted) {
2257 return -EINVAL;
2258 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2259 return -ENOMEDIUM;
2261 ret = bs->drv->bdrv_set_key(bs, key);
2262 if (ret < 0) {
2263 bs->valid_key = 0;
2264 } else if (!bs->valid_key) {
2265 bs->valid_key = 1;
2266 /* call the change callback now, we skipped it on open */
2267 bdrv_dev_change_media_cb(bs, true);
2269 return ret;
2272 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
2274 if (!bs->drv) {
2275 buf[0] = '\0';
2276 } else {
2277 pstrcpy(buf, buf_size, bs->drv->format_name);
2281 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2282 void *opaque)
2284 BlockDriver *drv;
2286 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2287 it(opaque, drv->format_name);
2291 BlockDriverState *bdrv_find(const char *name)
2293 BlockDriverState *bs;
2295 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2296 if (!strcmp(name, bs->device_name)) {
2297 return bs;
2300 return NULL;
2303 BlockDriverState *bdrv_next(BlockDriverState *bs)
2305 if (!bs) {
2306 return QTAILQ_FIRST(&bdrv_states);
2308 return QTAILQ_NEXT(bs, list);
2311 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
2313 BlockDriverState *bs;
2315 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2316 it(opaque, bs);
2320 const char *bdrv_get_device_name(BlockDriverState *bs)
2322 return bs->device_name;
2325 void bdrv_flush_all(void)
2327 BlockDriverState *bs;
2329 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2330 if (!bdrv_is_read_only(bs) && bdrv_is_inserted(bs)) {
2331 bdrv_flush(bs);
2336 int bdrv_has_zero_init(BlockDriverState *bs)
2338 assert(bs->drv);
2340 if (bs->drv->bdrv_has_zero_init) {
2341 return bs->drv->bdrv_has_zero_init(bs);
2344 return 1;
2347 typedef struct BdrvCoIsAllocatedData {
2348 BlockDriverState *bs;
2349 int64_t sector_num;
2350 int nb_sectors;
2351 int *pnum;
2352 int ret;
2353 bool done;
2354 } BdrvCoIsAllocatedData;
2357 * Returns true iff the specified sector is present in the disk image. Drivers
2358 * not implementing the functionality are assumed to not support backing files,
2359 * hence all their sectors are reported as allocated.
2361 * If 'sector_num' is beyond the end of the disk image the return value is 0
2362 * and 'pnum' is set to 0.
2364 * 'pnum' is set to the number of sectors (including and immediately following
2365 * the specified sector) that are known to be in the same
2366 * allocated/unallocated state.
2368 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2369 * beyond the end of the disk image it will be clamped.
2371 int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
2372 int nb_sectors, int *pnum)
2374 int64_t n;
2376 if (sector_num >= bs->total_sectors) {
2377 *pnum = 0;
2378 return 0;
2381 n = bs->total_sectors - sector_num;
2382 if (n < nb_sectors) {
2383 nb_sectors = n;
2386 if (!bs->drv->bdrv_co_is_allocated) {
2387 *pnum = nb_sectors;
2388 return 1;
2391 return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum);
2394 /* Coroutine wrapper for bdrv_is_allocated() */
2395 static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque)
2397 BdrvCoIsAllocatedData *data = opaque;
2398 BlockDriverState *bs = data->bs;
2400 data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors,
2401 data->pnum);
2402 data->done = true;
2406 * Synchronous wrapper around bdrv_co_is_allocated().
2408 * See bdrv_co_is_allocated() for details.
2410 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2411 int *pnum)
2413 Coroutine *co;
2414 BdrvCoIsAllocatedData data = {
2415 .bs = bs,
2416 .sector_num = sector_num,
2417 .nb_sectors = nb_sectors,
2418 .pnum = pnum,
2419 .done = false,
2422 co = qemu_coroutine_create(bdrv_is_allocated_co_entry);
2423 qemu_coroutine_enter(co, &data);
2424 while (!data.done) {
2425 qemu_aio_wait();
2427 return data.ret;
2430 BlockInfoList *qmp_query_block(Error **errp)
2432 BlockInfoList *head = NULL, *cur_item = NULL;
2433 BlockDriverState *bs;
2435 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2436 BlockInfoList *info = g_malloc0(sizeof(*info));
2438 info->value = g_malloc0(sizeof(*info->value));
2439 info->value->device = g_strdup(bs->device_name);
2440 info->value->type = g_strdup("unknown");
2441 info->value->locked = bdrv_dev_is_medium_locked(bs);
2442 info->value->removable = bdrv_dev_has_removable_media(bs);
2444 if (bdrv_dev_has_removable_media(bs)) {
2445 info->value->has_tray_open = true;
2446 info->value->tray_open = bdrv_dev_is_tray_open(bs);
2449 if (bdrv_iostatus_is_enabled(bs)) {
2450 info->value->has_io_status = true;
2451 info->value->io_status = bs->iostatus;
2454 if (bs->drv) {
2455 info->value->has_inserted = true;
2456 info->value->inserted = g_malloc0(sizeof(*info->value->inserted));
2457 info->value->inserted->file = g_strdup(bs->filename);
2458 info->value->inserted->ro = bs->read_only;
2459 info->value->inserted->drv = g_strdup(bs->drv->format_name);
2460 info->value->inserted->encrypted = bs->encrypted;
2461 if (bs->backing_file[0]) {
2462 info->value->inserted->has_backing_file = true;
2463 info->value->inserted->backing_file = g_strdup(bs->backing_file);
2466 if (bs->io_limits_enabled) {
2467 info->value->inserted->bps =
2468 bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
2469 info->value->inserted->bps_rd =
2470 bs->io_limits.bps[BLOCK_IO_LIMIT_READ];
2471 info->value->inserted->bps_wr =
2472 bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];
2473 info->value->inserted->iops =
2474 bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
2475 info->value->inserted->iops_rd =
2476 bs->io_limits.iops[BLOCK_IO_LIMIT_READ];
2477 info->value->inserted->iops_wr =
2478 bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];
2482 /* XXX: waiting for the qapi to support GSList */
2483 if (!cur_item) {
2484 head = cur_item = info;
2485 } else {
2486 cur_item->next = info;
2487 cur_item = info;
2491 return head;
2494 /* Consider exposing this as a full fledged QMP command */
2495 static BlockStats *qmp_query_blockstat(const BlockDriverState *bs, Error **errp)
2497 BlockStats *s;
2499 s = g_malloc0(sizeof(*s));
2501 if (bs->device_name[0]) {
2502 s->has_device = true;
2503 s->device = g_strdup(bs->device_name);
2506 s->stats = g_malloc0(sizeof(*s->stats));
2507 s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];
2508 s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];
2509 s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];
2510 s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];
2511 s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;
2512 s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];
2513 s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];
2514 s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];
2515 s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];
2517 if (bs->file) {
2518 s->has_parent = true;
2519 s->parent = qmp_query_blockstat(bs->file, NULL);
2522 return s;
2525 BlockStatsList *qmp_query_blockstats(Error **errp)
2527 BlockStatsList *head = NULL, *cur_item = NULL;
2528 BlockDriverState *bs;
2530 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2531 BlockStatsList *info = g_malloc0(sizeof(*info));
2532 info->value = qmp_query_blockstat(bs, NULL);
2534 /* XXX: waiting for the qapi to support GSList */
2535 if (!cur_item) {
2536 head = cur_item = info;
2537 } else {
2538 cur_item->next = info;
2539 cur_item = info;
2543 return head;
2546 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2548 if (bs->backing_hd && bs->backing_hd->encrypted)
2549 return bs->backing_file;
2550 else if (bs->encrypted)
2551 return bs->filename;
2552 else
2553 return NULL;
2556 void bdrv_get_backing_filename(BlockDriverState *bs,
2557 char *filename, int filename_size)
2559 pstrcpy(filename, filename_size, bs->backing_file);
2562 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
2563 const uint8_t *buf, int nb_sectors)
2565 BlockDriver *drv = bs->drv;
2566 if (!drv)
2567 return -ENOMEDIUM;
2568 if (!drv->bdrv_write_compressed)
2569 return -ENOTSUP;
2570 if (bdrv_check_request(bs, sector_num, nb_sectors))
2571 return -EIO;
2573 if (bs->dirty_bitmap) {
2574 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2577 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
2580 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2582 BlockDriver *drv = bs->drv;
2583 if (!drv)
2584 return -ENOMEDIUM;
2585 if (!drv->bdrv_get_info)
2586 return -ENOTSUP;
2587 memset(bdi, 0, sizeof(*bdi));
2588 return drv->bdrv_get_info(bs, bdi);
2591 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
2592 int64_t pos, int size)
2594 BlockDriver *drv = bs->drv;
2595 if (!drv)
2596 return -ENOMEDIUM;
2597 if (drv->bdrv_save_vmstate)
2598 return drv->bdrv_save_vmstate(bs, buf, pos, size);
2599 if (bs->file)
2600 return bdrv_save_vmstate(bs->file, buf, pos, size);
2601 return -ENOTSUP;
2604 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
2605 int64_t pos, int size)
2607 BlockDriver *drv = bs->drv;
2608 if (!drv)
2609 return -ENOMEDIUM;
2610 if (drv->bdrv_load_vmstate)
2611 return drv->bdrv_load_vmstate(bs, buf, pos, size);
2612 if (bs->file)
2613 return bdrv_load_vmstate(bs->file, buf, pos, size);
2614 return -ENOTSUP;
2617 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2619 BlockDriver *drv = bs->drv;
2621 if (!drv || !drv->bdrv_debug_event) {
2622 return;
2625 return drv->bdrv_debug_event(bs, event);
2629 /**************************************************************/
2630 /* handling of snapshots */
2632 int bdrv_can_snapshot(BlockDriverState *bs)
2634 BlockDriver *drv = bs->drv;
2635 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2636 return 0;
2639 if (!drv->bdrv_snapshot_create) {
2640 if (bs->file != NULL) {
2641 return bdrv_can_snapshot(bs->file);
2643 return 0;
2646 return 1;
2649 int bdrv_is_snapshot(BlockDriverState *bs)
2651 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
2654 BlockDriverState *bdrv_snapshots(void)
2656 BlockDriverState *bs;
2658 if (bs_snapshots) {
2659 return bs_snapshots;
2662 bs = NULL;
2663 while ((bs = bdrv_next(bs))) {
2664 if (bdrv_can_snapshot(bs)) {
2665 bs_snapshots = bs;
2666 return bs;
2669 return NULL;
2672 int bdrv_snapshot_create(BlockDriverState *bs,
2673 QEMUSnapshotInfo *sn_info)
2675 BlockDriver *drv = bs->drv;
2676 if (!drv)
2677 return -ENOMEDIUM;
2678 if (drv->bdrv_snapshot_create)
2679 return drv->bdrv_snapshot_create(bs, sn_info);
2680 if (bs->file)
2681 return bdrv_snapshot_create(bs->file, sn_info);
2682 return -ENOTSUP;
2685 int bdrv_snapshot_goto(BlockDriverState *bs,
2686 const char *snapshot_id)
2688 BlockDriver *drv = bs->drv;
2689 int ret, open_ret;
2691 if (!drv)
2692 return -ENOMEDIUM;
2693 if (drv->bdrv_snapshot_goto)
2694 return drv->bdrv_snapshot_goto(bs, snapshot_id);
2696 if (bs->file) {
2697 drv->bdrv_close(bs);
2698 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
2699 open_ret = drv->bdrv_open(bs, bs->open_flags);
2700 if (open_ret < 0) {
2701 bdrv_delete(bs->file);
2702 bs->drv = NULL;
2703 return open_ret;
2705 return ret;
2708 return -ENOTSUP;
2711 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
2713 BlockDriver *drv = bs->drv;
2714 if (!drv)
2715 return -ENOMEDIUM;
2716 if (drv->bdrv_snapshot_delete)
2717 return drv->bdrv_snapshot_delete(bs, snapshot_id);
2718 if (bs->file)
2719 return bdrv_snapshot_delete(bs->file, snapshot_id);
2720 return -ENOTSUP;
2723 int bdrv_snapshot_list(BlockDriverState *bs,
2724 QEMUSnapshotInfo **psn_info)
2726 BlockDriver *drv = bs->drv;
2727 if (!drv)
2728 return -ENOMEDIUM;
2729 if (drv->bdrv_snapshot_list)
2730 return drv->bdrv_snapshot_list(bs, psn_info);
2731 if (bs->file)
2732 return bdrv_snapshot_list(bs->file, psn_info);
2733 return -ENOTSUP;
2736 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
2737 const char *snapshot_name)
2739 BlockDriver *drv = bs->drv;
2740 if (!drv) {
2741 return -ENOMEDIUM;
2743 if (!bs->read_only) {
2744 return -EINVAL;
2746 if (drv->bdrv_snapshot_load_tmp) {
2747 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
2749 return -ENOTSUP;
2752 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
2753 const char *backing_file)
2755 if (!bs->drv) {
2756 return NULL;
2759 if (bs->backing_hd) {
2760 if (strcmp(bs->backing_file, backing_file) == 0) {
2761 return bs->backing_hd;
2762 } else {
2763 return bdrv_find_backing_image(bs->backing_hd, backing_file);
2767 return NULL;
2770 #define NB_SUFFIXES 4
2772 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
2774 static const char suffixes[NB_SUFFIXES] = "KMGT";
2775 int64_t base;
2776 int i;
2778 if (size <= 999) {
2779 snprintf(buf, buf_size, "%" PRId64, size);
2780 } else {
2781 base = 1024;
2782 for(i = 0; i < NB_SUFFIXES; i++) {
2783 if (size < (10 * base)) {
2784 snprintf(buf, buf_size, "%0.1f%c",
2785 (double)size / base,
2786 suffixes[i]);
2787 break;
2788 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
2789 snprintf(buf, buf_size, "%" PRId64 "%c",
2790 ((size + (base >> 1)) / base),
2791 suffixes[i]);
2792 break;
2794 base = base * 1024;
2797 return buf;
2800 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
2802 char buf1[128], date_buf[128], clock_buf[128];
2803 #ifdef _WIN32
2804 struct tm *ptm;
2805 #else
2806 struct tm tm;
2807 #endif
2808 time_t ti;
2809 int64_t secs;
2811 if (!sn) {
2812 snprintf(buf, buf_size,
2813 "%-10s%-20s%7s%20s%15s",
2814 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2815 } else {
2816 ti = sn->date_sec;
2817 #ifdef _WIN32
2818 ptm = localtime(&ti);
2819 strftime(date_buf, sizeof(date_buf),
2820 "%Y-%m-%d %H:%M:%S", ptm);
2821 #else
2822 localtime_r(&ti, &tm);
2823 strftime(date_buf, sizeof(date_buf),
2824 "%Y-%m-%d %H:%M:%S", &tm);
2825 #endif
2826 secs = sn->vm_clock_nsec / 1000000000;
2827 snprintf(clock_buf, sizeof(clock_buf),
2828 "%02d:%02d:%02d.%03d",
2829 (int)(secs / 3600),
2830 (int)((secs / 60) % 60),
2831 (int)(secs % 60),
2832 (int)((sn->vm_clock_nsec / 1000000) % 1000));
2833 snprintf(buf, buf_size,
2834 "%-10s%-20s%7s%20s%15s",
2835 sn->id_str, sn->name,
2836 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
2837 date_buf,
2838 clock_buf);
2840 return buf;
2843 /**************************************************************/
2844 /* async I/Os */
2846 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
2847 QEMUIOVector *qiov, int nb_sectors,
2848 BlockDriverCompletionFunc *cb, void *opaque)
2850 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
2852 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
2853 cb, opaque, false);
2856 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2857 QEMUIOVector *qiov, int nb_sectors,
2858 BlockDriverCompletionFunc *cb, void *opaque)
2860 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2862 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
2863 cb, opaque, true);
2867 typedef struct MultiwriteCB {
2868 int error;
2869 int num_requests;
2870 int num_callbacks;
2871 struct {
2872 BlockDriverCompletionFunc *cb;
2873 void *opaque;
2874 QEMUIOVector *free_qiov;
2875 } callbacks[];
2876 } MultiwriteCB;
2878 static void multiwrite_user_cb(MultiwriteCB *mcb)
2880 int i;
2882 for (i = 0; i < mcb->num_callbacks; i++) {
2883 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2884 if (mcb->callbacks[i].free_qiov) {
2885 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2887 g_free(mcb->callbacks[i].free_qiov);
2891 static void multiwrite_cb(void *opaque, int ret)
2893 MultiwriteCB *mcb = opaque;
2895 trace_multiwrite_cb(mcb, ret);
2897 if (ret < 0 && !mcb->error) {
2898 mcb->error = ret;
2901 mcb->num_requests--;
2902 if (mcb->num_requests == 0) {
2903 multiwrite_user_cb(mcb);
2904 g_free(mcb);
2908 static int multiwrite_req_compare(const void *a, const void *b)
2910 const BlockRequest *req1 = a, *req2 = b;
2913 * Note that we can't simply subtract req2->sector from req1->sector
2914 * here as that could overflow the return value.
2916 if (req1->sector > req2->sector) {
2917 return 1;
2918 } else if (req1->sector < req2->sector) {
2919 return -1;
2920 } else {
2921 return 0;
2926 * Takes a bunch of requests and tries to merge them. Returns the number of
2927 * requests that remain after merging.
2929 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2930 int num_reqs, MultiwriteCB *mcb)
2932 int i, outidx;
2934 // Sort requests by start sector
2935 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2937 // Check if adjacent requests touch the same clusters. If so, combine them,
2938 // filling up gaps with zero sectors.
2939 outidx = 0;
2940 for (i = 1; i < num_reqs; i++) {
2941 int merge = 0;
2942 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2944 // Handle exactly sequential writes and overlapping writes.
2945 if (reqs[i].sector <= oldreq_last) {
2946 merge = 1;
2949 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2950 merge = 0;
2953 if (merge) {
2954 size_t size;
2955 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
2956 qemu_iovec_init(qiov,
2957 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2959 // Add the first request to the merged one. If the requests are
2960 // overlapping, drop the last sectors of the first request.
2961 size = (reqs[i].sector - reqs[outidx].sector) << 9;
2962 qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2964 // We should need to add any zeros between the two requests
2965 assert (reqs[i].sector <= oldreq_last);
2967 // Add the second request
2968 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2970 reqs[outidx].nb_sectors = qiov->size >> 9;
2971 reqs[outidx].qiov = qiov;
2973 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2974 } else {
2975 outidx++;
2976 reqs[outidx].sector = reqs[i].sector;
2977 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2978 reqs[outidx].qiov = reqs[i].qiov;
2982 return outidx + 1;
2986 * Submit multiple AIO write requests at once.
2988 * On success, the function returns 0 and all requests in the reqs array have
2989 * been submitted. In error case this function returns -1, and any of the
2990 * requests may or may not be submitted yet. In particular, this means that the
2991 * callback will be called for some of the requests, for others it won't. The
2992 * caller must check the error field of the BlockRequest to wait for the right
2993 * callbacks (if error != 0, no callback will be called).
2995 * The implementation may modify the contents of the reqs array, e.g. to merge
2996 * requests. However, the fields opaque and error are left unmodified as they
2997 * are used to signal failure for a single request to the caller.
2999 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3001 MultiwriteCB *mcb;
3002 int i;
3004 /* don't submit writes if we don't have a medium */
3005 if (bs->drv == NULL) {
3006 for (i = 0; i < num_reqs; i++) {
3007 reqs[i].error = -ENOMEDIUM;
3009 return -1;
3012 if (num_reqs == 0) {
3013 return 0;
3016 // Create MultiwriteCB structure
3017 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
3018 mcb->num_requests = 0;
3019 mcb->num_callbacks = num_reqs;
3021 for (i = 0; i < num_reqs; i++) {
3022 mcb->callbacks[i].cb = reqs[i].cb;
3023 mcb->callbacks[i].opaque = reqs[i].opaque;
3026 // Check for mergable requests
3027 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3029 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3031 /* Run the aio requests. */
3032 mcb->num_requests = num_reqs;
3033 for (i = 0; i < num_reqs; i++) {
3034 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
3035 reqs[i].nb_sectors, multiwrite_cb, mcb);
3038 return 0;
3041 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
3043 acb->pool->cancel(acb);
3046 /* block I/O throttling */
3047 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
3048 bool is_write, double elapsed_time, uint64_t *wait)
3050 uint64_t bps_limit = 0;
3051 double bytes_limit, bytes_base, bytes_res;
3052 double slice_time, wait_time;
3054 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3055 bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
3056 } else if (bs->io_limits.bps[is_write]) {
3057 bps_limit = bs->io_limits.bps[is_write];
3058 } else {
3059 if (wait) {
3060 *wait = 0;
3063 return false;
3066 slice_time = bs->slice_end - bs->slice_start;
3067 slice_time /= (NANOSECONDS_PER_SECOND);
3068 bytes_limit = bps_limit * slice_time;
3069 bytes_base = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write];
3070 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3071 bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write];
3074 /* bytes_base: the bytes of data which have been read/written; and
3075 * it is obtained from the history statistic info.
3076 * bytes_res: the remaining bytes of data which need to be read/written.
3077 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3078 * the total time for completing reading/writting all data.
3080 bytes_res = (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
3082 if (bytes_base + bytes_res <= bytes_limit) {
3083 if (wait) {
3084 *wait = 0;
3087 return false;
3090 /* Calc approx time to dispatch */
3091 wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time;
3093 /* When the I/O rate at runtime exceeds the limits,
3094 * bs->slice_end need to be extended in order that the current statistic
3095 * info can be kept until the timer fire, so it is increased and tuned
3096 * based on the result of experiment.
3098 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3099 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3100 if (wait) {
3101 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3104 return true;
3107 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
3108 double elapsed_time, uint64_t *wait)
3110 uint64_t iops_limit = 0;
3111 double ios_limit, ios_base;
3112 double slice_time, wait_time;
3114 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3115 iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
3116 } else if (bs->io_limits.iops[is_write]) {
3117 iops_limit = bs->io_limits.iops[is_write];
3118 } else {
3119 if (wait) {
3120 *wait = 0;
3123 return false;
3126 slice_time = bs->slice_end - bs->slice_start;
3127 slice_time /= (NANOSECONDS_PER_SECOND);
3128 ios_limit = iops_limit * slice_time;
3129 ios_base = bs->nr_ops[is_write] - bs->io_base.ios[is_write];
3130 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3131 ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write];
3134 if (ios_base + 1 <= ios_limit) {
3135 if (wait) {
3136 *wait = 0;
3139 return false;
3142 /* Calc approx time to dispatch */
3143 wait_time = (ios_base + 1) / iops_limit;
3144 if (wait_time > elapsed_time) {
3145 wait_time = wait_time - elapsed_time;
3146 } else {
3147 wait_time = 0;
3150 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3151 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3152 if (wait) {
3153 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3156 return true;
3159 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
3160 bool is_write, int64_t *wait)
3162 int64_t now, max_wait;
3163 uint64_t bps_wait = 0, iops_wait = 0;
3164 double elapsed_time;
3165 int bps_ret, iops_ret;
3167 now = qemu_get_clock_ns(vm_clock);
3168 if ((bs->slice_start < now)
3169 && (bs->slice_end > now)) {
3170 bs->slice_end = now + bs->slice_time;
3171 } else {
3172 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
3173 bs->slice_start = now;
3174 bs->slice_end = now + bs->slice_time;
3176 bs->io_base.bytes[is_write] = bs->nr_bytes[is_write];
3177 bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write];
3179 bs->io_base.ios[is_write] = bs->nr_ops[is_write];
3180 bs->io_base.ios[!is_write] = bs->nr_ops[!is_write];
3183 elapsed_time = now - bs->slice_start;
3184 elapsed_time /= (NANOSECONDS_PER_SECOND);
3186 bps_ret = bdrv_exceed_bps_limits(bs, nb_sectors,
3187 is_write, elapsed_time, &bps_wait);
3188 iops_ret = bdrv_exceed_iops_limits(bs, is_write,
3189 elapsed_time, &iops_wait);
3190 if (bps_ret || iops_ret) {
3191 max_wait = bps_wait > iops_wait ? bps_wait : iops_wait;
3192 if (wait) {
3193 *wait = max_wait;
3196 now = qemu_get_clock_ns(vm_clock);
3197 if (bs->slice_end < now + max_wait) {
3198 bs->slice_end = now + max_wait;
3201 return true;
3204 if (wait) {
3205 *wait = 0;
3208 return false;
3211 /**************************************************************/
3212 /* async block device emulation */
3214 typedef struct BlockDriverAIOCBSync {
3215 BlockDriverAIOCB common;
3216 QEMUBH *bh;
3217 int ret;
3218 /* vector translation state */
3219 QEMUIOVector *qiov;
3220 uint8_t *bounce;
3221 int is_write;
3222 } BlockDriverAIOCBSync;
3224 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3226 BlockDriverAIOCBSync *acb =
3227 container_of(blockacb, BlockDriverAIOCBSync, common);
3228 qemu_bh_delete(acb->bh);
3229 acb->bh = NULL;
3230 qemu_aio_release(acb);
3233 static AIOPool bdrv_em_aio_pool = {
3234 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3235 .cancel = bdrv_aio_cancel_em,
3238 static void bdrv_aio_bh_cb(void *opaque)
3240 BlockDriverAIOCBSync *acb = opaque;
3242 if (!acb->is_write)
3243 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
3244 qemu_vfree(acb->bounce);
3245 acb->common.cb(acb->common.opaque, acb->ret);
3246 qemu_bh_delete(acb->bh);
3247 acb->bh = NULL;
3248 qemu_aio_release(acb);
3251 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3252 int64_t sector_num,
3253 QEMUIOVector *qiov,
3254 int nb_sectors,
3255 BlockDriverCompletionFunc *cb,
3256 void *opaque,
3257 int is_write)
3260 BlockDriverAIOCBSync *acb;
3262 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
3263 acb->is_write = is_write;
3264 acb->qiov = qiov;
3265 acb->bounce = qemu_blockalign(bs, qiov->size);
3266 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
3268 if (is_write) {
3269 qemu_iovec_to_buffer(acb->qiov, acb->bounce);
3270 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
3271 } else {
3272 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
3275 qemu_bh_schedule(acb->bh);
3277 return &acb->common;
3280 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3281 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3282 BlockDriverCompletionFunc *cb, void *opaque)
3284 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
3287 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3288 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3289 BlockDriverCompletionFunc *cb, void *opaque)
3291 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3295 typedef struct BlockDriverAIOCBCoroutine {
3296 BlockDriverAIOCB common;
3297 BlockRequest req;
3298 bool is_write;
3299 QEMUBH* bh;
3300 } BlockDriverAIOCBCoroutine;
3302 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3304 qemu_aio_flush();
3307 static AIOPool bdrv_em_co_aio_pool = {
3308 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
3309 .cancel = bdrv_aio_co_cancel_em,
3312 static void bdrv_co_em_bh(void *opaque)
3314 BlockDriverAIOCBCoroutine *acb = opaque;
3316 acb->common.cb(acb->common.opaque, acb->req.error);
3317 qemu_bh_delete(acb->bh);
3318 qemu_aio_release(acb);
3321 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3322 static void coroutine_fn bdrv_co_do_rw(void *opaque)
3324 BlockDriverAIOCBCoroutine *acb = opaque;
3325 BlockDriverState *bs = acb->common.bs;
3327 if (!acb->is_write) {
3328 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
3329 acb->req.nb_sectors, acb->req.qiov, 0);
3330 } else {
3331 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
3332 acb->req.nb_sectors, acb->req.qiov, 0);
3335 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3336 qemu_bh_schedule(acb->bh);
3339 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
3340 int64_t sector_num,
3341 QEMUIOVector *qiov,
3342 int nb_sectors,
3343 BlockDriverCompletionFunc *cb,
3344 void *opaque,
3345 bool is_write)
3347 Coroutine *co;
3348 BlockDriverAIOCBCoroutine *acb;
3350 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3351 acb->req.sector = sector_num;
3352 acb->req.nb_sectors = nb_sectors;
3353 acb->req.qiov = qiov;
3354 acb->is_write = is_write;
3356 co = qemu_coroutine_create(bdrv_co_do_rw);
3357 qemu_coroutine_enter(co, acb);
3359 return &acb->common;
3362 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
3364 BlockDriverAIOCBCoroutine *acb = opaque;
3365 BlockDriverState *bs = acb->common.bs;
3367 acb->req.error = bdrv_co_flush(bs);
3368 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3369 qemu_bh_schedule(acb->bh);
3372 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
3373 BlockDriverCompletionFunc *cb, void *opaque)
3375 trace_bdrv_aio_flush(bs, opaque);
3377 Coroutine *co;
3378 BlockDriverAIOCBCoroutine *acb;
3380 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3381 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
3382 qemu_coroutine_enter(co, acb);
3384 return &acb->common;
3387 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
3389 BlockDriverAIOCBCoroutine *acb = opaque;
3390 BlockDriverState *bs = acb->common.bs;
3392 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
3393 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3394 qemu_bh_schedule(acb->bh);
3397 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
3398 int64_t sector_num, int nb_sectors,
3399 BlockDriverCompletionFunc *cb, void *opaque)
3401 Coroutine *co;
3402 BlockDriverAIOCBCoroutine *acb;
3404 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
3406 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3407 acb->req.sector = sector_num;
3408 acb->req.nb_sectors = nb_sectors;
3409 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
3410 qemu_coroutine_enter(co, acb);
3412 return &acb->common;
3415 void bdrv_init(void)
3417 module_call_init(MODULE_INIT_BLOCK);
3420 void bdrv_init_with_whitelist(void)
3422 use_bdrv_whitelist = 1;
3423 bdrv_init();
3426 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
3427 BlockDriverCompletionFunc *cb, void *opaque)
3429 BlockDriverAIOCB *acb;
3431 if (pool->free_aiocb) {
3432 acb = pool->free_aiocb;
3433 pool->free_aiocb = acb->next;
3434 } else {
3435 acb = g_malloc0(pool->aiocb_size);
3436 acb->pool = pool;
3438 acb->bs = bs;
3439 acb->cb = cb;
3440 acb->opaque = opaque;
3441 return acb;
3444 void qemu_aio_release(void *p)
3446 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
3447 AIOPool *pool = acb->pool;
3448 acb->next = pool->free_aiocb;
3449 pool->free_aiocb = acb;
3452 /**************************************************************/
3453 /* Coroutine block device emulation */
3455 typedef struct CoroutineIOCompletion {
3456 Coroutine *coroutine;
3457 int ret;
3458 } CoroutineIOCompletion;
3460 static void bdrv_co_io_em_complete(void *opaque, int ret)
3462 CoroutineIOCompletion *co = opaque;
3464 co->ret = ret;
3465 qemu_coroutine_enter(co->coroutine, NULL);
3468 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
3469 int nb_sectors, QEMUIOVector *iov,
3470 bool is_write)
3472 CoroutineIOCompletion co = {
3473 .coroutine = qemu_coroutine_self(),
3475 BlockDriverAIOCB *acb;
3477 if (is_write) {
3478 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
3479 bdrv_co_io_em_complete, &co);
3480 } else {
3481 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
3482 bdrv_co_io_em_complete, &co);
3485 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
3486 if (!acb) {
3487 return -EIO;
3489 qemu_coroutine_yield();
3491 return co.ret;
3494 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
3495 int64_t sector_num, int nb_sectors,
3496 QEMUIOVector *iov)
3498 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
3501 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
3502 int64_t sector_num, int nb_sectors,
3503 QEMUIOVector *iov)
3505 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
3508 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
3510 RwCo *rwco = opaque;
3512 rwco->ret = bdrv_co_flush(rwco->bs);
3515 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
3517 int ret;
3519 if (!bs->drv) {
3520 return 0;
3523 /* Write back cached data to the OS even with cache=unsafe */
3524 if (bs->drv->bdrv_co_flush_to_os) {
3525 ret = bs->drv->bdrv_co_flush_to_os(bs);
3526 if (ret < 0) {
3527 return ret;
3531 /* But don't actually force it to the disk with cache=unsafe */
3532 if (bs->open_flags & BDRV_O_NO_FLUSH) {
3533 return 0;
3536 if (bs->drv->bdrv_co_flush_to_disk) {
3537 return bs->drv->bdrv_co_flush_to_disk(bs);
3538 } else if (bs->drv->bdrv_aio_flush) {
3539 BlockDriverAIOCB *acb;
3540 CoroutineIOCompletion co = {
3541 .coroutine = qemu_coroutine_self(),
3544 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
3545 if (acb == NULL) {
3546 return -EIO;
3547 } else {
3548 qemu_coroutine_yield();
3549 return co.ret;
3551 } else {
3553 * Some block drivers always operate in either writethrough or unsafe
3554 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3555 * know how the server works (because the behaviour is hardcoded or
3556 * depends on server-side configuration), so we can't ensure that
3557 * everything is safe on disk. Returning an error doesn't work because
3558 * that would break guests even if the server operates in writethrough
3559 * mode.
3561 * Let's hope the user knows what he's doing.
3563 return 0;
3567 void bdrv_invalidate_cache(BlockDriverState *bs)
3569 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
3570 bs->drv->bdrv_invalidate_cache(bs);
3574 void bdrv_invalidate_cache_all(void)
3576 BlockDriverState *bs;
3578 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3579 bdrv_invalidate_cache(bs);
3583 int bdrv_flush(BlockDriverState *bs)
3585 Coroutine *co;
3586 RwCo rwco = {
3587 .bs = bs,
3588 .ret = NOT_DONE,
3591 if (qemu_in_coroutine()) {
3592 /* Fast-path if already in coroutine context */
3593 bdrv_flush_co_entry(&rwco);
3594 } else {
3595 co = qemu_coroutine_create(bdrv_flush_co_entry);
3596 qemu_coroutine_enter(co, &rwco);
3597 while (rwco.ret == NOT_DONE) {
3598 qemu_aio_wait();
3602 return rwco.ret;
3605 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
3607 RwCo *rwco = opaque;
3609 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
3612 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
3613 int nb_sectors)
3615 if (!bs->drv) {
3616 return -ENOMEDIUM;
3617 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
3618 return -EIO;
3619 } else if (bs->read_only) {
3620 return -EROFS;
3621 } else if (bs->drv->bdrv_co_discard) {
3622 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
3623 } else if (bs->drv->bdrv_aio_discard) {
3624 BlockDriverAIOCB *acb;
3625 CoroutineIOCompletion co = {
3626 .coroutine = qemu_coroutine_self(),
3629 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
3630 bdrv_co_io_em_complete, &co);
3631 if (acb == NULL) {
3632 return -EIO;
3633 } else {
3634 qemu_coroutine_yield();
3635 return co.ret;
3637 } else {
3638 return 0;
3642 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
3644 Coroutine *co;
3645 RwCo rwco = {
3646 .bs = bs,
3647 .sector_num = sector_num,
3648 .nb_sectors = nb_sectors,
3649 .ret = NOT_DONE,
3652 if (qemu_in_coroutine()) {
3653 /* Fast-path if already in coroutine context */
3654 bdrv_discard_co_entry(&rwco);
3655 } else {
3656 co = qemu_coroutine_create(bdrv_discard_co_entry);
3657 qemu_coroutine_enter(co, &rwco);
3658 while (rwco.ret == NOT_DONE) {
3659 qemu_aio_wait();
3663 return rwco.ret;
3666 /**************************************************************/
3667 /* removable device support */
3670 * Return TRUE if the media is present
3672 int bdrv_is_inserted(BlockDriverState *bs)
3674 BlockDriver *drv = bs->drv;
3676 if (!drv)
3677 return 0;
3678 if (!drv->bdrv_is_inserted)
3679 return 1;
3680 return drv->bdrv_is_inserted(bs);
3684 * Return whether the media changed since the last call to this
3685 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3687 int bdrv_media_changed(BlockDriverState *bs)
3689 BlockDriver *drv = bs->drv;
3691 if (drv && drv->bdrv_media_changed) {
3692 return drv->bdrv_media_changed(bs);
3694 return -ENOTSUP;
3698 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3700 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3702 BlockDriver *drv = bs->drv;
3704 if (drv && drv->bdrv_eject) {
3705 drv->bdrv_eject(bs, eject_flag);
3708 if (bs->device_name[0] != '\0') {
3709 bdrv_emit_qmp_eject_event(bs, eject_flag);
3714 * Lock or unlock the media (if it is locked, the user won't be able
3715 * to eject it manually).
3717 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3719 BlockDriver *drv = bs->drv;
3721 trace_bdrv_lock_medium(bs, locked);
3723 if (drv && drv->bdrv_lock_medium) {
3724 drv->bdrv_lock_medium(bs, locked);
3728 /* needed for generic scsi interface */
3730 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3732 BlockDriver *drv = bs->drv;
3734 if (drv && drv->bdrv_ioctl)
3735 return drv->bdrv_ioctl(bs, req, buf);
3736 return -ENOTSUP;
3739 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
3740 unsigned long int req, void *buf,
3741 BlockDriverCompletionFunc *cb, void *opaque)
3743 BlockDriver *drv = bs->drv;
3745 if (drv && drv->bdrv_aio_ioctl)
3746 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
3747 return NULL;
3750 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
3752 bs->buffer_alignment = align;
3755 void *qemu_blockalign(BlockDriverState *bs, size_t size)
3757 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
3760 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
3762 int64_t bitmap_size;
3764 bs->dirty_count = 0;
3765 if (enable) {
3766 if (!bs->dirty_bitmap) {
3767 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
3768 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
3769 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
3771 bs->dirty_bitmap = g_malloc0(bitmap_size);
3773 } else {
3774 if (bs->dirty_bitmap) {
3775 g_free(bs->dirty_bitmap);
3776 bs->dirty_bitmap = NULL;
3781 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
3783 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
3785 if (bs->dirty_bitmap &&
3786 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
3787 return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
3788 (1UL << (chunk % (sizeof(unsigned long) * 8))));
3789 } else {
3790 return 0;
3794 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
3795 int nr_sectors)
3797 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
3800 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
3802 return bs->dirty_count;
3805 void bdrv_set_in_use(BlockDriverState *bs, int in_use)
3807 assert(bs->in_use != in_use);
3808 bs->in_use = in_use;
3811 int bdrv_in_use(BlockDriverState *bs)
3813 return bs->in_use;
3816 void bdrv_iostatus_enable(BlockDriverState *bs)
3818 bs->iostatus_enabled = true;
3819 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3822 /* The I/O status is only enabled if the drive explicitly
3823 * enables it _and_ the VM is configured to stop on errors */
3824 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3826 return (bs->iostatus_enabled &&
3827 (bs->on_write_error == BLOCK_ERR_STOP_ENOSPC ||
3828 bs->on_write_error == BLOCK_ERR_STOP_ANY ||
3829 bs->on_read_error == BLOCK_ERR_STOP_ANY));
3832 void bdrv_iostatus_disable(BlockDriverState *bs)
3834 bs->iostatus_enabled = false;
3837 void bdrv_iostatus_reset(BlockDriverState *bs)
3839 if (bdrv_iostatus_is_enabled(bs)) {
3840 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3844 /* XXX: Today this is set by device models because it makes the implementation
3845 quite simple. However, the block layer knows about the error, so it's
3846 possible to implement this without device models being involved */
3847 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3849 if (bdrv_iostatus_is_enabled(bs) &&
3850 bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3851 assert(error >= 0);
3852 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3853 BLOCK_DEVICE_IO_STATUS_FAILED;
3857 void
3858 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
3859 enum BlockAcctType type)
3861 assert(type < BDRV_MAX_IOTYPE);
3863 cookie->bytes = bytes;
3864 cookie->start_time_ns = get_clock();
3865 cookie->type = type;
3868 void
3869 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
3871 assert(cookie->type < BDRV_MAX_IOTYPE);
3873 bs->nr_bytes[cookie->type] += cookie->bytes;
3874 bs->nr_ops[cookie->type]++;
3875 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
3878 int bdrv_img_create(const char *filename, const char *fmt,
3879 const char *base_filename, const char *base_fmt,
3880 char *options, uint64_t img_size, int flags)
3882 QEMUOptionParameter *param = NULL, *create_options = NULL;
3883 QEMUOptionParameter *backing_fmt, *backing_file, *size;
3884 BlockDriverState *bs = NULL;
3885 BlockDriver *drv, *proto_drv;
3886 BlockDriver *backing_drv = NULL;
3887 int ret = 0;
3889 /* Find driver and parse its options */
3890 drv = bdrv_find_format(fmt);
3891 if (!drv) {
3892 error_report("Unknown file format '%s'", fmt);
3893 ret = -EINVAL;
3894 goto out;
3897 proto_drv = bdrv_find_protocol(filename);
3898 if (!proto_drv) {
3899 error_report("Unknown protocol '%s'", filename);
3900 ret = -EINVAL;
3901 goto out;
3904 create_options = append_option_parameters(create_options,
3905 drv->create_options);
3906 create_options = append_option_parameters(create_options,
3907 proto_drv->create_options);
3909 /* Create parameter list with default values */
3910 param = parse_option_parameters("", create_options, param);
3912 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
3914 /* Parse -o options */
3915 if (options) {
3916 param = parse_option_parameters(options, create_options, param);
3917 if (param == NULL) {
3918 error_report("Invalid options for file format '%s'.", fmt);
3919 ret = -EINVAL;
3920 goto out;
3924 if (base_filename) {
3925 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
3926 base_filename)) {
3927 error_report("Backing file not supported for file format '%s'",
3928 fmt);
3929 ret = -EINVAL;
3930 goto out;
3934 if (base_fmt) {
3935 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
3936 error_report("Backing file format not supported for file "
3937 "format '%s'", fmt);
3938 ret = -EINVAL;
3939 goto out;
3943 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
3944 if (backing_file && backing_file->value.s) {
3945 if (!strcmp(filename, backing_file->value.s)) {
3946 error_report("Error: Trying to create an image with the "
3947 "same filename as the backing file");
3948 ret = -EINVAL;
3949 goto out;
3953 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
3954 if (backing_fmt && backing_fmt->value.s) {
3955 backing_drv = bdrv_find_format(backing_fmt->value.s);
3956 if (!backing_drv) {
3957 error_report("Unknown backing file format '%s'",
3958 backing_fmt->value.s);
3959 ret = -EINVAL;
3960 goto out;
3964 // The size for the image must always be specified, with one exception:
3965 // If we are using a backing file, we can obtain the size from there
3966 size = get_option_parameter(param, BLOCK_OPT_SIZE);
3967 if (size && size->value.n == -1) {
3968 if (backing_file && backing_file->value.s) {
3969 uint64_t size;
3970 char buf[32];
3972 bs = bdrv_new("");
3974 ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv);
3975 if (ret < 0) {
3976 error_report("Could not open '%s'", backing_file->value.s);
3977 goto out;
3979 bdrv_get_geometry(bs, &size);
3980 size *= 512;
3982 snprintf(buf, sizeof(buf), "%" PRId64, size);
3983 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
3984 } else {
3985 error_report("Image creation needs a size parameter");
3986 ret = -EINVAL;
3987 goto out;
3991 printf("Formatting '%s', fmt=%s ", filename, fmt);
3992 print_option_parameters(param);
3993 puts("");
3995 ret = bdrv_create(drv, filename, param);
3997 if (ret < 0) {
3998 if (ret == -ENOTSUP) {
3999 error_report("Formatting or formatting option not supported for "
4000 "file format '%s'", fmt);
4001 } else if (ret == -EFBIG) {
4002 error_report("The image size is too large for file format '%s'",
4003 fmt);
4004 } else {
4005 error_report("%s: error while creating %s: %s", filename, fmt,
4006 strerror(-ret));
4010 out:
4011 free_option_parameters(create_options);
4012 free_option_parameters(param);
4014 if (bs) {
4015 bdrv_delete(bs);
4018 return ret;
4021 void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs,
4022 BlockDriverCompletionFunc *cb, void *opaque)
4024 BlockJob *job;
4026 if (bs->job || bdrv_in_use(bs)) {
4027 return NULL;
4029 bdrv_set_in_use(bs, 1);
4031 job = g_malloc0(job_type->instance_size);
4032 job->job_type = job_type;
4033 job->bs = bs;
4034 job->cb = cb;
4035 job->opaque = opaque;
4036 bs->job = job;
4037 return job;
4040 void block_job_complete(BlockJob *job, int ret)
4042 BlockDriverState *bs = job->bs;
4044 assert(bs->job == job);
4045 job->cb(job->opaque, ret);
4046 bs->job = NULL;
4047 g_free(job);
4048 bdrv_set_in_use(bs, 0);
4051 int block_job_set_speed(BlockJob *job, int64_t value)
4053 if (!job->job_type->set_speed) {
4054 return -ENOTSUP;
4056 return job->job_type->set_speed(job, value);
4059 void block_job_cancel(BlockJob *job)
4061 job->cancelled = true;
4064 bool block_job_is_cancelled(BlockJob *job)
4066 return job->cancelled;