From patchwork Wed Oct 19 14:59:55 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paolo Bonzini X-Patchwork-Id: 120652 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [140.186.70.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 6AFF3B71BE for ; Thu, 20 Oct 2011 02:11:40 +1100 (EST) Received: from localhost ([::1]:44294 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1RGXdZ-0003Mr-VS for incoming@patchwork.ozlabs.org; Wed, 19 Oct 2011 11:00:57 -0400 Received: from eggs.gnu.org ([140.186.70.92]:36665) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1RGXd9-00034G-Fk for qemu-devel@nongnu.org; Wed, 19 Oct 2011 11:00:36 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1RGXd4-0006J9-0Z for qemu-devel@nongnu.org; Wed, 19 Oct 2011 11:00:31 -0400 Received: from mail-qy0-f180.google.com ([209.85.216.180]:38740) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1RGXd3-0006Ih-M3 for qemu-devel@nongnu.org; Wed, 19 Oct 2011 11:00:25 -0400 Received: by qyk10 with SMTP id 10so2265455qyk.4 for ; Wed, 19 Oct 2011 08:00:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=sender:from:to:cc:subject:date:message-id:x-mailer:in-reply-to :references; bh=7+GsA45lUC+YSWn1WhsWxvupkXeGjG7EU88/15srqiI=; b=kpMrxuOUdZbdJu+lZ5E//ua6EiKrhSdJfYWuv1vqVteph6F0qkITv84Zmx413oubqL +etz9lwFs7r613L9jJVAn+Gk5dI+Nxn+BAtsOusw+Xylc8XH/S9jqyWPvB1uzABNS75F A2Zqi9X8rizRv+60UL3bW2a1NrhgTV9yOcW1k= Received: by 10.68.209.37 with SMTP id mj5mr12852025pbc.123.1319036424296; Wed, 19 Oct 2011 08:00:24 -0700 (PDT) Received: from localhost.localdomain (93-34-218-143.ip51.fastwebnet.it. [93.34.218.143]) by mx.google.com with ESMTPS id w4sm8198844pbf.6.2011.10.19.08.00.21 (version=TLSv1/SSLv3 cipher=OTHER); Wed, 19 Oct 2011 08:00:23 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Date: Wed, 19 Oct 2011 16:59:55 +0200 Message-Id: <1319036398-14320-6-git-send-email-pbonzini@redhat.com> X-Mailer: git-send-email 1.7.6 In-Reply-To: <1319036398-14320-1-git-send-email-pbonzini@redhat.com> References: <1319036398-14320-1-git-send-email-pbonzini@redhat.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 2) X-Received-From: 209.85.216.180 Cc: kwolf@redhat.com, stefanha@linux.vnet.ibm.com Subject: [Qemu-devel] [PATCH 5/8] block: take lock around bdrv_read implementations X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org This does the first part of the conversion to coroutines, by wrapping bdrv_read implementations to take the read side of the rwlock. Drivers that implement bdrv_read rather than bdrv_co_readv can then benefit from asynchronous operation (at least if the underlying protocol supports it, which is not the case for raw-win32), even though they still operate with a bounce buffer. raw-win32 does not need the lock, because it cannot yield. nbd also doesn't probably, but better be safe. Signed-off-by: Paolo Bonzini --- block/cow.c | 13 ++++++++++++- block/nbd.c | 13 ++++++++++++- block/vmdk.c | 13 ++++++++++++- block/vpc.c | 13 ++++++++++++- block/vvfat.c | 13 ++++++++++++- 5 files changed, 60 insertions(+), 5 deletions(-) diff --git a/block/cow.c b/block/cow.c index d27e0aa..9571549 100644 --- a/block/cow.c +++ b/block/cow.c @@ -201,6 +201,17 @@ static int cow_read(BlockDriverState *bs, int64_t sector_num, return 0; } +static coroutine_fn int cow_co_read(BlockDriverState *bs, int64_t sector_num, + uint8_t *buf, int nb_sectors) +{ + int ret; + BDRVCowState *s = bs->opaque; + qemu_co_rwlock_rdlock(&s->lock); + ret = cow_read(bs, sector_num, buf, nb_sectors); + qemu_co_rwlock_unlock(&s->lock); + return ret; +} + static int cow_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors) { @@ -308,7 +319,7 @@ static BlockDriver bdrv_cow = { .instance_size = sizeof(BDRVCowState), .bdrv_probe = cow_probe, .bdrv_open = cow_open, - .bdrv_read = cow_read, + .bdrv_read = cow_co_read, .bdrv_write = cow_write, .bdrv_close = cow_close, .bdrv_create = cow_create, diff --git a/block/nbd.c b/block/nbd.c index ec8f086..f8fed92 100644 --- a/block/nbd.c +++ b/block/nbd.c @@ -240,6 +240,17 @@ static int nbd_write(BlockDriverState *bs, int64_t sector_num, return 0; } +static coroutine_fn int nbd_co_read(BlockDriverState *bs, int64_t sector_num, + uint8_t *buf, int nb_sectors) +{ + int ret; + BDRVNBDState *s = bs->opaque; + qemu_co_rwlock_rdlock(&s->lock); + ret = nbd_read(bs, sector_num, buf, nb_sectors); + qemu_co_rwlock_unlock(&s->lock); + return ret; +} + static void nbd_close(BlockDriverState *bs) { BDRVNBDState *s = bs->opaque; @@ -260,7 +271,7 @@ static BlockDriver bdrv_nbd = { .format_name = "nbd", .instance_size = sizeof(BDRVNBDState), .bdrv_file_open = nbd_open, - .bdrv_read = nbd_read, + .bdrv_read = nbd_co_read, .bdrv_write = nbd_write, .bdrv_close = nbd_close, .bdrv_getlength = nbd_getlength, diff --git a/block/vmdk.c b/block/vmdk.c index 6afd53e..ff78e25 100644 --- a/block/vmdk.c +++ b/block/vmdk.c @@ -1022,6 +1022,17 @@ static int vmdk_read(BlockDriverState *bs, int64_t sector_num, return 0; } +static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num, + uint8_t *buf, int nb_sectors) +{ + int ret; + BDRVVmdkState *s = bs->opaque; + qemu_co_rwlock_rdlock(&s->lock); + ret = vmdk_read(bs, sector_num, buf, nb_sectors); + qemu_co_rwlock_unlock(&s->lock); + return ret; +} + static int vmdk_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors) { @@ -1540,7 +1551,7 @@ static BlockDriver bdrv_vmdk = { .instance_size = sizeof(BDRVVmdkState), .bdrv_probe = vmdk_probe, .bdrv_open = vmdk_open, - .bdrv_read = vmdk_read, + .bdrv_read = vmdk_co_read, .bdrv_write = vmdk_write, .bdrv_close = vmdk_close, .bdrv_create = vmdk_create, diff --git a/block/vpc.c b/block/vpc.c index 7220488..e805769 100644 --- a/block/vpc.c +++ b/block/vpc.c @@ -409,6 +409,17 @@ static int vpc_read(BlockDriverState *bs, int64_t sector_num, return 0; } +static coroutine_fn int vpc_co_read(BlockDriverState *bs, int64_t sector_num, + uint8_t *buf, int nb_sectors) +{ + int ret; + BDRVVPCState *s = bs->opaque; + qemu_co_rwlock_rdlock(&s->lock); + ret = vpc_read(bs, sector_num, buf, nb_sectors); + qemu_co_rwlock_unlock(&s->lock); + return ret; +} + static int vpc_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors) { @@ -649,7 +660,7 @@ static BlockDriver bdrv_vpc = { .instance_size = sizeof(BDRVVPCState), .bdrv_probe = vpc_probe, .bdrv_open = vpc_open, - .bdrv_read = vpc_read, + .bdrv_read = vpc_co_read, .bdrv_write = vpc_write, .bdrv_flush = vpc_flush, .bdrv_close = vpc_close, diff --git a/block/vvfat.c b/block/vvfat.c index 08a72ee..f1d94ad 100644 --- a/block/vvfat.c +++ b/block/vvfat.c @@ -1279,6 +1279,17 @@ DLOG(fprintf(stderr, "sector %d not allocated\n", (int)sector_num)); return 0; } +static coroutine_fn int vvfat_co_read(BlockDriverState *bs, int64_t sector_num, + uint8_t *buf, int nb_sectors) +{ + int ret; + BDRVVVFATState *s = bs->opaque; + qemu_co_rwlock_rdlock(&s->lock); + ret = vvfat_read(bs, sector_num, buf, nb_sectors); + qemu_co_rwlock_unlock(&s->lock); + return ret; +} + /* LATER TODO: statify all functions */ /* @@ -2803,7 +2814,7 @@ static BlockDriver bdrv_vvfat = { .format_name = "vvfat", .instance_size = sizeof(BDRVVVFATState), .bdrv_file_open = vvfat_open, - .bdrv_read = vvfat_read, + .bdrv_read = vvfat_co_read, .bdrv_write = vvfat_write, .bdrv_close = vvfat_close, .bdrv_is_allocated = vvfat_is_allocated,