proper locking on bitmap add/remove paths
v2 cover proper locking on bitmap add/remove paths
We need to lock qcow2 mutex on accessing in-image metadata, especially on updating this metadata. Let's implement it.
v2:
fix uninitialized variable in 03, found by Patchew
Vladimir Sementsov-Ogievskiy (3):
block: move bdrv_can_store_new_dirty_bitmap to block/dirty-bitmap.c block/dirty-bitmap: return int from
bdrv_remove_persistent_dirty_bitmap
block/qcow2: proper locking on bitmap add/remove paths
block/qcow2.h | 14 ++--- include/block/block_int.h | 14 ++--- include/block/dirty-bitmap.h | 5 +- block.c | 22 ------- block/dirty-bitmap.c | 119 +++++++++++++++++++++++++++++++++-- block/qcow2-bitmap.c | 38 ++++++----- block/qcow2.c | 5 +- blockdev.c | 28 +++------ 8 files changed, 164 insertions(+), 81 deletions(-)
Signature · 1 line
2.18.0
PATCH v2 1/3 block: move bdrv_can_store_new_dirty_bitmap to block/dirty-bitmap.c
block/dirty-bitmap.c seems to be more appropriate for it and bdrv_remove_persistent_dirty_bitmap already in it.
--- block.c | 22 ---------------------- block/dirty-bitmap.c | 22 ++++++++++++++++++++++ 2 files changed, 22 insertions(+), 22 deletions(-)
block.c +0 -22
@@ -6555,25 +6555,3 @@ void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp) parent_bs->drv->bdrv_del_child (parent_bs, child, errp); } - -bool bdrv_can_store_new_dirty_bitmap (BlockDriverState *bs,const char *name, -uint32_t granularity,Error **errp) -{ -BlockDriver *drv = bs->drv; - -if (!drv) { -error_setg_errno (errp,ENOMEDIUM , -"Can't store persistent bitmaps to %s" , -bdrv_get_device_or_node_name (bs)); -return false; - } - -if (!drv->bdrv_can_store_new_dirty_bitmap) { -error_setg_errno (errp,ENOTSUP , -"Can't store persistent bitmaps to %s" , -bdrv_get_device_or_node_name (bs)); -return false; - } - -return drv->bdrv_can_store_new_dirty_bitmap (bs, name, granularity, errp); -}
block/dirty-bitmap.c +22 -0
@@ -464,6 +464,28 @@ void bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, } } +bool bdrv_can_store_new_dirty_bitmap (BlockDriverState *bs,const char *name, +uint32_t granularity,Error **errp) +{ +BlockDriver *drv = bs->drv; + +if (!drv) { +error_setg_errno (errp,ENOMEDIUM , +"Can't store persistent bitmaps to %s" , +bdrv_get_device_or_node_name (bs)); +return false; + } + +if (!drv->bdrv_can_store_new_dirty_bitmap) { +error_setg_errno (errp,ENOTSUP , +"Can't store persistent bitmaps to %s" , +bdrv_get_device_or_node_name (bs)); +return false; + } + +return drv->bdrv_can_store_new_dirty_bitmap (bs, name, granularity, errp); +} +void bdrv_disable_dirty_bitmap (BdrvDirtyBitmap *bitmap) {bdrv_dirty_bitmap_lock (bitmap);
Signature · 1 line
2.18.0
Re: [Qemu-devel] [PATCH v2 1/3] block: move bdrv_can_store_new_dirty_bitmap to block/dirty-bitmap.c
Quoted 4 lines · Vladimir Sementsov-Ogievskiy
block/dirty-bitmap.cseems to be more appropriate for it andbdrv_remove_persistent_dirty_bitmapalready in it.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>
No disagreements here. I think we put it in block.c initially because it's a bdrv callback/dispatch function, but dirty-block.c is just a logical subdivision of block.c, so it's fine.
PATCH v2 2/3 block/dirty-bitmap: return int from bdrv_remove_persistent_dirty_bitmap
In reply to Vladimir Sementsov-OgievskiyIt's more comfortable to not deal with local_err.
--- block/qcow2.h | 5 ++--- include/block/block_int.h | 6 +++--- include/block/dirty-bitmap.h | 5 ++--- block/dirty-bitmap.c | 9 +++++---- block/qcow2-bitmap.c | 20 +++++++++++--------- blockdev.c | 7 +++---- 6 files changed, 26 insertions(+), 26 deletions(-)
block/qcow2.h +2 -3
@@ -747,9 +747,8 @@ bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,const char *name, uint32_t granularity, Error **errp); -void qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp); +int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp); ssize_t coroutine_fn qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size,
include/block/block_int.h +3 -3
@@ -556,9 +556,9 @@ struct BlockDriver {const char *name, uint32_t granularity, Error **errp); -void (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, -const char *name, -Error **errp); +int (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, +const char *name, +Error **errp);/** * Register/unregister a buffer for I/O. For example, when the driver is
include/block/dirty-bitmap.h +2 -3
@@ -37,9 +37,8 @@ int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags, Error **errp);void bdrv_release_dirty_bitmap (BlockDriverState *bs,BdrvDirtyBitmap *bitmap);void bdrv_release_named_dirty_bitmaps (BlockDriverState *bs); -void bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp); +int bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp);void bdrv_disable_dirty_bitmap (BdrvDirtyBitmap *bitmap);void bdrv_enable_dirty_bitmap (BdrvDirtyBitmap *bitmap);void bdrv_enable_dirty_bitmap_locked (BdrvDirtyBitmap *bitmap);
block/dirty-bitmap.c +5 -4
@@ -455,13 +455,14 @@ void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)* not fail. * This function doesn't release corresponding BdrvDirtyBitmap. */ -void bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp) +int bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp) {if (bs->drv && bs->drv->bdrv_remove_persistent_dirty_bitmap) { - bs->drv->bdrv_remove_persistent_dirty_bitmap (bs, name, errp); +return bs->drv->bdrv_remove_persistent_dirty_bitmap (bs, name, errp); } + +return -ENOTSUP ; } bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
block/qcow2-bitmap.c +11 -9
@@ -1404,11 +1404,10 @@ static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,return NULL ; } -void qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp) +int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp) { -int ret; +int ret =0 ;BDRVQcow2State *s = bs->opaque;Qcow2Bitmap *bm;Qcow2BitmapList *bm_list;
@@ -1416,18 +1415,19 @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,if (s->nb_bitmaps ==0 ) {/* Absence of the bitmap is not an error: see explanation above * bdrv_remove_persistent_dirty_bitmap() definition. */ -return ; +return 0 ; } bm_list =bitmap_list_load (bs, s->bitmap_directory_offset, s->bitmap_directory_size, errp);if (bm_list ==NULL ) { -return ; +return -EIO ; } bm =find_bitmap_by_name (bm_list, name);if (bm ==NULL ) { - goto fail; + ret = -EINVAL ; + goto out; }QSIMPLEQ_REMOVE (bm_list, bm, Qcow2Bitmap, entry);
@@ -1435,14 +1435,16 @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, ret =update_ext_header_and_dir (bs, bm_list);if (ret <0 ) {error_setg_errno (errp, -ret,"Failed to update bitmap extension" ); - goto fail; + goto out; }free_bitmap_clusters (bs, &bm->table); -fail: +out:bitmap_free (bm);bitmap_list_free (bm_list); + +return ret; }void qcow2_store_persistent_dirty_bitmaps (BlockDriverState *bs,Error **errp)
blockdev.c +3 -4
@@ -2940,15 +2940,14 @@ static BdrvDirtyBitmap *do_block_dirty_bitmap_remove( }if (bdrv_dirty_bitmap_get_persistence (bitmap)) { +int ret;AioContext *aio_context =bdrv_get_aio_context (bs); -Error *local_err =NULL ;aio_context_acquire (aio_context); -bdrv_remove_persistent_dirty_bitmap (bs, name, &local_err); + ret =bdrv_remove_persistent_dirty_bitmap (bs, name, errp);aio_context_release (aio_context); -if (local_err !=NULL ) { -error_propagate (errp, local_err); +if (ret <0 ) {return NULL ; } }
Signature · 1 line
2.18.0
Re: [Qemu-devel] [PATCH v2 2/3] block/dirty-bitmap: return int from bdrv_remove_persistent_dirty_bitmap
Quoted 2 lines · Vladimir Sementsov-Ogievskiy
It's more comfortable to not deal with
local_err.
I agree.
Quoted 68 lines
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/qcow2.h | 5 ++--- include/block/block_int.h | 6 +++--- include/block/dirty-bitmap.h | 5 ++--- block/dirty-bitmap.c | 9 +++++---- block/qcow2-bitmap.c | 20 +++++++++++--------- blockdev.c | 7 +++---- 6 files changed, 26 insertions(+), 26 deletions(-)block/qcow2.h +2
-3@@ -747,9 +747,8 @@ bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,const char *name, uint32_t granularity, Error **errp); -void qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp); +int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp); ssize_t coroutine_fn qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size,include/block/block_int.h +3
-3@@ -556,9 +556,9 @@ struct BlockDriver {const char *name, uint32_t granularity, Error **errp); -void (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, -const char *name, -Error **errp); +int (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, +const char *name, +Error **errp);/** * Register/unregister a buffer for I/O. For example, when the driver is include/block/dirty-bitmap.h +2
-3@@ -37,9 +37,8 @@ int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags, Error **errp);void bdrv_release_dirty_bitmap (BlockDriverState *bs,BdrvDirtyBitmap *bitmap);void bdrv_release_named_dirty_bitmaps (BlockDriverState *bs); -void bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp); +int bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp);void bdrv_disable_dirty_bitmap (BdrvDirtyBitmap *bitmap);void bdrv_enable_dirty_bitmap (BdrvDirtyBitmap *bitmap);void bdrv_enable_dirty_bitmap_locked (BdrvDirtyBitmap *bitmap);block/dirty-bitmap.c +0
-1@@ -455,13 +455,14 @@ void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)* not fail. * This function doesn't release corresponding BdrvDirtyBitmap. */ -void bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs,
block/dirty-bitmap.c void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs) · line 464
Quoted 10 lines
block/dirty-bitmap.c +4
-3-const char *name, - Error **errp) +int bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp) {if (bs->drv && bs->drv->bdrv_remove_persistent_dirty_bitmap) { - bs->drv->bdrv_remove_persistent_dirty_bitmap(bs, name, errp); +return bs->drv->bdrv_remove_persistent_dirty_bitmap (bs, name, errp); } +
But is it a problem if we return an error code without setting errp now? If this is for the sake of not having to deal with local_err, we should make sure that a non-zero return means that errp is set. Right?
Quoted 10 lines
block/dirty-bitmap.c +1
-0+return -ENOTSUP ; } bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,block/qcow2-bitmap.c +0
-0@@ -1404,11 +1404,10 @@ static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,return NULL ;
block/qcow2-bitmap.c static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list, · line 1410
Quoted 10 lines
block/qcow2-bitmap.c +3
-4} -void qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp) +int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp) { -int ret; +int ret =0 ;
I was going to say I'd rather not initialize this, but is this related to ubsan linting?
Quoted 69 lines
block/qcow2-bitmap.c +8
-5BDRVQcow2State *s = bs->opaque;Qcow2Bitmap *bm;Qcow2BitmapList *bm_list;@@ -1416,18 +1415,19 @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,if (s->nb_bitmaps ==0 ) {/* Absence of the bitmap is not an error: see explanation above * bdrv_remove_persistent_dirty_bitmap() definition. */ -return ; +return 0 ; } bm_list =bitmap_list_load (bs, s->bitmap_directory_offset, s->bitmap_directory_size, errp);if (bm_list ==NULL ) { -return ; +return -EIO ; } bm =find_bitmap_by_name (bm_list, name);if (bm ==NULL ) { - goto fail; + ret = -EINVAL ; + goto out; }QSIMPLEQ_REMOVE (bm_list, bm, Qcow2Bitmap, entry);@@ -1435,14 +1435,16 @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, ret =update_ext_header_and_dir (bs, bm_list);if (ret <0 ) {error_setg_errno (errp, -ret,"Failed to update bitmap extension" ); - goto fail; + goto out; }free_bitmap_clusters (bs, &bm->table); -fail: +out:bitmap_free (bm);bitmap_list_free (bm_list); + +return ret; }void qcow2_store_persistent_dirty_bitmaps (BlockDriverState *bs,Error **errp)blockdev.c +3
-4@@ -2940,15 +2940,14 @@ static BdrvDirtyBitmap *do_block_dirty_bitmap_remove( }if (bdrv_dirty_bitmap_get_persistence (bitmap)) { +int ret;AioContext *aio_context =bdrv_get_aio_context (bs); -Error *local_err =NULL ;aio_context_acquire (aio_context); -bdrv_remove_persistent_dirty_bitmap (bs, name, &local_err); + ret =bdrv_remove_persistent_dirty_bitmap (bs, name, errp);aio_context_release (aio_context); -if (local_err !=NULL ) { -error_propagate (errp, local_err); +if (ret <0 ) {return NULL ; } }
Re: [Qemu-devel] [PATCH v2 2/3] block/dirty-bitmap: return int from bdrv_remove_persistent_dirty_bitmap
Quoted 82 lines · John Snow
Quoted 2 lines · Vladimir Sementsov-Ogievskiy
It's more comfortable to not deal with
local_err.I agree.
Quoted 74 lines
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/qcow2.h | 5 ++--- include/block/block_int.h | 6 +++--- include/block/dirty-bitmap.h | 5 ++--- block/dirty-bitmap.c | 9 +++++---- block/qcow2-bitmap.c | 20 +++++++++++--------- blockdev.c | 7 +++---- 6 files changed, 26 insertions(+), 26 deletions(-)block/qcow2.h +2
-3@@ -747,9 +747,8 @@ bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,const char *name, uint32_t granularity, Error **errp); -void qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp); +int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp); ssize_t coroutine_fn qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size,include/block/block_int.h +3
-3@@ -556,9 +556,9 @@ struct BlockDriver {const char *name, uint32_t granularity, Error **errp); -void (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, -const char *name, -Error **errp); +int (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, +const char *name, +Error **errp);/** * Register/unregister a buffer for I/O. For example, when the driver is include/block/dirty-bitmap.h +2
-3@@ -37,9 +37,8 @@ int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags, Error **errp);void bdrv_release_dirty_bitmap (BlockDriverState *bs,BdrvDirtyBitmap *bitmap);void bdrv_release_named_dirty_bitmaps (BlockDriverState *bs); -void bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp); +int bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp);void bdrv_disable_dirty_bitmap (BdrvDirtyBitmap *bitmap);void bdrv_enable_dirty_bitmap (BdrvDirtyBitmap *bitmap);void bdrv_enable_dirty_bitmap_locked (BdrvDirtyBitmap *bitmap);block/dirty-bitmap.c +2
-3@@ -455,13 +455,14 @@ void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)* not fail. * This function doesn't release corresponding BdrvDirtyBitmap. */ -void bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp) +int bdrv_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp) {if (bs->drv && bs->drv->bdrv_remove_persistent_dirty_bitmap) {
Quoted 8 lines
block/dirty-bitmap.c void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs) · line 464
Quoted 4 lines
block/dirty-bitmap.c +2
-1- bs->drv->bdrv_remove_persistent_dirty_bitmap (bs, name, errp); +return bs->drv->bdrv_remove_persistent_dirty_bitmap (bs, name, errp); } +But is it a problem if we return an error code without setting errp now? If this is for the sake of not having to deal with
local_err, we should make sure that a non-zero return means that errp is set. Right?
Oops, of course, I should set errp here
Quoted 13 lines
Quoted 13 lines
block/dirty-bitmap.c +1
-0+return -ENOTSUP ; } bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,block/qcow2-bitmap.c +0
-0@@ -1404,11 +1404,10 @@ static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,return NULL ; }
Quoted 11 lines
block/qcow2-bitmap.c static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list, · line 1410
Quoted 8 lines
block/qcow2-bitmap.c +3
-4-void qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs, -const char *name, -Error **errp) +int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +Error **errp) { -int ret; +int ret =0 ;I was going to say I'd rather not initialize this, but is this related to ubsan linting?
Hmm, don't remember. For some reason I thought it's needed.. Will drop and check what compiler says.
Quoted 70 lines
Quoted 70 lines
block/qcow2-bitmap.c +8
-5BDRVQcow2State *s = bs->opaque;Qcow2Bitmap *bm;Qcow2BitmapList *bm_list;@@ -1416,18 +1415,19 @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,if (s->nb_bitmaps ==0 ) {/* Absence of the bitmap is not an error: see explanation above * bdrv_remove_persistent_dirty_bitmap() definition. */ -return ; +return 0 ; } bm_list =bitmap_list_load (bs, s->bitmap_directory_offset, s->bitmap_directory_size, errp);if (bm_list ==NULL ) { -return ; +return -EIO ; } bm =find_bitmap_by_name (bm_list, name);if (bm ==NULL ) { - goto fail; + ret = -EINVAL ; + goto out; }QSIMPLEQ_REMOVE (bm_list, bm, Qcow2Bitmap, entry);@@ -1435,14 +1435,16 @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, ret =update_ext_header_and_dir (bs, bm_list);if (ret <0 ) {error_setg_errno (errp, -ret,"Failed to update bitmap extension" ); - goto fail; + goto out; }free_bitmap_clusters (bs, &bm->table); -fail: +out:bitmap_free (bm);bitmap_list_free (bm_list); + +return ret; }void qcow2_store_persistent_dirty_bitmaps (BlockDriverState *bs,Error **errp)blockdev.c +3
-4@@ -2940,15 +2940,14 @@ static BdrvDirtyBitmap *do_block_dirty_bitmap_remove( }if (bdrv_dirty_bitmap_get_persistence (bitmap)) { +int ret;AioContext *aio_context =bdrv_get_aio_context (bs); -Error *local_err =NULL ;aio_context_acquire (aio_context); -bdrv_remove_persistent_dirty_bitmap (bs, name, &local_err); + ret =bdrv_remove_persistent_dirty_bitmap (bs, name, errp);aio_context_release (aio_context); -if (local_err !=NULL ) { -error_propagate (errp, local_err); +if (ret <0 ) {return NULL ; } }
Signature · 2 lines
Best regards, Vladimir
PATCH v2 3/3 block/qcow2: proper locking on bitmap add/remove paths
In reply to Vladimir Sementsov-Ogievskiyqmp_block_dirty_bitmap_add and do_block_dirty_bitmap_remove do acquire aio context since 0a6c86d024c52b. But this is not enough: we also must lock qcow2 mutex when access in-image metadata. Especially it concerns freeing qcow2 clusters.
To achieve this, move qcow2_can_store_new_dirty_bitmap and qcow2_remove_persistent_dirty_bitmap to coroutine context.
Since we work in coroutines in correct aio context, we don't need context acquiring in blockdev.c anymore, drop it.
--- block/qcow2.h | 11 ++-- include/block/block_int.h | 10 ++-- block/dirty-bitmap.c | 102 +++++++++++++++++++++++++++++++++++--- block/qcow2-bitmap.c | 24 ++++++--- block/qcow2.c | 5 +- blockdev.c | 27 +++------- 6 files changed, 131 insertions(+), 48 deletions(-)
block/qcow2.h +6 -5
@@ -743,12 +743,13 @@ int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp);int qcow2_truncate_bitmaps_check (BlockDriverState *bs,Error **errp);void qcow2_store_persistent_dirty_bitmaps (BlockDriverState *bs,Error **errp);int qcow2_reopen_bitmaps_ro (BlockDriverState *bs,Error **errp); -bool qcow2_can_store_new_dirty_bitmap (BlockDriverState *bs, -const char *name, -uint32_t granularity, -Error **errp); -int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, +bool qcow2_co_can_store_new_dirty_bitmap (BlockDriverState *bs, +const char *name, +uint32_t granularity,Error **errp); +int qcow2_co_remove_persistent_dirty_bitmap (BlockDriverState *bs, +const char *name, +Error **errp); ssize_t coroutine_fn qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size,
include/block/block_int.h +5 -5
@@ -552,13 +552,13 @@ struct BlockDriver {* field of BlockDirtyBitmap's in case of success. */ int (*bdrv_reopen_bitmaps_rw)(BlockDriverState *bs,Error **errp); -bool (*bdrv_can_store_new_dirty_bitmap)(BlockDriverState *bs, -const char *name, -uint32_t granularity, -Error **errp); -int (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, +bool (*bdrv_co_can_store_new_dirty_bitmap)(BlockDriverState *bs,const char *name, +uint32_t granularity,Error **errp); +int (*bdrv_co_remove_persistent_dirty_bitmap)(BlockDriverState *bs, +const char *name, +Error **errp);/** * Register/unregister a buffer for I/O. For example, when the driver is
block/dirty-bitmap.c +94 -8
132 lines not on this page · raw message
block/qcow2-bitmap.c +16 -8
@@ -1404,12 +1404,13 @@ static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,return NULL ; } -int qcow2_remove_persistent_dirty_bitmap (BlockDriverState *bs,const char *name, -Error **errp) +int coroutine_fn qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState *bs, +const char *name, +Error **errp) {int ret =0 ;BDRVQcow2State *s = bs->opaque; -Qcow2Bitmap *bm; +Qcow2Bitmap *bm =NULL ;Qcow2BitmapList *bm_list;if (s->nb_bitmaps ==0 ) {
@@ -1418,10 +1419,13 @@ int qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,return 0 ; } +qemu_co_mutex_lock (&s->lock); + bm_list =bitmap_list_load (bs, s->bitmap_directory_offset, s->bitmap_directory_size, errp);if (bm_list ==NULL ) { -return -EIO ; + ret = -EIO ; + goto out; } bm =find_bitmap_by_name (bm_list, name);
@@ -1441,6 +1445,8 @@ int qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,free_bitmap_clusters (bs, &bm->table); out: +qemu_co_mutex_unlock (&s->lock); +bitmap_free (bm);bitmap_list_free (bm_list);
@@ -1615,10 +1621,10 @@ int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp)return 0 ; } -bool qcow2_can_store_new_dirty_bitmap (BlockDriverState *bs, -const char *name, -uint32_t granularity, -Error **errp) +bool coroutine_fn qcow2_co_can_store_new_dirty_bitmap(BlockDriverState *bs, +const char *name, +uint32_t granularity, +Error **errp) {BDRVQcow2State *s = bs->opaque;bool found;
@@ -1655,8 +1661,10 @@ bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs, goto fail; } +qemu_co_mutex_lock (&s->lock); bm_list =bitmap_list_load (bs, s->bitmap_directory_offset, s->bitmap_directory_size, errp); +qemu_co_mutex_unlock (&s->lock);if (bm_list ==NULL ) { goto fail; }
block/qcow2.c +3 -2
@@ -5258,8 +5258,9 @@ BlockDriver bdrv_qcow2 = { .bdrv_attach_aio_context = qcow2_attach_aio_context, .bdrv_reopen_bitmaps_rw = qcow2_reopen_bitmaps_rw, - .bdrv_can_store_new_dirty_bitmap = qcow2_can_store_new_dirty_bitmap, - .bdrv_remove_persistent_dirty_bitmap = qcow2_remove_persistent_dirty_bitmap, + .bdrv_co_can_store_new_dirty_bitmap = qcow2_co_can_store_new_dirty_bitmap, + .bdrv_co_remove_persistent_dirty_bitmap = + qcow2_co_remove_persistent_dirty_bitmap, };static void bdrv_qcow2_init (void )
blockdev.c +7 -20
@@ -2898,16 +2898,10 @@ void qmp_block_dirty_bitmap_add(const char *node, const char *name, disabled = false; } -if (persistent) { -AioContext *aio_context =bdrv_get_aio_context (bs); -bool ok; - -aio_context_acquire (aio_context); - ok =bdrv_can_store_new_dirty_bitmap (bs, name, granularity, errp); -aio_context_release (aio_context); -if (!ok) { -return ; - } +if (persistent && + !bdrv_can_store_new_dirty_bitmap (bs, name, granularity, errp)) + { +return ; } bitmap =bdrv_create_dirty_bitmap (bs, granularity, name, errp);
@@ -2939,17 +2933,10 @@ static BdrvDirtyBitmap *do_block_dirty_bitmap_remove(return NULL ; } -if (bdrv_dirty_bitmap_get_persistence (bitmap)) { -int ret; -AioContext *aio_context =bdrv_get_aio_context (bs); - -aio_context_acquire (aio_context); - ret =bdrv_remove_persistent_dirty_bitmap (bs, name, errp); -aio_context_release (aio_context); - -if (ret <0 ) { +if (bdrv_dirty_bitmap_get_persistence (bitmap) && +bdrv_remove_persistent_dirty_bitmap (bs, name, errp) <0 ) + {return NULL ; - } }if (release) {
Signature · 1 line
2.18.0
Re: [Qemu-devel] [PATCH v2 3/3] block/qcow2: proper locking on bitmap add/remove paths
Quoted 5 lines · Vladimir Sementsov-Ogievskiy
qmp_block_dirty_bitmap_addanddo_block_dirty_bitmap_removedo acquire aio context since0a6c86d024c52b. But this is not enough: we also must lock qcow2 mutex when access in-image metadata. Especially it concerns freeing qcow2 clusters.
Quoted 7 lines
To achieve this, move
qcow2_can_store_new_dirty_bitmapandqcow2_remove_persistent_dirty_bitmapto coroutine context.Since we work in coroutines in correct aio context, we don't need context acquiring in
blockdev.canymore, drop it.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>
It makes sense to me given the context, but I'll want Kevin or Max to eye it over for locking correctness, admittedly.
Here's my good faith RB:
(I'm not so sure about the aio_wait_kick. Why is that needed here? ...
oh, 4720cbeea1f42fd905fc69338fd42b191e58b412 explains why. I suppose any synchronous caller of a co_ function needs to make sure that the entry shim kicks on the way out. This seems very easy to get wrong, doesn't it?)