Commit 2914caa0 authored by Paolo Bonzini's avatar Paolo Bonzini Committed by Kevin Wolf
Browse files

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: default avatarPaolo Bonzini <pbonzini@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 848c66e8

block/bochs.c

+12 −1
Original line number Diff line number Diff line
@@ -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,

};

block/cloop.c

+12 −1
Original line number Diff line number Diff line
@@ -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,

};

block/cow.c

+12 −1
Original line number Diff line number Diff line
@@ -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,

block/dmg.c

+12 −1
Original line number Diff line number Diff line
@@ -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,

};

block/nbd.c

+12 −1
Original line number Diff line number Diff line
@@ -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,