system/qemu
system/qemu
1
0
Fork 0
mirror of https://gitlab.com/qemu-project/qemu synced 2024-10-14 23:13:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

block/dirty-bitmap: add bs link

Browse source 
Add bs field to BdrvDirtyBitmap structure. Drop BlockDriverState
parameter from bitmap APIs where possible.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190916141911.5255-3-vsementsov@virtuozzo.com
[Rebased on top of block-copy. --js]
Signed-off-by: John Snow <jsnow@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2019-09-16 17:19:09 +03:00 committed by John Snow
parent 767db3aad8
commit 5deb6cbd1f
9 changed files with 35 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
block/backup.c
View file

@ -98,13 +98,13 @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
* We succeeded, or we always intended to sync the bitmap. * We succeeded, or we always intended to sync the bitmap.
* Delete this bitmap and install the child. * Delete this bitmap and install the child.
*/ */
bm = bdrv_dirty_bitmap_abdicate(job->source_bs, job->sync_bitmap, NULL); bm = bdrv_dirty_bitmap_abdicate(job->sync_bitmap, NULL);
} else { } else {
/* /*
* We failed, or we never intended to sync the bitmap anyway. * We failed, or we never intended to sync the bitmap anyway.
* Merge the successor back into the parent, keeping all data. * Merge the successor back into the parent, keeping all data.
*/ */
bm = bdrv_reclaim_dirty_bitmap(job->source_bs, job->sync_bitmap, NULL); bm = bdrv_reclaim_dirty_bitmap(job->sync_bitmap, NULL);
} }
assert(bm); assert(bm);
@ -402,7 +402,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
} }
/* Create a new bitmap, and freeze/disable this one. */ /* Create a new bitmap, and freeze/disable this one. */
if (bdrv_dirty_bitmap_create_successor(bs, sync_bitmap, errp) < 0) { if (bdrv_dirty_bitmap_create_successor(sync_bitmap, errp) < 0) {
return NULL; return NULL;
} }
} }
@ -472,7 +472,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
error: error:
if (sync_bitmap) { if (sync_bitmap) {
bdrv_reclaim_dirty_bitmap(bs, sync_bitmap, NULL); bdrv_reclaim_dirty_bitmap(sync_bitmap, NULL);
} }
if (job) { if (job) {
backup_clean(&job->common.job); backup_clean(&job->common.job);

2
block/block-copy.c
View file

@ -60,7 +60,7 @@ void block_copy_state_free(BlockCopyState *s)
return; return;
} }
bdrv_release_dirty_bitmap(s->source->bs, s->copy_bitmap); bdrv_release_dirty_bitmap(s->copy_bitmap);
g_free(s); g_free(s);
} }

24
block/dirty-bitmap.c
View file

@ -30,6 +30,7 @@
struct BdrvDirtyBitmap { struct BdrvDirtyBitmap {
QemuMutex *mutex; QemuMutex *mutex;
BlockDriverState *bs;
HBitmap *bitmap; /* Dirty bitmap implementation */ HBitmap *bitmap; /* Dirty bitmap implementation */
bool busy; /* Bitmap is busy, it can't be used via QMP */ bool busy; /* Bitmap is busy, it can't be used via QMP */
BdrvDirtyBitmap *successor; /* Anonymous child, if any. */ BdrvDirtyBitmap *successor; /* Anonymous child, if any. */
@ -115,6 +116,7 @@ BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
return NULL; return NULL;
} }
bitmap = g_new0(BdrvDirtyBitmap, 1); bitmap = g_new0(BdrvDirtyBitmap, 1);
bitmap->bs = bs;
bitmap->mutex = &bs->dirty_bitmap_mutex; bitmap->mutex = &bs->dirty_bitmap_mutex;
bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(granularity)); bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(granularity));
bitmap->size = bitmap_size; bitmap->size = bitmap_size;
@ -237,8 +239,7 @@ int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags,
* The successor will be enabled if the parent bitmap was. * The successor will be enabled if the parent bitmap was.
* Called with BQL taken. * Called with BQL taken.
*/ */
int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs, int bdrv_dirty_bitmap_create_successor(BdrvDirtyBitmap *bitmap, Error **errp)
BdrvDirtyBitmap *bitmap, Error **errp)
{ {
uint64_t granularity; uint64_t granularity;
BdrvDirtyBitmap *child; BdrvDirtyBitmap *child;
@ -254,7 +255,7 @@ int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
/* Create an anonymous successor */ /* Create an anonymous successor */
granularity = bdrv_dirty_bitmap_granularity(bitmap); granularity = bdrv_dirty_bitmap_granularity(bitmap);
child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp); child = bdrv_create_dirty_bitmap(bitmap->bs, granularity, NULL, errp);
if (!child) { if (!child) {
return -1; return -1;
} }
@ -300,8 +301,7 @@ static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap)
* delete the old bitmap, and return a handle to the new bitmap. * delete the old bitmap, and return a handle to the new bitmap.
* Called with BQL taken. * Called with BQL taken.
*/ */
BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BdrvDirtyBitmap *bitmap,
BdrvDirtyBitmap *bitmap,
Error **errp) Error **errp)
{ {
char *name; char *name;
@ -320,7 +320,7 @@ BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
successor->persistent = bitmap->persistent; successor->persistent = bitmap->persistent;
bitmap->persistent = false; bitmap->persistent = false;
bitmap->busy = false; bitmap->busy = false;
bdrv_release_dirty_bitmap(bs, bitmap); bdrv_release_dirty_bitmap(bitmap);
return successor; return successor;
} }
@ -332,8 +332,7 @@ BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
* The marged parent will be enabled if and only if the successor was enabled. * The marged parent will be enabled if and only if the successor was enabled.
* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken.
*/ */
BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *parent,
BdrvDirtyBitmap *parent,
Error **errp) Error **errp)
{ {
BdrvDirtyBitmap *successor = parent->successor; BdrvDirtyBitmap *successor = parent->successor;
@ -357,14 +356,13 @@ BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs,
} }
/* Called with BQL taken. */ /* Called with BQL taken. */
BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BdrvDirtyBitmap *parent,
BdrvDirtyBitmap *parent,
Error **errp) Error **errp)
{ {
BdrvDirtyBitmap *ret; BdrvDirtyBitmap *ret;
qemu_mutex_lock(parent->mutex); qemu_mutex_lock(parent->mutex);
ret = bdrv_reclaim_dirty_bitmap_locked(bs, parent, errp); ret = bdrv_reclaim_dirty_bitmap_locked(parent, errp);
qemu_mutex_unlock(parent->mutex); qemu_mutex_unlock(parent->mutex);
return ret; return ret;
@ -390,8 +388,10 @@ void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes)
} }
/* Called with BQL taken. */ /* Called with BQL taken. */
void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap) void bdrv_release_dirty_bitmap(BdrvDirtyBitmap *bitmap)
{ {
BlockDriverState *bs = bitmap->bs;
bdrv_dirty_bitmaps_lock(bs); bdrv_dirty_bitmaps_lock(bs);
bdrv_release_dirty_bitmap_locked(bitmap); bdrv_release_dirty_bitmap_locked(bitmap);
bdrv_dirty_bitmaps_unlock(bs); bdrv_dirty_bitmaps_unlock(bs);

4
block/mirror.c
View file

@ -638,7 +638,7 @@ static int mirror_exit_common(Job *job)
bdrv_unfreeze_backing_chain(mirror_top_bs, target_bs); bdrv_unfreeze_backing_chain(mirror_top_bs, target_bs);
} }
bdrv_release_dirty_bitmap(src, s->dirty_bitmap); bdrv_release_dirty_bitmap(s->dirty_bitmap);
/* Make sure that the source BDS doesn't go away during bdrv_replace_node, /* Make sure that the source BDS doesn't go away during bdrv_replace_node,
* before we can call bdrv_drained_end */ * before we can call bdrv_drained_end */
@ -1709,7 +1709,7 @@ fail:
blk_unref(s->target); blk_unref(s->target);
bs_opaque->job = NULL; bs_opaque->job = NULL;
if (s->dirty_bitmap) { if (s->dirty_bitmap) {
bdrv_release_dirty_bitmap(bs, s->dirty_bitmap); bdrv_release_dirty_bitmap(s->dirty_bitmap);
} }
job_early_fail(&s->common.job); job_early_fail(&s->common.job);
} }

6
block/qcow2-bitmap.c
View file

@ -374,7 +374,7 @@ static BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
fail: fail:
g_free(bitmap_table); g_free(bitmap_table);
if (bitmap != NULL) { if (bitmap != NULL) {
bdrv_release_dirty_bitmap(bs, bitmap); bdrv_release_dirty_bitmap(bitmap);
} }
return NULL; return NULL;
@ -941,7 +941,7 @@ fail:
static void release_dirty_bitmap_helper(gpointer bitmap, static void release_dirty_bitmap_helper(gpointer bitmap,
gpointer bs) gpointer bs)
{ {
bdrv_release_dirty_bitmap(bs, bitmap); bdrv_release_dirty_bitmap(bitmap);
} }
/* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */ /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
@ -1577,7 +1577,7 @@ void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp)
continue; continue;
} }
bdrv_release_dirty_bitmap(bs, bm->dirty_bitmap); bdrv_release_dirty_bitmap(bm->dirty_bitmap);
} }
bitmap_list_free(bm_list); bitmap_list_free(bm_list);

6
blockdev.c
View file

@ -2178,7 +2178,7 @@ static void block_dirty_bitmap_remove_commit(BlkActionState *common)
common, common); common, common);
bdrv_dirty_bitmap_set_busy(state->bitmap, false); bdrv_dirty_bitmap_set_busy(state->bitmap, false);
bdrv_release_dirty_bitmap(state->bs, state->bitmap); bdrv_release_dirty_bitmap(state->bitmap);
} }
static void abort_prepare(BlkActionState *common, Error **errp) static void abort_prepare(BlkActionState *common, Error **errp)
@ -2940,7 +2940,7 @@ static BdrvDirtyBitmap *do_block_dirty_bitmap_remove(
} }
if (release) { if (release) {
bdrv_release_dirty_bitmap(bs, bitmap); bdrv_release_dirty_bitmap(bitmap);
} }
if (bitmap_bs) { if (bitmap_bs) {
@ -3072,7 +3072,7 @@ static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
bdrv_merge_dirty_bitmap(dst, anon, backup, errp); bdrv_merge_dirty_bitmap(dst, anon, backup, errp);
out: out:
bdrv_release_dirty_bitmap(bs, anon); bdrv_release_dirty_bitmap(anon);
return dst; return dst;
} }

14
include/block/dirty-bitmap.h
View file

@ -18,21 +18,18 @@ BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
uint32_t granularity, uint32_t granularity,
const char *name, const char *name,
Error **errp); Error **errp);
int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs, int bdrv_dirty_bitmap_create_successor(BdrvDirtyBitmap *bitmap,
BdrvDirtyBitmap *bitmap,
Error **errp); Error **errp);
BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BdrvDirtyBitmap *bitmap,
BdrvDirtyBitmap *bitmap,
Error **errp); Error **errp);
BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BdrvDirtyBitmap *bitmap,
BdrvDirtyBitmap *bitmap,
Error **errp); Error **errp);
void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap); void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap);
BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs,
const char *name); const char *name);
int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags, int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags,
Error **errp); Error **errp);
void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap); void bdrv_release_dirty_bitmap(BdrvDirtyBitmap *bitmap);
void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs); void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs);
int bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name, int bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,
Error **errp); Error **errp);
@ -106,8 +103,7 @@ int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, uint64_t offset,
uint64_t bytes); uint64_t bytes);
bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap, bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
uint64_t *offset, uint64_t *bytes); uint64_t *offset, uint64_t *bytes);
BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BlockDriverState *bs, BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
BdrvDirtyBitmap *bitmap,
Error **errp); Error **errp);
#endif #endif

7
migration/block-dirty-bitmap.c
View file

@ -474,7 +474,7 @@ static int dirty_bitmap_load_start(QEMUFile *f, DirtyBitmapLoadState *s)
if (flags & DIRTY_BITMAP_MIG_START_FLAG_ENABLED) { if (flags & DIRTY_BITMAP_MIG_START_FLAG_ENABLED) {
DirtyBitmapLoadBitmapState *b; DirtyBitmapLoadBitmapState *b;
bdrv_dirty_bitmap_create_successor(s->bs, s->bitmap, &local_err); bdrv_dirty_bitmap_create_successor(s->bitmap, &local_err);
if (local_err) { if (local_err) {
error_report_err(local_err); error_report_err(local_err);
return -EINVAL; return -EINVAL;
@ -535,13 +535,12 @@ static void dirty_bitmap_load_complete(QEMUFile *f, DirtyBitmapLoadState *s)
bdrv_dirty_bitmap_lock(s->bitmap); bdrv_dirty_bitmap_lock(s->bitmap);
if (enabled_bitmaps == NULL) { if (enabled_bitmaps == NULL) {
/* in postcopy */ /* in postcopy */
bdrv_reclaim_dirty_bitmap_locked(s->bs, s->bitmap, &error_abort); bdrv_reclaim_dirty_bitmap_locked(s->bitmap, &error_abort);
bdrv_enable_dirty_bitmap_locked(s->bitmap); bdrv_enable_dirty_bitmap_locked(s->bitmap);
} else { } else {
/* target not started, successor must be empty */ /* target not started, successor must be empty */
int64_t count = bdrv_get_dirty_count(s->bitmap); int64_t count = bdrv_get_dirty_count(s->bitmap);
BdrvDirtyBitmap *ret = bdrv_reclaim_dirty_bitmap_locked(s->bs, BdrvDirtyBitmap *ret = bdrv_reclaim_dirty_bitmap_locked(s->bitmap,
s->bitmap,
NULL); NULL);
/* bdrv_reclaim_dirty_bitmap can fail only on no successor (it /* bdrv_reclaim_dirty_bitmap can fail only on no successor (it
* must be) or on merge fail, but merge can't fail when second * must be) or on merge fail, but merge can't fail when second

4
migration/block.c
View file

@ -361,7 +361,7 @@ static int set_dirty_tracking(void)
fail: fail:
QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
if (bmds->dirty_bitmap) { if (bmds->dirty_bitmap) {
bdrv_release_dirty_bitmap(blk_bs(bmds->blk), bmds->dirty_bitmap); bdrv_release_dirty_bitmap(bmds->dirty_bitmap);
} }
} }
return ret; return ret;
@ -374,7 +374,7 @@ static void unset_dirty_tracking(void)
BlkMigDevState *bmds; BlkMigDevState *bmds;
QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
bdrv_release_dirty_bitmap(blk_bs(bmds->blk), bmds->dirty_bitmap); bdrv_release_dirty_bitmap(bmds->dirty_bitmap);
} }
} }