2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
26 /* include native header before sys-queue.h */
27 #include <sys/queue.h>
30 #include "qemu-common.h"
32 #include "block_int.h"
35 #include <sys/types.h>
37 #include <sys/ioctl.h>
48 #define SECTOR_SIZE (1 << SECTOR_BITS)
50 typedef struct BlockDriverAIOCBSync {
51 BlockDriverAIOCB common;
54 } BlockDriverAIOCBSync;
56 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
57 int64_t sector_num, uint8_t *buf, int nb_sectors,
58 BlockDriverCompletionFunc *cb, void *opaque);
59 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
60 int64_t sector_num, const uint8_t *buf, int nb_sectors,
61 BlockDriverCompletionFunc *cb, void *opaque);
62 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
63 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
64 uint8_t *buf, int nb_sectors);
65 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
66 const uint8_t *buf, int nb_sectors);
68 BlockDriverState *bdrv_first;
70 static BlockDriver *first_drv;
72 int path_is_absolute(const char *path)
76 /* specific case for names like: "\\.\d:" */
77 if (*path == '/' || *path == '\\')
80 p = strchr(path, ':');
86 return (*p == '/' || *p == '\\');
92 /* if filename is absolute, just copy it to dest. Otherwise, build a
93 path to it by considering it is relative to base_path. URL are
95 void path_combine(char *dest, int dest_size,
96 const char *base_path,
104 if (path_is_absolute(filename)) {
105 pstrcpy(dest, dest_size, filename);
107 p = strchr(base_path, ':');
112 p1 = strrchr(base_path, '/');
116 p2 = strrchr(base_path, '\\');
128 if (len > dest_size - 1)
130 memcpy(dest, base_path, len);
132 pstrcat(dest, dest_size, filename);
137 static void bdrv_register(BlockDriver *bdrv)
139 if (!bdrv->bdrv_aio_read) {
140 /* add AIO emulation layer */
141 bdrv->bdrv_aio_read = bdrv_aio_read_em;
142 bdrv->bdrv_aio_write = bdrv_aio_write_em;
143 bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
144 bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
145 } else if (!bdrv->bdrv_read) {
146 /* add synchronous IO emulation layer */
147 bdrv->bdrv_read = bdrv_read_em;
148 bdrv->bdrv_write = bdrv_write_em;
150 bdrv->next = first_drv;
154 /* create a new block device (by default it is empty) */
155 BlockDriverState *bdrv_new(const char *device_name)
157 BlockDriverState **pbs, *bs;
159 bs = qemu_mallocz(sizeof(BlockDriverState));
160 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
161 if (device_name[0] != '\0') {
162 /* insert at the end */
171 BlockDriver *bdrv_find_format(const char *format_name)
174 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
175 if (!strcmp(drv1->format_name, format_name))
181 int bdrv_create(BlockDriver *drv,
182 const char *filename, int64_t size_in_sectors,
183 const char *backing_file, int flags)
185 if (!drv->bdrv_create)
187 return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
191 void get_tmp_filename(char *filename, int size)
193 char temp_dir[MAX_PATH];
195 GetTempPath(MAX_PATH, temp_dir);
196 GetTempFileName(temp_dir, "qem", 0, filename);
199 void get_tmp_filename(char *filename, int size)
203 /* XXX: race condition possible */
204 tmpdir = getenv("TMPDIR");
207 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
208 fd = mkstemp(filename);
214 static int is_windows_drive_prefix(const char *filename)
216 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
217 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
221 static int is_windows_drive(const char *filename)
223 if (is_windows_drive_prefix(filename) &&
226 if (strstart(filename, "\\\\.\\", NULL) ||
227 strstart(filename, "//./", NULL))
233 static BlockDriver *find_protocol(const char *filename)
241 if (is_windows_drive(filename) ||
242 is_windows_drive_prefix(filename))
245 p = strchr(filename, ':');
249 if (len > sizeof(protocol) - 1)
250 len = sizeof(protocol) - 1;
251 memcpy(protocol, filename, len);
252 protocol[len] = '\0';
253 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
254 if (drv1->protocol_name &&
255 !strcmp(drv1->protocol_name, protocol))
261 /* XXX: force raw format if block or character device ? It would
262 simplify the BSD case */
263 static BlockDriver *find_image_format(const char *filename)
265 int ret, score, score_max;
266 BlockDriver *drv1, *drv;
268 BlockDriverState *bs;
270 /* detect host devices. By convention, /dev/cdrom[N] is always
271 recognized as a host CDROM */
272 if (strstart(filename, "/dev/cdrom", NULL))
273 return &bdrv_host_device;
275 if (is_windows_drive(filename))
276 return &bdrv_host_device;
280 if (stat(filename, &st) >= 0 &&
281 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
282 return &bdrv_host_device;
287 drv = find_protocol(filename);
288 /* no need to test disk image formats for vvfat */
289 if (drv == &bdrv_vvfat)
292 ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
295 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
302 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
303 if (drv1->bdrv_probe) {
304 score = drv1->bdrv_probe(buf, ret, filename);
305 if (score > score_max) {
314 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
316 BlockDriverState *bs;
320 ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
330 int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
332 return bdrv_open2(bs, filename, flags, NULL);
335 int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
339 char tmp_filename[PATH_MAX];
340 char backing_filename[PATH_MAX];
343 bs->is_temporary = 0;
347 if (flags & BDRV_O_SNAPSHOT) {
348 BlockDriverState *bs1;
352 /* if snapshot, we create a temporary backing file and open it
353 instead of opening 'filename' directly */
355 /* if there is a backing file, use it */
357 ret = bdrv_open(bs1, filename, 0);
362 total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
364 if (bs1->drv && bs1->drv->protocol_name)
369 get_tmp_filename(tmp_filename, sizeof(tmp_filename));
371 /* Real path is meaningless for protocols */
373 snprintf(backing_filename, sizeof(backing_filename),
376 realpath(filename, backing_filename);
378 ret = bdrv_create(&bdrv_qcow2, tmp_filename,
379 total_size, backing_filename, 0);
383 filename = tmp_filename;
384 bs->is_temporary = 1;
387 pstrcpy(bs->filename, sizeof(bs->filename), filename);
388 if (flags & BDRV_O_FILE) {
389 drv = find_protocol(filename);
391 drv = find_image_format(filename);
395 goto unlink_and_fail;
398 bs->opaque = qemu_mallocz(drv->instance_size);
399 /* Note: for compatibility, we open disk image files as RDWR, and
400 RDONLY as fallback */
401 if (!(flags & BDRV_O_FILE))
402 open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK);
404 open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
405 ret = drv->bdrv_open(bs, filename, open_flags);
406 if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
407 ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
411 qemu_free(bs->opaque);
415 if (bs->is_temporary)
419 if (drv->bdrv_getlength) {
420 bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
423 if (bs->is_temporary) {
427 if (bs->backing_file[0] != '\0') {
428 /* if there is a backing file, use it */
429 bs->backing_hd = bdrv_new("");
430 path_combine(backing_filename, sizeof(backing_filename),
431 filename, bs->backing_file);
432 ret = bdrv_open(bs->backing_hd, backing_filename, open_flags);
439 if (!bdrv_key_required(bs)) {
440 /* call the change callback */
441 bs->media_changed = 1;
443 bs->change_cb(bs->change_opaque);
448 void bdrv_close(BlockDriverState *bs)
452 bdrv_delete(bs->backing_hd);
453 bs->drv->bdrv_close(bs);
454 qemu_free(bs->opaque);
456 if (bs->is_temporary) {
457 unlink(bs->filename);
463 /* call the change callback */
464 bs->media_changed = 1;
466 bs->change_cb(bs->change_opaque);
470 void bdrv_delete(BlockDriverState *bs)
472 BlockDriverState **pbs;
475 while (*pbs != bs && *pbs != NULL)
484 /* commit COW file into the raw image */
485 int bdrv_commit(BlockDriverState *bs)
487 BlockDriver *drv = bs->drv;
488 int64_t i, total_sectors;
490 unsigned char sector[512];
499 if (!bs->backing_hd) {
503 total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
504 for (i = 0; i < total_sectors;) {
505 if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
506 for(j = 0; j < n; j++) {
507 if (bdrv_read(bs, i, sector, 1) != 0) {
511 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
521 if (drv->bdrv_make_empty)
522 return drv->bdrv_make_empty(bs);
527 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
532 if (!bdrv_is_inserted(bs))
538 len = bdrv_getlength(bs);
540 if ((offset + size) > len)
546 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
551 /* Deal with byte accesses */
553 offset = -sector_num;
555 offset = sector_num * 512;
557 return bdrv_check_byte_request(bs, offset, nb_sectors * 512);
560 /* return < 0 if error. See bdrv_write() for the return codes */
561 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
562 uint8_t *buf, int nb_sectors)
564 BlockDriver *drv = bs->drv;
568 if (bdrv_check_request(bs, sector_num, nb_sectors))
571 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
574 /* Return < 0 if error. Important errors are:
575 -EIO generic I/O error (may happen for all errors)
576 -ENOMEDIUM No media inserted.
577 -EINVAL Invalid sector number or nb_sectors
578 -EACCES Trying to write a read-only device
580 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
581 const uint8_t *buf, int nb_sectors)
583 BlockDriver *drv = bs->drv;
588 if (bdrv_check_request(bs, sector_num, nb_sectors))
591 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
594 int bdrv_pread(BlockDriverState *bs, int64_t offset,
595 void *buf, int count1)
597 uint8_t tmp_buf[SECTOR_SIZE];
598 int len, nb_sectors, count;
602 /* first read to align to sector start */
603 len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
606 sector_num = offset >> SECTOR_BITS;
608 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
610 memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
618 /* read the sectors "in place" */
619 nb_sectors = count >> SECTOR_BITS;
620 if (nb_sectors > 0) {
621 if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
623 sector_num += nb_sectors;
624 len = nb_sectors << SECTOR_BITS;
629 /* add data from the last sector */
631 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
633 memcpy(buf, tmp_buf, count);
638 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
639 const void *buf, int count1)
641 uint8_t tmp_buf[SECTOR_SIZE];
642 int len, nb_sectors, count;
646 /* first write to align to sector start */
647 len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
650 sector_num = offset >> SECTOR_BITS;
652 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
654 memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len);
655 if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
664 /* write the sectors "in place" */
665 nb_sectors = count >> SECTOR_BITS;
666 if (nb_sectors > 0) {
667 if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
669 sector_num += nb_sectors;
670 len = nb_sectors << SECTOR_BITS;
675 /* add data from the last sector */
677 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
679 memcpy(tmp_buf, buf, count);
680 if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
687 * Truncate file to 'offset' bytes (needed only for file protocols)
689 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
691 BlockDriver *drv = bs->drv;
694 if (!drv->bdrv_truncate)
696 return drv->bdrv_truncate(bs, offset);
700 * Length of a file in bytes. Return < 0 if error or unknown.
702 int64_t bdrv_getlength(BlockDriverState *bs)
704 BlockDriver *drv = bs->drv;
707 if (!drv->bdrv_getlength) {
709 return bs->total_sectors * SECTOR_SIZE;
711 return drv->bdrv_getlength(bs);
714 /* return 0 as number of sectors if no device present or error */
715 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
718 length = bdrv_getlength(bs);
722 length = length >> SECTOR_BITS;
723 *nb_sectors_ptr = length;
727 uint8_t boot_ind; /* 0x80 - active */
728 uint8_t head; /* starting head */
729 uint8_t sector; /* starting sector */
730 uint8_t cyl; /* starting cylinder */
731 uint8_t sys_ind; /* What partition type */
732 uint8_t end_head; /* end head */
733 uint8_t end_sector; /* end sector */
734 uint8_t end_cyl; /* end cylinder */
735 uint32_t start_sect; /* starting sector counting from 0 */
736 uint32_t nr_sects; /* nr of sectors in partition */
737 } __attribute__((packed));
739 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
740 static int guess_disk_lchs(BlockDriverState *bs,
741 int *pcylinders, int *pheads, int *psectors)
744 int ret, i, heads, sectors, cylinders;
749 bdrv_get_geometry(bs, &nb_sectors);
751 ret = bdrv_read(bs, 0, buf, 1);
754 /* test msdos magic */
755 if (buf[510] != 0x55 || buf[511] != 0xaa)
757 for(i = 0; i < 4; i++) {
758 p = ((struct partition *)(buf + 0x1be)) + i;
759 nr_sects = le32_to_cpu(p->nr_sects);
760 if (nr_sects && p->end_head) {
761 /* We make the assumption that the partition terminates on
762 a cylinder boundary */
763 heads = p->end_head + 1;
764 sectors = p->end_sector & 63;
767 cylinders = nb_sectors / (heads * sectors);
768 if (cylinders < 1 || cylinders > 16383)
772 *pcylinders = cylinders;
774 printf("guessed geometry: LCHS=%d %d %d\n",
775 cylinders, heads, sectors);
783 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
785 int translation, lba_detected = 0;
786 int cylinders, heads, secs;
789 /* if a geometry hint is available, use it */
790 bdrv_get_geometry(bs, &nb_sectors);
791 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
792 translation = bdrv_get_translation_hint(bs);
793 if (cylinders != 0) {
798 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
800 /* if heads > 16, it means that a BIOS LBA
801 translation was active, so the default
802 hardware geometry is OK */
804 goto default_geometry;
809 /* disable any translation to be in sync with
810 the logical geometry */
811 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
812 bdrv_set_translation_hint(bs,
813 BIOS_ATA_TRANSLATION_NONE);
818 /* if no geometry, use a standard physical disk geometry */
819 cylinders = nb_sectors / (16 * 63);
821 if (cylinders > 16383)
823 else if (cylinders < 2)
828 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
829 if ((*pcyls * *pheads) <= 131072) {
830 bdrv_set_translation_hint(bs,
831 BIOS_ATA_TRANSLATION_LARGE);
833 bdrv_set_translation_hint(bs,
834 BIOS_ATA_TRANSLATION_LBA);
838 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
842 void bdrv_set_geometry_hint(BlockDriverState *bs,
843 int cyls, int heads, int secs)
850 void bdrv_set_type_hint(BlockDriverState *bs, int type)
853 bs->removable = ((type == BDRV_TYPE_CDROM ||
854 type == BDRV_TYPE_FLOPPY));
857 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
859 bs->translation = translation;
862 void bdrv_get_geometry_hint(BlockDriverState *bs,
863 int *pcyls, int *pheads, int *psecs)
870 int bdrv_get_type_hint(BlockDriverState *bs)
875 int bdrv_get_translation_hint(BlockDriverState *bs)
877 return bs->translation;
880 int bdrv_is_removable(BlockDriverState *bs)
882 return bs->removable;
885 int bdrv_is_read_only(BlockDriverState *bs)
887 return bs->read_only;
890 int bdrv_is_sg(BlockDriverState *bs)
895 /* XXX: no longer used */
896 void bdrv_set_change_cb(BlockDriverState *bs,
897 void (*change_cb)(void *opaque), void *opaque)
899 bs->change_cb = change_cb;
900 bs->change_opaque = opaque;
903 int bdrv_is_encrypted(BlockDriverState *bs)
905 if (bs->backing_hd && bs->backing_hd->encrypted)
907 return bs->encrypted;
910 int bdrv_key_required(BlockDriverState *bs)
912 BlockDriverState *backing_hd = bs->backing_hd;
914 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
916 return (bs->encrypted && !bs->valid_key);
919 int bdrv_set_key(BlockDriverState *bs, const char *key)
922 if (bs->backing_hd && bs->backing_hd->encrypted) {
923 ret = bdrv_set_key(bs->backing_hd, key);
929 if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
931 ret = bs->drv->bdrv_set_key(bs, key);
934 } else if (!bs->valid_key) {
936 /* call the change callback now, we skipped it on open */
937 bs->media_changed = 1;
939 bs->change_cb(bs->change_opaque);
944 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
949 pstrcpy(buf, buf_size, bs->drv->format_name);
953 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
958 for (drv = first_drv; drv != NULL; drv = drv->next) {
959 it(opaque, drv->format_name);
963 BlockDriverState *bdrv_find(const char *name)
965 BlockDriverState *bs;
967 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
968 if (!strcmp(name, bs->device_name))
974 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
976 BlockDriverState *bs;
978 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
983 const char *bdrv_get_device_name(BlockDriverState *bs)
985 return bs->device_name;
988 void bdrv_flush(BlockDriverState *bs)
990 if (bs->drv->bdrv_flush)
991 bs->drv->bdrv_flush(bs);
993 bdrv_flush(bs->backing_hd);
996 void bdrv_flush_all(void)
998 BlockDriverState *bs;
1000 for (bs = bdrv_first; bs != NULL; bs = bs->next)
1001 if (bs->drv && !bdrv_is_read_only(bs) &&
1002 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
1007 * Returns true iff the specified sector is present in the disk image. Drivers
1008 * not implementing the functionality are assumed to not support backing files,
1009 * hence all their sectors are reported as allocated.
1011 * 'pnum' is set to the number of sectors (including and immediately following
1012 * the specified sector) that are known to be in the same
1013 * allocated/unallocated state.
1015 * 'nb_sectors' is the max value 'pnum' should be set to.
1017 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1021 if (!bs->drv->bdrv_is_allocated) {
1022 if (sector_num >= bs->total_sectors) {
1026 n = bs->total_sectors - sector_num;
1027 *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1030 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1033 void bdrv_info(Monitor *mon)
1035 BlockDriverState *bs;
1037 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1038 monitor_printf(mon, "%s:", bs->device_name);
1039 monitor_printf(mon, " type=");
1042 monitor_printf(mon, "hd");
1044 case BDRV_TYPE_CDROM:
1045 monitor_printf(mon, "cdrom");
1047 case BDRV_TYPE_FLOPPY:
1048 monitor_printf(mon, "floppy");
1051 monitor_printf(mon, " removable=%d", bs->removable);
1052 if (bs->removable) {
1053 monitor_printf(mon, " locked=%d", bs->locked);
1056 monitor_printf(mon, " file=");
1057 monitor_print_filename(mon, bs->filename);
1058 if (bs->backing_file[0] != '\0') {
1059 monitor_printf(mon, " backing_file=");
1060 monitor_print_filename(mon, bs->backing_file);
1062 monitor_printf(mon, " ro=%d", bs->read_only);
1063 monitor_printf(mon, " drv=%s", bs->drv->format_name);
1064 monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
1066 monitor_printf(mon, " [not inserted]");
1068 monitor_printf(mon, "\n");
1072 /* The "info blockstats" command. */
1073 void bdrv_info_stats(Monitor *mon)
1075 BlockDriverState *bs;
1077 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1078 monitor_printf(mon, "%s:"
1079 " rd_bytes=%" PRIu64
1080 " wr_bytes=%" PRIu64
1081 " rd_operations=%" PRIu64
1082 " wr_operations=%" PRIu64
1085 bs->rd_bytes, bs->wr_bytes,
1086 bs->rd_ops, bs->wr_ops);
1090 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1092 if (bs->backing_hd && bs->backing_hd->encrypted)
1093 return bs->backing_file;
1094 else if (bs->encrypted)
1095 return bs->filename;
1100 void bdrv_get_backing_filename(BlockDriverState *bs,
1101 char *filename, int filename_size)
1103 if (!bs->backing_hd) {
1104 pstrcpy(filename, filename_size, "");
1106 pstrcpy(filename, filename_size, bs->backing_file);
1110 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1111 const uint8_t *buf, int nb_sectors)
1113 BlockDriver *drv = bs->drv;
1116 if (!drv->bdrv_write_compressed)
1118 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1121 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1123 BlockDriver *drv = bs->drv;
1126 if (!drv->bdrv_get_info)
1128 memset(bdi, 0, sizeof(*bdi));
1129 return drv->bdrv_get_info(bs, bdi);
1132 /**************************************************************/
1133 /* handling of snapshots */
1135 int bdrv_snapshot_create(BlockDriverState *bs,
1136 QEMUSnapshotInfo *sn_info)
1138 BlockDriver *drv = bs->drv;
1141 if (!drv->bdrv_snapshot_create)
1143 return drv->bdrv_snapshot_create(bs, sn_info);
1146 int bdrv_snapshot_goto(BlockDriverState *bs,
1147 const char *snapshot_id)
1149 BlockDriver *drv = bs->drv;
1152 if (!drv->bdrv_snapshot_goto)
1154 return drv->bdrv_snapshot_goto(bs, snapshot_id);
1157 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1159 BlockDriver *drv = bs->drv;
1162 if (!drv->bdrv_snapshot_delete)
1164 return drv->bdrv_snapshot_delete(bs, snapshot_id);
1167 int bdrv_snapshot_list(BlockDriverState *bs,
1168 QEMUSnapshotInfo **psn_info)
1170 BlockDriver *drv = bs->drv;
1173 if (!drv->bdrv_snapshot_list)
1175 return drv->bdrv_snapshot_list(bs, psn_info);
1178 #define NB_SUFFIXES 4
1180 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1182 static const char suffixes[NB_SUFFIXES] = "KMGT";
1187 snprintf(buf, buf_size, "%" PRId64, size);
1190 for(i = 0; i < NB_SUFFIXES; i++) {
1191 if (size < (10 * base)) {
1192 snprintf(buf, buf_size, "%0.1f%c",
1193 (double)size / base,
1196 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1197 snprintf(buf, buf_size, "%" PRId64 "%c",
1198 ((size + (base >> 1)) / base),
1208 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1210 char buf1[128], date_buf[128], clock_buf[128];
1220 snprintf(buf, buf_size,
1221 "%-10s%-20s%7s%20s%15s",
1222 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1226 ptm = localtime(&ti);
1227 strftime(date_buf, sizeof(date_buf),
1228 "%Y-%m-%d %H:%M:%S", ptm);
1230 localtime_r(&ti, &tm);
1231 strftime(date_buf, sizeof(date_buf),
1232 "%Y-%m-%d %H:%M:%S", &tm);
1234 secs = sn->vm_clock_nsec / 1000000000;
1235 snprintf(clock_buf, sizeof(clock_buf),
1236 "%02d:%02d:%02d.%03d",
1238 (int)((secs / 60) % 60),
1240 (int)((sn->vm_clock_nsec / 1000000) % 1000));
1241 snprintf(buf, buf_size,
1242 "%-10s%-20s%7s%20s%15s",
1243 sn->id_str, sn->name,
1244 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1252 /**************************************************************/
1255 typedef struct VectorTranslationState {
1259 BlockDriverAIOCB *aiocb;
1260 BlockDriverAIOCB *this_aiocb;
1261 } VectorTranslationState;
1263 static void bdrv_aio_rw_vector_cb(void *opaque, int ret)
1265 VectorTranslationState *s = opaque;
1268 qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size);
1270 qemu_vfree(s->bounce);
1271 s->this_aiocb->cb(s->this_aiocb->opaque, ret);
1272 qemu_aio_release(s->this_aiocb);
1275 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
1279 BlockDriverCompletionFunc *cb,
1284 VectorTranslationState *s = qemu_mallocz(sizeof(*s));
1285 BlockDriverAIOCB *aiocb = qemu_aio_get(bs, cb, opaque);
1287 s->this_aiocb = aiocb;
1289 s->bounce = qemu_memalign(512, nb_sectors * 512);
1290 s->is_write = is_write;
1292 qemu_iovec_to_buffer(s->iov, s->bounce);
1293 s->aiocb = bdrv_aio_write(bs, sector_num, s->bounce, nb_sectors,
1294 bdrv_aio_rw_vector_cb, s);
1296 s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors,
1297 bdrv_aio_rw_vector_cb, s);
1302 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1303 QEMUIOVector *iov, int nb_sectors,
1304 BlockDriverCompletionFunc *cb, void *opaque)
1306 if (bdrv_check_request(bs, sector_num, nb_sectors))
1309 return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
1313 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
1314 QEMUIOVector *iov, int nb_sectors,
1315 BlockDriverCompletionFunc *cb, void *opaque)
1317 if (bdrv_check_request(bs, sector_num, nb_sectors))
1320 return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
1324 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
1325 uint8_t *buf, int nb_sectors,
1326 BlockDriverCompletionFunc *cb, void *opaque)
1328 BlockDriver *drv = bs->drv;
1329 BlockDriverAIOCB *ret;
1333 if (bdrv_check_request(bs, sector_num, nb_sectors))
1336 ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
1339 /* Update stats even though technically transfer has not happened. */
1340 bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1347 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
1348 const uint8_t *buf, int nb_sectors,
1349 BlockDriverCompletionFunc *cb, void *opaque)
1351 BlockDriver *drv = bs->drv;
1352 BlockDriverAIOCB *ret;
1358 if (bdrv_check_request(bs, sector_num, nb_sectors))
1361 ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
1364 /* Update stats even though technically transfer has not happened. */
1365 bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1372 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1374 BlockDriver *drv = acb->bs->drv;
1376 if (acb->cb == bdrv_aio_rw_vector_cb) {
1377 VectorTranslationState *s = acb->opaque;
1381 drv->bdrv_aio_cancel(acb);
1385 /**************************************************************/
1386 /* async block device emulation */
1388 static void bdrv_aio_bh_cb(void *opaque)
1390 BlockDriverAIOCBSync *acb = opaque;
1391 acb->common.cb(acb->common.opaque, acb->ret);
1392 qemu_aio_release(acb);
1395 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
1396 int64_t sector_num, uint8_t *buf, int nb_sectors,
1397 BlockDriverCompletionFunc *cb, void *opaque)
1399 BlockDriverAIOCBSync *acb;
1402 acb = qemu_aio_get(bs, cb, opaque);
1404 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1405 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
1407 qemu_bh_schedule(acb->bh);
1408 return &acb->common;
1411 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
1412 int64_t sector_num, const uint8_t *buf, int nb_sectors,
1413 BlockDriverCompletionFunc *cb, void *opaque)
1415 BlockDriverAIOCBSync *acb;
1418 acb = qemu_aio_get(bs, cb, opaque);
1420 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1421 ret = bdrv_write(bs, sector_num, buf, nb_sectors);
1423 qemu_bh_schedule(acb->bh);
1424 return &acb->common;
1427 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
1429 BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1430 qemu_bh_cancel(acb->bh);
1431 qemu_aio_release(acb);
1434 /**************************************************************/
1435 /* sync block device emulation */
1437 static void bdrv_rw_em_cb(void *opaque, int ret)
1439 *(int *)opaque = ret;
1442 #define NOT_DONE 0x7fffffff
1444 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1445 uint8_t *buf, int nb_sectors)
1448 BlockDriverAIOCB *acb;
1450 async_ret = NOT_DONE;
1451 acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
1452 bdrv_rw_em_cb, &async_ret);
1456 while (async_ret == NOT_DONE) {
1463 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
1464 const uint8_t *buf, int nb_sectors)
1467 BlockDriverAIOCB *acb;
1469 async_ret = NOT_DONE;
1470 acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
1471 bdrv_rw_em_cb, &async_ret);
1474 while (async_ret == NOT_DONE) {
1480 void bdrv_init(void)
1482 bdrv_register(&bdrv_raw);
1483 bdrv_register(&bdrv_host_device);
1485 bdrv_register(&bdrv_cow);
1487 bdrv_register(&bdrv_qcow);
1488 bdrv_register(&bdrv_vmdk);
1489 bdrv_register(&bdrv_cloop);
1490 bdrv_register(&bdrv_dmg);
1491 bdrv_register(&bdrv_bochs);
1492 bdrv_register(&bdrv_vpc);
1493 bdrv_register(&bdrv_vvfat);
1494 bdrv_register(&bdrv_qcow2);
1495 bdrv_register(&bdrv_parallels);
1496 bdrv_register(&bdrv_nbd);
1499 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
1503 BlockDriverAIOCB *acb;
1506 if (drv->free_aiocb) {
1507 acb = drv->free_aiocb;
1508 drv->free_aiocb = acb->next;
1510 acb = qemu_mallocz(drv->aiocb_size);
1514 acb->opaque = opaque;
1518 void qemu_aio_release(void *p)
1520 BlockDriverAIOCB *acb = p;
1521 BlockDriver *drv = acb->bs->drv;
1522 acb->next = drv->free_aiocb;
1523 drv->free_aiocb = acb;
1526 /**************************************************************/
1527 /* removable device support */
1530 * Return TRUE if the media is present
1532 int bdrv_is_inserted(BlockDriverState *bs)
1534 BlockDriver *drv = bs->drv;
1538 if (!drv->bdrv_is_inserted)
1540 ret = drv->bdrv_is_inserted(bs);
1545 * Return TRUE if the media changed since the last call to this
1546 * function. It is currently only used for floppy disks
1548 int bdrv_media_changed(BlockDriverState *bs)
1550 BlockDriver *drv = bs->drv;
1553 if (!drv || !drv->bdrv_media_changed)
1556 ret = drv->bdrv_media_changed(bs);
1557 if (ret == -ENOTSUP)
1558 ret = bs->media_changed;
1559 bs->media_changed = 0;
1564 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
1566 void bdrv_eject(BlockDriverState *bs, int eject_flag)
1568 BlockDriver *drv = bs->drv;
1571 if (!drv || !drv->bdrv_eject) {
1574 ret = drv->bdrv_eject(bs, eject_flag);
1576 if (ret == -ENOTSUP) {
1582 int bdrv_is_locked(BlockDriverState *bs)
1588 * Lock or unlock the media (if it is locked, the user won't be able
1589 * to eject it manually).
1591 void bdrv_set_locked(BlockDriverState *bs, int locked)
1593 BlockDriver *drv = bs->drv;
1595 bs->locked = locked;
1596 if (drv && drv->bdrv_set_locked) {
1597 drv->bdrv_set_locked(bs, locked);
1601 /* needed for generic scsi interface */
1603 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1605 BlockDriver *drv = bs->drv;
1607 if (drv && drv->bdrv_ioctl)
1608 return drv->bdrv_ioctl(bs, req, buf);
1612 int bdrv_sg_send_command(BlockDriverState *bs, void *buf, int count)
1614 return bs->drv->bdrv_sg_send_command(bs, buf, count);
1617 int bdrv_sg_recv_response(BlockDriverState *bs, void *buf, int count)
1619 return bs->drv->bdrv_sg_recv_response(bs, buf, count);
1622 BlockDriverAIOCB *bdrv_sg_aio_read(BlockDriverState *bs, void *buf, int count,
1623 BlockDriverCompletionFunc *cb, void *opaque)
1625 return bs->drv->bdrv_sg_aio_read(bs, buf, count, cb, opaque);
1628 BlockDriverAIOCB *bdrv_sg_aio_write(BlockDriverState *bs, void *buf, int count,
1629 BlockDriverCompletionFunc *cb, void *opaque)
1631 return bs->drv->bdrv_sg_aio_write(bs, buf, count, cb, opaque);