qemu/block.c - diff

Return to block.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu

Diff for /qemu/block.c between versions 1.1.1.7 and 1.1.1.13

version 1.1.1.7, 2018/04/24 16:50:42	version 1.1.1.13, 2018/04/24 17:20:50
Line 22	Line 22
* THE SOFTWARE.	* THE SOFTWARE.
*/	*/
#include "config-host.h"	#include "config-host.h"
#ifdef _BSD	#ifdef HOST_BSD
/* include native header before sys-queue.h */	/* include native header before sys-queue.h */
#include <sys/queue.h>	#include <sys/queue.h>
#endif	#endif

#include "qemu-common.h"	#include "qemu-common.h"
#include "console.h"	#include "monitor.h"
#include "block_int.h"	#include "block_int.h"
	#include "module.h"

#ifdef _BSD	#ifdef HOST_BSD
#include <sys/types.h>	#include <sys/types.h>
#include <sys/stat.h>	#include <sys/stat.h>
#include <sys/ioctl.h>	#include <sys/ioctl.h>
	#ifndef __DragonFly__
#include <sys/disk.h>	#include <sys/disk.h>
#endif	#endif
	#endif

	#ifdef _WIN32
	#include <windows.h>
	#endif

#define SECTOR_BITS 9	#define SECTOR_BITS 9
#define SECTOR_SIZE (1 << SECTOR_BITS)	#define SECTOR_SIZE (1 << SECTOR_BITS)

typedef struct BlockDriverAIOCBSync {	static BlockDriverAIOCB bdrv_aio_readv_em(BlockDriverState bs,
BlockDriverAIOCB common;	int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
QEMUBH *bh;
int ret;
} BlockDriverAIOCBSync;

static BlockDriverAIOCB bdrv_aio_read_em(BlockDriverState bs,
int64_t sector_num, uint8_t *buf, int nb_sectors,
BlockDriverCompletionFunc cb, void opaque);	BlockDriverCompletionFunc cb, void opaque);
static BlockDriverAIOCB bdrv_aio_write_em(BlockDriverState bs,	static BlockDriverAIOCB bdrv_aio_writev_em(BlockDriverState bs,
int64_t sector_num, const uint8_t *buf, int nb_sectors,	int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc cb, void opaque);	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);	uint8_t *buf, int nb_sectors);
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,	static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
Line 127 void path_combine(char *dest, int dest_s	Line 127 void path_combine(char *dest, int dest_s
}	}
}	}

	void bdrv_register(BlockDriver *bdrv)
static void bdrv_register(BlockDriver *bdrv)
{	{
if (!bdrv->bdrv_aio_read) {	if (!bdrv->bdrv_aio_readv) {
/* add AIO emulation layer */	/* add AIO emulation layer */
bdrv->bdrv_aio_read = bdrv_aio_read_em;	bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
bdrv->bdrv_aio_write = bdrv_aio_write_em;	bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;	} else if (!bdrv->bdrv_read) {
bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
} else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
/* add synchronous IO emulation layer */	/* add synchronous IO emulation layer */
bdrv->bdrv_read = bdrv_read_em;	bdrv->bdrv_read = bdrv_read_em;
bdrv->bdrv_write = bdrv_write_em;	bdrv->bdrv_write = bdrv_write_em;
Line 172 BlockDriver *bdrv_find_format(const char	Line 169 BlockDriver *bdrv_find_format(const char
return NULL;	return NULL;
}	}

int bdrv_create(BlockDriver *drv,	int bdrv_create(BlockDriver drv, const char filename,
const char *filename, int64_t size_in_sectors,	QEMUOptionParameter *options)
const char *backing_file, int flags)
{	{
if (!drv->bdrv_create)	if (!drv->bdrv_create)
return -ENOTSUP;	return -ENOTSUP;
return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
	return drv->bdrv_create(filename, options);
}	}

#ifdef _WIN32	#ifdef _WIN32
Line 212 static int is_windows_drive_prefix(const	Line 209 static int is_windows_drive_prefix(const
filename[1] == ':');	filename[1] == ':');
}	}

static int is_windows_drive(const char *filename)	int is_windows_drive(const char *filename)
{	{
if (is_windows_drive_prefix(filename) &&	if (is_windows_drive_prefix(filename) &&
filename[2] == '\0')	filename[2] == '\0')
Line 234 static BlockDriver *find_protocol(const	Line 231 static BlockDriver *find_protocol(const
#ifdef _WIN32	#ifdef _WIN32
if (is_windows_drive(filename) \|\|	if (is_windows_drive(filename) \|\|
is_windows_drive_prefix(filename))	is_windows_drive_prefix(filename))
return &bdrv_raw;	return bdrv_find_format("raw");
#endif	#endif
p = strchr(filename, ':');	p = strchr(filename, ':');
if (!p)	if (!p)
return &bdrv_raw;	return bdrv_find_format("raw");
len = p - filename;	len = p - filename;
if (len > sizeof(protocol) - 1)	if (len > sizeof(protocol) - 1)
len = sizeof(protocol) - 1;	len = sizeof(protocol) - 1;
Line 252 static BlockDriver *find_protocol(const	Line 249 static BlockDriver *find_protocol(const
return NULL;	return NULL;
}	}

/* XXX: force raw format if block or character device ? It would	/*
simplify the BSD case */	* Detect host devices. By convention, /dev/cdrom[N] is always
	* recognized as a host CDROM.
	*/
	static BlockDriver find_hdev_driver(const char filename)
	{
	int score_max = 0, score;
	BlockDriver drv = NULL, d;

	for (d = first_drv; d; d = d->next) {
	if (d->bdrv_probe_device) {
	score = d->bdrv_probe_device(filename);
	if (score > score_max) {
	score_max = score;
	drv = d;
	}
	}
	}

	return drv;
	}

static BlockDriver find_image_format(const char filename)	static BlockDriver find_image_format(const char filename)
{	{
int ret, score, score_max;	int ret, score, score_max;
Line 261 static BlockDriver *find_image_format(co	Line 278 static BlockDriver *find_image_format(co
uint8_t buf[2048];	uint8_t buf[2048];
BlockDriverState *bs;	BlockDriverState *bs;

/* detect host devices. By convention, /dev/cdrom[N] is always
recognized as a host CDROM */
if (strstart(filename, "/dev/cdrom", NULL))
return &bdrv_host_device;
#ifdef _WIN32
if (is_windows_drive(filename))
return &bdrv_host_device;
#else
{
struct stat st;
if (stat(filename, &st) >= 0 &&
(S_ISCHR(st.st_mode) \|\| S_ISBLK(st.st_mode))) {
return &bdrv_host_device;
}
}
#endif

drv = find_protocol(filename);	drv = find_protocol(filename);
/* no need to test disk image formats for vvfat */	/* no need to test disk image formats for vvfat */
if (drv == &bdrv_vvfat)	if (drv && strcmp(drv->format_name, "vvfat") == 0)
return drv;	return drv;

ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);	ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
Line 311 int bdrv_file_open(BlockDriverState **pb	Line 311 int bdrv_file_open(BlockDriverState **pb
int ret;	int ret;

bs = bdrv_new("");	bs = bdrv_new("");
if (!bs)
return -ENOMEM;
ret = bdrv_open2(bs, filename, flags \| BDRV_O_FILE, NULL);	ret = bdrv_open2(bs, filename, flags \| BDRV_O_FILE, NULL);
if (ret < 0) {	if (ret < 0) {
bdrv_delete(bs);	bdrv_delete(bs);
Line 338 int bdrv_open2(BlockDriverState *bs, con	Line 336 int bdrv_open2(BlockDriverState *bs, con
bs->read_only = 0;	bs->read_only = 0;
bs->is_temporary = 0;	bs->is_temporary = 0;
bs->encrypted = 0;	bs->encrypted = 0;
	bs->valid_key = 0;
	/* buffer_alignment defaulted to 512, drivers can change this value */
	bs->buffer_alignment = 512;

if (flags & BDRV_O_SNAPSHOT) {	if (flags & BDRV_O_SNAPSHOT) {
BlockDriverState *bs1;	BlockDriverState *bs1;
int64_t total_size;	int64_t total_size;
int is_protocol = 0;	int is_protocol = 0;
	BlockDriver *bdrv_qcow2;
	QEMUOptionParameter *options;

/* if snapshot, we create a temporary backing file and open it	/* if snapshot, we create a temporary backing file and open it
instead of opening 'filename' directly */	instead of opening 'filename' directly */

/* if there is a backing file, use it */	/* if there is a backing file, use it */
bs1 = bdrv_new("");	bs1 = bdrv_new("");
if (!bs1) {	ret = bdrv_open2(bs1, filename, 0, drv);
return -ENOMEM;	if (ret < 0) {
}
if (bdrv_open(bs1, filename, 0) < 0) {
bdrv_delete(bs1);	bdrv_delete(bs1);
return -1;	return ret;
}	}
total_size = bdrv_getlength(bs1) >> SECTOR_BITS;	total_size = bdrv_getlength(bs1) >> SECTOR_BITS;

Line 372 int bdrv_open2(BlockDriverState *bs, con	Line 373 int bdrv_open2(BlockDriverState *bs, con
else	else
realpath(filename, backing_filename);	realpath(filename, backing_filename);

if (bdrv_create(&bdrv_qcow2, tmp_filename,	bdrv_qcow2 = bdrv_find_format("qcow2");
total_size, backing_filename, 0) < 0) {	options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
return -1;
	set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size * 512);
	set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
	if (drv) {
	set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
	drv->format_name);
}	}

	ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
	if (ret < 0) {
	return ret;
	}

filename = tmp_filename;	filename = tmp_filename;
	drv = bdrv_qcow2;
bs->is_temporary = 1;	bs->is_temporary = 1;
}	}

pstrcpy(bs->filename, sizeof(bs->filename), filename);	pstrcpy(bs->filename, sizeof(bs->filename), filename);
if (flags & BDRV_O_FILE) {	if (flags & BDRV_O_FILE) {
drv = find_protocol(filename);	drv = find_protocol(filename);
if (!drv)	} else if (!drv) {
return -ENOENT;	drv = find_hdev_driver(filename);
} else {
if (!drv) {	if (!drv) {
drv = find_image_format(filename);	drv = find_image_format(filename);
if (!drv)
return -1;
}	}
}	}
	if (!drv) {
	ret = -ENOENT;
	goto unlink_and_fail;
	}
bs->drv = drv;	bs->drv = drv;
bs->opaque = qemu_mallocz(drv->instance_size);	bs->opaque = qemu_mallocz(drv->instance_size);
/* Note: for compatibility, we open disk image files as RDWR, and	/* Note: for compatibility, we open disk image files as RDWR, and
Line 409 int bdrv_open2(BlockDriverState *bs, con	Line 423 int bdrv_open2(BlockDriverState *bs, con
qemu_free(bs->opaque);	qemu_free(bs->opaque);
bs->opaque = NULL;	bs->opaque = NULL;
bs->drv = NULL;	bs->drv = NULL;
	unlink_and_fail:
	if (bs->is_temporary)
	unlink(filename);
return ret;	return ret;
}	}
if (drv->bdrv_getlength) {	if (drv->bdrv_getlength) {
Line 421 int bdrv_open2(BlockDriverState *bs, con	Line 438 int bdrv_open2(BlockDriverState *bs, con
#endif	#endif
if (bs->backing_file[0] != '\0') {	if (bs->backing_file[0] != '\0') {
/* if there is a backing file, use it */	/* if there is a backing file, use it */
	BlockDriver *back_drv = NULL;
bs->backing_hd = bdrv_new("");	bs->backing_hd = bdrv_new("");
if (!bs->backing_hd) {
fail:
bdrv_close(bs);
return -ENOMEM;
}
path_combine(backing_filename, sizeof(backing_filename),	path_combine(backing_filename, sizeof(backing_filename),
filename, bs->backing_file);	filename, bs->backing_file);
if (bdrv_open(bs->backing_hd, backing_filename, open_flags) < 0)	if (bs->backing_format[0] != '\0')
goto fail;	back_drv = bdrv_find_format(bs->backing_format);
	ret = bdrv_open2(bs->backing_hd, backing_filename, open_flags,
	back_drv);
	if (ret < 0) {
	bdrv_close(bs);
	return ret;
	}
}	}

/* call the change callback */	if (!bdrv_key_required(bs)) {
bs->media_changed = 1;	/* call the change callback */
if (bs->change_cb)	bs->media_changed = 1;
bs->change_cb(bs->change_opaque);	if (bs->change_cb)
	bs->change_cb(bs->change_opaque);
	}
return 0;	return 0;
}	}

Line 477 void bdrv_delete(BlockDriverState *bs)	Line 497 void bdrv_delete(BlockDriverState *bs)
qemu_free(bs);	qemu_free(bs);
}	}

	/*
	* Run consistency checks on an image
	*
	* Returns the number of errors or -errno when an internal error occurs
	*/
	int bdrv_check(BlockDriverState *bs)
	{
	if (bs->drv->bdrv_check == NULL) {
	return -ENOTSUP;
	}

	return bs->drv->bdrv_check(bs);
	}

/* commit COW file into the raw image */	/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)	int bdrv_commit(BlockDriverState *bs)
{	{
Line 533 static int bdrv_check_byte_request(Block	Line 567 static int bdrv_check_byte_request(Block

len = bdrv_getlength(bs);	len = bdrv_getlength(bs);

if ((offset + size) > len)	if (offset < 0)
	return -EIO;

	if ((offset > len) \|\| (len - offset < size))
return -EIO;	return -EIO;

return 0;	return 0;
Line 542 static int bdrv_check_byte_request(Block	Line 579 static int bdrv_check_byte_request(Block
static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,	static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
int nb_sectors)	int nb_sectors)
{	{
int64_t offset;	return bdrv_check_byte_request(bs, sector_num * 512, nb_sectors * 512);

/* 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 */	/* return < 0 if error. See bdrv_write() for the return codes */
Line 564 int bdrv_read(BlockDriverState *bs, int6	Line 593 int bdrv_read(BlockDriverState *bs, int6
if (bdrv_check_request(bs, sector_num, nb_sectors))	if (bdrv_check_request(bs, sector_num, nb_sectors))
return -EIO;	return -EIO;

if (drv->bdrv_pread) {	return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
int ret, len;
len = nb_sectors * 512;
ret = drv->bdrv_pread(bs, sector_num * 512, buf, len);
if (ret < 0)
return ret;
else if (ret != len)
return -EINVAL;
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:
Line 599 int bdrv_write(BlockDriverState *bs, int	Line 613 int bdrv_write(BlockDriverState *bs, int
if (bdrv_check_request(bs, sector_num, nb_sectors))	if (bdrv_check_request(bs, sector_num, nb_sectors))
return -EIO;	return -EIO;

if (drv->bdrv_pwrite) {
int ret, len, count = 0;
len = nb_sectors * 512;
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);	return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
}	}

static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,	int bdrv_pread(BlockDriverState *bs, int64_t offset,
uint8_t *buf, int count1)	void *buf, int count1)
{	{
uint8_t tmp_buf[SECTOR_SIZE];	uint8_t tmp_buf[SECTOR_SIZE];
int len, nb_sectors, count;	int len, nb_sectors, count;
Line 662 static int bdrv_pread_em(BlockDriverStat	Line 660 static int bdrv_pread_em(BlockDriverStat
return count1;	return count1;
}	}

static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,	int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
const uint8_t *buf, int count1)	const void *buf, int count1)
{	{
uint8_t tmp_buf[SECTOR_SIZE];	uint8_t tmp_buf[SECTOR_SIZE];
int len, nb_sectors, count;	int len, nb_sectors, count;
Line 711 static int bdrv_pwrite_em(BlockDriverSta	Line 709 static int bdrv_pwrite_em(BlockDriverSta
}	}

/**	/**
* Read with byte offsets (needed only for file protocols)
*/
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)
*/
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);
}

/**
* Truncate file to 'offset' bytes (needed only for file protocols)	* Truncate file to 'offset' bytes (needed only for file protocols)
*/	*/
int bdrv_truncate(BlockDriverState *bs, int64_t offset)	int bdrv_truncate(BlockDriverState *bs, int64_t offset)
Line 970 int bdrv_is_encrypted(BlockDriverState *	Line 932 int bdrv_is_encrypted(BlockDriverState *
return bs->encrypted;	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 bdrv_set_key(BlockDriverState bs, const char key)
{	{
int ret;	int ret;
Line 982 int bdrv_set_key(BlockDriverState *bs, c	Line 953 int bdrv_set_key(BlockDriverState *bs, c
}	}
if (!bs->encrypted \|\| !bs->drv \|\| !bs->drv->bdrv_set_key)	if (!bs->encrypted \|\| !bs->drv \|\| !bs->drv->bdrv_set_key)
return -1;	return -1;
return bs->drv->bdrv_set_key(bs, key);	ret = bs->drv->bdrv_set_key(bs, key);
	if (ret < 0) {
	bs->valid_key = 0;
	} else if (!bs->valid_key) {
	bs->valid_key = 1;
	/* call the change callback now, we skipped it on open */
	bs->media_changed = 1;
	if (bs->change_cb)
	bs->change_cb(bs->change_opaque);
	}
	return ret;
}	}

void bdrv_get_format(BlockDriverState bs, char buf, int buf_size)	void bdrv_get_format(BlockDriverState bs, char buf, int buf_size)
Line 1015 BlockDriverState bdrv_find(const char	Line 996 BlockDriverState bdrv_find(const char
return NULL;	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;	BlockDriverState *bs;

for (bs = bdrv_first; bs != NULL; bs = bs->next) {	for (bs = bdrv_first; bs != NULL; bs = bs->next) {
it(opaque, bs->device_name);	it(opaque, bs);
}	}
}	}

Line 1031 const char *bdrv_get_device_name(BlockDr	Line 1012 const char *bdrv_get_device_name(BlockDr

void bdrv_flush(BlockDriverState *bs)	void bdrv_flush(BlockDriverState *bs)
{	{
	if (!bs->drv)
	return;
if (bs->drv->bdrv_flush)	if (bs->drv->bdrv_flush)
bs->drv->bdrv_flush(bs);	bs->drv->bdrv_flush(bs);
if (bs->backing_hd)	if (bs->backing_hd)
Line 1074 int bdrv_is_allocated(BlockDriverState *	Line 1057 int bdrv_is_allocated(BlockDriverState *
return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);	return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
}	}

void bdrv_info(void)	void bdrv_info(Monitor *mon)
{	{
BlockDriverState *bs;	BlockDriverState *bs;

for (bs = bdrv_first; bs != NULL; bs = bs->next) {	for (bs = bdrv_first; bs != NULL; bs = bs->next) {
term_printf("%s:", bs->device_name);	monitor_printf(mon, "%s:", bs->device_name);
term_printf(" type=");	monitor_printf(mon, " type=");
switch(bs->type) {	switch(bs->type) {
case BDRV_TYPE_HD:	case BDRV_TYPE_HD:
term_printf("hd");	monitor_printf(mon, "hd");
break;	break;
case BDRV_TYPE_CDROM:	case BDRV_TYPE_CDROM:
term_printf("cdrom");	monitor_printf(mon, "cdrom");
break;	break;
case BDRV_TYPE_FLOPPY:	case BDRV_TYPE_FLOPPY:
term_printf("floppy");	monitor_printf(mon, "floppy");
break;	break;
}	}
term_printf(" removable=%d", bs->removable);	monitor_printf(mon, " removable=%d", bs->removable);
if (bs->removable) {	if (bs->removable) {
term_printf(" locked=%d", bs->locked);	monitor_printf(mon, " locked=%d", bs->locked);
}	}
if (bs->drv) {	if (bs->drv) {
term_printf(" file=");	monitor_printf(mon, " file=");
term_print_filename(bs->filename);	monitor_print_filename(mon, bs->filename);
if (bs->backing_file[0] != '\0') {	if (bs->backing_file[0] != '\0') {
term_printf(" backing_file=");	monitor_printf(mon, " backing_file=");
term_print_filename(bs->backing_file);	monitor_print_filename(mon, bs->backing_file);
}	}
term_printf(" ro=%d", bs->read_only);	monitor_printf(mon, " ro=%d", bs->read_only);
term_printf(" drv=%s", bs->drv->format_name);	monitor_printf(mon, " drv=%s", bs->drv->format_name);
if (bs->encrypted)	monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
term_printf(" encrypted");
} else {	} else {
term_printf(" [not inserted]");	monitor_printf(mon, " [not inserted]");
}	}
term_printf("\n");	monitor_printf(mon, "\n");
}	}
}	}

/* The "info blockstats" command. */	/* The "info blockstats" command. */
void bdrv_info_stats (void)	void bdrv_info_stats(Monitor *mon)
{	{
BlockDriverState *bs;	BlockDriverState *bs;
BlockDriverInfo bdi;

for (bs = bdrv_first; bs != NULL; bs = bs->next) {	for (bs = bdrv_first; bs != NULL; bs = bs->next) {
term_printf ("%s:"	monitor_printf(mon, "%s:"
" rd_bytes=%" PRIu64	" rd_bytes=%" PRIu64
" wr_bytes=%" PRIu64	" wr_bytes=%" PRIu64
" rd_operations=%" PRIu64	" rd_operations=%" PRIu64
" wr_operations=%" PRIu64	" wr_operations=%" PRIu64
,	"\n",
bs->device_name,	bs->device_name,
bs->rd_bytes, bs->wr_bytes,	bs->rd_bytes, bs->wr_bytes,
bs->rd_ops, bs->wr_ops);	bs->rd_ops, bs->wr_ops);
if (bdrv_get_info(bs, &bdi) == 0)
term_printf(" high=%" PRId64
" bytes_free=%" PRId64,
bdi.highest_alloc, bdi.num_free_bytes);
term_printf("\n");
}	}
}	}

	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,	void bdrv_get_backing_filename(BlockDriverState *bs,
char *filename, int filename_size)	char *filename, int filename_size)
{	{
Line 1156 int bdrv_write_compressed(BlockDriverSta	Line 1142 int bdrv_write_compressed(BlockDriverSta
return -ENOMEDIUM;	return -ENOMEDIUM;
if (!drv->bdrv_write_compressed)	if (!drv->bdrv_write_compressed)
return -ENOTSUP;	return -ENOTSUP;
	if (bdrv_check_request(bs, sector_num, nb_sectors))
	return -EIO;
return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);	return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}	}

Line 1170 int bdrv_get_info(BlockDriverState *bs,	Line 1158 int bdrv_get_info(BlockDriverState *bs,
return drv->bdrv_get_info(bs, bdi);	return drv->bdrv_get_info(bs, bdi);
}	}

	int bdrv_save_vmstate(BlockDriverState bs, const uint8_t buf,
	int64_t pos, int size)
	{
	BlockDriver *drv = bs->drv;
	if (!drv)
	return -ENOMEDIUM;
	if (!drv->bdrv_save_vmstate)
	return -ENOTSUP;
	return drv->bdrv_save_vmstate(bs, buf, pos, size);
	}

	int bdrv_load_vmstate(BlockDriverState bs, uint8_t buf,
	int64_t pos, int size)
	{
	BlockDriver *drv = bs->drv;
	if (!drv)
	return -ENOMEDIUM;
	if (!drv->bdrv_load_vmstate)
	return -ENOTSUP;
	return drv->bdrv_load_vmstate(bs, buf, pos, size);
	}

/**************************************************************/	/**************************************************************/
/* handling of snapshots */	/* handling of snapshots */

Line 1293 char bdrv_snapshot_dump(char buf, int	Line 1303 char bdrv_snapshot_dump(char buf, int
/**************************************************************/	/**************************************************************/
/* async I/Os */	/* 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,	BlockDriverAIOCB bdrv_aio_readv(BlockDriverState bs, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors,	QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc cb, void opaque)	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;	BlockDriver *drv = bs->drv;
BlockDriverAIOCB *ret;	BlockDriverAIOCB *ret;

Line 1374 BlockDriverAIOCB *bdrv_aio_read(BlockDri	Line 1315 BlockDriverAIOCB *bdrv_aio_read(BlockDri
if (bdrv_check_request(bs, sector_num, nb_sectors))	if (bdrv_check_request(bs, sector_num, nb_sectors))
return NULL;	return NULL;

ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);	ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
	cb, opaque);

if (ret) {	if (ret) {
/* Update stats even though technically transfer has not happened. */	/* Update stats even though technically transfer has not happened. */
Line 1385 BlockDriverAIOCB *bdrv_aio_read(BlockDri	Line 1327 BlockDriverAIOCB *bdrv_aio_read(BlockDri
return ret;	return ret;
}	}

BlockDriverAIOCB bdrv_aio_write(BlockDriverState bs, int64_t sector_num,	BlockDriverAIOCB bdrv_aio_writev(BlockDriverState bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors,	QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc cb, void opaque)	BlockDriverCompletionFunc cb, void opaque)
{	{
BlockDriver *drv = bs->drv;	BlockDriver *drv = bs->drv;
BlockDriverAIOCB *ret;	BlockDriverAIOCB *ret;
Line 1399 BlockDriverAIOCB *bdrv_aio_write(BlockDr	Line 1341 BlockDriverAIOCB *bdrv_aio_write(BlockDr
if (bdrv_check_request(bs, sector_num, nb_sectors))	if (bdrv_check_request(bs, sector_num, nb_sectors))
return NULL;	return NULL;

ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);	ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
	cb, opaque);

if (ret) {	if (ret) {
/* Update stats even though technically transfer has not happened. */	/* Update stats even though technically transfer has not happened. */
Line 1412 BlockDriverAIOCB *bdrv_aio_write(BlockDr	Line 1355 BlockDriverAIOCB *bdrv_aio_write(BlockDr

void bdrv_aio_cancel(BlockDriverAIOCB *acb)	void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{	{
BlockDriver *drv = acb->bs->drv;	acb->pool->cancel(acb);

if (acb->cb == bdrv_aio_rw_vector_cb) {
VectorTranslationState *s = acb->opaque;
acb = s->aiocb;
}

drv->bdrv_aio_cancel(acb);
}	}


/**************************************************************/	/**************************************************************/
/* async block device emulation */	/* async block device emulation */

	typedef struct BlockDriverAIOCBSync {
	BlockDriverAIOCB common;
	QEMUBH *bh;
	int ret;
	/* vector translation state */
	QEMUIOVector *qiov;
	uint8_t *bounce;
	int is_write;
	} BlockDriverAIOCBSync;

	static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
	{
	BlockDriverAIOCBSync acb = (BlockDriverAIOCBSync )blockacb;
	qemu_bh_delete(acb->bh);
	acb->bh = NULL;
	qemu_aio_release(acb);
	}

	static AIOPool bdrv_em_aio_pool = {
	.aiocb_size = sizeof(BlockDriverAIOCBSync),
	.cancel = bdrv_aio_cancel_em,
	};

static void bdrv_aio_bh_cb(void *opaque)	static void bdrv_aio_bh_cb(void *opaque)
{	{
BlockDriverAIOCBSync *acb = opaque;	BlockDriverAIOCBSync *acb = opaque;

	if (!acb->is_write)
	qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
	qemu_vfree(acb->bounce);
acb->common.cb(acb->common.opaque, acb->ret);	acb->common.cb(acb->common.opaque, acb->ret);
	qemu_bh_delete(acb->bh);
	acb->bh = NULL;
qemu_aio_release(acb);	qemu_aio_release(acb);
}	}

static BlockDriverAIOCB bdrv_aio_read_em(BlockDriverState bs,	static BlockDriverAIOCB bdrv_aio_rw_vector(BlockDriverState bs,
int64_t sector_num, uint8_t *buf, int nb_sectors,	int64_t sector_num,
BlockDriverCompletionFunc cb, void opaque)	QEMUIOVector *qiov,
	int nb_sectors,
	BlockDriverCompletionFunc *cb,
	void *opaque,
	int is_write)

{	{
BlockDriverAIOCBSync *acb;	BlockDriverAIOCBSync *acb;
int ret;

acb = qemu_aio_get(bs, cb, opaque);	acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
	acb->is_write = is_write;
	acb->qiov = qiov;
	acb->bounce = qemu_blockalign(bs, qiov->size);

if (!acb->bh)	if (!acb->bh)
acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);	acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
ret = bdrv_read(bs, sector_num, buf, nb_sectors);
acb->ret = ret;	if (is_write) {
	qemu_iovec_to_buffer(acb->qiov, acb->bounce);
	acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
	} else {
	acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
	}

qemu_bh_schedule(acb->bh);	qemu_bh_schedule(acb->bh);

return &acb->common;	return &acb->common;
}	}

static BlockDriverAIOCB bdrv_aio_write_em(BlockDriverState bs,	static BlockDriverAIOCB bdrv_aio_readv_em(BlockDriverState bs,
int64_t sector_num, const uint8_t *buf, int nb_sectors,	int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc cb, void opaque)	BlockDriverCompletionFunc cb, void opaque)
{	{
BlockDriverAIOCBSync *acb;	return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
int ret;

acb = qemu_aio_get(bs, cb, opaque);
if (!acb->bh)
acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
ret = bdrv_write(bs, sector_num, buf, nb_sectors);
acb->ret = ret;
qemu_bh_schedule(acb->bh);
return &acb->common;
}	}

static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)	static BlockDriverAIOCB bdrv_aio_writev_em(BlockDriverState bs,
	int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
	BlockDriverCompletionFunc cb, void opaque)
{	{
BlockDriverAIOCBSync acb = (BlockDriverAIOCBSync )blockacb;	return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
qemu_bh_cancel(acb->bh);
qemu_aio_release(acb);
}	}

/**************************************************************/	/**************************************************************/
Line 1487 static int bdrv_read_em(BlockDriverState	Line 1458 static int bdrv_read_em(BlockDriverState
{	{
int async_ret;	int async_ret;
BlockDriverAIOCB *acb;	BlockDriverAIOCB *acb;
	struct iovec iov;
	QEMUIOVector qiov;

async_ret = NOT_DONE;	async_ret = NOT_DONE;
acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,	iov.iov_base = (void *)buf;
bdrv_rw_em_cb, &async_ret);	iov.iov_len = nb_sectors * 512;
	qemu_iovec_init_external(&qiov, &iov, 1);
	acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
	bdrv_rw_em_cb, &async_ret);
if (acb == NULL)	if (acb == NULL)
return -1;	return -1;

Line 1506 static int bdrv_write_em(BlockDriverStat	Line 1482 static int bdrv_write_em(BlockDriverStat
{	{
int async_ret;	int async_ret;
BlockDriverAIOCB *acb;	BlockDriverAIOCB *acb;
	struct iovec iov;
	QEMUIOVector qiov;

async_ret = NOT_DONE;	async_ret = NOT_DONE;
acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,	iov.iov_base = (void *)buf;
bdrv_rw_em_cb, &async_ret);	iov.iov_len = nb_sectors * 512;
	qemu_iovec_init_external(&qiov, &iov, 1);
	acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
	bdrv_rw_em_cb, &async_ret);
if (acb == NULL)	if (acb == NULL)
return -1;	return -1;
while (async_ret == NOT_DONE) {	while (async_ret == NOT_DONE) {
Line 1520 static int bdrv_write_em(BlockDriverStat	Line 1501 static int bdrv_write_em(BlockDriverStat

void bdrv_init(void)	void bdrv_init(void)
{	{
bdrv_register(&bdrv_raw);	module_call_init(MODULE_INIT_BLOCK);
bdrv_register(&bdrv_host_device);
#ifndef _WIN32
bdrv_register(&bdrv_cow);
#endif
bdrv_register(&bdrv_qcow);
bdrv_register(&bdrv_vmdk);
bdrv_register(&bdrv_cloop);
bdrv_register(&bdrv_dmg);
bdrv_register(&bdrv_bochs);
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,	void qemu_aio_get(AIOPool pool, BlockDriverState *bs,
void *opaque)	BlockDriverCompletionFunc cb, void opaque)
{	{
BlockDriver *drv;
BlockDriverAIOCB *acb;	BlockDriverAIOCB *acb;

drv = bs->drv;	if (pool->free_aiocb) {
if (drv->free_aiocb) {	acb = pool->free_aiocb;
acb = drv->free_aiocb;	pool->free_aiocb = acb->next;
drv->free_aiocb = acb->next;
} else {	} else {
acb = qemu_mallocz(drv->aiocb_size);	acb = qemu_mallocz(pool->aiocb_size);
	acb->pool = pool;
}	}
acb->bs = bs;	acb->bs = bs;
acb->cb = cb;	acb->cb = cb;
Line 1558 void qemu_aio_get(BlockDriverState bs,	Line 1524 void qemu_aio_get(BlockDriverState bs,

void qemu_aio_release(void *p)	void qemu_aio_release(void *p)
{	{
BlockDriverAIOCB *acb = p;	BlockDriverAIOCB acb = (BlockDriverAIOCB )p;
BlockDriver *drv = acb->bs->drv;	AIOPool *pool = acb->pool;
acb->next = drv->free_aiocb;	acb->next = pool->free_aiocb;
drv->free_aiocb = acb;	pool->free_aiocb = acb;
}	}

/**************************************************************/	/**************************************************************/
Line 1604 int bdrv_media_changed(BlockDriverState	Line 1570 int bdrv_media_changed(BlockDriverState
/**	/**
* If eject_flag is TRUE, eject the media. Otherwise, close the tray	* If eject_flag is TRUE, eject the media. Otherwise, close the tray
*/	*/
void bdrv_eject(BlockDriverState *bs, int eject_flag)	int bdrv_eject(BlockDriverState *bs, int eject_flag)
{	{
BlockDriver *drv = bs->drv;	BlockDriver *drv = bs->drv;
int ret;	int ret;

	if (bs->locked) {
	return -EBUSY;
	}

if (!drv \|\| !drv->bdrv_eject) {	if (!drv \|\| !drv->bdrv_eject) {
ret = -ENOTSUP;	ret = -ENOTSUP;
} else {	} else {
Line 1617 void bdrv_eject(BlockDriverState *bs, in	Line 1587 void bdrv_eject(BlockDriverState *bs, in
if (ret == -ENOTSUP) {	if (ret == -ENOTSUP) {
if (eject_flag)	if (eject_flag)
bdrv_close(bs);	bdrv_close(bs);
	ret = 0;
}	}

	return ret;
}	}

int bdrv_is_locked(BlockDriverState *bs)	int bdrv_is_locked(BlockDriverState *bs)
Line 1649 int bdrv_ioctl(BlockDriverState *bs, uns	Line 1622 int bdrv_ioctl(BlockDriverState *bs, uns
return drv->bdrv_ioctl(bs, req, buf);	return drv->bdrv_ioctl(bs, req, buf);
return -ENOTSUP;	return -ENOTSUP;
}	}

	BlockDriverAIOCB bdrv_aio_ioctl(BlockDriverState bs,
	unsigned long int req, void *buf,
	BlockDriverCompletionFunc cb, void opaque)
	{
	BlockDriver *drv = bs->drv;

	if (drv && drv->bdrv_aio_ioctl)
	return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
	return NULL;
	}

	void qemu_blockalign(BlockDriverState bs, size_t size)
	{
	return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
	}

unix.superglobalmegacorp.com

Removed from v.1.1.1.7
changed lines
	Added in v.1.1.1.13