mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Drop internal bdrv_pread()/bdrv_pwrite() APIs (Avi Kivity)

Browse Source 
Now that scsi generic no longer uses bdrv_pread() and bdrv_pwrite(), we can
drop the corresponding internal APIs, which overlap bdrv_read()/bdrv_write()
and, being byte oriented, are unnatural for a block device.

Signed-off-by: Avi Kivity <avi@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6824 c046a42c-6fe2-441c-8c8c-71466251a162
This commit is contained in:
aliguori 2009-03-12 19:57:16 +00:00
parent 04eeb8b6d6
commit eda578e559
4 changed files with 34 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
block-raw-posix.c
View File

@ -358,6 +358,12 @@ static int raw_pread(BlockDriverState *bs, int64_t offset,
return raw_pread_aligned(bs, offset, buf, count) + sum;
}
static int raw_read(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sectors)
{
return raw_pread(bs, sector_num * 512, buf, (uint64_t)nb_sectors * 512);
}
/*
* offset and count are in bytes and possibly not aligned. For files opened
* with O_DIRECT, necessary alignments are ensured before calling
@ -436,6 +442,12 @@ static int raw_pwrite(BlockDriverState *bs, int64_t offset,
return raw_pwrite_aligned(bs, offset, buf, count) + sum;
}
static int raw_write(BlockDriverState *bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors)
{
return raw_pwrite(bs, sector_num * 512, buf, (uint64_t)nb_sectors * 512);
}
#ifdef CONFIG_AIO
/***********************************************************/
/* Unix AIO using POSIX AIO */
@ -843,8 +855,8 @@ BlockDriver bdrv_raw = {
.aiocb_size = sizeof(RawAIOCB),
#endif
.bdrv_pread = raw_pread,
.bdrv_pwrite = raw_pwrite,
.bdrv_read = raw_read,
.bdrv_write = raw_write,
.bdrv_truncate = raw_truncate,
.bdrv_getlength = raw_getlength,
};
@ -1219,8 +1231,8 @@ BlockDriver bdrv_host_device = {
.aiocb_size = sizeof(RawAIOCB),
#endif
.bdrv_pread = raw_pread,
.bdrv_pwrite = raw_pwrite,
.bdrv_read = raw_read,
.bdrv_write = raw_write,
.bdrv_getlength = raw_getlength,
/* removable device support */

20
block-raw-win32.c
View File

@ -122,13 +122,15 @@ static int raw_open(BlockDriverState *bs, const char *filename, int flags)
return 0;
}
static int raw_pread(BlockDriverState *bs, int64_t offset,
uint8_t *buf, int count)
static int raw_read(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sectors)
{
BDRVRawState *s = bs->opaque;
OVERLAPPED ov;
DWORD ret_count;
int ret;
int64_t offset = sector_num * 512;
int count = nb_sectors * 512;
memset(&ov, 0, sizeof(ov));
ov.Offset = offset;
@ -146,13 +148,15 @@ static int raw_pread(BlockDriverState *bs, int64_t offset,
return ret_count;
}
static int raw_pwrite(BlockDriverState *bs, int64_t offset,
const uint8_t *buf, int count)
static int raw_write(BlockDriverState *bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors)
{
BDRVRawState *s = bs->opaque;
OVERLAPPED ov;
DWORD ret_count;
int ret;
int64_t offset = sector_num * 512;
int count = nb_sectors * 512;
memset(&ov, 0, sizeof(ov));
ov.Offset = offset;
@ -359,8 +363,8 @@ BlockDriver bdrv_raw = {
.bdrv_aio_cancel = raw_aio_cancel,
.aiocb_size = sizeof(RawAIOCB);
#endif
.bdrv_pread = raw_pread,
.bdrv_pwrite = raw_pwrite,
.bdrv_read = raw_read,
.bdrv_write = raw_write,
.bdrv_truncate = raw_truncate,
.bdrv_getlength = raw_getlength,
};
@ -508,7 +512,7 @@ BlockDriver bdrv_host_device = {
.bdrv_aio_cancel = raw_aio_cancel,
.aiocb_size = sizeof(RawAIOCB);
#endif
.bdrv_pread = raw_pread,
.bdrv_pwrite = raw_pwrite,
.bdrv_read = raw_read,
.bdrv_write = raw_write,
.bdrv_getlength = raw_getlength,
};

79
block.c
View File

@ -142,7 +142,7 @@ static void bdrv_register(BlockDriver *bdrv)
bdrv->bdrv_aio_write = bdrv_aio_write_em;
bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
} else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
} else if (!bdrv->bdrv_read) {
/* add synchronous IO emulation layer */
bdrv->bdrv_read = bdrv_read_em;
bdrv->bdrv_write = bdrv_write_em;
@ -568,22 +568,7 @@ int bdrv_read(BlockDriverState *bs, int64_t sector_num,
if (bdrv_check_request(bs, sector_num, nb_sectors))
return -EIO;
if (drv->bdrv_pread) {
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 drv->bdrv_read(bs, sector_num, buf, nb_sectors);
}
/* Return < 0 if error. Important errors are:
@ -603,27 +588,11 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num,
if (bdrv_check_request(bs, sector_num, nb_sectors))
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);
}
static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
uint8_t *buf, int count1)
int bdrv_pread(BlockDriverState *bs, int64_t offset,
void *buf, int count1)
{
uint8_t tmp_buf[SECTOR_SIZE];
int len, nb_sectors, count;
@ -666,8 +635,8 @@ static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
return count1;
}
static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
const uint8_t *buf, int count1)
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
const void *buf, int count1)
{
uint8_t tmp_buf[SECTOR_SIZE];
int len, nb_sectors, count;
@ -714,42 +683,6 @@ static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
return count1;
}
/**
* 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)
*/

4
block_int.h
View File

@ -58,10 +58,6 @@ struct BlockDriver {
int aiocb_size;
const char *protocol_name;
int (*bdrv_pread)(BlockDriverState *bs, int64_t offset,
uint8_t *buf, int count);
int (*bdrv_pwrite)(BlockDriverState *bs, int64_t offset,
const uint8_t *buf, int count);
int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
int64_t (*bdrv_getlength)(BlockDriverState *bs);
int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,