--- qemu/block.c 2018/04/24 16:44:58 1.1.1.5 +++ qemu/block.c 2018/04/24 17:01:52 1.1.1.9 @@ -1,8 +1,8 @@ /* * QEMU System Emulator block driver - * + * * Copyright (c) 2003 Fabrice Bellard - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights @@ -21,14 +21,20 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -#include "vl.h" +#include "config-host.h" +#ifdef _BSD +/* include native header before sys-queue.h */ +#include +#endif + +#include "qemu-common.h" +#include "console.h" #include "block_int.h" #ifdef _BSD #include #include #include -#include #include #endif @@ -48,12 +54,13 @@ static BlockDriverAIOCB *bdrv_aio_write_ int64_t sector_num, const uint8_t *buf, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb); -static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, +static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors); static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors); -static BlockDriverState *bdrv_first; +BlockDriverState *bdrv_first; + static BlockDriver *first_drv; int path_is_absolute(const char *path) @@ -121,7 +128,7 @@ void path_combine(char *dest, int dest_s } -void bdrv_register(BlockDriver *bdrv) +static void bdrv_register(BlockDriver *bdrv) { if (!bdrv->bdrv_aio_read) { /* add AIO emulation layer */ @@ -144,8 +151,6 @@ BlockDriverState *bdrv_new(const char *d BlockDriverState **pbs, *bs; bs = qemu_mallocz(sizeof(BlockDriverState)); - if(!bs) - return NULL; pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); if (device_name[0] != '\0') { /* insert at the end */ @@ -167,7 +172,7 @@ BlockDriver *bdrv_find_format(const char return NULL; } -int bdrv_create(BlockDriver *drv, +int bdrv_create(BlockDriver *drv, const char *filename, int64_t size_in_sectors, const char *backing_file, int flags) { @@ -180,7 +185,7 @@ int bdrv_create(BlockDriver *drv, void get_tmp_filename(char *filename, int size) { char temp_dir[MAX_PATH]; - + GetTempPath(MAX_PATH, temp_dir); GetTempFileName(temp_dir, "qem", 0, filename); } @@ -188,8 +193,12 @@ void get_tmp_filename(char *filename, in void get_tmp_filename(char *filename, int size) { int fd; + const char *tmpdir; /* XXX: race condition possible */ - pstrcpy(filename, size, "/tmp/vl.XXXXXX"); + tmpdir = getenv("TMPDIR"); + if (!tmpdir) + tmpdir = "/tmp"; + snprintf(filename, size, "%s/vl.XXXXXX", tmpdir); fd = mkstemp(filename); close(fd); } @@ -202,10 +211,10 @@ static int is_windows_drive_prefix(const (filename[0] >= 'A' && filename[0] <= 'Z')) && filename[1] == ':'); } - + static int is_windows_drive(const char *filename) { - if (is_windows_drive_prefix(filename) && + if (is_windows_drive_prefix(filename) && filename[2] == '\0') return 1; if (strstart(filename, "\\\\.\\", NULL) || @@ -236,7 +245,7 @@ static BlockDriver *find_protocol(const memcpy(protocol, filename, len); protocol[len] = '\0'; for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) { - if (drv1->protocol_name && + if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) return drv1; } @@ -251,7 +260,7 @@ static BlockDriver *find_image_format(co BlockDriver *drv1, *drv; uint8_t buf[2048]; BlockDriverState *bs; - + /* detect host devices. By convention, /dev/cdrom[N] is always recognized as a host CDROM */ if (strstart(filename, "/dev/cdrom", NULL)) @@ -262,13 +271,13 @@ static BlockDriver *find_image_format(co #else { struct stat st; - if (stat(filename, &st) >= 0 && + if (stat(filename, &st) >= 0 && (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) { return &bdrv_host_device; } } #endif - + drv = find_protocol(filename); /* no need to test disk image formats for vvfat */ if (drv == &bdrv_vvfat) @@ -302,13 +311,12 @@ int bdrv_file_open(BlockDriverState **pb int ret; bs = bdrv_new(""); - if (!bs) - return -ENOMEM; ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL); if (ret < 0) { bdrv_delete(bs); return ret; } + bs->growable = 1; *pbs = bs; return 0; } @@ -322,37 +330,49 @@ int bdrv_open2(BlockDriverState *bs, con BlockDriver *drv) { int ret, open_flags; - char tmp_filename[1024]; - char backing_filename[1024]; - + char tmp_filename[PATH_MAX]; + char backing_filename[PATH_MAX]; + bs->read_only = 0; bs->is_temporary = 0; bs->encrypted = 0; + bs->valid_key = 0; if (flags & BDRV_O_SNAPSHOT) { BlockDriverState *bs1; int64_t total_size; - + int is_protocol = 0; + /* if snapshot, we create a temporary backing file and open it instead of opening 'filename' directly */ /* if there is a backing file, use it */ bs1 = bdrv_new(""); - if (!bs1) { - return -ENOMEM; - } - if (bdrv_open(bs1, filename, 0) < 0) { + ret = bdrv_open(bs1, filename, 0); + if (ret < 0) { bdrv_delete(bs1); - return -1; + return ret; } total_size = bdrv_getlength(bs1) >> SECTOR_BITS; + + if (bs1->drv && bs1->drv->protocol_name) + is_protocol = 1; + bdrv_delete(bs1); - + get_tmp_filename(tmp_filename, sizeof(tmp_filename)); - realpath(filename, backing_filename); - if (bdrv_create(&bdrv_qcow2, tmp_filename, - total_size, backing_filename, 0) < 0) { - return -1; + + /* Real path is meaningless for protocols */ + if (is_protocol) + snprintf(backing_filename, sizeof(backing_filename), + "%s", filename); + else + realpath(filename, backing_filename); + + ret = bdrv_create(&bdrv_qcow2, tmp_filename, + total_size, backing_filename, 0); + if (ret < 0) { + return ret; } filename = tmp_filename; bs->is_temporary = 1; @@ -361,34 +381,33 @@ int bdrv_open2(BlockDriverState *bs, con pstrcpy(bs->filename, sizeof(bs->filename), filename); if (flags & BDRV_O_FILE) { drv = find_protocol(filename); - if (!drv) - return -ENOENT; - } else { - if (!drv) { - drv = find_image_format(filename); - if (!drv) - return -1; - } + } else if (!drv) { + drv = find_image_format(filename); + } + if (!drv) { + ret = -ENOENT; + goto unlink_and_fail; } bs->drv = drv; bs->opaque = qemu_mallocz(drv->instance_size); - if (bs->opaque == NULL && drv->instance_size > 0) - return -1; /* Note: for compatibility, we open disk image files as RDWR, and RDONLY as fallback */ if (!(flags & BDRV_O_FILE)) - open_flags = BDRV_O_RDWR; + open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK); else open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT); ret = drv->bdrv_open(bs, filename, open_flags); - if (ret == -EACCES && !(flags & BDRV_O_FILE)) { - ret = drv->bdrv_open(bs, filename, BDRV_O_RDONLY); + if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) { + ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR); bs->read_only = 1; } if (ret < 0) { qemu_free(bs->opaque); bs->opaque = NULL; bs->drv = NULL; + unlink_and_fail: + if (bs->is_temporary) + unlink(filename); return ret; } if (drv->bdrv_getlength) { @@ -402,15 +421,13 @@ int bdrv_open2(BlockDriverState *bs, con if (bs->backing_file[0] != '\0') { /* if there is a backing file, use it */ bs->backing_hd = bdrv_new(""); - if (!bs->backing_hd) { - fail: - bdrv_close(bs); - return -ENOMEM; - } path_combine(backing_filename, sizeof(backing_filename), filename, bs->backing_file); - if (bdrv_open(bs->backing_hd, backing_filename, 0) < 0) - goto fail; + ret = bdrv_open(bs->backing_hd, backing_filename, open_flags); + if (ret < 0) { + bdrv_close(bs); + return ret; + } } /* call the change callback */ @@ -445,7 +462,14 @@ void bdrv_close(BlockDriverState *bs) void bdrv_delete(BlockDriverState *bs) { - /* XXX: remove the driver list */ + BlockDriverState **pbs; + + pbs = &bdrv_first; + while (*pbs != bs && *pbs != NULL) + pbs = &(*pbs)->next; + if (*pbs == bs) + *pbs = bs->next; + bdrv_close(bs); qemu_free(bs); } @@ -493,23 +517,50 @@ int bdrv_commit(BlockDriverState *bs) return 0; } +static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, + size_t size) +{ + int64_t len; + + if (!bdrv_is_inserted(bs)) + return -ENOMEDIUM; + + if (bs->growable) + return 0; + + len = bdrv_getlength(bs); + + if ((offset + size) > len) + return -EIO; + + return 0; +} + +static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, + int nb_sectors) +{ + int64_t offset; + + /* Deal with byte accesses */ + if (sector_num < 0) + offset = -sector_num; + else + offset = sector_num * 512; + + return bdrv_check_byte_request(bs, offset, nb_sectors * 512); +} + /* return < 0 if error. See bdrv_write() for the return codes */ -int bdrv_read(BlockDriverState *bs, int64_t sector_num, +int bdrv_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors) { BlockDriver *drv = bs->drv; if (!drv) return -ENOMEDIUM; + if (bdrv_check_request(bs, sector_num, nb_sectors)) + return -EIO; - if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { - memcpy(buf, bs->boot_sector_data, 512); - sector_num++; - nb_sectors--; - buf += 512; - if (nb_sectors == 0) - return 0; - } if (drv->bdrv_pread) { int ret, len; len = nb_sectors * 512; @@ -518,20 +569,23 @@ int bdrv_read(BlockDriverState *bs, int6 return ret; else if (ret != len) return -EINVAL; - else + else { + bs->rd_bytes += (unsigned) len; + bs->rd_ops ++; return 0; + } } else { return drv->bdrv_read(bs, sector_num, buf, nb_sectors); } } -/* Return < 0 if error. Important errors are: +/* Return < 0 if error. Important errors are: -EIO generic I/O error (may happen for all errors) -ENOMEDIUM No media inserted. -EINVAL Invalid sector number or nb_sectors -EACCES Trying to write a read-only device */ -int bdrv_write(BlockDriverState *bs, int64_t sector_num, +int bdrv_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors) { BlockDriver *drv = bs->drv; @@ -539,25 +593,29 @@ int bdrv_write(BlockDriverState *bs, int return -ENOMEDIUM; if (bs->read_only) return -EACCES; - if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { - memcpy(bs->boot_sector_data, buf, 512); - } + if (bdrv_check_request(bs, sector_num, nb_sectors)) + return -EIO; + if (drv->bdrv_pwrite) { - int ret, len; + int ret, len, count = 0; len = nb_sectors * 512; - ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len); - if (ret < 0) - return ret; - else if (ret != len) - return -EIO; - else - return 0; - } else { - return drv->bdrv_write(bs, sector_num, buf, nb_sectors); + do { + ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len - count); + if (ret < 0) { + printf("bdrv_write ret=%d\n", ret); + return ret; + } + count += ret; + buf += ret; + } while (count != len); + bs->wr_bytes += (unsigned) len; + bs->wr_ops ++; + return 0; } + return drv->bdrv_write(bs, sector_num, buf, nb_sectors); } -static int bdrv_pread_em(BlockDriverState *bs, int64_t offset, +static int bdrv_pread_em(BlockDriverState *bs, int64_t offset, uint8_t *buf, int count1) { uint8_t tmp_buf[SECTOR_SIZE]; @@ -601,7 +659,7 @@ static int bdrv_pread_em(BlockDriverStat return count1; } -static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset, +static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset, const uint8_t *buf, int count1) { uint8_t tmp_buf[SECTOR_SIZE]; @@ -650,30 +708,36 @@ static int bdrv_pwrite_em(BlockDriverSta } /** - * Read with byte offsets (needed only for file protocols) + * Read with byte offsets (needed only for file protocols) */ -int bdrv_pread(BlockDriverState *bs, int64_t offset, +int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf1, int count1) { BlockDriver *drv = bs->drv; if (!drv) return -ENOMEDIUM; + if (bdrv_check_byte_request(bs, offset, count1)) + return -EIO; + if (!drv->bdrv_pread) return bdrv_pread_em(bs, offset, buf1, count1); return drv->bdrv_pread(bs, offset, buf1, count1); } -/** - * Write with byte offsets (needed only for file protocols) +/** + * Write with byte offsets (needed only for file protocols) */ -int bdrv_pwrite(BlockDriverState *bs, int64_t offset, +int bdrv_pwrite(BlockDriverState *bs, int64_t offset, const void *buf1, int count1) { BlockDriver *drv = bs->drv; if (!drv) return -ENOMEDIUM; + if (bdrv_check_byte_request(bs, offset, count1)) + return -EIO; + if (!drv->bdrv_pwrite) return bdrv_pwrite_em(bs, offset, buf1, count1); return drv->bdrv_pwrite(bs, offset, buf1, count1); @@ -708,7 +772,7 @@ int64_t bdrv_getlength(BlockDriverState } /* return 0 as number of sectors if no device present or error */ -void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr) +void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) { int64_t length; length = bdrv_getlength(bs); @@ -719,17 +783,123 @@ void bdrv_get_geometry(BlockDriverState *nb_sectors_ptr = length; } -/* force a given boot sector. */ -void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size) +struct partition { + uint8_t boot_ind; /* 0x80 - active */ + uint8_t head; /* starting head */ + uint8_t sector; /* starting sector */ + uint8_t cyl; /* starting cylinder */ + uint8_t sys_ind; /* What partition type */ + uint8_t end_head; /* end head */ + uint8_t end_sector; /* end sector */ + uint8_t end_cyl; /* end cylinder */ + uint32_t start_sect; /* starting sector counting from 0 */ + uint32_t nr_sects; /* nr of sectors in partition */ +} __attribute__((packed)); + +/* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */ +static int guess_disk_lchs(BlockDriverState *bs, + int *pcylinders, int *pheads, int *psectors) +{ + uint8_t buf[512]; + int ret, i, heads, sectors, cylinders; + struct partition *p; + uint32_t nr_sects; + uint64_t nb_sectors; + + bdrv_get_geometry(bs, &nb_sectors); + + ret = bdrv_read(bs, 0, buf, 1); + if (ret < 0) + return -1; + /* test msdos magic */ + if (buf[510] != 0x55 || buf[511] != 0xaa) + return -1; + for(i = 0; i < 4; i++) { + p = ((struct partition *)(buf + 0x1be)) + i; + nr_sects = le32_to_cpu(p->nr_sects); + if (nr_sects && p->end_head) { + /* We make the assumption that the partition terminates on + a cylinder boundary */ + heads = p->end_head + 1; + sectors = p->end_sector & 63; + if (sectors == 0) + continue; + cylinders = nb_sectors / (heads * sectors); + if (cylinders < 1 || cylinders > 16383) + continue; + *pheads = heads; + *psectors = sectors; + *pcylinders = cylinders; +#if 0 + printf("guessed geometry: LCHS=%d %d %d\n", + cylinders, heads, sectors); +#endif + return 0; + } + } + return -1; +} + +void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs) { - bs->boot_sector_enabled = 1; - if (size > 512) - size = 512; - memcpy(bs->boot_sector_data, data, size); - memset(bs->boot_sector_data + size, 0, 512 - size); + int translation, lba_detected = 0; + int cylinders, heads, secs; + uint64_t nb_sectors; + + /* if a geometry hint is available, use it */ + bdrv_get_geometry(bs, &nb_sectors); + bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs); + translation = bdrv_get_translation_hint(bs); + if (cylinders != 0) { + *pcyls = cylinders; + *pheads = heads; + *psecs = secs; + } else { + if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) { + if (heads > 16) { + /* if heads > 16, it means that a BIOS LBA + translation was active, so the default + hardware geometry is OK */ + lba_detected = 1; + goto default_geometry; + } else { + *pcyls = cylinders; + *pheads = heads; + *psecs = secs; + /* disable any translation to be in sync with + the logical geometry */ + if (translation == BIOS_ATA_TRANSLATION_AUTO) { + bdrv_set_translation_hint(bs, + BIOS_ATA_TRANSLATION_NONE); + } + } + } else { + default_geometry: + /* if no geometry, use a standard physical disk geometry */ + cylinders = nb_sectors / (16 * 63); + + if (cylinders > 16383) + cylinders = 16383; + else if (cylinders < 2) + cylinders = 2; + *pcyls = cylinders; + *pheads = 16; + *psecs = 63; + if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) { + if ((*pcyls * *pheads) <= 131072) { + bdrv_set_translation_hint(bs, + BIOS_ATA_TRANSLATION_LARGE); + } else { + bdrv_set_translation_hint(bs, + BIOS_ATA_TRANSLATION_LBA); + } + } + } + bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs); + } } -void bdrv_set_geometry_hint(BlockDriverState *bs, +void bdrv_set_geometry_hint(BlockDriverState *bs, int cyls, int heads, int secs) { bs->cyls = cyls; @@ -749,7 +919,7 @@ void bdrv_set_translation_hint(BlockDriv bs->translation = translation; } -void bdrv_get_geometry_hint(BlockDriverState *bs, +void bdrv_get_geometry_hint(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs) { *pcyls = bs->cyls; @@ -777,8 +947,13 @@ int bdrv_is_read_only(BlockDriverState * return bs->read_only; } +int bdrv_is_sg(BlockDriverState *bs) +{ + return bs->sg; +} + /* XXX: no longer used */ -void bdrv_set_change_cb(BlockDriverState *bs, +void bdrv_set_change_cb(BlockDriverState *bs, void (*change_cb)(void *opaque), void *opaque) { bs->change_cb = change_cb; @@ -792,6 +967,15 @@ int bdrv_is_encrypted(BlockDriverState * return bs->encrypted; } +int bdrv_key_required(BlockDriverState *bs) +{ + BlockDriverState *backing_hd = bs->backing_hd; + + if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key) + return 1; + return (bs->encrypted && !bs->valid_key); +} + int bdrv_set_key(BlockDriverState *bs, const char *key) { int ret; @@ -804,7 +988,9 @@ int bdrv_set_key(BlockDriverState *bs, c } if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key) return -1; - return bs->drv->bdrv_set_key(bs, key); + ret = bs->drv->bdrv_set_key(bs, key); + bs->valid_key = (ret == 0); + return ret; } void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size) @@ -816,7 +1002,7 @@ void bdrv_get_format(BlockDriverState *b } } -void bdrv_iterate_format(void (*it)(void *opaque, const char *name), +void bdrv_iterate_format(void (*it)(void *opaque, const char *name), void *opaque) { BlockDriver *drv; @@ -837,12 +1023,12 @@ BlockDriverState *bdrv_find(const char * return NULL; } -void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque) +void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) { BlockDriverState *bs; for (bs = bdrv_first; bs != NULL; bs = bs->next) { - it(opaque, bs->device_name); + it(opaque, bs); } } @@ -859,6 +1045,43 @@ void bdrv_flush(BlockDriverState *bs) bdrv_flush(bs->backing_hd); } +void bdrv_flush_all(void) +{ + BlockDriverState *bs; + + for (bs = bdrv_first; bs != NULL; bs = bs->next) + if (bs->drv && !bdrv_is_read_only(bs) && + (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) + bdrv_flush(bs); +} + +/* + * Returns true iff the specified sector is present in the disk image. Drivers + * not implementing the functionality are assumed to not support backing files, + * hence all their sectors are reported as allocated. + * + * 'pnum' is set to the number of sectors (including and immediately following + * the specified sector) that are known to be in the same + * allocated/unallocated state. + * + * 'nb_sectors' is the max value 'pnum' should be set to. + */ +int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, + int *pnum) +{ + int64_t n; + if (!bs->drv->bdrv_is_allocated) { + if (sector_num >= bs->total_sectors) { + *pnum = 0; + return 0; + } + n = bs->total_sectors - sector_num; + *pnum = (n < nb_sectors) ? (n) : (nb_sectors); + return 1; + } + return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum); +} + void bdrv_info(void) { BlockDriverState *bs; @@ -890,8 +1113,7 @@ void bdrv_info(void) } term_printf(" ro=%d", bs->read_only); term_printf(" drv=%s", bs->drv->format_name); - if (bs->encrypted) - term_printf(" encrypted"); + term_printf(" encrypted=%d", bdrv_is_encrypted(bs)); } else { term_printf(" [not inserted]"); } @@ -899,7 +1121,35 @@ void bdrv_info(void) } } -void bdrv_get_backing_filename(BlockDriverState *bs, +/* The "info blockstats" command. */ +void bdrv_info_stats (void) +{ + BlockDriverState *bs; + + for (bs = bdrv_first; bs != NULL; bs = bs->next) { + term_printf ("%s:" + " rd_bytes=%" PRIu64 + " wr_bytes=%" PRIu64 + " rd_operations=%" PRIu64 + " wr_operations=%" PRIu64 + "\n", + bs->device_name, + bs->rd_bytes, bs->wr_bytes, + bs->rd_ops, bs->wr_ops); + } +} + +const char *bdrv_get_encrypted_filename(BlockDriverState *bs) +{ + if (bs->backing_hd && bs->backing_hd->encrypted) + return bs->backing_file; + else if (bs->encrypted) + return bs->filename; + else + return NULL; +} + +void bdrv_get_backing_filename(BlockDriverState *bs, char *filename, int filename_size) { if (!bs->backing_hd) { @@ -909,7 +1159,7 @@ void bdrv_get_backing_filename(BlockDriv } } -int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, +int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors) { BlockDriver *drv = bs->drv; @@ -919,7 +1169,7 @@ int bdrv_write_compressed(BlockDriverSta return -ENOTSUP; return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); } - + int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) { BlockDriver *drv = bs->drv; @@ -931,10 +1181,30 @@ int bdrv_get_info(BlockDriverState *bs, return drv->bdrv_get_info(bs, bdi); } +int bdrv_put_buffer(BlockDriverState *bs, const uint8_t *buf, int64_t pos, int size) +{ + BlockDriver *drv = bs->drv; + if (!drv) + return -ENOMEDIUM; + if (!drv->bdrv_put_buffer) + return -ENOTSUP; + return drv->bdrv_put_buffer(bs, buf, pos, size); +} + +int bdrv_get_buffer(BlockDriverState *bs, uint8_t *buf, int64_t pos, int size) +{ + BlockDriver *drv = bs->drv; + if (!drv) + return -ENOMEDIUM; + if (!drv->bdrv_get_buffer) + return -ENOTSUP; + return drv->bdrv_get_buffer(bs, buf, pos, size); +} + /**************************************************************/ /* handling of snapshots */ -int bdrv_snapshot_create(BlockDriverState *bs, +int bdrv_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) { BlockDriver *drv = bs->drv; @@ -945,7 +1215,7 @@ int bdrv_snapshot_create(BlockDriverStat return drv->bdrv_snapshot_create(bs, sn_info); } -int bdrv_snapshot_goto(BlockDriverState *bs, +int bdrv_snapshot_goto(BlockDriverState *bs, const char *snapshot_id) { BlockDriver *drv = bs->drv; @@ -966,7 +1236,7 @@ int bdrv_snapshot_delete(BlockDriverStat return drv->bdrv_snapshot_delete(bs, snapshot_id); } -int bdrv_snapshot_list(BlockDriverState *bs, +int bdrv_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_info) { BlockDriver *drv = bs->drv; @@ -991,12 +1261,12 @@ char *get_human_readable_size(char *buf, base = 1024; for(i = 0; i < NB_SUFFIXES; i++) { if (size < (10 * base)) { - snprintf(buf, buf_size, "%0.1f%c", + snprintf(buf, buf_size, "%0.1f%c", (double)size / base, suffixes[i]); break; } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { - snprintf(buf, buf_size, "%" PRId64 "%c", + snprintf(buf, buf_size, "%" PRId64 "%c", ((size + (base >> 1)) / base), suffixes[i]); break; @@ -1019,8 +1289,8 @@ char *bdrv_snapshot_dump(char *buf, int int64_t secs; if (!sn) { - snprintf(buf, buf_size, - "%-10s%-20s%7s%20s%15s", + snprintf(buf, buf_size, + "%-10s%-20s%7s%20s%15s", "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); } else { ti = sn->date_sec; @@ -1038,10 +1308,10 @@ char *bdrv_snapshot_dump(char *buf, int "%02d:%02d:%02d.%03d", (int)(secs / 3600), (int)((secs / 60) % 60), - (int)(secs % 60), + (int)(secs % 60), (int)((sn->vm_clock_nsec / 1000000) % 1000)); snprintf(buf, buf_size, - "%-10s%-20s%7s%20s%15s", + "%-10s%-20s%7s%20s%15s", sn->id_str, sn->name, get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size), date_buf, @@ -1054,24 +1324,96 @@ char *bdrv_snapshot_dump(char *buf, int /**************************************************************/ /* async I/Os */ +typedef struct VectorTranslationState { + QEMUIOVector *iov; + uint8_t *bounce; + int is_write; + BlockDriverAIOCB *aiocb; + BlockDriverAIOCB *this_aiocb; +} VectorTranslationState; + +static void bdrv_aio_rw_vector_cb(void *opaque, int ret) +{ + VectorTranslationState *s = opaque; + + if (!s->is_write) { + qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size); + } + qemu_vfree(s->bounce); + s->this_aiocb->cb(s->this_aiocb->opaque, ret); + qemu_aio_release(s->this_aiocb); +} + +static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *iov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque, + int is_write) + +{ + VectorTranslationState *s = qemu_mallocz(sizeof(*s)); + BlockDriverAIOCB *aiocb = qemu_aio_get(bs, cb, opaque); + + s->this_aiocb = aiocb; + s->iov = iov; + s->bounce = qemu_memalign(512, nb_sectors * 512); + s->is_write = is_write; + if (is_write) { + qemu_iovec_to_buffer(s->iov, s->bounce); + s->aiocb = bdrv_aio_write(bs, sector_num, s->bounce, nb_sectors, + bdrv_aio_rw_vector_cb, s); + } else { + s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors, + bdrv_aio_rw_vector_cb, s); + } + return aiocb; +} + +BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque) +{ + if (bdrv_check_request(bs, sector_num, nb_sectors)) + return NULL; + + return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors, + cb, opaque, 0); +} + +BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque) +{ + if (bdrv_check_request(bs, sector_num, nb_sectors)) + return NULL; + + return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors, + cb, opaque, 1); +} + BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { BlockDriver *drv = bs->drv; + BlockDriverAIOCB *ret; if (!drv) return NULL; - - /* XXX: we assume that nb_sectors == 0 is suppored by the async read */ - if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { - memcpy(buf, bs->boot_sector_data, 512); - sector_num++; - nb_sectors--; - buf += 512; + if (bdrv_check_request(bs, sector_num, nb_sectors)) + return NULL; + + ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque); + + if (ret) { + /* Update stats even though technically transfer has not happened. */ + bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE; + bs->rd_ops ++; } - return drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque); + return ret; } BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num, @@ -1079,22 +1421,35 @@ BlockDriverAIOCB *bdrv_aio_write(BlockDr BlockDriverCompletionFunc *cb, void *opaque) { BlockDriver *drv = bs->drv; + BlockDriverAIOCB *ret; if (!drv) return NULL; if (bs->read_only) return NULL; - if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { - memcpy(bs->boot_sector_data, buf, 512); + if (bdrv_check_request(bs, sector_num, nb_sectors)) + return NULL; + + ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque); + + if (ret) { + /* Update stats even though technically transfer has not happened. */ + bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE; + bs->wr_ops ++; } - return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque); + return ret; } void bdrv_aio_cancel(BlockDriverAIOCB *acb) { BlockDriver *drv = acb->bs->drv; + if (acb->cb == bdrv_aio_rw_vector_cb) { + VectorTranslationState *s = acb->opaque; + acb = s->aiocb; + } + drv->bdrv_aio_cancel(acb); } @@ -1102,31 +1457,6 @@ void bdrv_aio_cancel(BlockDriverAIOCB *a /**************************************************************/ /* async block device emulation */ -#ifdef QEMU_TOOL -static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs, - int64_t sector_num, uint8_t *buf, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) -{ - int ret; - ret = bdrv_read(bs, sector_num, buf, nb_sectors); - cb(opaque, ret); - return NULL; -} - -static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs, - int64_t sector_num, const uint8_t *buf, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) -{ - int ret; - ret = bdrv_write(bs, sector_num, buf, nb_sectors); - cb(opaque, ret); - return NULL; -} - -static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb) -{ -} -#else static void bdrv_aio_bh_cb(void *opaque) { BlockDriverAIOCBSync *acb = opaque; @@ -1172,7 +1502,6 @@ static void bdrv_aio_cancel_em(BlockDriv qemu_bh_cancel(acb->bh); qemu_aio_release(acb); } -#endif /* !QEMU_TOOL */ /**************************************************************/ /* sync block device emulation */ @@ -1184,24 +1513,22 @@ static void bdrv_rw_em_cb(void *opaque, #define NOT_DONE 0x7fffffff -static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, +static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors) { int async_ret; BlockDriverAIOCB *acb; async_ret = NOT_DONE; - qemu_aio_wait_start(); - acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors, + acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors, bdrv_rw_em_cb, &async_ret); - if (acb == NULL) { - qemu_aio_wait_end(); + if (acb == NULL) return -1; - } + while (async_ret == NOT_DONE) { qemu_aio_wait(); } - qemu_aio_wait_end(); + return async_ret; } @@ -1212,17 +1539,13 @@ static int bdrv_write_em(BlockDriverStat BlockDriverAIOCB *acb; async_ret = NOT_DONE; - qemu_aio_wait_start(); - acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors, + acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors, bdrv_rw_em_cb, &async_ret); - if (acb == NULL) { - qemu_aio_wait_end(); + if (acb == NULL) return -1; - } while (async_ret == NOT_DONE) { qemu_aio_wait(); } - qemu_aio_wait_end(); return async_ret; } @@ -1241,6 +1564,8 @@ void bdrv_init(void) bdrv_register(&bdrv_vpc); bdrv_register(&bdrv_vvfat); bdrv_register(&bdrv_qcow2); + bdrv_register(&bdrv_parallels); + bdrv_register(&bdrv_nbd); } void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb, @@ -1255,8 +1580,6 @@ void *qemu_aio_get(BlockDriverState *bs, drv->free_aiocb = acb->next; } else { acb = qemu_mallocz(drv->aiocb_size); - if (!acb) - return NULL; } acb->bs = bs; acb->cb = cb; @@ -1292,7 +1615,7 @@ int bdrv_is_inserted(BlockDriverState *b /** * Return TRUE if the media changed since the last call to this - * function. It is currently only used for floppy disks + * function. It is currently only used for floppy disks */ int bdrv_media_changed(BlockDriverState *bs) { @@ -1346,3 +1669,14 @@ void bdrv_set_locked(BlockDriverState *b drv->bdrv_set_locked(bs, locked); } } + +/* needed for generic scsi interface */ + +int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) +{ + BlockDriver *drv = bs->drv; + + if (drv && drv->bdrv_ioctl) + return drv->bdrv_ioctl(bs, req, buf); + return -ENOTSUP; +}