239 lines
9.6 KiB
Diff
239 lines
9.6 KiB
Diff
From 629e54cc030235909720da73d6367fc0b703d062 Mon Sep 17 00:00:00 2001
|
|
Message-Id: <629e54cc030235909720da73d6367fc0b703d062@dist-git>
|
|
From: Peter Krempa <pkrempa@redhat.com>
|
|
Date: Tue, 23 Jun 2020 12:23:56 +0200
|
|
Subject: [PATCH] qemu: block: Add universal helper for merging dirty bitmaps
|
|
for all scenarios
|
|
MIME-Version: 1.0
|
|
Content-Type: text/plain; charset=UTF-8
|
|
Content-Transfer-Encoding: 8bit
|
|
|
|
Add a function which allows merging bitmaps according to the new
|
|
semantics and will allow replacing all the specific ad-hoc functions
|
|
currently in use for 'backup', 'block commit', 'block copy' and will
|
|
also be usable in the future for 'block pull' and non-shared storage
|
|
migration.
|
|
|
|
The semantics are a bit quirky for the 'backup' case but these quirks
|
|
are documented and will prevent us from having two slightly different
|
|
algorithms.
|
|
|
|
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
|
|
Reviewed-by: Eric Blake <eblake@redhat.com>
|
|
(cherry picked from commit 4fa8654eced8b0362d3f3ff33eebb108fe833869)
|
|
https://bugzilla.redhat.com/show_bug.cgi?id=1804593
|
|
Message-Id: <25acdc313844a20a9c884048498c42b9a8105de7.1592906423.git.pkrempa@redhat.com>
|
|
Reviewed-by: Ján Tomko <jtomko@redhat.com>
|
|
---
|
|
src/qemu/qemu_block.c | 172 ++++++++++++++++++++++++++++++++++++++++++
|
|
src/qemu/qemu_block.h | 10 +++
|
|
2 files changed, 182 insertions(+)
|
|
|
|
diff --git a/src/qemu/qemu_block.c b/src/qemu/qemu_block.c
|
|
index 38c8269721..b2296c2b4c 100644
|
|
--- a/src/qemu/qemu_block.c
|
|
+++ b/src/qemu/qemu_block.c
|
|
@@ -2832,6 +2832,178 @@ qemuBlockGetNamedNodeData(virDomainObjPtr vm,
|
|
}
|
|
|
|
|
|
+/**
|
|
+ * qemuBlockGetBitmapMergeActionsGetBitmaps:
|
|
+ *
|
|
+ * Collect a list of bitmaps which need to be handled in
|
|
+ * qemuBlockGetBitmapMergeActions. The list contains only valid bitmaps in the
|
|
+ * sub-chain which is being processed.
|
|
+ *
|
|
+ * Note that the returned GSList contains bitmap names string pointers borrowed
|
|
+ * from @blockNamedNodeData so they must not be freed.
|
|
+ */
|
|
+static GSList *
|
|
+qemuBlockGetBitmapMergeActionsGetBitmaps(virStorageSourcePtr topsrc,
|
|
+ const char *bitmapname,
|
|
+ virHashTablePtr blockNamedNodeData)
|
|
+{
|
|
+ g_autoptr(GSList) ret = NULL;
|
|
+ qemuBlockNamedNodeDataPtr entry;
|
|
+ size_t i;
|
|
+
|
|
+ /* for now it doesn't make sense to consider bitmaps which are not present
|
|
+ * in @topsrc as we can't recreate a bitmap for a layer if it's missing */
|
|
+
|
|
+ if (!(entry = virHashLookup(blockNamedNodeData, topsrc->nodeformat)))
|
|
+ return NULL;
|
|
+
|
|
+ for (i = 0; i < entry->nbitmaps; i++) {
|
|
+ qemuBlockNamedNodeDataBitmapPtr bitmap = entry->bitmaps[i];
|
|
+
|
|
+ if (bitmapname &&
|
|
+ STRNEQ(bitmapname, bitmap->name))
|
|
+ continue;
|
|
+
|
|
+ if (!qemuBlockBitmapChainIsValid(topsrc, bitmap->name, blockNamedNodeData))
|
|
+ continue;
|
|
+
|
|
+ ret = g_slist_prepend(ret, bitmap->name);
|
|
+ }
|
|
+
|
|
+ return g_steal_pointer(&ret);
|
|
+}
|
|
+
|
|
+
|
|
+/**
|
|
+ * qemuBlockGetBitmapMergeActions:
|
|
+ * @topsrc: top of the chain to merge bitmaps in
|
|
+ * @basesrc: bottom of the chain to merge bitmaps in (NULL for full chain)
|
|
+ * @target: destination storage source of the merge (may be part of original chain)
|
|
+ * @bitmapname: name of bitmap to perform the merge (NULL for all bitmaps)
|
|
+ * @dstbitmapname: name of destination bitmap of the merge (see below for caveats)
|
|
+ * @writebitmapsrc: storage source corresponding to the node containing the write temporary bitmap
|
|
+ * @actions: returns actions for a 'transaction' QMP command for executing the merge
|
|
+ * @blockNamedNodeData: hash table filled with qemuBlockNamedNodeData
|
|
+ *
|
|
+ * Calculate handling of dirty block bitmaps between @topsrc and @basesrc. If
|
|
+ * @basesrc is NULL the end of the chain is considered. @target is the destination
|
|
+ * storage source definition of the merge and may or may not be part of the
|
|
+ * merged chain.
|
|
+ *
|
|
+ * Specifically the merging algorithm ensures that each considered bitmap is
|
|
+ * merged with the appropriate bitmaps so that it properly describes
|
|
+ * the state of dirty blocks when looked at from @topsrc based on the depth
|
|
+ * of the backing chain where the bitmap is placed.
|
|
+ *
|
|
+ * If @bitmapname is non-NULL only bitmaps with that name are handled, otherwise
|
|
+ * all bitmaps are considered.
|
|
+ *
|
|
+ * If @dstbitmap is non-NULL everything is merged into a bitmap with that name,
|
|
+ * otherwise each bitmap is merged into a bitmap with the same name into @target.
|
|
+ * Additionally if @dstbitmap is non-NULL the target bitmap is created as 'inactive'
|
|
+ * and 'transient' as a special case for the backup operation.
|
|
+ *
|
|
+ * If @writebitmapsrc is non-NULL, the 'libvirt-tmp-activewrite' bitmap from
|
|
+ * given node is merged along with others. This bitmap corresponds to the writes
|
|
+ * which occurred between an active layer job finished and the rest of the bitmap
|
|
+ * merging.
|
|
+ *
|
|
+ * If the bitmap is not valid somehow (see qemuBlockBitmapChainIsValid) given
|
|
+ * bitmap is silently skipped, so callers must ensure that given bitmap is valid
|
|
+ * if they care about it.
|
|
+ *
|
|
+ * The resulting 'transaction' QMP command actions are filled in and returned via
|
|
+ * @actions.
|
|
+ *
|
|
+ * Note that @actions may be NULL if no merging is required.
|
|
+ */
|
|
+int
|
|
+qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
|
|
+ virStorageSourcePtr basesrc,
|
|
+ virStorageSourcePtr target,
|
|
+ const char *bitmapname,
|
|
+ const char *dstbitmapname,
|
|
+ virStorageSourcePtr writebitmapsrc,
|
|
+ virJSONValuePtr *actions,
|
|
+ virHashTablePtr blockNamedNodeData)
|
|
+{
|
|
+ g_autoptr(virJSONValue) act = virJSONValueNewArray();
|
|
+ virStorageSourcePtr n;
|
|
+
|
|
+ g_autoptr(GSList) bitmaps = NULL;
|
|
+ GSList *next;
|
|
+
|
|
+ if (!(bitmaps = qemuBlockGetBitmapMergeActionsGetBitmaps(topsrc, bitmapname,
|
|
+ blockNamedNodeData)))
|
|
+ return 0;
|
|
+
|
|
+ for (next = bitmaps; next; next = next->next) {
|
|
+ const char *curbitmap = next->data;
|
|
+ const char *mergebitmapname = dstbitmapname;
|
|
+ bool mergebitmappersistent = false;
|
|
+ bool mergebitmapdisabled = true;
|
|
+ g_autoptr(virJSONValue) merge = virJSONValueNewArray();
|
|
+ unsigned long long granularity = 0;
|
|
+ qemuBlockNamedNodeDataBitmapPtr bitmap;
|
|
+
|
|
+ /* explicitly named destinations mean that we want a temporary
|
|
+ * disabled bitmap only, so undo the default for non-explicit cases */
|
|
+ if (!mergebitmapname) {
|
|
+ mergebitmapname = curbitmap;
|
|
+ mergebitmappersistent = true;
|
|
+ mergebitmapdisabled = false;
|
|
+ }
|
|
+
|
|
+ for (n = topsrc; virStorageSourceIsBacking(n) && n != basesrc; n = n->backingStore) {
|
|
+ if (!(bitmap = qemuBlockNamedNodeDataGetBitmapByName(blockNamedNodeData,
|
|
+ n, curbitmap)))
|
|
+ continue;
|
|
+
|
|
+ if (granularity == 0)
|
|
+ granularity = bitmap->granularity;
|
|
+
|
|
+ if (qemuMonitorTransactionBitmapMergeSourceAddBitmap(merge,
|
|
+ n->nodeformat,
|
|
+ bitmap->name) < 0)
|
|
+ return -1;
|
|
+ }
|
|
+
|
|
+ if (dstbitmapname ||
|
|
+ !(bitmap = qemuBlockNamedNodeDataGetBitmapByName(blockNamedNodeData,
|
|
+ target, curbitmap))) {
|
|
+
|
|
+ if (qemuMonitorTransactionBitmapAdd(act,
|
|
+ target->nodeformat,
|
|
+ mergebitmapname,
|
|
+ mergebitmappersistent,
|
|
+ mergebitmapdisabled,
|
|
+ granularity) < 0)
|
|
+ return -1;
|
|
+ }
|
|
+
|
|
+ if (writebitmapsrc &&
|
|
+ qemuMonitorTransactionBitmapMergeSourceAddBitmap(merge,
|
|
+ writebitmapsrc->nodeformat,
|
|
+ "libvirt-tmp-activewrite") < 0)
|
|
+ return -1;
|
|
+
|
|
+ if (qemuMonitorTransactionBitmapMerge(act, target->nodeformat,
|
|
+ mergebitmapname, &merge) < 0)
|
|
+ return -1;
|
|
+ }
|
|
+
|
|
+ if (writebitmapsrc &&
|
|
+ qemuMonitorTransactionBitmapRemove(act, writebitmapsrc->nodeformat,
|
|
+ "libvirt-tmp-activewrite") < 0)
|
|
+ return -1;
|
|
+
|
|
+ if (virJSONValueArraySize(act) > 0)
|
|
+ *actions = g_steal_pointer(&act);
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+
|
|
/**
|
|
* qemuBlockBitmapChainIsValid:
|
|
*
|
|
diff --git a/src/qemu/qemu_block.h b/src/qemu/qemu_block.h
|
|
index 06afa54115..2500390734 100644
|
|
--- a/src/qemu/qemu_block.h
|
|
+++ b/src/qemu/qemu_block.h
|
|
@@ -221,6 +221,16 @@ virHashTablePtr
|
|
qemuBlockGetNamedNodeData(virDomainObjPtr vm,
|
|
qemuDomainAsyncJob asyncJob);
|
|
|
|
+int
|
|
+qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
|
|
+ virStorageSourcePtr basesrc,
|
|
+ virStorageSourcePtr target,
|
|
+ const char *bitmapname,
|
|
+ const char *dstbitmapname,
|
|
+ virStorageSourcePtr writebitmapsrc,
|
|
+ virJSONValuePtr *actions,
|
|
+ virHashTablePtr blockNamedNodeData);
|
|
+
|
|
bool
|
|
qemuBlockBitmapChainIsValid(virStorageSourcePtr src,
|
|
const char *bitmapname,
|
|
--
|
|
2.27.0
|
|
|