add real vectored block I/O support
cover add real vectored block I/O support
This patch adds support to pass down vectored I/O requests from virtio and ide all the way down to the posix raw image format.
Note that the last patch is rather hacky and shouldn't be merged, it's just for those wanting to play with real vectored aio support on Linux until it's exposed through glibc.
PATCH 1/5 more BlockDriver C99 initializers
Looks like the two bdrv_raw instances were missed last time.
block-raw-posix.c +14 -17
@@ -847,27 +847,24 @@ static void raw_flush(BlockDriverState * }BlockDriver bdrv_raw = { -"raw" , -sizeof (BDRVRawState), -NULL ,/* no probe for protocols */ - raw_open, -NULL , -NULL , - raw_close, - raw_create, - raw_flush, + .format_name ="raw" , + .instance_size =sizeof (BDRVRawState), + .bdrv_open = raw_open, + .bdrv_close = raw_close, + .bdrv_create = raw_create, + .bdrv_flush = raw_flush, #ifdef CONFIG_AIO - .bdrv_aio_read = raw_aio_read, - .bdrv_aio_write = raw_aio_write, - .bdrv_aio_cancel = raw_aio_cancel, - .aiocb_size =sizeof (RawAIOCB), + .bdrv_aio_read = raw_aio_read, + .bdrv_aio_write = raw_aio_write, + .bdrv_aio_cancel = raw_aio_cancel, + .aiocb_size =sizeof (RawAIOCB), #endif - .bdrv_read = raw_read, - .bdrv_write = raw_write, - .bdrv_truncate = raw_truncate, - .bdrv_getlength = raw_getlength, + .bdrv_read = raw_read, + .bdrv_write = raw_write, + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, };/***********************************************/
block-raw-win32.c +14 -17
@@ -351,26 +351,23 @@ static int raw_create(const char *filena }BlockDriver bdrv_raw = { -"raw" , -sizeof (BDRVRawState), -NULL ,/* no probe for protocols */ - raw_open, -NULL , -NULL , - raw_close, - raw_create, - raw_flush, + .format_name ="raw" , + .instance_size =sizeof (BDRVRawState), + .bdrv_open = raw_open, + .bdrv_close = raw_close, + .bdrv_create = raw_create, + .bdrv_flush = raw_flush, #ifdef WIN32_AIO - .bdrv_aio_read = raw_aio_read, - .bdrv_aio_write = raw_aio_write, - .bdrv_aio_cancel = raw_aio_cancel, - .aiocb_size = sizeof(RawAIOCB); + .bdrv_aio_read = raw_aio_read, + .bdrv_aio_write = raw_aio_write, + .bdrv_aio_cancel = raw_aio_cancel, + .aiocb_size = sizeof(RawAIOCB);#endif - .bdrv_read = raw_read, - .bdrv_write = raw_write, - .bdrv_truncate = raw_truncate, - .bdrv_getlength = raw_getlength, + .bdrv_read = raw_read, + .bdrv_write = raw_write, + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, };/***********************************************/
PATCH 2/5 remove bdrv_aio_read/bdrv_aio_write
In reply to Christoph HellwigAlways use the vectored APIs to reduce code churn once we switch the BlockDriver API to be vectored.
hw/ide.c +7 -3
@@ -496,6 +496,8 @@ typedef struct BMDMAState {IDEState *ide_if;BlockDriverCompletionFunc *dma_cb;BlockDriverAIOCB *aiocb; +struct iovec iov; +QEMUIOVector qiov;int64_t sector_num;uint32_t nsector; } BMDMAState;
@@ -1467,9 +1469,11 @@ static void ide_atapi_cmd_read_dma_cb(vo#ifdef DEBUG_AIO printf ("aio_read_cd: lba=%u n=%d\n" , s->lba, n);#endif - bm->aiocb =bdrv_aio_read (s->bs, (int64_t )s->lba <<2 , - s->io_buffer + data_offset, n *4 , - ide_atapi_cmd_read_dma_cb, bm); + bm->iov.iov_base = s->io_buffer + data_offset; + bm->iov.iov_len = n *4 *512 ; +qemu_iovec_init_external (&bm->qiov, &bm->iov,1 ); + bm->aiocb =bdrv_aio_readv (s->bs, (int64_t )s->lba <<2 , &bm->qiov, + n *4 , ide_atapi_cmd_read_dma_cb, bm);if (!bm->aiocb) {/* Note: media not present is the most likely case */ ide_atapi_cmd_error(s, SENSE_NOT_READY,
hw/scsi-disk.c +63 -62
283 lines not on this page · raw message
block-qcow.c +20 -8
@@ -530,6 +530,8 @@ typedef struct QCowAIOCB {int n;uint64_t cluster_offset;uint8_t *cluster_data; +struct iovec hd_iov; +QEMUIOVector hd_qiov;BlockDriverAIOCB *hd_aiocb; } QCowAIOCB;
@@ -584,8 +586,11 @@ static void qcow_aio_read_cb(void *opaquif (!acb->cluster_offset) {if (bs->backing_hd) {/* read from the base image */ - acb->hd_aiocb =bdrv_aio_read (bs->backing_hd, - acb->sector_num, acb->buf, acb->n, qcow_aio_read_cb, acb); + acb->hd_iov.iov_base = acb->buf; + acb->hd_iov.iov_len = acb->n *512 ; +qemu_iovec_init_external (&acb->hd_qiov, &acb->hd_iov,1 ); + acb->hd_aiocb =bdrv_aio_readv (bs->backing_hd, acb->sector_num, + &acb->hd_qiov, acb->n, qcow_aio_read_cb, acb);if (acb->hd_aiocb ==NULL ) goto fail; }else {
@@ -605,9 +610,12 @@ static void qcow_aio_read_cb(void *opaqu ret = -EIO ; goto fail; } - acb->hd_aiocb =bdrv_aio_read (s->hd, + acb->hd_iov.iov_base = acb->buf; + acb->hd_iov.iov_len = acb->n *512 ; +qemu_iovec_init_external (&acb->hd_qiov, &acb->hd_iov,1 ); + acb->hd_aiocb =bdrv_aio_readv (s->hd, (acb->cluster_offset >>9 ) + index_in_cluster, - acb->buf, acb->n, qcow_aio_read_cb, acb); + &acb->hd_qiov, acb->n, qcow_aio_read_cb, acb);if (acb->hd_aiocb ==NULL ) goto fail; }
@@ -687,10 +695,14 @@ static void qcow_aio_write_cb(void *opaq }else { src_buf = acb->buf; } - acb->hd_aiocb =bdrv_aio_write (s->hd, - (cluster_offset >>9 ) + index_in_cluster, - src_buf, acb->n, - qcow_aio_write_cb, acb); + + acb->hd_iov.iov_base = (void *)src_buf; + acb->hd_iov.iov_len = acb->n *512 ; +qemu_iovec_init_external (&acb->hd_qiov, &acb->hd_iov,1 ); + acb->hd_aiocb =bdrv_aio_writev (s->hd, + (cluster_offset >>9 ) + index_in_cluster, + &acb->hd_qiov, acb->n, + qcow_aio_write_cb, acb);if (acb->hd_aiocb ==NULL ) goto fail; }
block-qcow2.c +21 -8
@@ -1266,6 +1266,8 @@ typedef struct QCowAIOCB {uint64_t cluster_offset;uint8_t *cluster_data;BlockDriverAIOCB *hd_aiocb; +struct iovec hd_iov; +QEMUIOVector hd_qiov;QEMUBH *bh;QCowL2Meta l2meta; } QCowAIOCB;
@@ -1343,8 +1345,12 @@ fail: n1 =backing_read1 (bs->backing_hd, acb->sector_num, acb->buf, acb->n);if (n1 >0 ) { - acb->hd_aiocb =bdrv_aio_read (bs->backing_hd, acb->sector_num, - acb->buf, acb->n, qcow_aio_read_cb, acb); + acb->hd_iov.iov_base = acb->buf; + acb->hd_iov.iov_len = acb->n *512 ; +qemu_iovec_init_external (&acb->hd_qiov, &acb->hd_iov,1 ); + acb->hd_aiocb =bdrv_aio_readv (bs->backing_hd, acb->sector_num, + &acb->hd_qiov, acb->n, + qcow_aio_read_cb, acb);if (acb->hd_aiocb ==NULL ) goto fail; }else {
@@ -1373,9 +1379,13 @@ fail: ret = -EIO ; goto fail; } - acb->hd_aiocb =bdrv_aio_read (s->hd, + + acb->hd_iov.iov_base = acb->buf; + acb->hd_iov.iov_len = acb->n *512 ; +qemu_iovec_init_external (&acb->hd_qiov, &acb->hd_iov,1 ); + acb->hd_aiocb =bdrv_aio_readv (s->hd, (acb->cluster_offset >>9 ) + index_in_cluster, - acb->buf, acb->n, qcow_aio_read_cb, acb); + &acb->hd_qiov, acb->n, qcow_aio_read_cb, acb);if (acb->hd_aiocb ==NULL ) goto fail; }
@@ -1472,10 +1482,13 @@ static void qcow_aio_write_cb(void *opaq }else { src_buf = acb->buf; } - acb->hd_aiocb =bdrv_aio_write (s->hd, - (acb->cluster_offset >>9 ) + index_in_cluster, - src_buf, acb->n, - qcow_aio_write_cb, acb); + acb->hd_iov.iov_base = (void *)src_buf; + acb->hd_iov.iov_len = acb->n *512 ; +qemu_iovec_init_external (&acb->hd_qiov, &acb->hd_iov,1 ); + acb->hd_aiocb =bdrv_aio_writev (s->hd, + (acb->cluster_offset >>9 ) + index_in_cluster, + &acb->hd_qiov, acb->n, + qcow_aio_write_cb, acb);if (acb->hd_aiocb ==NULL ) goto fail; }
block.c +8 -2
@@ -55,6 +55,12 @@ typedef struct BlockDriverAIOCBSync {int ret; } BlockDriverAIOCBSync; +static BlockDriverAIOCB *bdrv_aio_read (BlockDriverState *bs, +int64_t sector_num,uint8_t *buf,int nb_sectors, +BlockDriverCompletionFunc *cb,void *opaque); +static BlockDriverAIOCB *bdrv_aio_write (BlockDriverState *bs, +int64_t sector_num,const uint8_t *buf,int nb_sectors, +BlockDriverCompletionFunc *cb,void *opaque);static BlockDriverAIOCB *bdrv_aio_read_em (BlockDriverState *bs,int64_t sector_num,uint8_t *buf,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque);
@@ -1350,7 +1356,7 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockD cb, opaque, 1); } -BlockDriverAIOCB *bdrv_aio_read (BlockDriverState *bs,int64_t sector_num, +static BlockDriverAIOCB *bdrv_aio_read (BlockDriverState *bs,int64_t sector_num,uint8_t *buf,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque) {
@@ -1373,7 +1379,7 @@ BlockDriverAIOCB *bdrv_aio_read(BlockDrireturn ret; } -BlockDriverAIOCB *bdrv_aio_write (BlockDriverState *bs,int64_t sector_num, +static BlockDriverAIOCB *bdrv_aio_write (BlockDriverState *bs,int64_t sector_num,const uint8_t *buf,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque) {
block.h +0 -7
@@ -96,13 +96,6 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDrBlockDriverAIOCB *bdrv_aio_writev (BlockDriverState *bs,int64_t sector_num,QEMUIOVector *iov,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque); - -BlockDriverAIOCB *bdrv_aio_read (BlockDriverState *bs,int64_t sector_num, -uint8_t *buf,int nb_sectors, -BlockDriverCompletionFunc *cb,void *opaque); -BlockDriverAIOCB *bdrv_aio_write (BlockDriverState *bs,int64_t sector_num, -const uint8_t *buf,int nb_sectors, -BlockDriverCompletionFunc *cb,void *opaque);void bdrv_aio_cancel (BlockDriverAIOCB *acb);/* sg packet commands */
PATCH 3/5 push down vector linearization to posix-aio-compat.c
In reply to Christoph HellwigMake all AIO requests vectored and defer linearization until the actual I/O thread. This prepares for using native preadv/pwritev.
Also enables asynchronous direct I/O by handling that case in the I/O thread.
Win32 support is untested and uncompiled. Then again I can't even find a know to turn on win32 aio support.
Qcow and qcow2 propably want to be adopted to directly deal with multi-segment requests, but that can be implemented later.
block.c +70 -126
@@ -47,25 +47,21 @@#define SECTOR_BITS 9#define SECTOR_SIZE (1 << SECTOR_BITS) -static AIOPool vectored_aio_pool; -typedef struct BlockDriverAIOCBSync {BlockDriverAIOCB common;QEMUBH *bh;int ret; +/* vector translation state */ +QEMUIOVector *qiov; +uint8_t *bounce; +int is_write; }BlockDriverAIOCBSync ; -static BlockDriverAIOCB *bdrv_aio_read (BlockDriverState *bs, -int64_t sector_num,uint8_t *buf,int nb_sectors, +static BlockDriverAIOCB *bdrv_aio_readv_em (BlockDriverState *bs, +int64_t sector_num,QEMUIOVector *qiov,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque); -static BlockDriverAIOCB *bdrv_aio_write (BlockDriverState *bs, -int64_t sector_num,const uint8_t *buf,int nb_sectors, -BlockDriverCompletionFunc *cb,void *opaque); -static BlockDriverAIOCB *bdrv_aio_read_em (BlockDriverState *bs, -int64_t sector_num,uint8_t *buf,int nb_sectors, -BlockDriverCompletionFunc *cb,void *opaque); -static BlockDriverAIOCB *bdrv_aio_write_em (BlockDriverState *bs, -int64_t sector_num,const uint8_t *buf,int nb_sectors, +static BlockDriverAIOCB *bdrv_aio_writev_em (BlockDriverState *bs, +int64_t sector_num,QEMUIOVector *qiov,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,
@@ -144,10 +140,10 @@ void path_combine(char *dest, int dest_sstatic void bdrv_register (BlockDriver *bdrv) { -if (!bdrv->bdrv_aio_read) { +if (!bdrv->bdrv_aio_readv) {/* add AIO emulation layer */ - bdrv->bdrv_aio_read = bdrv_aio_read_em; - bdrv->bdrv_aio_write = bdrv_aio_write_em; + bdrv->bdrv_aio_readv = bdrv_aio_readv_em; + bdrv->bdrv_aio_writev = bdrv_aio_writev_em; bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em; bdrv->aiocb_size =sizeof (BlockDriverAIOCBSync); }else if (!bdrv->bdrv_read) {
@@ -1275,91 +1271,10 @@ char *bdrv_snapshot_dump(char *buf, int/**************************************************************/ /* async I/Os */ -typedef struct VectorTranslationAIOCB { -BlockDriverAIOCB common; -QEMUIOVector *iov; -uint8_t *bounce; -int is_write; -BlockDriverAIOCB *aiocb; -}VectorTranslationAIOCB ; - -static void bdrv_aio_cancel_vector (BlockDriverAIOCB *_acb) -{ -VectorTranslationAIOCB *acb - =container_of (_acb, VectorTranslationAIOCB, common); - -bdrv_aio_cancel (acb->aiocb); -} - -static void bdrv_aio_rw_vector_cb (void *opaque,int ret) -{ -VectorTranslationAIOCB *s = (VectorTranslationAIOCB *)opaque; - -if (!s->is_write) { -qemu_iovec_from_buffer (s->iov, s->bounce, s->iov->size); - } -qemu_vfree (s->bounce); - s->common.cb (s->common.opaque, ret); -qemu_aio_release (s); -} - -static BlockDriverAIOCB *bdrv_aio_rw_vector (BlockDriverState *bs, -int64_t sector_num, -QEMUIOVector *iov, -int nb_sectors, -BlockDriverCompletionFunc *cb, -void *opaque, -int is_write) - -{ -VectorTranslationAIOCB *s =qemu_aio_get_pool (&vectored_aio_pool, bs, - cb, opaque); - - 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); - } -if (!s->aiocb) { -qemu_vfree (s->bounce); -qemu_aio_release (s); -return NULL ; - } -return &s->common; -} -BlockDriverAIOCB *bdrv_aio_readv (BlockDriverState *bs,int64_t sector_num, -QEMUIOVector *iov,int nb_sectors, +QEMUIOVector *qiov,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 ); -} - -static 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;
@@ -1368,7 +1283,8 @@ static BlockDriverAIOCB *bdrv_aio_read(Bif (bdrv_check_request (bs, sector_num, nb_sectors))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) {/* Update stats even though technically transfer has not happened. */
@@ -1379,9 +1295,9 @@ static BlockDriverAIOCB *bdrv_aio_read(Breturn ret; } -static BlockDriverAIOCB *bdrv_aio_write (BlockDriverState *bs,int64_t sector_num, -const uint8_t *buf,int nb_sectors, -BlockDriverCompletionFunc *cb,void *opaque) +BlockDriverAIOCB *bdrv_aio_writev (BlockDriverState *bs,int64_t sector_num, +QEMUIOVector *qiov,int nb_sectors, +BlockDriverCompletionFunc *cb,void *opaque) {BlockDriver *drv = bs->drv;BlockDriverAIOCB *ret;
@@ -1393,7 +1309,8 @@ static BlockDriverAIOCB *bdrv_aio_write(if (bdrv_check_request (bs, sector_num, nb_sectors))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) {/* Update stats even though technically transfer has not happened. */
@@ -1416,42 +1333,62 @@ void bdrv_aio_cancel(BlockDriverAIOCB *astatic void bdrv_aio_bh_cb (void *opaque) {BlockDriverAIOCBSync *acb = opaque; + +qemu_vfree (acb->bounce); + +if (!acb->is_write) +qemu_iovec_from_buffer (acb->qiov, acb->bounce, acb->qiov->size); acb->common.cb (acb->common.opaque, acb->ret); +qemu_aio_release (acb); } -static BlockDriverAIOCB *bdrv_aio_read_em (BlockDriverState *bs, -int64_t sector_num,uint8_t *buf,int nb_sectors, -BlockDriverCompletionFunc *cb,void *opaque) +static BlockDriverAIOCB *bdrv_aio_rw_vector (BlockDriverState *bs, +int64_t sector_num, +QEMUIOVector *qiov, +int nb_sectors, +BlockDriverCompletionFunc *cb, +void *opaque, +int is_write) + {BlockDriverAIOCBSync *acb; -int ret; acb =qemu_aio_get (bs, cb, opaque); + acb->is_write = is_write; + acb->qiov = qiov; + acb->bounce =qemu_memalign (512 , qiov->size); +if (!acb->bh) 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); +return &acb->common; } -static BlockDriverAIOCB *bdrv_aio_write_em (BlockDriverState *bs, -int64_t sector_num,const uint8_t *buf,int nb_sectors, +static BlockDriverAIOCB *bdrv_aio_readv_em (BlockDriverState *bs, +int64_t sector_num,QEMUIOVector *qiov,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque) { -BlockDriverAIOCBSync *acb; -int ret; +return bdrv_aio_rw_vector (bs, sector_num, qiov, nb_sectors, cb, opaque,0 ); +} - 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 BlockDriverAIOCB *bdrv_aio_writev_em (BlockDriverState *bs, +int64_t sector_num,QEMUIOVector *qiov,int nb_sectors, +BlockDriverCompletionFunc *cb,void *opaque) +{ +return bdrv_aio_rw_vector (bs, sector_num, qiov, nb_sectors, cb, opaque,1 ); } +static void bdrv_aio_cancel_em (BlockDriverAIOCB *blockacb) {BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
@@ -1474,10 +1411,15 @@ static int bdrv_read_em(BlockDriverState {int async_ret;BlockDriverAIOCB *acb; +struct iovec iov; +QEMUIOVector qiov; async_ret =NOT_DONE ; - acb =bdrv_aio_read (bs, sector_num, buf, nb_sectors, - bdrv_rw_em_cb, &async_ret); + iov.iov_base = buf; + 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 )return -1 ;
@@ -1493,10 +1435,15 @@ static int bdrv_write_em(BlockDriverStat {int async_ret;BlockDriverAIOCB *acb; +struct iovec iov; +QEMUIOVector qiov; async_ret =NOT_DONE ; - acb =bdrv_aio_write (bs, sector_num, buf, nb_sectors, - bdrv_rw_em_cb, &async_ret); + iov.iov_base = (void *)buf; + 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 )return -1 ;while (async_ret ==NOT_DONE ) {
@@ -1507,9 +1454,6 @@ static int bdrv_write_em(BlockDriverStatvoid bdrv_init (void ) { -aio_pool_init (&vectored_aio_pool,sizeof (VectorTranslationAIOCB), - bdrv_aio_cancel_vector); -bdrv_register (&bdrv_raw);bdrv_register (&bdrv_host_device);#ifndef _WIN32
block-qcow.c +51 -33
180 lines not on this page · raw message
block-qcow2.c +54 -39
205 lines not on this page · raw message
block-raw-posix.c +38 -55
154 lines not on this page · raw message
block-raw-win32.c +44 -14
123 lines not on this page · raw message
block_int.h +4 -4
@@ -54,11 +54,11 @@ struct BlockDriver {int (*bdrv_set_key)(BlockDriverState *bs,const char *key);int (*bdrv_make_empty)(BlockDriverState *bs);/* aio */ -BlockDriverAIOCB *(*bdrv_aio_read)(BlockDriverState *bs, -int64_t sector_num,uint8_t *buf,int nb_sectors, +BlockDriverAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, +int64_t sector_num,QEMUIOVector *qiov,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque); -BlockDriverAIOCB *(*bdrv_aio_write)(BlockDriverState *bs, -int64_t sector_num,const uint8_t *buf,int nb_sectors, +BlockDriverAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, +int64_t sector_num,QEMUIOVector *qiov,int nb_sectors,BlockDriverCompletionFunc *cb,void *opaque);void (*bdrv_aio_cancel)(BlockDriverAIOCB *acb);int aiocb_size;
posix-aio-compat.c +92 -26
150 lines not on this page · raw message
posix-aio-compat.h +8 -1
@@ -27,11 +27,18 @@struct qemu_paiocb {int aio_fildes; -void *aio_buf; +union { +struct iovec *aio_iov; +void *aio_ioctl_buf; + }; +int aio_niov;size_t aio_nbytes;#define aio_ioctl_cmd aio_nbytes/* for QEMU_PAIO_IOCTL */ int ev_signo;off_t aio_offset; +unsigned aio_flags; +/* 512 byte alignment required for buffer, offset and length */ +#define QEMU_AIO_SECTOR_ALIGNED 0x01/* private */ TAILQ_ENTRY (qemu_paiocb) node;
PATCH 4/5 native preadv/pwritev support
In reply to Christoph HellwigThis ties up the preadv/pwritev syscalls to qemu if they are declared in unistd.h. This is the case currently on at least NetBSD and OpenBSD and will hopefully soon be the case on Linux.
Thanks to Blue Swirl and Gerd Hoffmann for the configure autodetection of preadv/pwritev.
posix-aio-compat.c +83 -2
@@ -33,6 +33,12 @@ static int cur_threads = 0;static int idle_threads =0 ; static TAILQ_HEAD(, qemu_paiocb) request_list; +#ifdef HAVE_PREADV +static int preadv_present =1 ; +#else +static int preadv_present =0 ; +#endif +static void die2 (int err,const char *what) {fprintf (stderr,"%s failed: %s\n" , what,strerror (err));
@@ -87,6 +93,36 @@ static size_t handle_aiocb_ioctl(structreturn ret; } +#ifdef HAVE_PREADV + +static ssize_t +qemu_preadv (int fd,const struct iovec *iov,int nr_iov,off_t offset) +{ +return preadv (fd, iov, nr_iov, offset); +} + +static ssize_t +qemu_pwritev (int fd,const struct iovec *iov,int nr_iov,off_t offset) +{ +return pwritev (fd, iov, nr_iov, offset); +} + +#else + +static ssize_t +qemu_preadv (int fd,const struct iovec *iov,int nr_iov,off_t offset) +{ +return -ENOSYS ; +} + +static ssize_t +qemu_pwritev (int fd,const struct iovec *iov,int nr_iov,off_t offset) +{ +return -ENOSYS ; +} + +#endif +/* * Check if we need to copy the data in the aiocb into a new * properly aligned buffer.
@@ -104,6 +140,29 @@ static int aiocb_needs_copy(struct qemu_return 0 ; } +static size_t handle_aiocb_rw_vector (struct qemu_paiocb *aiocb) +{ +size_t offset =0 ; +ssize_t len; + +do { +if (aiocb->aio_type ==QEMU_PAIO_WRITE ) + len =qemu_pwritev (aiocb->aio_fildes, + aiocb->aio_iov, + aiocb->aio_niov, + aiocb->aio_offset + offset); +else + len =qemu_preadv (aiocb->aio_fildes, + aiocb->aio_iov, + aiocb->aio_niov, + aiocb->aio_offset + offset); + }while (len ==-1 && errno ==EINTR ); + +if (len ==-1 ) +return -errno; +return len; +} +static size_t handle_aiocb_rw_linear (struct qemu_paiocb *aiocb,char *buf) {size_t offset =0 ;
@@ -140,12 +199,34 @@ static size_t handle_aiocb_rw(struct qemsize_t nbytes;char *buf; -if (!aiocb_needs_copy (aiocb) && aiocb->aio_niov ==1 ) { +if (!aiocb_needs_copy (aiocb)) {/* * If there is just a single buffer, and it is properly aligned * we can just use plain pread/pwrite without any problems. */ -return handle_aiocb_rw_linear (aiocb, aiocb->aio_iov->iov_base); +if (aiocb->aio_niov ==1 ) +return handle_aiocb_rw_linear (aiocb, aiocb->aio_iov->iov_base); + +/* +* We have more than one iovec, and all are properly aligned. +* +* Try preadv/pwritev first and fall back to linearizing the +* buffer if it's not supported. +*/ +if (preadv_present) { + nbytes =handle_aiocb_rw_vector (aiocb); +if (nbytes == aiocb->aio_nbytes) +return nbytes; +if (nbytes <0 && nbytes != -ENOSYS ) +return nbytes; + preadv_present =0 ; + } + +/* +* XXX(hch): short read/write. no easy way to handle the reminder +* using these interfaces. For now retry using plain +* pread/pwrite? +*/ }/*
configure +17 -0
@@ -1095,6 +1095,19 @@ if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /de fi ########################################## +# preadv probe +cat > $TMPC <<EOF +#include <sys/types.h> +#include <sys/uio.h> +#include <unistd.h> +int main(void) { preadv; } +EOF +preadv=no +if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /dev/null 2> /dev/null ; then + preadv=yes +fi + +########################################## # fdt probe if test "$fdt" = "yes" ; then fdt=no
@@ -1207,6 +1220,7 @@ echo "AIO support $aio" echo "Install blobs $blobs" echo "KVM support $kvm" echo "fdt support $fdt" +echo "preadv support $preadv" if test $sdl_too_old = "yes"; then echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -1506,6 +1520,9 @@ fi if test "$iovec" = "yes" ; then echo "#define HAVE_IOVEC 1" >> $config_h fi +if test "$preadv" = "yes" ; then + echo "#define HAVE_PREADV 1" >> $config_h +fi if test "$fdt" = "yes" ; then echo "#define HAVE_FDT 1" >> $config_h echo "FDT_LIBS=-lfdt" >> $config_mak
PATCH 5/5 experimental native preadv/pwritev support for Linux
In reply to Christoph HellwigThis ties up Gerd Hoffmann's unmerged preadv/pwritev syscalls to qemu. Use with care as the syscall numbers aren't finalized yet.
Also the patch is ugly enough that I hope we might not need it at all if preadv/pwritev go into glibc fast enough..
posix-aio-compat.c +27 -1
@@ -33,7 +33,7 @@ static int cur_threads = 0;static int idle_threads =0 ; static TAILQ_HEAD(, qemu_paiocb) request_list; -#ifdef HAVE_PREADV +#if defined(HAVE_PREADV ) || (defined(__linux__) && defined(__i386__))static int preadv_present =1 ;#else static int preadv_present =0 ;
@@ -93,6 +93,31 @@ static size_t handle_aiocb_ioctl(structreturn ret; } +#if defined (__linux__) && defined(__i386__) + +#define __NR_preadv 333 +#define __NR_pwritev 334 + +static ssize_t +qemu_preadv (int fd,const struct iovec *iov,int nr_iov,off_t offset) +{ +uint32_t pos_high = offset >>32 ; +uint32_t pos_low = offset; + +return syscall (__NR_preadv, fd, iov, (unsigned long )nr_iov, pos_high, pos_low); +} + +static ssize_t +qemu_pwritev (int fd,const struct iovec *iov,int nr_iov,off_t offset) +{ +uint32_t pos_high = offset >>32 ; +uint32_t pos_low = offset; + +return syscall (__NR_pwritev, fd, iov, (unsigned long )nr_iov, pos_high, pos_low); +} + +#else +#ifdef HAVE_PREADV static ssize_t
@@ -122,6 +147,7 @@ qemu_pwritev(int fd, const struct iovec }#endif +#endif /* * Check if we need to copy the data in the aiocb into a new
Re: [Qemu-devel] [PATCH 3/5] push down vector linearization to posix-aio-compat.c
In reply to Christoph HellwigQuoted 8 lines · Christoph Hellwig
Make all AIO requests vectored and defer linearization until the actual I/O thread. This prepares for using native preadv/pwritev.
Also enables asynchronous direct I/O by handling that case in the I/O thread.
Win32 support is untested and uncompiled. Then again I can't even find a know to turn on win32 aio support.
It compiles for win32 but it breaks at this patch. Win32 doesn't actually support AIO. The code that's in #ifdefs has been dead for a long time. I just committed a patch to remove it to avoid future confusion. For the future, you can build/test win32 entirely in fedora by using the mingw32 packages and wine.
This bug is not limited to win32 though. It has to do with having a backend disk format that does not provide a proper aio implement (which suggests your new brv_aio_{readv,writev}_em at fault). You can reproduce on a normal Linux build by converting an existing image to a format like vmdk and then testing with that. It's not 100% reliable but 9 times out of 10 I don't get past the grub loader with this patch applied.
Regards,
Anthony Liguori
Quoted 6 lines
Qcow and qcow2 propably want to be adopted to directly deal with multi-segment requests, but that can be implemented later.
Signed-off-by Christoph Hellwig <[email protected]>
Re: [Qemu-devel] [PATCH 3/5] push down vector linearization to posix-aio-compat.c
Quoted 6 lines · Anthony Liguori
This bug is not limited to win32 though. It has to do with having a backend disk format that does not provide a proper aio implement (which suggests your new brv_aio_{readv,writev}_em at fault). You can reproduce on a normal Linux build by converting an existing image to a format like vmdk and then testing with that. It's not 100% reliable but 9 times out of 10 I don't get past the grub loader with this patch applied.
This bug? I did test cow, vmdk and vpc and can't reproduce it. By inspection I can find a use after free in bdrv_aio_bh_cb, though.
Will repost the whole series, the win32 aio removal and some recent scsi-disk commits caused a whole lot of rejects..
Re: [Qemu-devel] [PATCH 3/5] push down vector linearization to posix-aio-compat.c
Quoted 8 lines · Christoph Hellwig
Quoted 2 lines · Anthony Liguori
This bug is not limited to win32 though. It has to do with having a backend disk format that does not provide a proper aio implement (which suggests your new brv_aio_{readv,writev}_em at fault). You can reproduce on a normal Linux build by converting an existing image to a format like vmdk and then testing with that. It's not 100% reliable but 9 times out of 10 I don't get past the grub loader with this patch applied.
This bug? I did test cow, vmdk and vpc and can't reproduce it. By inspection I can find a use after free in
bdrv_aio_bh_cb, though
I assume you mean this. I've confirmed that with this fix, it now works with win32 and vmdk on Linux. It doesn't get triggered unless you're bouncing in block.c which won't happen unless you have a driver that doesn't support the aio functions. That's why I couldn't reproduce it without vmdk on Linux.
block.c +0 -0
@@ -1334,12 +1334,12 @@ static void bdrv_aio_bh_cb(void *opaque)
{
BlockDriverAIOCBSync *acb = opaque;- qemu_vfree(acb->bounce);
-
if (!acb->is_write)
qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
acb->common.cb(acb->common.opaque, acb->ret);+ qemu_vfree(acb->bounce);
+
qemu_aio_release(acb); }
Quoted 3 lines
Will repost the whole series, the win32 aio removal and some recent scsi-disk commits caused a whole lot of rejects..
Just two and I've fixed them locally but I can wait for you to resubmit if you'd like.
Regards,
Anthony Liguori
Re: [Qemu-devel] [PATCH 3/5] push down vector linearization to posix-aio-compat.c
Quoted 5 lines · Anthony Liguori
I assume you mean this. I've confirmed that with this fix, it now works with win32 and vmdk on Linux. It doesn't get triggered unless you're bouncing in
block.cwhich won't happen unless you have a driver that doesn't support the aio functions. That's why I couldn't reproduce it without vmdk on Linux.
Yeah, that's what I mean. But my testing includes vmdk, cow and vpc which should require the block level bouncing. Guess I just didn't manage to get free poison it fast enough.
Quoted 6 lines
Quoted 3 lines
Will repost the whole series, the win32 aio removal and some recent scsi-disk commits caused a whole lot of rejects..
Just two and I've fixed them locally but I can wait for you to resubmit if you'd like.
Three including the fix above. But if you can commit them directly that makes it easier for me.