proper locking on bitmap add/remove paths
v3 cover proper locking on bitmap add/remove paths
Hi all!
We need to lock qcow2 mutex on accessing in-image metadata, especially on updating this metadata. Let's implement it.
v3:
01: add John's r-b
02: - fix bdrv_remove_persistent_dirty_bitmap return value
- drop extra zeroing of ret in qcow2_remove_persistent_dirty_bitmap
03: add John's r-b
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 | 36 +++++++---- block/qcow2.c | 5 +- blockdev.c | 28 +++------ 8 files changed, 163 insertions(+), 80 deletions(-)
Signature · 1 line
2.21.0
PATCH v3 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.21.0
PATCH v3 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 | 18 ++++++++++-------- blockdev.c | 7 +++---- 6 files changed, 25 insertions(+), 25 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 0 ; } bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
block/qcow2-bitmap.c +10 -8
@@ -1404,9 +1404,8 @@ 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;BDRVQcow2State *s = bs->opaque;
@@ -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.21.0
Re: [PATCH v3 2/3] block/dirty-bitmap: return int from bdrv_remove_persistent_dirty_bitmap
Quoted 3 lines · Vladimir Sementsov-Ogievskiy
It's more comfortable to not deal with
local_err.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>
PATCH v3 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;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
@@ -5263,8 +5263,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.21.0
Quoted 17 lines · Vladimir Sementsov-Ogievskiy
Hi all!
We need to lock qcow2 mutex on accessing in-image metadata, especially on updating this metadata. Let's implement it.
v3:
01: add John's r-b
02: - fixbdrv_remove_persistent_dirty_bitmapreturn value
- drop extra zeroing of ret inqcow2_remove_persistent_dirty_bitmap
03: add John's r-bVladimir Sementsov-Ogievskiy (3):
block: movebdrv_can_store_new_dirty_bitmaptoblock/dirty-bitmap.cblock/dirty-bitmap: return int from
bdrv_remove_persistent_dirty_bitmap
block/qcow2: proper locking on bitmap add/remove paths
Quoted 10 lines
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 | 36 +++++++---- block/qcow2.c | 5 +- blockdev.c | 28 +++------ 8 files changed, 163 insertions(+), 80 deletions(-)
I'll take this; I imagine the return signatures are going to change again with your error propagation series, though ...?
Quoted 31 lines · John Snow
Quoted 17 lines · Vladimir Sementsov-Ogievskiy
Hi all!
We need to lock qcow2 mutex on accessing in-image metadata, especially on updating this metadata. Let's implement it.
v3:
01: add John's r-b
02: - fixbdrv_remove_persistent_dirty_bitmapreturn value
- drop extra zeroing of ret inqcow2_remove_persistent_dirty_bitmap
03: add John's r-bVladimir Sementsov-Ogievskiy (3):
block: movebdrv_can_store_new_dirty_bitmaptoblock/dirty-bitmap.cblock/dirty-bitmap: return int from
bdrv_remove_persistent_dirty_bitmap
block/qcow2: proper locking on bitmap add/remove pathsQuoted 10 lines
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 | 36 +++++++---- block/qcow2.c | 5 +- blockdev.c | 28 +++------ 8 files changed, 163 insertions(+), 80 deletions(-)
Quoted 3 lines
I'll take this; I imagine the return signatures are going to change again with your error propagation series, though ...?
Thanks a lot!
Hmm, I don't think so, as I used to think that returning int for errp-functions is better anyway..
ret = f(..., errp);
if (ret < 0) {
}
vs
f(..., errp);
if (*errp) {
}
Hmmm... The latter just looks unfamiliar in comparison with "if (ret < 0)".. But if we anyway going to convert a lot of "if (*local_err)" to "if (*errp)", it will become familiar.. And the latter may save 6 characters in a line with function call, which may save the whole line in some places.
So I don't know.
returning two errors is not very good, we don't have convention for it actually.
if I have int ret = f(..., errp), what should I report?
error_report_err_errno(ret, errp), or just error_report_err(errp), assuming errp contains the whole information?
Still, sometimes we need to distinguish one error code from another, and we can't check errp for such thing..
Signature · 2 lines
Best regards, Vladimir
Quoted 32 lines · Vladimir Sementsov-Ogievskiy
Quoted 31 lines · John Snow
Quoted 27 lines · Vladimir Sementsov-Ogievskiy
Hi all!
We need to lock qcow2 mutex on accessing in-image metadata, especially on updating this metadata. Let's implement it.
v3:
01: add John's r-b
02: - fixbdrv_remove_persistent_dirty_bitmapreturn value
- drop extra zeroing of ret inqcow2_remove_persistent_dirty_bitmap
03: add John's r-bVladimir Sementsov-Ogievskiy (3):
block: movebdrv_can_store_new_dirty_bitmaptoblock/dirty-bitmap.cblock/dirty-bitmap: return int from
bdrv_remove_persistent_dirty_bitmap
block/qcow2: proper locking on bitmap add/remove pathsblock/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 | 36 +++++++---- block/qcow2.c | 5 +- blockdev.c | 28 +++------ 8 files changed, 163 insertions(+), 80 deletions(-)
Quoted 9 lines
Quoted 3 lines
I'll take this; I imagine the return signatures are going to change again with your error propagation series, though ...?
Thanks a lot!
Hmm, I don't think so, as I used to think that returning int for errp-functions is better anyway..
OK, well, no problem. I'm not very picky about the error propagation paradigm; since you are investing your effort in it lately I'm just going to trust your judgment here.
Quoted 21 lines
ret =
f(..., errp);
if (ret < 0) {}
vs
f(..., errp);
if (*errp) {}
Hmmm... The latter just looks unfamiliar in comparison with "if (ret < 0)".. But if we anyway going to convert a lot of "if (
*local_err)" to "if (*errp)", it will become familiar.. And the latter may save 6 characters in a line with function call, which may save the whole line in some places.So I don't know.
returning two errors is not very good, we don't have convention for it actually.
Quoted 8 lines
if I have int ret =
f(..., errp), what should I report?
error_report_err_errno(ret, errp), or justerror_report_err(errp), assuming errp contains the whole information?Still, sometimes we need to distinguish one error code from another, and we can't check errp for such thing..
OK, I just wasn't sure the details of your series, actually -- I just wanted to know if we'd need to make changes, but if not, that's easier :)
--js
John Snow
AppliedQuoted 17 lines · Vladimir Sementsov-Ogievskiy
Hi all!
We need to lock qcow2 mutex on accessing in-image metadata, especially on updating this metadata. Let's implement it.
v3:
01: add John's r-b
02: - fixbdrv_remove_persistent_dirty_bitmapreturn value
- drop extra zeroing of ret inqcow2_remove_persistent_dirty_bitmap
03: add John's r-bVladimir Sementsov-Ogievskiy (3):
block: movebdrv_can_store_new_dirty_bitmaptoblock/dirty-bitmap.cblock/dirty-bitmap: return int from
bdrv_remove_persistent_dirty_bitmap
block/qcow2: proper locking on bitmap add/remove paths
Quoted 10 lines
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 | 36 +++++++---- block/qcow2.c | 5 +- blockdev.c | 28 +++------ 8 files changed, 163 insertions(+), 80 deletions(-)
Thanks, applied to my bitmaps tree:
https://github.com/jnsnow/qemu/commits/bitmaps
https://github.com/jnsnow/qemu.git
--js