From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:56554) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Yviqb-0003PO-4E for qemu-devel@nongnu.org; Fri, 22 May 2015 05:02:34 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1YviqZ-0004ed-Fi for qemu-devel@nongnu.org; Fri, 22 May 2015 05:02:29 -0400 Received: from mx1.redhat.com ([209.132.183.28]:39067) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YviqZ-0004eL-9P for qemu-devel@nongnu.org; Fri, 22 May 2015 05:02:27 -0400 From: Stefan Hajnoczi Date: Fri, 22 May 2015 10:01:38 +0100 Message-Id: <1432285330-13994-7-git-send-email-stefanha@redhat.com> In-Reply-To: <1432285330-13994-1-git-send-email-stefanha@redhat.com> References: <1432285330-13994-1-git-send-email-stefanha@redhat.com> Subject: [Qemu-devel] [PULL 06/38] block/parallels: provide _co_readv routine for parallels format driver List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: Kevin Wolf , Peter Maydell , Roman Kagan , Stefan Hajnoczi , "Denis V. Lunev" From: "Denis V. Lunev" Main approach is taken from qcow2_co_readv. The patch drops coroutine lock for the duration of IO operation and peforms normal scatter-gather IO using standard QEMU backend. The patch also adds comment about locking considerations in the driver. Signed-off-by: Denis V. Lunev Reviewed-by: Roman Kagan Signed-off-by: Roman Kagan Message-id: 1430207220-24458-7-git-send-email-den@openvz.org CC: Roman Kagan CC: Kevin Wolf CC: Stefan Hajnoczi Signed-off-by: Stefan Hajnoczi --- block/parallels.c | 54 +++++++++++++++++++++++++++++++++--------------------- 1 file changed, 33 insertions(+), 21 deletions(-) diff --git a/block/parallels.c b/block/parallels.c index b469984..f3ffece 100644 --- a/block/parallels.c +++ b/block/parallels.c @@ -49,6 +49,10 @@ typedef struct ParallelsHeader { } QEMU_PACKED ParallelsHeader; typedef struct BDRVParallelsState { + /** Locking is conservative, the lock protects + * - image file extending (truncate, fallocate) + * - any access to block allocation table + */ CoMutex lock; uint32_t *catalog_bitmap; @@ -186,37 +190,45 @@ static int64_t coroutine_fn parallels_co_get_block_status(BlockDriverState *bs, BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; } -static int parallels_read(BlockDriverState *bs, int64_t sector_num, - uint8_t *buf, int nb_sectors) +static coroutine_fn int parallels_co_readv(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) { BDRVParallelsState *s = bs->opaque; + uint64_t bytes_done = 0; + QEMUIOVector hd_qiov; + int ret = 0; + + qemu_iovec_init(&hd_qiov, qiov->niov); while (nb_sectors > 0) { - int64_t position = seek_to_sector(s, sector_num); - int n = cluster_remainder(s, sector_num, nb_sectors); - if (position >= 0) { - int ret = bdrv_read(bs->file, position, buf, n); + int64_t position; + int n, nbytes; + + qemu_co_mutex_lock(&s->lock); + position = seek_to_sector(s, sector_num); + qemu_co_mutex_unlock(&s->lock); + + n = cluster_remainder(s, sector_num, nb_sectors); + nbytes = n << BDRV_SECTOR_BITS; + + if (position < 0) { + qemu_iovec_memset(qiov, bytes_done, 0, nbytes); + } else { + qemu_iovec_reset(&hd_qiov); + qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes); + + ret = bdrv_co_readv(bs->file, position, n, &hd_qiov); if (ret < 0) { - return ret; + break; } - } else { - memset(buf, 0, n << BDRV_SECTOR_BITS); } + nb_sectors -= n; sector_num += n; - buf += n << BDRV_SECTOR_BITS; + bytes_done += nbytes; } - return 0; -} -static coroutine_fn int parallels_co_read(BlockDriverState *bs, int64_t sector_num, - uint8_t *buf, int nb_sectors) -{ - int ret; - BDRVParallelsState *s = bs->opaque; - qemu_co_mutex_lock(&s->lock); - ret = parallels_read(bs, sector_num, buf, nb_sectors); - qemu_co_mutex_unlock(&s->lock); + qemu_iovec_destroy(&hd_qiov); return ret; } @@ -231,9 +243,9 @@ static BlockDriver bdrv_parallels = { .instance_size = sizeof(BDRVParallelsState), .bdrv_probe = parallels_probe, .bdrv_open = parallels_open, - .bdrv_read = parallels_co_read, .bdrv_close = parallels_close, .bdrv_co_get_block_status = parallels_co_get_block_status, + .bdrv_co_readv = parallels_co_readv, }; static void bdrv_parallels_init(void) -- 2.1.0