block: take lock around bdrv_read implementations

This does the first part of the conversion to coroutines, by
wrapping bdrv_read implementations to take the mutex.

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 <pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>

diff --git a/block/bochs.c b/block/bochs.c
index b0f80729fe5caae8b119c1269e37f9737618b4cc..ab7944dc43dfc82b52d8686eb47c521ba6cc07a9 100644 (file)
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -209,6 +209,17 @@ static int bochs_read(BlockDriverState *bs, int64_t sector_num,
     return 0;
 }
 
+static coroutine_fn int bochs_co_read(BlockDriverState *bs, int64_t sector_num,
+                                      uint8_t *buf, int nb_sectors)
+{
+    int ret;
+    BDRVBochsState *s = bs->opaque;
+    qemu_co_mutex_lock(&s->lock);
+    ret = bochs_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_unlock(&s->lock);
+    return ret;
+}
+
 static void bochs_close(BlockDriverState *bs)
 {
     BDRVBochsState *s = bs->opaque;
@@ -220,7 +231,7 @@ static BlockDriver bdrv_bochs = {
     .instance_size     = sizeof(BDRVBochsState),
     .bdrv_probe                = bochs_probe,
     .bdrv_open         = bochs_open,
-    .bdrv_read         = bochs_read,
+    .bdrv_read          = bochs_co_read,
     .bdrv_close                = bochs_close,
 };
 

diff --git a/block/cloop.c b/block/cloop.c
index a91f372aece802b09941d28cc786788fe166113d..775f8a98e1fe81059e8bf6a10a0c14c2e5fdbdb8 100644 (file)
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -146,6 +146,17 @@ static int cloop_read(BlockDriverState *bs, int64_t sector_num,
     return 0;
 }
 
+static coroutine_fn int cloop_co_read(BlockDriverState *bs, int64_t sector_num,
+                                      uint8_t *buf, int nb_sectors)
+{
+    int ret;
+    BDRVCloopState *s = bs->opaque;
+    qemu_co_mutex_lock(&s->lock);
+    ret = cloop_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_unlock(&s->lock);
+    return ret;
+}
+
 static void cloop_close(BlockDriverState *bs)
 {
     BDRVCloopState *s = bs->opaque;
@@ -161,7 +172,7 @@ static BlockDriver bdrv_cloop = {
     .instance_size     = sizeof(BDRVCloopState),
     .bdrv_probe                = cloop_probe,
     .bdrv_open         = cloop_open,
-    .bdrv_read         = cloop_read,
+    .bdrv_read          = cloop_co_read,
     .bdrv_close                = cloop_close,
 };
 

diff --git a/block/cow.c b/block/cow.c
index 2f426e74271ebdc854207daab6014072ae234446..a5fcd208172419b9cfb277b3da84d43b850a220b 100644 (file)
--- 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_mutex_lock(&s->lock);
+    ret = cow_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_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/dmg.c b/block/dmg.c
index 111aeaecd9960e5216f0cf7fc82f5ea706224a21..37902a4347ae579fb3ad17be838b3224354e9a84 100644 (file)
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -282,6 +282,17 @@ static int dmg_read(BlockDriverState *bs, int64_t sector_num,
     return 0;
 }
 
+static coroutine_fn int dmg_co_read(BlockDriverState *bs, int64_t sector_num,
+                                    uint8_t *buf, int nb_sectors)
+{
+    int ret;
+    BDRVDMGState *s = bs->opaque;
+    qemu_co_mutex_lock(&s->lock);
+    ret = dmg_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_unlock(&s->lock);
+    return ret;
+}
+
 static void dmg_close(BlockDriverState *bs)
 {
     BDRVDMGState *s = bs->opaque;
@@ -302,7 +313,7 @@ static BlockDriver bdrv_dmg = {
     .instance_size     = sizeof(BDRVDMGState),
     .bdrv_probe                = dmg_probe,
     .bdrv_open         = dmg_open,
-    .bdrv_read         = dmg_read,
+    .bdrv_read          = dmg_co_read,
     .bdrv_close                = dmg_close,
 };
 

diff --git a/block/nbd.c b/block/nbd.c
index 14ab2259c2a1f28f5d6f1d60996e68ef64fd1fe6..6b22ae1d151f567b1485cef5842398f654f5bc73 100644 (file)
--- 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_mutex_lock(&s->lock);
+    ret = nbd_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_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/parallels.c b/block/parallels.c
index b86e87e48fe7dd4714a7f8174c27a6776db75a33..d30f0ecf7775346e0b8f330a7f9f1cd13fd71f64 100644 (file)
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -136,6 +136,17 @@ static int parallels_read(BlockDriverState *bs, int64_t sector_num,
     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);
+    return ret;
+}
+
 static void parallels_close(BlockDriverState *bs)
 {
     BDRVParallelsState *s = bs->opaque;
@@ -147,7 +158,7 @@ static BlockDriver bdrv_parallels = {
     .instance_size     = sizeof(BDRVParallelsState),
     .bdrv_probe                = parallels_probe,
     .bdrv_open         = parallels_open,
-    .bdrv_read         = parallels_read,
+    .bdrv_read          = parallels_co_read,
     .bdrv_close                = parallels_close,
 };
 

diff --git a/block/vmdk.c b/block/vmdk.c
index 1ce220d5359f0f48d6a5e2ca09c45eed5d7eaf7d..0e791f2d8537f587a81c22ef82c902e697a71324 100644 (file)
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -1024,6 +1024,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_mutex_lock(&s->lock);
+    ret = vmdk_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_unlock(&s->lock);
+    return ret;
+}
+
 static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
                      const uint8_t *buf, int nb_sectors)
 {
@@ -1542,7 +1553,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 9155ee15e39f2a797417b5cbfd87a3e6d21a8cee..0941533f438f5a9501b2c391a8ec187a13bfa153 100644 (file)
--- 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_mutex_lock(&s->lock);
+    ret = vpc_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_unlock(&s->lock);
+    return ret;
+}
+
 static int vpc_write(BlockDriverState *bs, int64_t sector_num,
     const uint8_t *buf, int nb_sectors)
 {
@@ -641,7 +652,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 864bfcf245025fcada5c3b059a53f126cb4a6c49..970cccf1a4acf7faa46175ba5a207065095cecac 100644 (file)
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -1281,6 +1281,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_mutex_lock(&s->lock);
+    ret = vvfat_read(bs, sector_num, buf, nb_sectors);
+    qemu_co_mutex_unlock(&s->lock);
+    return ret;
+}
+
 /* LATER TODO: statify all functions */
 
 /*
@@ -2805,7 +2816,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,