From nobody Fri Nov 7 01:57:39 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=163.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1545202433531898.0653711879568; Tue, 18 Dec 2018 22:53:53 -0800 (PST) Received: from localhost ([::1]:57910 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gZVjs-0005th-8F for importer@patchew.org; Wed, 19 Dec 2018 01:53:52 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53901) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gZVhV-0004cl-J7 for qemu-devel@nongnu.org; Wed, 19 Dec 2018 01:51:27 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gZVhU-0003RY-1y for qemu-devel@nongnu.org; Wed, 19 Dec 2018 01:51:25 -0500 Received: from m12-17.163.com ([220.181.12.17]:49207) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gZVhO-0003Nz-HF; Wed, 19 Dec 2018 01:51:19 -0500 Received: from localhost.localdomain (unknown [111.202.166.3]) by smtp13 (Coremail) with SMTP id EcCowAD3Xb5e6hlcsmZaBQ--.29712S4; Wed, 19 Dec 2018 14:51:15 +0800 (CST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id; bh=kyNJvkkRV+U+knaF4i zL2nxFXoAq+z/rz9Uz70Ur+L4=; b=kzGwQDMkR36j23dCyueHj3OsuXLSEWp7wl 1greEtjrTEZ5uGaWzpx/veuXzryqxX0fiH5CgoWPFq8mJqeBmH5h4s+oYSxWwyVy 1ZZElGQaqFVtJMjn41CNqqe3d5af0Oy/2cP0sMOh+0bpreHNtuENGOc6DDum9WRI ZzKYWxVZw= From: mahaocong To: qemu-block@nongnu.org Date: Wed, 19 Dec 2018 14:50:20 +0800 Message-Id: <20181219065020.81256-2-mahaocong_work@163.com> X-Mailer: git-send-email 2.14.3 (Apple Git-98) In-Reply-To: <20181219065020.81256-1-mahaocong_work@163.com> References: <20181219065020.81256-1-mahaocong_work@163.com> X-CM-TRANSID: EcCowAD3Xb5e6hlcsmZaBQ--.29712S4 X-Coremail-Antispam: 1Uf129KBjvAXoW3KFWrJFWftr1kXFW3Aw1fZwb_yoW8JF45Ko WIyrs0g3W5XryY9ry7Cr15AryxXw1kKw1DAw15urZxua12vFyYvF48KF47Wa9xWr4vvryI qFyxKrZ8KFs7ZFyxn29KB7ZKAUJUUUU5529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUTH7KUUUUU X-Originating-IP: [111.202.166.3] X-CM-SenderInfo: 5pdkt05frqwspzruyqqrwthudrp/1tbiUQMiClWBI6Y5uAAAsq X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [fuzzy] X-Received-From: 220.181.12.17 Subject: [Qemu-devel] [PATCH v1] migration: add incremental mode on drive-mirror X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, jcody@redhat.com, mahaocong , qemu-devel@nongnu.org, mreitz@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: mahaocong Signed-off-by: mahaocong --- block/dirty-bitmap.c | 14 ++++++++++ block/mirror.c | 63 +++++++++++++++++++++++++++++++++++-----= ---- blockdev.c | 36 +++++++++++++++++++++++-- include/block/block_int.h | 3 ++- include/block/dirty-bitmap.h | 3 +++ include/qemu/hbitmap.h | 2 ++ qapi/block-core.json | 4 ++- util/hbitmap.c | 28 ++++++++++++++++++++ 8 files changed, 136 insertions(+), 17 deletions(-) diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c index 89fd1d7..118447d 100644 --- a/block/dirty-bitmap.c +++ b/block/dirty-bitmap.c @@ -348,6 +348,20 @@ BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriver= State *bs, return ret; } =20 +BdrvDirtyBitmap *bdrv_copy_dirty_bitmap_locked(BdrvDirtyBitmap *src, + BdrvDirtyBitmap *dest, + Error **errp) +{ + qemu_mutex_lock(src->mutex); + if (!hbitmap_copy(dest->bitmap, src->bitmap)) { + error_setg(errp, "Error: copy src bitmap failed"); + return NULL; + } + qemu_mutex_unlock(src->mutex); + + return dest; +} + /** * Truncates _all_ bitmaps attached to a BDS. * Called with BQL taken. diff --git a/block/mirror.c b/block/mirror.c index ab59ad7..a860fe7 100644 --- a/block/mirror.c +++ b/block/mirror.c @@ -50,6 +50,8 @@ typedef struct MirrorBlockJob { /* Used to block operations on the drive-mirror-replace target */ Error *replace_blocker; bool is_none_mode; + bool is_inc_mode; + char *bitmap_name; BlockMirrorBackingMode backing_mode; MirrorCopyMode copy_mode; BlockdevOnError on_source_error, on_target_error; @@ -814,6 +816,28 @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJ= ob *s) return 0; } =20 +/* + * init dirty bitmap by using user bitmap. usr->hbitmap will be copy to + * mirror bitmap->hbitmap instead of reuse it. + */ +static int coroutine_fn mirror_dirty_init_incremental(MirrorBlockJob *s) +{ + BlockDriverState *bs =3D s->mirror_top_bs->backing->bs; + BdrvDirtyBitmap *src, *dest; + + dest =3D s->dirty_bitmap; + src =3D bdrv_find_dirty_bitmap(bs, s->bitmap_name); + if (!src) { + return -1; + } + + if (!bdrv_copy_dirty_bitmap_locked(src, dest, NULL)) { + return -1; + } + + return 0; +} + /* Called when going out of the streaming phase to flush the bulk of the * data to the medium, or just before completing. */ @@ -913,9 +937,17 @@ static int coroutine_fn mirror_run(Job *job, Error **e= rrp) =20 s->last_pause_ns =3D qemu_clock_get_ns(QEMU_CLOCK_REALTIME); if (!s->is_none_mode) { - ret =3D mirror_dirty_init(s); - if (ret < 0 || job_is_cancelled(&s->common.job)) { - goto immediate_exit; + /* incremental mode */ + if (s->is_inc_mode) { + ret =3D mirror_dirty_init_incremental(s); + if (ret < 0 || job_is_cancelled(&s->common.job)) { + goto immediate_exit; + } + } else { + ret =3D mirror_dirty_init(s); + if (ret < 0 || job_is_cancelled(&s->common.job)) { + goto immediate_exit; + } } } =20 @@ -1484,7 +1516,9 @@ static void mirror_start_job(const char *job_id, Bloc= kDriverState *bs, BlockCompletionFunc *cb, void *opaque, const BlockJobDriver *driver, - bool is_none_mode, BlockDriverState *base, + bool is_none_mode, bool is_inc_mode, + const char *bitmap_name, + BlockDriverState *base, bool auto_complete, const char *filter_node_n= ame, bool is_mirror, MirrorCopyMode copy_mode, Error **errp) @@ -1598,6 +1632,8 @@ static void mirror_start_job(const char *job_id, Bloc= kDriverState *bs, s->on_source_error =3D on_source_error; s->on_target_error =3D on_target_error; s->is_none_mode =3D is_none_mode; + s->is_inc_mode =3D is_inc_mode; + s->bitmap_name =3D g_strdup(bitmap_name); s->backing_mode =3D backing_mode; s->copy_mode =3D copy_mode; s->base =3D base; @@ -1648,6 +1684,7 @@ fail: bdrv_ref(mirror_top_bs); =20 g_free(s->replaces); + g_free(s->bitmap_name); blk_unref(s->target); bs_opaque->job =3D NULL; job_early_fail(&s->common.job); @@ -1664,26 +1701,25 @@ void mirror_start(const char *job_id, BlockDriverSt= ate *bs, BlockDriverState *target, const char *replaces, int creation_flags, int64_t speed, uint32_t granularity, int64_t buf_size, - MirrorSyncMode mode, BlockMirrorBackingMode backing_mode, + MirrorSyncMode mode, const char *bitmap_name, + BlockMirrorBackingMode backing_mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, bool unmap, const char *filter_node_name, MirrorCopyMode copy_mode, Error **errp) { - bool is_none_mode; + bool is_none_mode, is_inc_mode; BlockDriverState *base; =20 - if (mode =3D=3D MIRROR_SYNC_MODE_INCREMENTAL) { - error_setg(errp, "Sync mode 'incremental' not supported"); - return; - } is_none_mode =3D mode =3D=3D MIRROR_SYNC_MODE_NONE; + is_inc_mode =3D mode =3D=3D MIRROR_SYNC_MODE_INCREMENTAL; base =3D mode =3D=3D MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL; mirror_start_job(job_id, bs, creation_flags, target, replaces, speed, granularity, buf_size, backing_mode, on_source_error, on_target_error, unmap, NULL, NULL, - &mirror_job_driver, is_none_mode, base, false, - filter_node_name, true, copy_mode, errp); + &mirror_job_driver, is_none_mode, is_inc_mode, + bitmap_name, base, false, filter_node_name, true, + copy_mode, errp); } =20 void commit_active_start(const char *job_id, BlockDriverState *bs, @@ -1707,7 +1743,8 @@ void commit_active_start(const char *job_id, BlockDri= verState *bs, mirror_start_job(job_id, bs, creation_flags, base, NULL, speed, 0, 0, MIRROR_LEAVE_BACKING_CHAIN, on_error, on_error, true, cb, opaque, - &commit_active_job_driver, false, base, auto_complete, + &commit_active_job_driver, false, false, + NULL, base, auto_complete, filter_node_name, false, MIRROR_COPY_MODE_BACKGROUND, &local_err); if (local_err) { diff --git a/blockdev.c b/blockdev.c index e6c8349..4ac36f3 100644 --- a/blockdev.c +++ b/blockdev.c @@ -3663,6 +3663,8 @@ static void blockdev_mirror_common(const char *job_id= , BlockDriverState *bs, BlockDriverState *target, bool has_replaces, const char *replaces, enum MirrorSyncMode sync, + bool has_bitmap_name, + const char *bitmap_name, BlockMirrorBackingMode backing_mode, bool has_speed, int64_t speed, bool has_granularity, uint32_t granular= ity, @@ -3680,6 +3682,7 @@ static void blockdev_mirror_common(const char *job_id= , BlockDriverState *bs, Error **errp) { int job_flags =3D JOB_DEFAULT; + BdrvDirtyBitmap *src_bitmap; =20 if (!has_speed) { speed =3D 0; @@ -3702,6 +3705,23 @@ static void blockdev_mirror_common(const char *job_i= d, BlockDriverState *bs, if (!has_filter_node_name) { filter_node_name =3D NULL; } + if (!has_bitmap_name) { + bitmap_name =3D NULL; + } + /* + * In incremental mode, we should create null name bitmap by + * using user bitmap's granularity. + */ + if (sync =3D=3D MIRROR_SYNC_MODE_INCREMENTAL && bitmap_name !=3D NULL)= { + src_bitmap =3D bdrv_find_dirty_bitmap(bs, bitmap_name); + if (!src_bitmap) { + error_setg(errp, "Error: can't find dirty bitmap " + "before start incremental drive-mirror"); + return; + } + granularity =3D bdrv_dirty_bitmap_granularity(src_bitmap); + } + if (!has_copy_mode) { copy_mode =3D MIRROR_COPY_MODE_BACKGROUND; } @@ -3739,7 +3759,7 @@ static void blockdev_mirror_common(const char *job_id= , BlockDriverState *bs, */ mirror_start(job_id, bs, target, has_replaces ? replaces : NULL, job_flags, - speed, granularity, buf_size, sync, backing_mode, + speed, granularity, buf_size, sync, bitmap_name, backing_= mode, on_source_error, on_target_error, unmap, filter_node_name, copy_mode, errp); } @@ -3786,6 +3806,16 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp) if (arg->sync =3D=3D MIRROR_SYNC_MODE_NONE) { source =3D bs; } + if ((arg->sync =3D=3D MIRROR_SYNC_MODE_INCREMENTAL) && + (!arg->has_bitmap_name)) { + error_setg(errp, "incremental mode must specify the bitmap name"); + goto out; + } + if ((arg->sync =3D=3D MIRROR_SYNC_MODE_INCREMENTAL) && + (arg->has_granularity)) { + error_setg(errp, "incremental mode can not set bitmap granularity"= ); + goto out; + } =20 size =3D bdrv_getlength(bs); if (size < 0) { @@ -3880,6 +3910,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp) =20 blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, targe= t_bs, arg->has_replaces, arg->replaces, arg->sync, + arg->has_bitmap_name, arg->bitmap_name, backing_mode, arg->has_speed, arg->speed, arg->has_granularity, arg->granularity, arg->has_buf_size, arg->buf_size, @@ -3937,7 +3968,8 @@ void qmp_blockdev_mirror(bool has_job_id, const char = *job_id, bdrv_set_aio_context(target_bs, aio_context); =20 blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs, - has_replaces, replaces, sync, backing_mode, + has_replaces, replaces, sync, false, NULL, + backing_mode, has_speed, speed, has_granularity, granularity, has_buf_size, buf_size, diff --git a/include/block/block_int.h b/include/block/block_int.h index f605622..2f4725e 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -1054,7 +1054,8 @@ void mirror_start(const char *job_id, BlockDriverStat= e *bs, BlockDriverState *target, const char *replaces, int creation_flags, int64_t speed, uint32_t granularity, int64_t buf_size, - MirrorSyncMode mode, BlockMirrorBackingMode backing_mode, + MirrorSyncMode mode, const char *bitmap_name, + BlockMirrorBackingMode backing_mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, bool unmap, const char *filter_node_name, diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h index 8f38a3d..d354d8f 100644 --- a/include/block/dirty-bitmap.h +++ b/include/block/dirty-bitmap.h @@ -21,6 +21,9 @@ BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverSt= ate *bs, BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, Error **errp); +BdrvDirtyBitmap *bdrv_copy_dirty_bitmap_locked(BdrvDirtyBitmap *src, + BdrvDirtyBitmap *dest, + Error **errp); void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap); BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name); diff --git a/include/qemu/hbitmap.h b/include/qemu/hbitmap.h index a7cb780..6de3b4e 100644 --- a/include/qemu/hbitmap.h +++ b/include/qemu/hbitmap.h @@ -91,6 +91,8 @@ bool hbitmap_merge(const HBitmap *a, const HBitmap *b, HB= itmap *result); */ bool hbitmap_can_merge(const HBitmap *a, const HBitmap *b); =20 +bool hbitmap_copy(HBitmap *dst, const HBitmap *src); + /** * hbitmap_empty: * @hb: HBitmap to operate on. diff --git a/qapi/block-core.json b/qapi/block-core.json index 762000f..b51e57c 100644 --- a/qapi/block-core.json +++ b/qapi/block-core.json @@ -1727,6 +1727,8 @@ # (all the disk, only the sectors allocated in the topmost image, or # only new I/O). # +# @bitmap-name: the bitmap to be used in incremental mode. +# # @granularity: granularity of the dirty bitmap, default is 64K # if the image format doesn't have clusters, 4K if the clust= ers # are smaller than that, else the cluster size. Must be a @@ -1768,7 +1770,7 @@ { 'struct': 'DriveMirror', 'data': { '*job-id': 'str', 'device': 'str', 'target': 'str', '*format': 'str', '*node-name': 'str', '*replaces': 'str', - 'sync': 'MirrorSyncMode', '*mode': 'NewImageMode', + 'sync': 'MirrorSyncMode', '*bitmap-name': 'str', '*mode': 'New= ImageMode', '*speed': 'int', '*granularity': 'uint32', '*buf-size': 'int', '*on-source-error': 'BlockdevOnError', '*on-target-error': 'BlockdevOnError', diff --git a/util/hbitmap.c b/util/hbitmap.c index 8d402c5..7ae2fc2 100644 --- a/util/hbitmap.c +++ b/util/hbitmap.c @@ -765,6 +765,34 @@ bool hbitmap_merge(const HBitmap *a, const HBitmap *b,= HBitmap *result) return true; } =20 +/* + * Copy HBitmaps form src to dst. + * + * @return true if the copy was successful, + * false if it was not attempted. + */ +bool hbitmap_copy(HBitmap *dst, const HBitmap *src) +{ + int i; + + if ((dst->size !=3D src->size) || (dst->granularity !=3D src->granular= ity)) { + return false; + } + + if (hbitmap_count(src) =3D=3D 0) { + return true; + } + + for (i =3D HBITMAP_LEVELS - 1; i >=3D 0; i--) { + memcpy(dst->levels[i], src->levels[i], + src->sizes[i] * sizeof(unsigned long)); + } + + dst->count =3D src->count; + return true; +} + + HBitmap *hbitmap_create_meta(HBitmap *hb, int chunk_size) { assert(!(chunk_size & (chunk_size - 1))); --=20 1.8.3.1