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

vxhs: Switch to byte-based callbacks

Browse Source 
We are gradually moving away from sector-based interfaces, towards
byte-based.  Make the change for the last few sector-based callbacks
in the vxhs driver.

Note that the driver was already using byte-based calls for
performing actual I/O, so this just gets rid of a round trip
of scaling; however, as I don't know if VxHS is tolerant of
non-sector AIO operations, I went with the conservative approach
of adding .bdrv_refresh_limits to override the block layer
defaults back to the pre-patch value of 512.

Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Eric Blake 2018-04-24 14:25:05 -05:00 committed by Kevin Wolf
parent e8e16d4baf
commit 918889b291
1 changed files with 22 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
block/vxhs.c
View File

@ -216,6 +216,12 @@ static void vxhs_parse_filename(const char *filename, QDict *options,
} }
} }
static void vxhs_refresh_limits(BlockDriverState *bs, Error **errp)
{
/* XXX Does VXHS support AIO on less than 512-byte alignment? */
bs->bl.request_alignment = 512;
}
static int vxhs_init_and_ref(void) static int vxhs_init_and_ref(void)
{ {
if (vxhs_ref++ == 0) { if (vxhs_ref++ == 0) {
@ -424,21 +430,17 @@ static const AIOCBInfo vxhs_aiocb_info = {
* and is passed to QNIO. When QNIO completes the work, * and is passed to QNIO. When QNIO completes the work,
* it will be passed back through the callback. * it will be passed back through the callback.
*/ */
static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num, static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, uint64_t offset,
QEMUIOVector *qiov, int nb_sectors, QEMUIOVector *qiov, uint64_t size,
BlockCompletionFunc *cb, void *opaque, BlockCompletionFunc *cb, void *opaque,
VDISKAIOCmd iodir) VDISKAIOCmd iodir)
{ {
VXHSAIOCB *acb = NULL; VXHSAIOCB *acb = NULL;
BDRVVXHSState *s = bs->opaque; BDRVVXHSState *s = bs->opaque;
size_t size;
uint64_t offset;
int iio_flags = 0; int iio_flags = 0;
int ret = 0; int ret = 0;
void *dev_handle = s->vdisk_hostinfo.dev_handle; void *dev_handle = s->vdisk_hostinfo.dev_handle;
offset = sector_num * BDRV_SECTOR_SIZE;
size = nb_sectors * BDRV_SECTOR_SIZE;
acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque); acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
/* /*
@ -451,11 +453,11 @@ static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
switch (iodir) { switch (iodir) {
case VDISK_AIO_WRITE: case VDISK_AIO_WRITE:
ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov, ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
offset, (uint64_t)size, iio_flags); offset, size, iio_flags);
break; break;
case VDISK_AIO_READ: case VDISK_AIO_READ:
ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov, ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
offset, (uint64_t)size, iio_flags); offset, size, iio_flags);
break; break;
default: default:
trace_vxhs_aio_rw_invalid(iodir); trace_vxhs_aio_rw_invalid(iodir);
@ -474,22 +476,20 @@ errout:
return NULL; return NULL;
} }
static BlockAIOCB *vxhs_aio_readv(BlockDriverState *bs, static BlockAIOCB *vxhs_aio_preadv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, uint64_t offset, uint64_t bytes,
int nb_sectors, QEMUIOVector *qiov, int flags,
BlockCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb, return vxhs_aio_rw(bs, offset, qiov, bytes, cb, opaque, VDISK_AIO_READ);
opaque, VDISK_AIO_READ);
} }
static BlockAIOCB *vxhs_aio_writev(BlockDriverState *bs, static BlockAIOCB *vxhs_aio_pwritev(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, uint64_t offset, uint64_t bytes,
int nb_sectors, QEMUIOVector *qiov, int flags,
BlockCompletionFunc *cb, void *opaque) BlockCompletionFunc *cb, void *opaque)
{ {
return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, return vxhs_aio_rw(bs, offset, qiov, bytes, cb, opaque, VDISK_AIO_WRITE);
cb, opaque, VDISK_AIO_WRITE);
} }
static void vxhs_close(BlockDriverState *bs) static void vxhs_close(BlockDriverState *bs)
@ -561,10 +561,11 @@ static BlockDriver bdrv_vxhs = {
.instance_size = sizeof(BDRVVXHSState), .instance_size = sizeof(BDRVVXHSState),
.bdrv_file_open = vxhs_open, .bdrv_file_open = vxhs_open,
.bdrv_parse_filename = vxhs_parse_filename, .bdrv_parse_filename = vxhs_parse_filename,
.bdrv_refresh_limits = vxhs_refresh_limits,
.bdrv_close = vxhs_close, .bdrv_close = vxhs_close,
.bdrv_getlength = vxhs_getlength, .bdrv_getlength = vxhs_getlength,
.bdrv_aio_readv = vxhs_aio_readv, .bdrv_aio_preadv = vxhs_aio_preadv,
.bdrv_aio_writev = vxhs_aio_writev, .bdrv_aio_pwritev = vxhs_aio_pwritev,
}; };
static void bdrv_vxhs_init(void) static void bdrv_vxhs_init(void)