From nobody Sat Feb 7 04:26:51 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1592596752; cv=none; d=zohomail.com; s=zohoarc; b=PQOD7DuJz0d7vW1tsEUOCMiBsvotZB9MqY539gtxPqVXfYxFJNX8hchoCDlmeRSwbew2QPd85e21uzebr6ZzDIu40zyTenf8Lf/ixv6+gU+JaWaNlSDheDpqONI6yA5DlP67JKUVkgGpRi6cOepTSZe+YErtcnIo7LnElpJA08g= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1592596752; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=0AGEILODxdwu+z0MlWOxApnCxyEGVRsM40/nHXFHodU=; b=N5cqIFo0vuSGpxQPD1ctzneyoRIBiD8JnLSwBgFrfszWRDlGQ8gySWVz03PExG2X8WwyoUoHTlsd0c3lPNLmEcrWtikR44kqHUL439SW1AMdlXtxuQ4OhAJIUVk8cpasGsHK8puN8RRVgB8NnNLTfaFv7yCHywK1UQoYiS5pwm0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1592596752587736.6189160047687; Fri, 19 Jun 2020 12:59:12 -0700 (PDT) Received: from localhost ([::1]:60330 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jmNAN-00011K-CY for importer@patchew.org; Fri, 19 Jun 2020 15:59:11 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42934) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jmN7p-0004It-1S for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:33 -0400 Received: from us-smtp-1.mimecast.com ([205.139.110.61]:53743 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1jmN7m-0007dK-Rk for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:32 -0400 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-78-I8W4WsMNPN-sAtG2RPKDgw-1; Fri, 19 Jun 2020 15:56:25 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 57BED801503; Fri, 19 Jun 2020 19:56:24 +0000 (UTC) Received: from blue.redhat.com (ovpn-114-4.phx2.redhat.com [10.3.114.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 92EBD71661; Fri, 19 Jun 2020 19:56:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1592596590; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=0AGEILODxdwu+z0MlWOxApnCxyEGVRsM40/nHXFHodU=; b=VK4UU0C+ecmBAMGxZOxJVgvaaArawHvcK7PrFSaI11lt7qbBUA/2b4RiSO3lC5rW59mlLU 85Q8o69bqA1/gO6ZhjnRUdKyT3rMvqlRbV4/pTAsc1XCEBOZYTUjDYiDRruDz33P6g/Hiw wJJRBjDcxBBYQ8sK1aCQ39RVrpjUkIM= X-MC-Unique: I8W4WsMNPN-sAtG2RPKDgw-1 From: Eric Blake To: qemu-devel@nongnu.org Subject: [PATCH v3 1/6] block: add bitmap-populate job Date: Fri, 19 Jun 2020 14:56:16 -0500 Message-Id: <20200619195621.58740-2-eblake@redhat.com> In-Reply-To: <20200619195621.58740-1-eblake@redhat.com> References: <20200619195621.58740-1-eblake@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=205.139.110.61; envelope-from=eblake@redhat.com; helo=us-smtp-delivery-1.mimecast.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/06/19 02:45:39 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -30 X-Spam_score: -3.1 X-Spam_bar: --- X-Spam_report: (-3.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=_AUTOLEARN X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, vsementsov@virtuozzo.com, qemu-block@nongnu.org, armbru@redhat.com, mreitz@redhat.com, pkrempa@redhat.com, jsnow@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-Type: text/plain; charset="utf-8" From: John Snow This job copies the allocation map into a bitmap. It's a job because there's no guarantee that allocation interrogation will be quick (or won't hang), so it cannot be retrofitted into block-dirty-bitmap-merge. It was designed with different possible population patterns in mind, but only top layer allocation was implemented for now. Signed-off-by: John Snow Signed-off-by: Eric Blake --- qapi/block-core.json | 48 +++++++++ qapi/job.json | 6 +- include/block/block_int.h | 21 ++++ block/bitmap-populate.c | 207 ++++++++++++++++++++++++++++++++++++++ blockjob.c | 3 +- MAINTAINERS | 1 + block/Makefile.objs | 1 + 7 files changed, 285 insertions(+), 2 deletions(-) create mode 100644 block/bitmap-populate.c diff --git a/qapi/block-core.json b/qapi/block-core.json index 0e1c6a59f228..a1bcdba04423 100644 --- a/qapi/block-core.json +++ b/qapi/block-core.json @@ -2211,6 +2211,54 @@ { 'command': 'block-dirty-bitmap-merge', 'data': 'BlockDirtyBitmapMerge' } +## +# @BitmapPattern: +# +# An enumeration of possible patterns that can be written into a bitmap. +# +# @allocation-top: The allocation status of the top layer +# of the attached storage node. +# +# Since: 5.1 +## +{ 'enum': 'BitmapPattern', + 'data': ['allocation-top'] } + +## +# @BlockDirtyBitmapPopulate: +# +# @job-id: identifier for the newly-created block job. +# +# @pattern: What pattern should be written into the bitmap? +# +# @on-error: the action to take if an error is encountered on a bitmap's +# attached node, default 'report'. +# 'stop' and 'enospc' can only be used if the block device supp= orts +# io-status (see BlockInfo). +# +# @auto-finalize: When false, this job will wait in a PENDING state after = it has +# finished its work, waiting for @block-job-finalize before +# making any block graph changes. +# When true, this job will automatically +# perform its abort or commit actions. +# Defaults to true. +# +# @auto-dismiss: When false, this job will wait in a CONCLUDED state after= it +# has completely ceased all work, and awaits @block-job-dis= miss. +# When true, this job will automatically disappear from the= query +# list without user intervention. +# Defaults to true. +# +# Since: 5.1 +## +{ 'struct': 'BlockDirtyBitmapPopulate', + 'base': 'BlockDirtyBitmap', + 'data': { 'job-id': 'str', + 'pattern': 'BitmapPattern', + '*on-error': 'BlockdevOnError', + '*auto-finalize': 'bool', + '*auto-dismiss': 'bool' } } + ## # @BlockDirtyBitmapSha256: # diff --git a/qapi/job.json b/qapi/job.json index 5e658281f5c4..33ff3500f794 100644 --- a/qapi/job.json +++ b/qapi/job.json @@ -19,10 +19,14 @@ # # @create: image creation job type, see "blockdev-create" (since 3.0) # +# @bitmap-populate: drive bitmap population job type, see +# "block-dirty-bitmap-populate" (since 5.1) +# # Since: 1.7 ## { 'enum': 'JobType', - 'data': ['commit', 'stream', 'mirror', 'backup', 'create'] } + 'data': ['commit', 'stream', 'mirror', 'backup', 'create', + 'bitmap-populate'] } ## # @JobStatus: diff --git a/include/block/block_int.h b/include/block/block_int.h index 791de6a59c2c..93fb886e7e97 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -1231,6 +1231,27 @@ BlockJob *backup_job_create(const char *job_id, Bloc= kDriverState *bs, BlockCompletionFunc *cb, void *opaque, JobTxn *txn, Error **errp); +/* + * bitpop_job_create: Create a new bitmap population job. + * + * @job_id: The id of the newly-created job. + * @bs: Block device associated with the @target_bitmap. + * @target_bitmap: The bitmap to populate. + * @on_error: What to do if an error on @bs is encountered. + * @creation_flags: Flags that control the behavior of the Job lifetime. + * See @BlockJobCreateFlags + * @cb: Completion function for the job. + * @opaque: Opaque pointer value passed to @cb. + * @txn: Transaction that this job is part of (may be NULL). + */ +BlockJob *bitpop_job_create(const char *job_id, BlockDriverState *bs, + BdrvDirtyBitmap *target_bitmap, + BitmapPattern pattern, + BlockdevOnError on_error, + int creation_flags, + BlockCompletionFunc *cb, void *opaque, + JobTxn *txn, Error **errp); + BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, const char *child_name, const BdrvChildClass *child_class, diff --git a/block/bitmap-populate.c b/block/bitmap-populate.c new file mode 100644 index 000000000000..901b78b56c3e --- /dev/null +++ b/block/bitmap-populate.c @@ -0,0 +1,207 @@ +/* + * Async Dirty Bitmap Populator + * + * Copyright (C) 2020 Red Hat, Inc. + * + * Authors: + * John Snow + * + * This work is licensed under the terms of the GNU GPL, version 2 or late= r. + * See the COPYING file in the top-level directory. + * + */ + +#include "qemu/osdep.h" + +#include "trace.h" +#include "block/block.h" +#include "block/block_int.h" +#include "block/blockjob_int.h" +#include "block/block_backup.h" +#include "block/block-copy.h" +#include "qapi/error.h" +#include "qapi/qmp/qerror.h" +#include "qemu/ratelimit.h" +#include "qemu/cutils.h" +#include "sysemu/block-backend.h" +#include "qemu/bitmap.h" +#include "qemu/error-report.h" + +typedef struct BitpopBlockJob { + BlockJob common; + BlockDriverState *bs; + BdrvDirtyBitmap *target_bitmap; + BdrvDirtyBitmap *new_bitmap; + BlockdevOnError on_error; + uint64_t len; +} BitpopBlockJob; + +static const BlockJobDriver bitpop_job_driver; + +static void bitpop_commit(Job *job) +{ + BitpopBlockJob *s =3D container_of(job, BitpopBlockJob, common.job); + + bdrv_dirty_bitmap_merge_internal(s->target_bitmap, s->new_bitmap, + NULL, true); +} + +/* no abort needed; just clean without committing. */ + +static void bitpop_clean(Job *job) +{ + BitpopBlockJob *s =3D container_of(job, BitpopBlockJob, common.job); + + bdrv_release_dirty_bitmap(s->new_bitmap); + bdrv_dirty_bitmap_set_busy(s->target_bitmap, false); +} + +static BlockErrorAction bitpop_error_action(BitpopBlockJob *job, int error) +{ + return block_job_error_action(&job->common, job->on_error, true, error= ); +} + +static bool coroutine_fn yield_and_check(Job *job) +{ + if (job_is_cancelled(job)) { + return true; + } + + job_sleep_ns(job, 0); + + if (job_is_cancelled(job)) { + return true; + } + + return false; +} + +static int coroutine_fn bitpop_run(Job *job, Error **errp) +{ + BitpopBlockJob *s =3D container_of(job, BitpopBlockJob, common.job); + int ret =3D 0; + int64_t offset; + int64_t count; + int64_t bytes; + + for (offset =3D 0; offset < s->len; ) { + if (yield_and_check(job)) { + ret =3D -ECANCELED; + break; + } + + bytes =3D s->len - offset; + ret =3D bdrv_is_allocated(s->bs, offset, bytes, &count); + if (ret < 0) { + if (bitpop_error_action(s, -ret) =3D=3D BLOCK_ERROR_ACTION_REP= ORT) { + break; + } + continue; + } + + if (!count) { + ret =3D 0; + break; + } + + if (ret) { + bdrv_set_dirty_bitmap(s->new_bitmap, offset, count); + ret =3D 0; + } + + job_progress_update(job, count); + offset +=3D count; + } + + return ret; +} + +static const BlockJobDriver bitpop_job_driver =3D { + .job_driver =3D { + .instance_size =3D sizeof(BitpopBlockJob), + .job_type =3D JOB_TYPE_BITMAP_POPULATE, + .free =3D block_job_free, + .user_resume =3D block_job_user_resume, + .run =3D bitpop_run, + .commit =3D bitpop_commit, + .clean =3D bitpop_clean, + } +}; + + +BlockJob *bitpop_job_create( + const char *job_id, + BlockDriverState *bs, + BdrvDirtyBitmap *target_bitmap, + BitmapPattern pattern, + BlockdevOnError on_error, + int creation_flags, + BlockCompletionFunc *cb, + void *opaque, + JobTxn *txn, + Error **errp) +{ + int64_t len; + BitpopBlockJob *job =3D NULL; + int64_t cluster_size; + BdrvDirtyBitmap *new_bitmap =3D NULL; + + assert(bs); + assert(target_bitmap); + + if (!bdrv_is_inserted(bs)) { + error_setg(errp, "Device is not inserted: %s", + bdrv_get_device_name(bs)); + return NULL; + } + + if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) { + return NULL; + } + + if (bdrv_dirty_bitmap_check(target_bitmap, BDRV_BITMAP_DEFAULT, errp))= { + return NULL; + } + + if (pattern !=3D BITMAP_PATTERN_ALLOCATION_TOP) { + error_setg(errp, "Unrecognized bitmap pattern"); + return NULL; + } + + len =3D bdrv_getlength(bs); + if (len < 0) { + error_setg_errno(errp, -len, "unable to get length for '%s'", + bdrv_get_device_or_node_name(bs)); + return NULL; + } + + /* NB: new bitmap is anonymous and enabled */ + cluster_size =3D bdrv_dirty_bitmap_granularity(target_bitmap); + new_bitmap =3D bdrv_create_dirty_bitmap(bs, cluster_size, NULL, errp); + if (!new_bitmap) { + return NULL; + } + + /* Take ownership; we reserve the right to write into this on-commit. = */ + bdrv_dirty_bitmap_set_busy(target_bitmap, true); + + job =3D block_job_create(job_id, &bitpop_job_driver, txn, bs, + BLK_PERM_CONSISTENT_READ, + BLK_PERM_ALL & ~BLK_PERM_RESIZE, + 0, creation_flags, + cb, opaque, errp); + if (!job) { + bdrv_dirty_bitmap_set_busy(target_bitmap, false); + bdrv_release_dirty_bitmap(new_bitmap); + return NULL; + } + + job->bs =3D bs; + job->on_error =3D on_error; + job->target_bitmap =3D target_bitmap; + job->new_bitmap =3D new_bitmap; + job->len =3D len; + job_progress_set_remaining(&job->common.job, job->len); + + return &job->common; +} diff --git a/blockjob.c b/blockjob.c index 470facfd47a0..e6ee8376645d 100644 --- a/blockjob.c +++ b/blockjob.c @@ -56,7 +56,8 @@ static bool is_block_job(Job *job) return job_type(job) =3D=3D JOB_TYPE_BACKUP || job_type(job) =3D=3D JOB_TYPE_COMMIT || job_type(job) =3D=3D JOB_TYPE_MIRROR || - job_type(job) =3D=3D JOB_TYPE_STREAM; + job_type(job) =3D=3D JOB_TYPE_STREAM || + job_type(job) =3D=3D JOB_TYPE_BITMAP_POPULATE; } BlockJob *block_job_next(BlockJob *bjob) diff --git a/MAINTAINERS b/MAINTAINERS index 955cc8dd5cd0..99651abcac4a 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2050,6 +2050,7 @@ S: Supported F: include/qemu/hbitmap.h F: include/block/dirty-bitmap.h F: block/monitor/bitmap-qmp-cmds.c +F: block/bitmap-populate.c F: block/dirty-bitmap.c F: block/qcow2-bitmap.c F: migration/block-dirty-bitmap.c diff --git a/block/Makefile.objs b/block/Makefile.objs index 96028eedcef7..55f5970f7625 100644 --- a/block/Makefile.objs +++ b/block/Makefile.objs @@ -36,6 +36,7 @@ block-obj-$(CONFIG_LIBSSH) +=3D ssh.o block-obj-y +=3D accounting.o dirty-bitmap.o block-obj-y +=3D write-threshold.o block-obj-y +=3D backup.o +block-obj-y +=3D bitmap-populate.o block-obj-$(CONFIG_REPLICATION) +=3D replication.o block-obj-y +=3D throttle.o copy-on-read.o block-obj-y +=3D block-copy.o --=20 2.27.0 From nobody Sat Feb 7 04:26:51 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1592596658; cv=none; d=zohomail.com; s=zohoarc; b=IS9azmQpzDQVPaZtHBYOTwqbRnRvh8S1XQahnL3UHknpWvw2p+6Wk/kL6a8dMRyj65zofk4mYn8FXusT9ak71+Ri12kCroOuZVtFH89xC4Ll8p5bw0YE2CSPnbXDa7URerkv3LvCYfKQOZFWIE7r3ZJcPcz8M8Q17Zgq3gfUeEk= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1592596658; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=ECTBnS2he4XAR+17tYX0uLcF6htb9lx7WX+8NFiYHJA=; b=IBHE8VxBTqKk9X1msgF3vB8UN1O9/6Q16yFbQ0O3Kr6tZDscmebFLrHEZAJXwIEjMoSe2qOd4zEtTp30huOV/UGlHSNJnujzWrtGzCICBIesVOrvEy2upoLt/y1wlF7KBoS6F9bhWpaqMLNZ1u+P5TnvmWO9gWPWdZ/bWlhzFzw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 15925966582691022.1791623829938; Fri, 19 Jun 2020 12:57:38 -0700 (PDT) Received: from localhost ([::1]:53798 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jmN8q-0005p6-Kt for importer@patchew.org; Fri, 19 Jun 2020 15:57:36 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42894) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jmN7n-0004FR-Bz for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:31 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:59658 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1jmN7l-0007d4-IH for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:31 -0400 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-135-cgoU-4E0OIOeWYnt62wZiw-1; Fri, 19 Jun 2020 15:56:26 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 2DF4C800053; Fri, 19 Jun 2020 19:56:25 +0000 (UTC) Received: from blue.redhat.com (ovpn-114-4.phx2.redhat.com [10.3.114.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 8571171661; Fri, 19 Jun 2020 19:56:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1592596588; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=ECTBnS2he4XAR+17tYX0uLcF6htb9lx7WX+8NFiYHJA=; b=KQUp0yysvMM9oNS1kTDU6jPacvIUnnjxM1NTOWshaSWRQSepXBdt54ig/59cfKk8G5UBZj j1mDgjLyFhGgLjRJoArgX674reCWPMtpTQHmdFIgsGZh/nB0eXP+aDYCOSICTePffnPb55 uYbV5FVqEdZgNt2afMtZYwShbG1gOgo= X-MC-Unique: cgoU-4E0OIOeWYnt62wZiw-1 From: Eric Blake To: qemu-devel@nongnu.org Subject: [PATCH v3 2/6] blockdev: combine DriveBackupState and BlockdevBackupState Date: Fri, 19 Jun 2020 14:56:17 -0500 Message-Id: <20200619195621.58740-3-eblake@redhat.com> In-Reply-To: <20200619195621.58740-1-eblake@redhat.com> References: <20200619195621.58740-1-eblake@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=207.211.31.81; envelope-from=eblake@redhat.com; helo=us-smtp-delivery-1.mimecast.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/06/19 01:50:04 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -30 X-Spam_score: -3.1 X-Spam_bar: --- X-Spam_report: (-3.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H4=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=_AUTOLEARN X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, vsementsov@virtuozzo.com, qemu-block@nongnu.org, armbru@redhat.com, mreitz@redhat.com, pkrempa@redhat.com, jsnow@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-Type: text/plain; charset="utf-8" From: John Snow They have the same fields -- rename it BlockJobActionState. Signed-off-by: John Snow Signed-off-by: Eric Blake --- blockdev.c | 30 ++++++++++++------------------ 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/blockdev.c b/blockdev.c index 72df193ca73b..6d80af903c55 100644 --- a/blockdev.c +++ b/blockdev.c @@ -1655,11 +1655,11 @@ static void external_snapshot_clean(BlkActionState = *common) aio_context_release(aio_context); } -typedef struct DriveBackupState { +typedef struct BlockJobActionState { BlkActionState common; BlockDriverState *bs; BlockJob *job; -} DriveBackupState; +} BlockJobActionState; static BlockJob *do_backup_common(BackupCommon *backup, BlockDriverState *bs, @@ -1669,7 +1669,7 @@ static BlockJob *do_backup_common(BackupCommon *backu= p, static void drive_backup_prepare(BlkActionState *common, Error **errp) { - DriveBackupState *state =3D DO_UPCAST(DriveBackupState, common, common= ); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); DriveBackup *backup; BlockDriverState *bs; BlockDriverState *target_bs; @@ -1806,7 +1806,7 @@ out: static void drive_backup_commit(BlkActionState *common) { - DriveBackupState *state =3D DO_UPCAST(DriveBackupState, common, common= ); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); AioContext *aio_context; aio_context =3D bdrv_get_aio_context(state->bs); @@ -1820,7 +1820,7 @@ static void drive_backup_commit(BlkActionState *commo= n) static void drive_backup_abort(BlkActionState *common) { - DriveBackupState *state =3D DO_UPCAST(DriveBackupState, common, common= ); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); if (state->job) { AioContext *aio_context; @@ -1836,7 +1836,7 @@ static void drive_backup_abort(BlkActionState *common) static void drive_backup_clean(BlkActionState *common) { - DriveBackupState *state =3D DO_UPCAST(DriveBackupState, common, common= ); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); AioContext *aio_context; if (!state->bs) { @@ -1851,15 +1851,9 @@ static void drive_backup_clean(BlkActionState *commo= n) aio_context_release(aio_context); } -typedef struct BlockdevBackupState { - BlkActionState common; - BlockDriverState *bs; - BlockJob *job; -} BlockdevBackupState; - static void blockdev_backup_prepare(BlkActionState *common, Error **errp) { - BlockdevBackupState *state =3D DO_UPCAST(BlockdevBackupState, common, = common); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); BlockdevBackup *backup; BlockDriverState *bs; BlockDriverState *target_bs; @@ -1907,7 +1901,7 @@ static void blockdev_backup_prepare(BlkActionState *c= ommon, Error **errp) static void blockdev_backup_commit(BlkActionState *common) { - BlockdevBackupState *state =3D DO_UPCAST(BlockdevBackupState, common, = common); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); AioContext *aio_context; aio_context =3D bdrv_get_aio_context(state->bs); @@ -1921,7 +1915,7 @@ static void blockdev_backup_commit(BlkActionState *co= mmon) static void blockdev_backup_abort(BlkActionState *common) { - BlockdevBackupState *state =3D DO_UPCAST(BlockdevBackupState, common, = common); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); if (state->job) { AioContext *aio_context; @@ -1937,7 +1931,7 @@ static void blockdev_backup_abort(BlkActionState *com= mon) static void blockdev_backup_clean(BlkActionState *common) { - BlockdevBackupState *state =3D DO_UPCAST(BlockdevBackupState, common, = common); + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); AioContext *aio_context; if (!state->bs) { @@ -2209,14 +2203,14 @@ static const BlkActionOps actions[] =3D { .clean =3D external_snapshot_clean, }, [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] =3D { - .instance_size =3D sizeof(DriveBackupState), + .instance_size =3D sizeof(BlockJobActionState), .prepare =3D drive_backup_prepare, .commit =3D drive_backup_commit, .abort =3D drive_backup_abort, .clean =3D drive_backup_clean, }, [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] =3D { - .instance_size =3D sizeof(BlockdevBackupState), + .instance_size =3D sizeof(BlockJobActionState), .prepare =3D blockdev_backup_prepare, .commit =3D blockdev_backup_commit, .abort =3D blockdev_backup_abort, --=20 2.27.0 From nobody Sat Feb 7 04:26:51 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1592596661; cv=none; d=zohomail.com; s=zohoarc; b=PlQiAAMRI/VEbq10iCyTDK+bXizgPvmyvPRqk7JGPq+muPog7S6WeP1k0dp690Ohx8QoYoYgxiJ5xNFAnkAGdK0Cd65XwrRQLQ4A5b3K1IoM5wzLooUG/NvSPKlgCz3KMBJhVaJ2YPGrjEQj6ysRNaPa/Yk66XgWz0G3sN1UTe4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1592596661; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=+EN9Do3mUyUs9jCHSaQNHba7uiBgnaN8VZWKJG82sDI=; b=Qi/vPbtdehCfh9/6MW9FsIv1XWTMbRSK4+L/RCV/M3FYgL5SPnLC7mzxGXkhMAVjE6dncTkzctXRQEsP/000iOVZQO8Fd9+MbbEEHxPS7WwAHSzkqVWZKTsb6SJR4qgUBbU07A4lqbsEowuyE09wgXNRLfxXsDLKYHpgye+OKMI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1592596661052293.1103257340303; Fri, 19 Jun 2020 12:57:41 -0700 (PDT) Received: from localhost ([::1]:54092 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jmN8t-0005wZ-Qd for importer@patchew.org; Fri, 19 Jun 2020 15:57:39 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42914) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jmN7o-0004H4-7H for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:32 -0400 Received: from us-smtp-1.mimecast.com ([205.139.110.61]:48774 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1jmN7l-0007d9-M8 for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:31 -0400 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-284-eoUF8EiuMi6aiCzQMWb3Eg-1; Fri, 19 Jun 2020 15:56:27 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 086DC1800D42; Fri, 19 Jun 2020 19:56:26 +0000 (UTC) Received: from blue.redhat.com (ovpn-114-4.phx2.redhat.com [10.3.114.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 61C9571661; Fri, 19 Jun 2020 19:56:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1592596589; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=+EN9Do3mUyUs9jCHSaQNHba7uiBgnaN8VZWKJG82sDI=; b=A8BiJ+pcyZ/EtJcxRwXHyori5PdXwtAJVIdtU6SZQwuSrJEmd2bc8WF/0T/NKDzE1BIwsj UrDU/ld07XaVynDjHUAyZywgjOuw/kYQkDo9TmZUCvM6s/k0t2fU8e6Dbg6tvsdknGoG7l 7Txw50zF3QjceJYS4lvvQAV4qq8Ze3Y= X-MC-Unique: eoUF8EiuMi6aiCzQMWb3Eg-1 From: Eric Blake To: qemu-devel@nongnu.org Subject: [PATCH v3 3/6] qmp: expose block-dirty-bitmap-populate Date: Fri, 19 Jun 2020 14:56:18 -0500 Message-Id: <20200619195621.58740-4-eblake@redhat.com> In-Reply-To: <20200619195621.58740-1-eblake@redhat.com> References: <20200619195621.58740-1-eblake@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=205.139.110.61; envelope-from=eblake@redhat.com; helo=us-smtp-delivery-1.mimecast.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/06/19 02:45:39 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -30 X-Spam_score: -3.1 X-Spam_bar: --- X-Spam_report: (-3.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=_AUTOLEARN X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, vsementsov@virtuozzo.com, qemu-block@nongnu.org, armbru@redhat.com, mreitz@redhat.com, pkrempa@redhat.com, jsnow@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-Type: text/plain; charset="utf-8" From: John Snow This is a new job-creating command. Signed-off-by: John Snow Signed-off-by: Eric Blake --- qapi/block-core.json | 18 +++++++++++ qapi/transaction.json | 2 ++ blockdev.c | 74 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 94 insertions(+) diff --git a/qapi/block-core.json b/qapi/block-core.json index a1bcdba04423..313583b47c16 100644 --- a/qapi/block-core.json +++ b/qapi/block-core.json @@ -2259,6 +2259,24 @@ '*auto-finalize': 'bool', '*auto-dismiss': 'bool' } } +## +# @block-dirty-bitmap-populate: +# +# Creates a new job that writes a pattern into a dirty bitmap. +# +# Since: 5.1 +# +# Example: +# +# -> { "execute": "block-dirty-bitmap-populate", +# "arguments": { "node": "drive0", "target": "bitmap0", +# "job-id": "job0", "pattern": "allocate-top" } } +# <- { "return": {} } +# +## +{ 'command': 'block-dirty-bitmap-populate', 'boxed': true, + 'data': 'BlockDirtyBitmapPopulate' } + ## # @BlockDirtyBitmapSha256: # diff --git a/qapi/transaction.json b/qapi/transaction.json index b6c11158f0b6..21be59faae56 100644 --- a/qapi/transaction.json +++ b/qapi/transaction.json @@ -50,6 +50,7 @@ # - @block-dirty-bitmap-enable: since 4.0 # - @block-dirty-bitmap-disable: since 4.0 # - @block-dirty-bitmap-merge: since 4.0 +# - @block-dirty-bitmap-populate: since 5.1 # - @blockdev-backup: since 2.3 # - @blockdev-snapshot: since 2.5 # - @blockdev-snapshot-internal-sync: since 1.7 @@ -67,6 +68,7 @@ 'block-dirty-bitmap-enable': 'BlockDirtyBitmap', 'block-dirty-bitmap-disable': 'BlockDirtyBitmap', 'block-dirty-bitmap-merge': 'BlockDirtyBitmapMerge', + 'block-dirty-bitmap-populate': 'BlockDirtyBitmapPopulate', 'blockdev-backup': 'BlockdevBackup', 'blockdev-snapshot': 'BlockdevSnapshot', 'blockdev-snapshot-internal-sync': 'BlockdevSnapshotInternal', diff --git a/blockdev.c b/blockdev.c index 6d80af903c55..d072519e7b91 100644 --- a/blockdev.c +++ b/blockdev.c @@ -2177,6 +2177,63 @@ static void block_dirty_bitmap_remove_commit(BlkActi= onState *common) bdrv_release_dirty_bitmap(state->bitmap); } +static void block_dirty_bitmap_populate_prepare(BlkActionState *common, + Error **errp) +{ + BlockJobActionState *state =3D DO_UPCAST(BlockJobActionState, common, = common); + BlockDirtyBitmapPopulate *bitpop; + BlockDriverState *bs; + AioContext *aio_context; + BdrvDirtyBitmap *bmap =3D NULL; + int job_flags =3D JOB_DEFAULT; + + assert(common->action->type =3D=3D + TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_POPULATE); + bitpop =3D common->action->u.block_dirty_bitmap_populate.data; + + bmap =3D block_dirty_bitmap_lookup(bitpop->node, bitpop->name, &bs, er= rp); + if (!bmap) { + return; + } + + aio_context =3D bdrv_get_aio_context(bs); + aio_context_acquire(aio_context); + state->bs =3D bs; + + /* Paired with .clean() */ + bdrv_drained_begin(state->bs); + + if (!bitpop->has_on_error) { + bitpop->on_error =3D BLOCKDEV_ON_ERROR_REPORT; + } + if (!bitpop->has_auto_finalize) { + bitpop->auto_finalize =3D true; + } + if (!bitpop->has_auto_dismiss) { + bitpop->auto_dismiss =3D true; + } + + if (!bitpop->auto_finalize) { + job_flags |=3D JOB_MANUAL_FINALIZE; + } + if (!bitpop->auto_dismiss) { + job_flags |=3D JOB_MANUAL_DISMISS; + } + + state->job =3D bitpop_job_create( + bitpop->job_id, + bs, + bmap, + bitpop->pattern, + bitpop->on_error, + job_flags, + NULL, NULL, + common->block_job_txn, + errp); + + aio_context_release(aio_context); +} + static void abort_prepare(BlkActionState *common, Error **errp) { error_setg(errp, "Transaction aborted using Abort action"); @@ -2260,6 +2317,13 @@ static const BlkActionOps actions[] =3D { .commit =3D block_dirty_bitmap_remove_commit, .abort =3D block_dirty_bitmap_remove_abort, }, + [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_POPULATE] =3D { + .instance_size =3D sizeof(BlockJobActionState), + .prepare =3D block_dirty_bitmap_populate_prepare, + .commit =3D blockdev_backup_commit, + .abort =3D blockdev_backup_abort, + .clean =3D blockdev_backup_clean, + }, /* Where are transactions for MIRROR, COMMIT and STREAM? * Although these blockjobs use transaction callbacks like the backup = job, * these jobs do not necessarily adhere to transaction semantics. @@ -2379,6 +2443,16 @@ void qmp_block_passwd(bool has_device, const char *d= evice, "Setting block passwords directly is no longer supported"); } +void qmp_block_dirty_bitmap_populate(BlockDirtyBitmapPopulate *bitpop, + Error **errp) +{ + TransactionAction action =3D { + .type =3D TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_POPULATE, + .u.block_dirty_bitmap_populate.data =3D bitpop, + }; + blockdev_do_action(&action, errp); +} + BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *= node, const char *= name, Error **errp) --=20 2.27.0 From nobody Sat Feb 7 04:26:51 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1592596746; cv=none; d=zohomail.com; s=zohoarc; b=Qe3Ya7MjUUrFiSxJsPzCxqn4jkDY0zCpv0erul5hbzwJNUmPih+F/5FGL/KY/hU1Li6pPUfuB6sYH0eKoFcK3WCIxmz193cEn5/bGupQoWDY543xjfthZ/UxCAjNT78LaJysf6i5WebYPSXl4+PBXn568yRDAF4cFQcZYDrZBlE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1592596746; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=dAaai+v3ekjzxQNoIAQM8Et+XPRTb/yLFReK68ARHEM=; b=WixhN9iUvid0GQScGQ30lwqRpnWA6XrjHav3WtwsqCeQ626sWoYPHBwwPwJKOgqEeisoKEaHF1YESkKF382b+qODZ2kSgl+f9mu8SnMxBToTEvV8LlqfOnsob51hIi0GjkufG/4FcZXgkxWmOxvlxsFHIAxU63DCKLrwhJ3T92o= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1592596746425169.26136013950486; Fri, 19 Jun 2020 12:59:06 -0700 (PDT) Received: from localhost ([::1]:59896 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jmNAH-0000ld-30 for importer@patchew.org; Fri, 19 Jun 2020 15:59:05 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42960) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jmN7r-0004OX-9G for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:35 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:20135 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1jmN7p-0007dq-3l for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:34 -0400 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-213-1n61iAabMYKLuHfifAlmAg-1; Fri, 19 Jun 2020 15:56:27 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id D9AB81800D4A; Fri, 19 Jun 2020 19:56:26 +0000 (UTC) Received: from blue.redhat.com (ovpn-114-4.phx2.redhat.com [10.3.114.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 3C0917166C; Fri, 19 Jun 2020 19:56:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1592596592; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=dAaai+v3ekjzxQNoIAQM8Et+XPRTb/yLFReK68ARHEM=; b=KRBrm7w8/F1yABPhleeP0bSzRpPHcus040+bhV2dcFW1mCu7uYfkGioL/i4o5XwOrvLGYN Qza/f2OeXR7w2/EUW4cshLgWK1UpmEWk9pdoe1QoFFAdnzb4l+3EQinXwrs84TJqcXQrfp /Qd6BTgFiblNK+XywOJi6JoEqbhFaG0= X-MC-Unique: 1n61iAabMYKLuHfifAlmAg-1 From: Eric Blake To: qemu-devel@nongnu.org Subject: [PATCH v3 4/6] iotests: move bitmap helpers into their own file Date: Fri, 19 Jun 2020 14:56:19 -0500 Message-Id: <20200619195621.58740-5-eblake@redhat.com> In-Reply-To: <20200619195621.58740-1-eblake@redhat.com> References: <20200619195621.58740-1-eblake@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=207.211.31.81; envelope-from=eblake@redhat.com; helo=us-smtp-delivery-1.mimecast.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/06/19 01:50:04 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -30 X-Spam_score: -3.1 X-Spam_bar: --- X-Spam_report: (-3.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H4=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, URIBL_BLOCKED=0.001 autolearn=_AUTOLEARN X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, vsementsov@virtuozzo.com, qemu-block@nongnu.org, armbru@redhat.com, mreitz@redhat.com, pkrempa@redhat.com, jsnow@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-Type: text/plain; charset="utf-8" From: John Snow Signed-off-by: John Snow Message-Id: <20200514034922.24834-5-jsnow@redhat.com> Signed-off-by: Eric Blake Reviewed-by: Vladimir Sementsov-Ogievskiy --- tests/qemu-iotests/257 | 110 +--------------------------- tests/qemu-iotests/bitmaps.py | 131 ++++++++++++++++++++++++++++++++++ 2 files changed, 132 insertions(+), 109 deletions(-) create mode 100644 tests/qemu-iotests/bitmaps.py diff --git a/tests/qemu-iotests/257 b/tests/qemu-iotests/257 index 004a433b8be2..2a81f9e30c56 100755 --- a/tests/qemu-iotests/257 +++ b/tests/qemu-iotests/257 @@ -24,120 +24,12 @@ import os import iotests from iotests import log, qemu_img +from bitmaps import EmulatedBitmap, GROUPS SIZE =3D 64 * 1024 * 1024 GRANULARITY =3D 64 * 1024 -class Pattern: - def __init__(self, byte, offset, size=3DGRANULARITY): - self.byte =3D byte - self.offset =3D offset - self.size =3D size - - def bits(self, granularity): - lower =3D self.offset // granularity - upper =3D (self.offset + self.size - 1) // granularity - return set(range(lower, upper + 1)) - - -class PatternGroup: - """Grouping of Pattern objects. Initialize with an iterable of Pattern= s.""" - def __init__(self, patterns): - self.patterns =3D patterns - - def bits(self, granularity): - """Calculate the unique bits dirtied by this pattern grouping""" - res =3D set() - for pattern in self.patterns: - res |=3D pattern.bits(granularity) - return res - - -GROUPS =3D [ - PatternGroup([ - # Batch 0: 4 clusters - Pattern('0x49', 0x0000000), - Pattern('0x6c', 0x0100000), # 1M - Pattern('0x6f', 0x2000000), # 32M - Pattern('0x76', 0x3ff0000)]), # 64M - 64K - PatternGroup([ - # Batch 1: 6 clusters (3 new) - Pattern('0x65', 0x0000000), # Full overwrite - Pattern('0x77', 0x00f8000), # Partial-left (1M-32K) - Pattern('0x72', 0x2008000), # Partial-right (32M+32K) - Pattern('0x69', 0x3fe0000)]), # Adjacent-left (64M - 128K) - PatternGroup([ - # Batch 2: 7 clusters (3 new) - Pattern('0x74', 0x0010000), # Adjacent-right - Pattern('0x69', 0x00e8000), # Partial-left (1M-96K) - Pattern('0x6e', 0x2018000), # Partial-right (32M+96K) - Pattern('0x67', 0x3fe0000, - 2*GRANULARITY)]), # Overwrite [(64M-128K)-64M) - PatternGroup([ - # Batch 3: 8 clusters (5 new) - # Carefully chosen such that nothing re-dirties the one cluster - # that copies out successfully before failure in Group #1. - Pattern('0xaa', 0x0010000, - 3*GRANULARITY), # Overwrite and 2x Adjacent-right - Pattern('0xbb', 0x00d8000), # Partial-left (1M-160K) - Pattern('0xcc', 0x2028000), # Partial-right (32M+160K) - Pattern('0xdd', 0x3fc0000)]), # New; leaving a gap to the right -] - - -class EmulatedBitmap: - def __init__(self, granularity=3DGRANULARITY): - self._bits =3D set() - self.granularity =3D granularity - - def dirty_bits(self, bits): - self._bits |=3D set(bits) - - def dirty_group(self, n): - self.dirty_bits(GROUPS[n].bits(self.granularity)) - - def clear(self): - self._bits =3D set() - - def clear_bits(self, bits): - self._bits -=3D set(bits) - - def clear_bit(self, bit): - self.clear_bits({bit}) - - def clear_group(self, n): - self.clear_bits(GROUPS[n].bits(self.granularity)) - - @property - def first_bit(self): - return sorted(self.bits)[0] - - @property - def bits(self): - return self._bits - - @property - def count(self): - return len(self.bits) - - def compare(self, qmp_bitmap): - """ - Print a nice human-readable message checking that a bitmap as repo= rted - by the QMP interface has as many bits set as we expect it to. - """ - - name =3D qmp_bitmap.get('name', '(anonymous)') - log("=3D Checking Bitmap {:s} =3D".format(name)) - - want =3D self.count - have =3D qmp_bitmap['count'] // qmp_bitmap['granularity'] - - log("expecting {:d} dirty sectors; have {:d}. {:s}".format( - want, have, "OK!" if want =3D=3D have else "ERROR!")) - log('') - - class Drive: """Represents, vaguely, a drive attached to a VM. Includes format, graph, and device information.""" diff --git a/tests/qemu-iotests/bitmaps.py b/tests/qemu-iotests/bitmaps.py new file mode 100644 index 000000000000..522fc25171d1 --- /dev/null +++ b/tests/qemu-iotests/bitmaps.py @@ -0,0 +1,131 @@ +# Bitmap-related helper utilities +# +# Copyright (c) 2020 John Snow for Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +# owner=3Djsnow@redhat.com + +from iotests import log + +GRANULARITY =3D 64 * 1024 + + +class Pattern: + def __init__(self, byte, offset, size=3DGRANULARITY): + self.byte =3D byte + self.offset =3D offset + self.size =3D size + + def bits(self, granularity): + lower =3D self.offset // granularity + upper =3D (self.offset + self.size - 1) // granularity + return set(range(lower, upper + 1)) + + +class PatternGroup: + """Grouping of Pattern objects. Initialize with an iterable of Pattern= s.""" + def __init__(self, patterns): + self.patterns =3D patterns + + def bits(self, granularity): + """Calculate the unique bits dirtied by this pattern grouping""" + res =3D set() + for pattern in self.patterns: + res |=3D pattern.bits(granularity) + return res + + +GROUPS =3D [ + PatternGroup([ + # Batch 0: 4 clusters + Pattern('0x49', 0x0000000), + Pattern('0x6c', 0x0100000), # 1M + Pattern('0x6f', 0x2000000), # 32M + Pattern('0x76', 0x3ff0000)]), # 64M - 64K + PatternGroup([ + # Batch 1: 6 clusters (3 new) + Pattern('0x65', 0x0000000), # Full overwrite + Pattern('0x77', 0x00f8000), # Partial-left (1M-32K) + Pattern('0x72', 0x2008000), # Partial-right (32M+32K) + Pattern('0x69', 0x3fe0000)]), # Adjacent-left (64M - 128K) + PatternGroup([ + # Batch 2: 7 clusters (3 new) + Pattern('0x74', 0x0010000), # Adjacent-right + Pattern('0x69', 0x00e8000), # Partial-left (1M-96K) + Pattern('0x6e', 0x2018000), # Partial-right (32M+96K) + Pattern('0x67', 0x3fe0000, + 2*GRANULARITY)]), # Overwrite [(64M-128K)-64M) + PatternGroup([ + # Batch 3: 8 clusters (5 new) + # Carefully chosen such that nothing re-dirties the one cluster + # that copies out successfully before failure in Group #1. + Pattern('0xaa', 0x0010000, + 3*GRANULARITY), # Overwrite and 2x Adjacent-right + Pattern('0xbb', 0x00d8000), # Partial-left (1M-160K) + Pattern('0xcc', 0x2028000), # Partial-right (32M+160K) + Pattern('0xdd', 0x3fc0000)]), # New; leaving a gap to the right +] + + +class EmulatedBitmap: + def __init__(self, granularity=3DGRANULARITY): + self._bits =3D set() + self.granularity =3D granularity + + def dirty_bits(self, bits): + self._bits |=3D set(bits) + + def dirty_group(self, n): + self.dirty_bits(GROUPS[n].bits(self.granularity)) + + def clear(self): + self._bits =3D set() + + def clear_bits(self, bits): + self._bits -=3D set(bits) + + def clear_bit(self, bit): + self.clear_bits({bit}) + + def clear_group(self, n): + self.clear_bits(GROUPS[n].bits(self.granularity)) + + @property + def first_bit(self): + return sorted(self.bits)[0] + + @property + def bits(self): + return self._bits + + @property + def count(self): + return len(self.bits) + + def compare(self, qmp_bitmap): + """ + Print a nice human-readable message checking that a bitmap as repo= rted + by the QMP interface has as many bits set as we expect it to. + """ + + name =3D qmp_bitmap.get('name', '(anonymous)') + log("=3D Checking Bitmap {:s} =3D".format(name)) + + want =3D self.count + have =3D qmp_bitmap['count'] // qmp_bitmap['granularity'] + + log("expecting {:d} dirty sectors; have {:d}. {:s}".format( + want, have, "OK!" if want =3D=3D have else "ERROR!")) + log('') --=20 2.27.0 From nobody Sat Feb 7 04:26:51 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1592596782; cv=none; d=zohomail.com; s=zohoarc; b=UwaFjQGO+g8osz2IrdFP4OT7Vu7gWrf8ptakPHjQ2t9M0C13evGdugInbspJCAmcBkgDb2drY2Fm1+lups9vNZatdkNiwhbKv2tTvLmqUJZ4MZ27/gkZmUb/9cU44YuJ0bW4T+1IeqzXEQx7OR3Z9/Kgs98oFS1Z2QXAjsGgvyY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1592596782; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Qn2fdAnTsHfGzHhQwUctUHkZ2+fpt8zc4ZymTnsk8Cc=; b=F67PlfQsvJWZc+cb+D8NP212NLjNLjtSvdwJhrLn9zpOFo0z+sP+taATaJQFP1KsTYx7+WHS2CiBsyR+zrng5XM4FG/deR7KlzJYY4pVW9m/amn2VCgwP+o81utYeXtghKfpn0uxdkJey77sdqNbsfrE9mj2684prj5y58rKGbg= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1592596782557890.0631939244489; Fri, 19 Jun 2020 12:59:42 -0700 (PDT) Received: from localhost ([::1]:33886 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jmNAq-000274-Cb for importer@patchew.org; Fri, 19 Jun 2020 15:59:40 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42992) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jmN83-0004pL-Dq for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:47 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:23394 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1jmN7z-0007fs-DK for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:47 -0400 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-233-iZn9lq_hPCaZsmOi2F7FYg-1; Fri, 19 Jun 2020 15:56:37 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 706B156C8E; Fri, 19 Jun 2020 19:56:36 +0000 (UTC) Received: from blue.redhat.com (ovpn-114-4.phx2.redhat.com [10.3.114.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E1E47166C; Fri, 19 Jun 2020 19:56:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1592596602; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Qn2fdAnTsHfGzHhQwUctUHkZ2+fpt8zc4ZymTnsk8Cc=; b=K8+NfTczil9zvuh3QE2P5Blop0Ar28MuOwOLvxvxMaVRwvp+VBsYLWq3SaXSDMCBcOW8z4 Hi2Vp16S+os9AhlxoryD2Wlx15gujSBfakoQdf4osCClpaqbcVe9oPeqrpybJ2P0mT6Suj q0I4Ogr+KwI/1TP25jfm7vLMTff/Aok= X-MC-Unique: iZn9lq_hPCaZsmOi2F7FYg-1 From: Eric Blake To: qemu-devel@nongnu.org Subject: [PATCH v3 5/6] iotests: add 298 for block-dirty-bitmap-populate Date: Fri, 19 Jun 2020 14:56:20 -0500 Message-Id: <20200619195621.58740-6-eblake@redhat.com> In-Reply-To: <20200619195621.58740-1-eblake@redhat.com> References: <20200619195621.58740-1-eblake@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=207.211.31.81; envelope-from=eblake@redhat.com; helo=us-smtp-delivery-1.mimecast.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/06/19 01:50:04 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -30 X-Spam_score: -3.1 X-Spam_bar: --- X-Spam_report: (-3.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H4=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=_AUTOLEARN X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, vsementsov@virtuozzo.com, qemu-block@nongnu.org, armbru@redhat.com, mreitz@redhat.com, pkrempa@redhat.com, jsnow@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-Type: text/plain; charset="utf-8" From: John Snow Give block-dirty-bitmap-populate a workout. Signed-off-by: John Snow Signed-off-by: Eric Blake --- tests/qemu-iotests/298 | 232 ++ tests/qemu-iotests/298.out | 4544 ++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 4777 insertions(+) create mode 100755 tests/qemu-iotests/298 create mode 100644 tests/qemu-iotests/298.out diff --git a/tests/qemu-iotests/298 b/tests/qemu-iotests/298 new file mode 100755 index 000000000000..4bfcecd3bc88 --- /dev/null +++ b/tests/qemu-iotests/298 @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +# +# Test block-dirty-bitmap-populate +# +# Copyright (c) 2020 John Snow for Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +# owner=3Djsnow@redhat.com + +from collections import namedtuple +import itertools +import math +import os + +import iotests +from iotests import log, qemu_img +from bitmaps import EmulatedBitmap, GROUPS + +SIZE =3D 64 * 1024 * 1024 +GRANULARITY =3D 64 * 1024 + + +class Drive: + def __init__(self, path, vm): + self.path =3D path + self.vm =3D vm + self.fmt =3D None + self.size =3D None + self.node =3D None + + def img_create(self, fmt, size): + self.fmt =3D fmt + self.size =3D size + iotests.qemu_img_create('-f', self.fmt, self.path, str(self.size)) + + +def block_dirty_bitmap_populate(vm, node, bitmap, job_id, pattern, **kwarg= s): + # Strip any arguments explicitly nulled by the caller: + kwargs =3D {key: val for key, val in kwargs.items() if val is not None} + result =3D vm.qmp_log('block-dirty-bitmap-populate', + node=3Dnode, + name=3Dbitmap, + job_id=3Djob_id, + pattern=3Dpattern, + **kwargs) + return result + + +def populate(drive, bitmap, job_id, pattern=3D'allocation-top', **kwargs): + kwargs.setdefault('pattern', pattern) + kwargs.setdefault('auto-finalize', False) + kwargs.setdefault('auto-dismiss', False) + ret =3D block_dirty_bitmap_populate(drive.vm, drive.node, + bitmap, job_id, **kwargs) + return { + 'id': job_id, + 'auto-finalize': kwargs['auto-finalize'], + 'auto-dismiss': kwargs['auto-dismiss'], + 'return': ret, + } + + +def perform_writes(drive, n, filter_node_name=3DNone): + log("-- Write #{:d}:".format(n)) + node_name =3D filter_node_name or drive.node + for pattern in GROUPS[n].patterns: + cmd =3D "write -P{:s} 0x{:07x} 0x{:x}".format( + pattern.byte, + pattern.offset, + pattern.size) + drive.vm.hmp_qemu_io(node_name, cmd, use_log=3DTrue) + log('') + + +TestConfig =3D namedtuple('TestConfig', [ + 'base_pattern', + 'disabled', + 'pre_writes', + 'mid_writes', + 'cancel', + 'post_writes', +]) + + +def test_bitmap_populate(config): + """ + Test bitmap populate. + + :param base_pattern: Write a base pattern? + :param disabled: Disable the target bitmap? + :param pre_writes: Write a pattern after bitmap creation, but before= job? + :param mid_writes: Write a pattern before job finalizes? + :param cancel: Cancel the job instead of finalizing it? + :param post_writes: Write a pattern after the job? + """ + with iotests.FilePaths(['img']) as (img_path,), iotests.VM() as vm: + log("\n=3D=3D=3D Bitmap Populate {:s} =3D=3D=3D\n".format(str(conf= ig))) + + log('-- Prepare image & VM:') + drive0 =3D Drive(img_path, vm=3Dvm) + drive0.img_create(iotests.imgfmt, SIZE) + vm.add_device("{},id=3Dscsi0".format(iotests.get_virtio_scsi_devic= e())) + vm.launch() + + file_config =3D { + 'driver': 'file', + 'filename': drive0.path + } + + drive0.node =3D 'drive0' + vm.qmp_log('blockdev-add', + filters=3D[iotests.filter_qmp_testfiles], + node_name=3Ddrive0.node, + driver=3Ddrive0.fmt, + file=3Dfile_config) + log('') + + + # Step 0: Prepare & Base Allocation Pattern + + if config.base_pattern: + perform_writes(drive0, 0) + + + # Step 1: Add test bitmap + + log('-- Add Bitmap:') + vm.qmp_log('block-dirty-bitmap-add', + node=3Ddrive0.node, + name=3D"target", + granularity=3DGRANULARITY, + disabled=3Dconfig.disabled) + ebitmap =3D EmulatedBitmap() + log('') + + # Step 2: Pre-Writes + + if config.pre_writes: + perform_writes(drive0, 1) + if not config.disabled: + ebitmap.dirty_group(1) + bitmap =3D vm.get_bitmap(drive0.node, 'target') + ebitmap.compare(bitmap) + + + # Step 3: Launch job & Mid-Writes + + log('-- Test block-dirty-bitmap-populate (bitpop0):') + def pre_finalize(): + # Writes issued prior to job finalization: + if config.mid_writes: + perform_writes(drive0, 2) + if not config.disabled: + ebitmap.dirty_group(2) + + job =3D populate(drive0, 'target', 'bitpop0') + assert job['return'] =3D=3D {'return': {}} + vm.run_job(job['id'], auto_dismiss=3Djob['auto-dismiss'], + auto_finalize=3Djob['auto-finalize'], + pre_finalize=3Dpre_finalize, + cancel=3Dconfig.cancel) + log('') + + + # Step 4: Post-job verification + + if not config.cancel: + # Any writes made prior to the job finishing should now be vis= ible. + if config.base_pattern: + ebitmap.dirty_group(0) + if config.pre_writes: + ebitmap.dirty_group(1) + if config.mid_writes: + ebitmap.dirty_group(2) + + bitmap =3D vm.get_bitmap(drive0.node, 'target') + ebitmap.compare(bitmap) + + + # Step 5: Post-Writes + + if config.post_writes: + perform_writes(drive0, 3) + if not config.disabled: + ebitmap.dirty_group(3) + + + # Step 6: Final Verification + + log('-- Verification:') + bitmaps =3D vm.query_bitmaps() + log({'bitmaps': bitmaps}, indent=3D2) + log('') + bitmap =3D vm.get_bitmap(drive0.node, 'target', bitmaps=3Dbitmaps) + ebitmap.compare(bitmap) + + + log('-- Cleanup:') + vm.qmp_log("block-dirty-bitmap-remove", + node=3Ddrive0.node, name=3D"target") + + bitmaps =3D vm.query_bitmaps() + if bitmaps: + log("ERROR: bitmaps unaccounted for:") + log(bitmaps) + else: + log('OK: All bitmaps removed') + vm.shutdown() + log('') + + +def main(): + for args in itertools.product((True, False), repeat=3D6): + cfg =3D TestConfig(*args) + test_bitmap_populate(cfg) + + +if __name__ =3D=3D '__main__': + iotests.script_main(main, supported_fmts=3D['qcow2'], + supported_protocols=3D['file']) diff --git a/tests/qemu-iotests/298.out b/tests/qemu-iotests/298.out new file mode 100644 index 000000000000..7c0afc71920c --- /dev/null +++ b/tests/qemu-iotests/298.out @@ -0,0 +1,4544 @@ + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFalse)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFalse)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 262144, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DTrue,= pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 262144, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 983040, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 15 dirty sectors; have 15. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 983040, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 15 dirty sectors; have 15. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 917504, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 14 dirty sectors; have 14. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 393216, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 983040, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 15 dirty sectors; have 15. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 786432, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 12 dirty sectors; have 12. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 983040, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 15 dirty sectors; have 15. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 524288, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 8 dirty sectors; have 8. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTru= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 786432, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 12 dirty sectors; have 12. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DTrue, disabled=3DFalse= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFal= se) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Write #0: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x49 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6c 0x0100000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6f 0x2000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x76 0x3ff0000 0x10000\""}} +{"return": ""} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 262144, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 4 dirty sectors; have 4. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue) = =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 393216, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 393216, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTru= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DTrue= , pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFal= se) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": true, "gra= nularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": false, + "status": "disabled" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue)= =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 983040, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 15 dirty sectors; have 15. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFalse= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 983040, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 15 dirty sectors; have 15. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 655360, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 10 dirty sectors; have 10. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 917504, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 14 dirty sectors; have 14. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 393216, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTru= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 917504, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 14 dirty sectors; have 14. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DTrue, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFal= se) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Write #1: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x65 0x0000000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x77 0x00f8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x72 0x2008000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x3fe0000 0x10000\""}} +{"return": ""} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 393216, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 6 dirty sectors; have 6. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DTrue= ) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 786432, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 12 dirty sectors; have 12. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DTrue, post_writes=3DFals= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DTru= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 786432, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 12 dirty sectors; have 12. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DTrue, cancel=3DFalse, post_writes=3DFal= se) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +-- Write #2: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x69 0x00e8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x6e 0x2018000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x67 0x3fe0000 0x20000\""}} +{"return": ""} + +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 458752, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 7 dirty sectors; have 7. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DTru= e) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 524288, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 8 dirty sectors; have 8. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DTrue, post_writes=3DFal= se) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-cancel", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +Job failed: Operation canceled +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_CANCELLED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DTr= ue) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Write #3: +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xaa 0x0010000 0x30000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xbb 0x00d8000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xcc 0x2028000 0x10000\""}} +{"return": ""} +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0xdd 0x3fc0000 0x10000\""}} +{"return": ""} + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 524288, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 8 dirty sectors; have 8. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + + +=3D=3D=3D Bitmap Populate TestConfig(base_pattern=3DFalse, disabled=3DFals= e, pre_writes=3DFalse, mid_writes=3DFalse, cancel=3DFalse, post_writes=3DFa= lse) =3D=3D=3D + +-- Prepare image & VM: +{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"dri= ver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}} +{"return": {}} + +-- Add Bitmap: +{"execute": "block-dirty-bitmap-add", "arguments": {"disabled": false, "gr= anularity": 65536, "name": "target", "node": "drive0"}} +{"return": {}} + +-- Test block-dirty-bitmap-populate (bitpop0): +{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"return": {}} +{"execute": "job-finalize", "arguments": {"id": "bitpop0"}} +{"return": {}} +{"data": {"id": "bitpop0", "type": "bitmap-populate"}, "event": "BLOCK_JOB= _PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "bitpop0", "len": 67108864, "offset": 67108864, "speed= ": 0, "type": "bitmap-populate"}, "event": "BLOCK_JOB_COMPLETED", "timestam= p": {"microseconds": "USECS", "seconds": "SECS"}} +{"execute": "job-dismiss", "arguments": {"id": "bitpop0"}} +{"return": {}} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Verification: +{ + "bitmaps": { + "drive0": [ + { + "busy": false, + "count": 0, + "granularity": 65536, + "name": "target", + "persistent": false, + "recording": true, + "status": "active" + } + ] + } +} + +=3D Checking Bitmap target =3D +expecting 0 dirty sectors; have 0. OK! + +-- Cleanup: +{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "target", "= node": "drive0"}} +{"return": {}} +OK: All bitmaps removed + diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index d886fa0cb355..9146aae84081 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -302,3 +302,4 @@ 291 rw quick 292 rw auto quick 297 meta +298 rw --=20 2.27.0 From nobody Sat Feb 7 04:26:51 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1592596831; cv=none; d=zohomail.com; s=zohoarc; b=lPVEQKjUyvgCMkCwLVEzadGlG0KSaE/o/SKP9HVdvdRi782aAqUlKzvuv7ZAan3OZKRkCLdrbUwJ9HtqnPjrMlN0u9nVeQ4Q37WAcr7JRCnnq/56JGiY9zWFT6l8OosIA0kgKuGbyg6800x1lVpWHllvB3NjkIbN/ducG+clDDI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1592596831; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=wwz7B0a4kmWj+6y73X0oaEKUPbUEAsp0c5c8Gw4VBkU=; b=Nhfhuc+PlVw5eV6G5hBBGLd54ZmyS1fTtS421FJyeCnYorT47h/YqXXbGMSmBFHOD/jGvtePMomVLGEbL/4Q210TVRrJkaaHYwEnOc2Nb1xbJBT/h52pYa2YMfuBGMldGI+JbYmG0u6UQ9YHrv37CXg/JR2g4klzKwwkx+V0pSI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 159259683125498.64067569285521; Fri, 19 Jun 2020 13:00:31 -0700 (PDT) Received: from localhost ([::1]:36616 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jmNBd-0003Ei-Qi for importer@patchew.org; Fri, 19 Jun 2020 16:00:29 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43032) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jmN8B-00058B-2U for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:55 -0400 Received: from us-smtp-delivery-1.mimecast.com ([207.211.31.120]:60018 helo=us-smtp-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1jmN87-0007gZ-9G for qemu-devel@nongnu.org; Fri, 19 Jun 2020 15:56:54 -0400 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-103-b56y-7G3PuiYmN0pTFFRXQ-1; Fri, 19 Jun 2020 15:56:48 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id A6D5564A7B; Fri, 19 Jun 2020 19:56:47 +0000 (UTC) Received: from blue.redhat.com (ovpn-114-4.phx2.redhat.com [10.3.114.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id AD2697166C; Fri, 19 Jun 2020 19:56:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1592596610; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=wwz7B0a4kmWj+6y73X0oaEKUPbUEAsp0c5c8Gw4VBkU=; b=aUPDaBFhB5tUCAxfqN6oK6+YlVcQXjoxlf2+ChJGLPTKvS5WS2TMyhXWTWkp0sJfP66Xka XoetRBbIugdHCBkVi32eNEMQ+So866rQI10NmFatFPQxdyRMDejBFtgLW6JXLfTYTL7kPb tjg7lE75aNDB0RVW8ZD2Knv1yAiTT78= X-MC-Unique: b56y-7G3PuiYmN0pTFFRXQ-1 From: Eric Blake To: qemu-devel@nongnu.org Subject: [PATCH v3 6/6] bitmaps: Use x- prefix for block-dirty-bitmap-popluate Date: Fri, 19 Jun 2020 14:56:21 -0500 Message-Id: <20200619195621.58740-7-eblake@redhat.com> In-Reply-To: <20200619195621.58740-1-eblake@redhat.com> References: <20200619195621.58740-1-eblake@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=207.211.31.120; envelope-from=eblake@redhat.com; helo=us-smtp-1.mimecast.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/06/19 03:15:03 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -30 X-Spam_score: -3.1 X-Spam_bar: --- X-Spam_report: (-3.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=_AUTOLEARN X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, vsementsov@virtuozzo.com, qemu-block@nongnu.org, armbru@redhat.com, mreitz@redhat.com, pkrempa@redhat.com, jsnow@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-Type: text/plain; charset="utf-8" Give ourselves an out if we need to tweak the interface, in order to gain more experience with what works when libvirt experiments with using it. Signed-off-by: Eric Blake --- qapi/block-core.json | 6 +- qapi/transaction.json | 4 +- blockdev.c | 14 ++-- tests/qemu-iotests/298 | 2 +- tests/qemu-iotests/298.out | 128 ++++++++++++++++++------------------- 5 files changed, 77 insertions(+), 77 deletions(-) diff --git a/qapi/block-core.json b/qapi/block-core.json index 313583b47c16..dcf6b907e45c 100644 --- a/qapi/block-core.json +++ b/qapi/block-core.json @@ -2260,7 +2260,7 @@ '*auto-dismiss': 'bool' } } ## -# @block-dirty-bitmap-populate: +# @x-block-dirty-bitmap-populate: # # Creates a new job that writes a pattern into a dirty bitmap. # @@ -2268,13 +2268,13 @@ # # Example: # -# -> { "execute": "block-dirty-bitmap-populate", +# -> { "execute": "x-block-dirty-bitmap-populate", # "arguments": { "node": "drive0", "target": "bitmap0", # "job-id": "job0", "pattern": "allocate-top" } } # <- { "return": {} } # ## -{ 'command': 'block-dirty-bitmap-populate', 'boxed': true, +{ 'command': 'x-block-dirty-bitmap-populate', 'boxed': true, 'data': 'BlockDirtyBitmapPopulate' } ## diff --git a/qapi/transaction.json b/qapi/transaction.json index 21be59faae56..3277e948f321 100644 --- a/qapi/transaction.json +++ b/qapi/transaction.json @@ -50,7 +50,7 @@ # - @block-dirty-bitmap-enable: since 4.0 # - @block-dirty-bitmap-disable: since 4.0 # - @block-dirty-bitmap-merge: since 4.0 -# - @block-dirty-bitmap-populate: since 5.1 +# - @x-block-dirty-bitmap-populate: since 5.1 # - @blockdev-backup: since 2.3 # - @blockdev-snapshot: since 2.5 # - @blockdev-snapshot-internal-sync: since 1.7 @@ -68,7 +68,7 @@ 'block-dirty-bitmap-enable': 'BlockDirtyBitmap', 'block-dirty-bitmap-disable': 'BlockDirtyBitmap', 'block-dirty-bitmap-merge': 'BlockDirtyBitmapMerge', - 'block-dirty-bitmap-populate': 'BlockDirtyBitmapPopulate', + 'x-block-dirty-bitmap-populate': 'BlockDirtyBitmapPopulate', 'blockdev-backup': 'BlockdevBackup', 'blockdev-snapshot': 'BlockdevSnapshot', 'blockdev-snapshot-internal-sync': 'BlockdevSnapshotInternal', diff --git a/blockdev.c b/blockdev.c index d072519e7b91..b86ef5b7f281 100644 --- a/blockdev.c +++ b/blockdev.c @@ -2188,8 +2188,8 @@ static void block_dirty_bitmap_populate_prepare(BlkAc= tionState *common, int job_flags =3D JOB_DEFAULT; assert(common->action->type =3D=3D - TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_POPULATE); - bitpop =3D common->action->u.block_dirty_bitmap_populate.data; + TRANSACTION_ACTION_KIND_X_BLOCK_DIRTY_BITMAP_POPULATE); + bitpop =3D common->action->u.x_block_dirty_bitmap_populate.data; bmap =3D block_dirty_bitmap_lookup(bitpop->node, bitpop->name, &bs, er= rp); if (!bmap) { @@ -2317,7 +2317,7 @@ static const BlkActionOps actions[] =3D { .commit =3D block_dirty_bitmap_remove_commit, .abort =3D block_dirty_bitmap_remove_abort, }, - [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_POPULATE] =3D { + [TRANSACTION_ACTION_KIND_X_BLOCK_DIRTY_BITMAP_POPULATE] =3D { .instance_size =3D sizeof(BlockJobActionState), .prepare =3D block_dirty_bitmap_populate_prepare, .commit =3D blockdev_backup_commit, @@ -2443,12 +2443,12 @@ void qmp_block_passwd(bool has_device, const char *= device, "Setting block passwords directly is no longer supported"); } -void qmp_block_dirty_bitmap_populate(BlockDirtyBitmapPopulate *bitpop, - Error **errp) +void qmp_x_block_dirty_bitmap_populate(BlockDirtyBitmapPopulate *bitpop, + Error **errp) { TransactionAction action =3D { - .type =3D TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_POPULATE, - .u.block_dirty_bitmap_populate.data =3D bitpop, + .type =3D TRANSACTION_ACTION_KIND_X_BLOCK_DIRTY_BITMAP_POPULATE, + .u.x_block_dirty_bitmap_populate.data =3D bitpop, }; blockdev_do_action(&action, errp); } diff --git a/tests/qemu-iotests/298 b/tests/qemu-iotests/298 index 4bfcecd3bc88..2a3df2de85db 100755 --- a/tests/qemu-iotests/298 +++ b/tests/qemu-iotests/298 @@ -49,7 +49,7 @@ class Drive: def block_dirty_bitmap_populate(vm, node, bitmap, job_id, pattern, **kwarg= s): # Strip any arguments explicitly nulled by the caller: kwargs =3D {key: val for key, val in kwargs.items() if val is not None} - result =3D vm.qmp_log('block-dirty-bitmap-populate', + result =3D vm.qmp_log('x-block-dirty-bitmap-populate', node=3Dnode, name=3Dbitmap, job_id=3Djob_id, diff --git a/tests/qemu-iotests/298.out b/tests/qemu-iotests/298.out index 7c0afc71920c..8b75f0e516c0 100644 --- a/tests/qemu-iotests/298.out +++ b/tests/qemu-iotests/298.out @@ -33,7 +33,7 @@ expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -126,7 +126,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -209,7 +209,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -301,7 +301,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -383,7 +383,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -466,7 +466,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -539,7 +539,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -621,7 +621,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -680,7 +680,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -760,7 +760,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -830,7 +830,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -909,7 +909,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -978,7 +978,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1048,7 +1048,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1108,7 +1108,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1177,7 +1177,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1249,7 +1249,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -1342,7 +1342,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -1425,7 +1425,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -1517,7 +1517,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -1599,7 +1599,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1682,7 +1682,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1755,7 +1755,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1837,7 +1837,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -1896,7 +1896,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -1976,7 +1976,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2046,7 +2046,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2125,7 +2125,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2194,7 +2194,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2264,7 +2264,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2324,7 +2324,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2393,7 +2393,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2455,7 +2455,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2538,7 +2538,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2611,7 +2611,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2693,7 +2693,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -2765,7 +2765,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2838,7 +2838,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2901,7 +2901,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -2973,7 +2973,7 @@ OK: All bitmaps removed expecting 0 dirty sectors; have 0. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3022,7 +3022,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3092,7 +3092,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3152,7 +3152,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3221,7 +3221,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3280,7 +3280,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3340,7 +3340,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3390,7 +3390,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3449,7 +3449,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3511,7 +3511,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3594,7 +3594,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3667,7 +3667,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3749,7 +3749,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -3821,7 +3821,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3894,7 +3894,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -3957,7 +3957,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -4029,7 +4029,7 @@ OK: All bitmaps removed expecting 6 dirty sectors; have 6. OK! -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -4078,7 +4078,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -4148,7 +4148,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -4208,7 +4208,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -4277,7 +4277,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} -- Write #2: {"execute": "human-monitor-command", "arguments": {"command-line": "qemu-i= o drive0 \"write -P0x74 0x0010000 0x10000\""}} @@ -4336,7 +4336,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -4396,7 +4396,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-cancel", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -4446,7 +4446,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} @@ -4505,7 +4505,7 @@ OK: All bitmaps removed {"return": {}} -- Test block-dirty-bitmap-populate (bitpop0): -{"execute": "block-dirty-bitmap-populate", "arguments": {"auto-dismiss": f= alse, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "node"= : "drive0", "pattern": "allocation-top"}} +{"execute": "x-block-dirty-bitmap-populate", "arguments": {"auto-dismiss":= false, "auto-finalize": false, "job-id": "bitpop0", "name": "target", "nod= e": "drive0", "pattern": "allocation-top"}} {"return": {}} {"execute": "job-finalize", "arguments": {"id": "bitpop0"}} {"return": {}} --=20 2.27.0