* [Qemu-devel] [PATCH v13 01/19] block: Add bdrv_drain_all_{begin, end}()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 02/19] block: Pause all jobs during bdrv_reopen_multiple() Alberto Garcia
` (18 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia, Paolo Bonzini
bdrv_drain_all() doesn't allow the caller to do anything after all
pending requests have been completed but before block jobs are
resumed.
This patch splits bdrv_drain_all() into _begin() and _end() for that
purpose. It also adds aio_{disable,enable}_external() calls to disable
external clients in the meantime.
An important restriction of this split is that no new block jobs or
BlockDriverStates can be created between the bdrv_drain_all_begin()
and bdrv_drain_all_end() calls. This is not a concern now because
we'll only be using this in bdrv_reopen_multiple(), but it must be
dealt with if we ever have other uses cases in the future.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block/io.c | 27 ++++++++++++++++++++++++---
include/block/block.h | 2 ++
2 files changed, 26 insertions(+), 3 deletions(-)
diff --git a/block/io.c b/block/io.c
index b136c89..d694336 100644
--- a/block/io.c
+++ b/block/io.c
@@ -275,8 +275,14 @@ void bdrv_drain(BlockDriverState *bs)
*
* This function does not flush data to disk, use bdrv_flush_all() for that
* after calling this function.
+ *
+ * This pauses all block jobs and disables external clients. It must
+ * be paired with bdrv_drain_all_end().
+ *
+ * NOTE: no new block jobs or BlockDriverStates can be created between
+ * the bdrv_drain_all_begin() and bdrv_drain_all_end() calls.
*/
-void bdrv_drain_all(void)
+void bdrv_drain_all_begin(void)
{
/* Always run first iteration so any pending completion BHs run */
bool busy = true;
@@ -300,6 +306,7 @@ void bdrv_drain_all(void)
bdrv_parent_drained_begin(bs);
bdrv_io_unplugged_begin(bs);
bdrv_drain_recurse(bs);
+ aio_disable_external(aio_context);
aio_context_release(aio_context);
if (!g_slist_find(aio_ctxs, aio_context)) {
@@ -333,17 +340,25 @@ void bdrv_drain_all(void)
}
}
+ g_slist_free(aio_ctxs);
+}
+
+void bdrv_drain_all_end(void)
+{
+ BlockDriverState *bs;
+ BdrvNextIterator it;
+ BlockJob *job = NULL;
+
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
AioContext *aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
+ aio_enable_external(aio_context);
bdrv_io_unplugged_end(bs);
bdrv_parent_drained_end(bs);
aio_context_release(aio_context);
}
- g_slist_free(aio_ctxs);
- job = NULL;
while ((job = block_job_next(job))) {
AioContext *aio_context = blk_get_aio_context(job->blk);
@@ -353,6 +368,12 @@ void bdrv_drain_all(void)
}
}
+void bdrv_drain_all(void)
+{
+ bdrv_drain_all_begin();
+ bdrv_drain_all_end();
+}
+
/**
* Remove an active request from the tracked requests list
*
diff --git a/include/block/block.h b/include/block/block.h
index 107c603..301d713 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -338,6 +338,8 @@ int bdrv_flush_all(void);
void bdrv_close_all(void);
void bdrv_drain(BlockDriverState *bs);
void coroutine_fn bdrv_co_drain(BlockDriverState *bs);
+void bdrv_drain_all_begin(void);
+void bdrv_drain_all_end(void);
void bdrv_drain_all(void);
int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int count);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 02/19] block: Pause all jobs during bdrv_reopen_multiple()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 01/19] block: Add bdrv_drain_all_{begin, end}() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 03/19] block: Add block_job_add_bdrv() Alberto Garcia
` (17 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
When a BlockDriverState is about to be reopened it can trigger certain
operations that need to write to disk. During this process a different
block job can be woken up. If that block job completes and also needs
to call bdrv_reopen() it can happen that it needs to do it on the same
BlockDriverState that is still in the process of being reopened.
This can have fatal consequences, like in this example:
1) Block job A starts and sleeps after a while.
2) Block job B starts and tries to reopen node1 (a qcow2 file).
3) Reopening node1 means flushing and replacing its qcow2 cache.
4) While the qcow2 cache is being flushed, job A wakes up.
5) Job A completes and reopens node1, replacing its cache.
6) Job B resumes, but the cache that was being flushed no longer
exists.
This patch splits the bdrv_drain_all() call to keep all block jobs
paused during bdrv_reopen_multiple(), so that step 4 can never happen
and the operation is safe.
Note that this scenario can only happen if both bdrv_reopen() calls
are made by block jobs on the same backing chain. Otherwise there's no
chance that the same BlockDriverState appears in both reopen queues.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/block.c b/block.c
index 7f3e7bc..adbecd0 100644
--- a/block.c
+++ b/block.c
@@ -2090,7 +2090,7 @@ int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
assert(bs_queue != NULL);
- bdrv_drain_all();
+ bdrv_drain_all_begin();
QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
@@ -2120,6 +2120,9 @@ cleanup:
g_free(bs_entry);
}
g_free(bs_queue);
+
+ bdrv_drain_all_end();
+
return ret;
}
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 03/19] block: Add block_job_add_bdrv()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 01/19] block: Add bdrv_drain_all_{begin, end}() Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 02/19] block: Pause all jobs during bdrv_reopen_multiple() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 04/19] block: Use block_job_add_bdrv() in mirror_start_job() Alberto Garcia
` (16 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
When a block job is created on a certain BlockDriverState, operations
are blocked there while the job exists. However, some block jobs may
involve additional BDSs, which must be blocked separately when the job
is created and unblocked manually afterwards.
This patch adds block_job_add_bdrv(), that simplifies this process by
keeping a list of BDSs that are involved in the specified block job.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
blockjob.c | 17 +++++++++++++++--
include/block/blockjob.h | 14 ++++++++++++++
2 files changed, 29 insertions(+), 2 deletions(-)
diff --git a/blockjob.c b/blockjob.c
index 43fecbe..c67c46d 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -117,6 +117,13 @@ static void block_job_detach_aio_context(void *opaque)
block_job_unref(job);
}
+void block_job_add_bdrv(BlockJob *job, BlockDriverState *bs)
+{
+ job->nodes = g_slist_prepend(job->nodes, bs);
+ bdrv_ref(bs);
+ bdrv_op_block_all(bs, job->blocker);
+}
+
void *block_job_create(const char *job_id, const BlockJobDriver *driver,
BlockDriverState *bs, int64_t speed,
BlockCompletionFunc *cb, void *opaque, Error **errp)
@@ -154,7 +161,7 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
job = g_malloc0(driver->instance_size);
error_setg(&job->blocker, "block device is in use by block job: %s",
BlockJobType_lookup[driver->job_type]);
- bdrv_op_block_all(bs, job->blocker);
+ block_job_add_bdrv(job, bs);
bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
job->driver = driver;
@@ -193,9 +200,15 @@ void block_job_ref(BlockJob *job)
void block_job_unref(BlockJob *job)
{
if (--job->refcnt == 0) {
+ GSList *l;
BlockDriverState *bs = blk_bs(job->blk);
bs->job = NULL;
- bdrv_op_unblock_all(bs, job->blocker);
+ for (l = job->nodes; l; l = l->next) {
+ bs = l->data;
+ bdrv_op_unblock_all(bs, job->blocker);
+ bdrv_unref(bs);
+ }
+ g_slist_free(job->nodes);
blk_remove_aio_context_notifier(job->blk,
block_job_attached_aio_context,
block_job_detach_aio_context, job);
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index 4ddb4ae..bab91b1 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -181,6 +181,9 @@ struct BlockJob {
/** Block other operations when block job is running */
Error *blocker;
+ /** BlockDriverStates that are involved in this block job */
+ GSList *nodes;
+
/** The opaque value that is passed to the completion function. */
void *opaque;
@@ -246,6 +249,17 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
BlockCompletionFunc *cb, void *opaque, Error **errp);
/**
+ * block_job_add_bdrv:
+ * @job: A block job
+ * @bs: A BlockDriverState that is involved in @job
+ *
+ * Add @bs to the list of BlockDriverState that are involved in
+ * @job. This means that all operations will be blocked on @bs while
+ * @job exists.
+ */
+void block_job_add_bdrv(BlockJob *job, BlockDriverState *bs);
+
+/**
* block_job_sleep_ns:
* @job: The job that calls the function.
* @clock: The clock to sleep on.
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 04/19] block: Use block_job_add_bdrv() in mirror_start_job()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (2 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 03/19] block: Add block_job_add_bdrv() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 05/19] block: Use block_job_add_bdrv() in backup_start() Alberto Garcia
` (15 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
Use block_job_add_bdrv() instead of blocking all operations in
mirror_start_job() and unblocking them in mirror_exit().
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block/mirror.c | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/block/mirror.c b/block/mirror.c
index a433e68..a4273f6 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -526,7 +526,6 @@ static void mirror_exit(BlockJob *job, void *opaque)
aio_context_release(replace_aio_context);
}
g_free(s->replaces);
- bdrv_op_unblock_all(target_bs, s->common.blocker);
blk_unref(s->target);
block_job_completed(&s->common, data->ret);
g_free(data);
@@ -967,7 +966,7 @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,
return;
}
- bdrv_op_block_all(target, s->common.blocker);
+ block_job_add_bdrv(&s->common, target);
s->common.co = qemu_coroutine_create(mirror_run, s);
trace_mirror_start(bs, s, s->common.co, opaque);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 05/19] block: Use block_job_add_bdrv() in backup_start()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (3 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 04/19] block: Use block_job_add_bdrv() in mirror_start_job() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 06/19] block: Check blockers in all nodes involved in a block-commit job Alberto Garcia
` (14 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
Use block_job_add_bdrv() instead of blocking all operations in
backup_start() and unblocking them in backup_run().
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block/backup.c | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/block/backup.c b/block/backup.c
index 02dbe48..2da4ff0 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -429,7 +429,6 @@ static void coroutine_fn backup_run(void *opaque)
BackupBlockJob *job = opaque;
BackupCompleteData *data;
BlockDriverState *bs = blk_bs(job->common.blk);
- BlockBackend *target = job->target;
int64_t start, end;
int64_t sectors_per_cluster = cluster_size_sectors(job);
int ret = 0;
@@ -516,8 +515,6 @@ static void coroutine_fn backup_run(void *opaque)
qemu_co_rwlock_unlock(&job->flush_rwlock);
g_free(job->done_bitmap);
- bdrv_op_unblock_all(blk_bs(target), job->common.blocker);
-
data = g_malloc(sizeof(*data));
data->ret = ret;
block_job_defer_to_main_loop(&job->common, backup_complete, data);
@@ -631,7 +628,7 @@ void backup_start(const char *job_id, BlockDriverState *bs,
job->cluster_size = MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);
}
- bdrv_op_block_all(target, job->common.blocker);
+ block_job_add_bdrv(&job->common, target);
job->common.len = len;
job->common.co = qemu_coroutine_create(backup_run, job);
block_job_txn_add_job(txn, &job->common);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 06/19] block: Check blockers in all nodes involved in a block-commit job
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (4 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 05/19] block: Use block_job_add_bdrv() in backup_start() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 07/19] block: Block all nodes involved in the block-commit operation Alberto Garcia
` (13 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
qmp_block_commit() checks for op blockers in the active and
destination (base) images. However all nodes between top_bs and base
are also involved, and they are removed from the chain afterwards.
In addition to that, if top_bs is not the active layer then top_bs's
overlay also needs to be checked because it's involved in the job (its
backing image string needs to be updated to point to 'base').
This patch checks that none of those nodes are blocked.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
blockdev.c | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/blockdev.c b/blockdev.c
index d11a74f..de5b5f5 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -3001,6 +3001,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
Error **errp)
{
BlockDriverState *bs;
+ BlockDriverState *iter;
BlockDriverState *base_bs, *top_bs;
AioContext *aio_context;
Error *local_err = NULL;
@@ -3067,8 +3068,10 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
assert(bdrv_get_aio_context(base_bs) == aio_context);
- if (bdrv_op_is_blocked(base_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
- goto out;
+ for (iter = top_bs; iter != backing_bs(base_bs); iter = backing_bs(iter)) {
+ if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
+ goto out;
+ }
}
/* Do not allow attempts to commit an image into itself */
@@ -3086,6 +3089,10 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
commit_active_start(has_job_id ? job_id : NULL, bs, base_bs, speed,
on_error, block_job_cb, bs, &local_err, false);
} else {
+ BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
+ if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
+ goto out;
+ }
commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, speed,
on_error, block_job_cb, bs,
has_backing_file ? backing_file : NULL, &local_err);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 07/19] block: Block all nodes involved in the block-commit operation
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (5 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 06/19] block: Check blockers in all nodes involved in a block-commit job Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 08/19] block: Block all intermediate nodes in commit_active_start() Alberto Garcia
` (12 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
After a successful block-commit operation all nodes between top and
base are removed from the backing chain, and top's overlay needs to
be updated to point to base. Because of that we should prevent other
block jobs from messing with them.
This patch blocks all operations in these nodes in commit_start().
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block/commit.c | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/block/commit.c b/block/commit.c
index 9f67a8b..1500d7c 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -216,6 +216,7 @@ void commit_start(const char *job_id, BlockDriverState *bs,
BlockReopenQueue *reopen_queue = NULL;
int orig_overlay_flags;
int orig_base_flags;
+ BlockDriverState *iter;
BlockDriverState *overlay_bs;
Error *local_err = NULL;
@@ -260,6 +261,19 @@ void commit_start(const char *job_id, BlockDriverState *bs,
}
+ /* Block all nodes between top and base, because they will
+ * disappear from the chain after this operation. */
+ assert(bdrv_chain_contains(top, base));
+ for (iter = top; iter != backing_bs(base); iter = backing_bs(iter)) {
+ block_job_add_bdrv(&s->common, iter);
+ }
+ /* overlay_bs must be blocked because it needs to be modified to
+ * update the backing image string, but if it's the root node then
+ * don't block it again */
+ if (bs != overlay_bs) {
+ block_job_add_bdrv(&s->common, overlay_bs);
+ }
+
s->base = blk_new();
blk_insert_bs(s->base, base);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 08/19] block: Block all intermediate nodes in commit_active_start()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (6 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 07/19] block: Block all nodes involved in the block-commit operation Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 09/19] block: Support streaming to an intermediate layer Alberto Garcia
` (11 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
When block-commit is launched without the top parameter, it uses
internally a mirror block job. In that case all intermediate nodes
between the active and base nodes must be blocked as well.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block/mirror.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/block/mirror.c b/block/mirror.c
index a4273f6..94be565 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -967,6 +967,14 @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,
}
block_job_add_bdrv(&s->common, target);
+ /* In commit_active_start() all intermediate nodes disappear, so
+ * any jobs in them must be blocked */
+ if (bdrv_chain_contains(bs, target)) {
+ BlockDriverState *iter;
+ for (iter = backing_bs(bs); iter != target; iter = backing_bs(iter)) {
+ block_job_add_bdrv(&s->common, iter);
+ }
+ }
s->common.co = qemu_coroutine_create(mirror_run, s);
trace_mirror_start(bs, s, s->common.co, opaque);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 09/19] block: Support streaming to an intermediate layer
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (7 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 08/19] block: Block all intermediate nodes in commit_active_start() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 10/19] block: Add QMP support for " Alberto Garcia
` (10 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
This makes sure that the image we are streaming into is open in
read-write mode during the operation.
Operation blockers are also set in all intermediate nodes, since they
will be removed from the chain afterwards.
Finally, this also unblocks the stream operation in backing files.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
block.c | 4 +++-
block/stream.c | 24 ++++++++++++++++++++++++
2 files changed, 27 insertions(+), 1 deletion(-)
diff --git a/block.c b/block.c
index adbecd0..1ef36c9 100644
--- a/block.c
+++ b/block.c
@@ -1428,9 +1428,11 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
backing_hd->drv ? backing_hd->drv->format_name : "");
bdrv_op_block_all(backing_hd, bs->backing_blocker);
- /* Otherwise we won't be able to commit due to check in bdrv_commit */
+ /* Otherwise we won't be able to commit or stream */
bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
bs->backing_blocker);
+ bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
+ bs->backing_blocker);
/*
* We do backup in 3 ways:
* 1. drive backup
diff --git a/block/stream.c b/block/stream.c
index 3187481..b8ab89a 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -37,6 +37,7 @@ typedef struct StreamBlockJob {
BlockDriverState *base;
BlockdevOnError on_error;
char *backing_file_str;
+ int bs_flags;
} StreamBlockJob;
static int coroutine_fn stream_populate(BlockBackend *blk,
@@ -81,6 +82,11 @@ static void stream_complete(BlockJob *job, void *opaque)
bdrv_set_backing_hd(bs, base);
}
+ /* Reopen the image back in read-only mode if necessary */
+ if (s->bs_flags != bdrv_get_flags(bs)) {
+ bdrv_reopen(bs, s->bs_flags, NULL);
+ }
+
g_free(s->backing_file_str);
block_job_completed(&s->common, data->ret);
g_free(data);
@@ -220,6 +226,8 @@ void stream_start(const char *job_id, BlockDriverState *bs,
BlockCompletionFunc *cb, void *opaque, Error **errp)
{
StreamBlockJob *s;
+ BlockDriverState *iter;
+ int orig_bs_flags;
s = block_job_create(job_id, &stream_job_driver, bs, speed,
cb, opaque, errp);
@@ -227,8 +235,24 @@ void stream_start(const char *job_id, BlockDriverState *bs,
return;
}
+ /* Make sure that the image is opened in read-write mode */
+ orig_bs_flags = bdrv_get_flags(bs);
+ if (!(orig_bs_flags & BDRV_O_RDWR)) {
+ if (bdrv_reopen(bs, orig_bs_flags | BDRV_O_RDWR, errp) != 0) {
+ block_job_unref(&s->common);
+ return;
+ }
+ }
+
+ /* Block all intermediate nodes between bs and base, because they
+ * will disappear from the chain after this operation */
+ for (iter = backing_bs(bs); iter && iter != base; iter = backing_bs(iter)) {
+ block_job_add_bdrv(&s->common, iter);
+ }
+
s->base = base;
s->backing_file_str = g_strdup(backing_file_str);
+ s->bs_flags = orig_bs_flags;
s->on_error = on_error;
s->common.co = qemu_coroutine_create(stream_run, s);
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 10/19] block: Add QMP support for streaming to an intermediate layer
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (8 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 09/19] block: Support streaming to an intermediate layer Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 11/19] docs: Document how to stream " Alberto Garcia
` (9 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
This patch makes the 'device' parameter of the 'block-stream' command
accept a node name that is not a root node. The presence of this
feature can't be directly tested with introspection; soon we'll
introduce a 'base-node' parameter whose presence can be checked for
this purpose.
In addition to that, operation blockers will be checked in all
intermediate nodes between the top and the base node.
Signed-off-by: Alberto Garcia <berto@igalia.com>
---
blockdev.c | 15 +++++++++------
qapi/block-core.json | 13 ++++++++++---
2 files changed, 19 insertions(+), 9 deletions(-)
diff --git a/blockdev.c b/blockdev.c
index de5b5f5..b5d4d69 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -2937,7 +2937,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
bool has_on_error, BlockdevOnError on_error,
Error **errp)
{
- BlockDriverState *bs;
+ BlockDriverState *bs, *iter;
BlockDriverState *base_bs = NULL;
AioContext *aio_context;
Error *local_err = NULL;
@@ -2947,7 +2947,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
on_error = BLOCKDEV_ON_ERROR_REPORT;
}
- bs = qmp_get_root_bs(device, errp);
+ bs = bdrv_lookup_bs(device, device, errp);
if (!bs) {
return;
}
@@ -2955,10 +2955,6 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
- if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_STREAM, errp)) {
- goto out;
- }
-
if (has_base) {
base_bs = bdrv_find_backing_image(bs, base);
if (base_bs == NULL) {
@@ -2969,6 +2965,13 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
base_name = base;
}
+ /* Check for op blockers in the whole chain between bs and base */
+ for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) {
+ if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
+ goto out;
+ }
+ }
+
/* if we are streaming the entire chain, the result will have no backing
* file, and specifying one is therefore an error */
if (base_bs == NULL && has_backing_file) {
diff --git a/qapi/block-core.json b/qapi/block-core.json
index 97b1205..821762c 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -1464,6 +1464,13 @@
# with query-block-jobs. The operation can be stopped before it has completed
# using the block-job-cancel command.
#
+# The node that receives the data is called the top image, can be located in
+# any part of the chain (but always above the base image; see below) and can be
+# specified using its device or node name. Earlier qemu versions only allowed
+# 'device' to name the top level node; presence of the 'base-node' parameter
+# during introspection can be used as a witness of the enhanced semantics
+# of 'device'.
+#
# If a base file is specified then sectors are not copied from that base file and
# its backing chain. When streaming completes the image file will have the base
# file as its backing file. This can be used to stream a subset of the backing
@@ -1475,12 +1482,12 @@
# @job-id: #optional identifier for the newly-created block job. If
# omitted, the device name will be used. (Since 2.7)
#
-# @device: the device name or node-name of a root node
+# @device: the device or node name of the top image
#
# @base: #optional the common backing file name
#
-# @backing-file: #optional The backing file string to write into the active
-# layer. This filename is not validated.
+# @backing-file: #optional The backing file string to write into the top
+# image. This filename is not validated.
#
# If a pathname string is such that it cannot be
# resolved by QEMU, that means that subsequent QMP or
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 11/19] docs: Document how to stream to an intermediate layer
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (9 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 10/19] block: Add QMP support for " Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 12/19] qemu-iotests: Test streaming " Alberto Garcia
` (8 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
docs/live-block-ops.txt | 36 +++++++++++++++++++++++++-----------
1 file changed, 25 insertions(+), 11 deletions(-)
diff --git a/docs/live-block-ops.txt b/docs/live-block-ops.txt
index a257087..2211d14 100644
--- a/docs/live-block-ops.txt
+++ b/docs/live-block-ops.txt
@@ -4,15 +4,20 @@ LIVE BLOCK OPERATIONS
High level description of live block operations. Note these are not
supported for use with the raw format at the moment.
+Note also that this document is incomplete and it currently only
+covers the 'stream' operation. Other operations supported by QEMU such
+as 'commit', 'mirror' and 'backup' are not described here yet. Please
+refer to the qapi/block-core.json file for an overview of those.
+
Snapshot live merge
===================
Given a snapshot chain, described in this document in the following
format:
-[A] -> [B] -> [C] -> [D]
+[A] <- [B] <- [C] <- [D] <- [E]
-Where the rightmost object ([D] in the example) described is the current
+Where the rightmost object ([E] in the example) described is the current
image which the guest OS has write access to. To the left of it is its base
image, and so on accordingly until the leftmost image, which has no
base.
@@ -21,11 +26,14 @@ The snapshot live merge operation transforms such a chain into a
smaller one with fewer elements, such as this transformation relative
to the first example:
-[A] -> [D]
+[A] <- [E]
-Currently only forward merge with target being the active image is
-supported, that is, data copy is performed in the right direction with
-destination being the rightmost image.
+Data is copied in the right direction with destination being the
+rightmost image, but any other intermediate image can be specified
+instead. In this example data is copied from [C] into [D], so [D] can
+be backed by [B]:
+
+[A] <- [B] <- [D] <- [E]
The operation is implemented in QEMU through image streaming facilities.
@@ -35,14 +43,20 @@ streaming operation completes it raises a QMP event. 'block_stream'
copies data from the backing file(s) into the active image. When finished,
it adjusts the backing file pointer.
-The 'base' parameter specifies an image which data need not be streamed from.
-This image will be used as the backing file for the active image when the
-operation is finished.
+The 'base' parameter specifies an image which data need not be
+streamed from. This image will be used as the backing file for the
+destination image when the operation is finished.
-In the example above, the command would be:
+In the first example above, the command would be:
-(qemu) block_stream virtio0 A
+(qemu) block_stream virtio0 file-A.img
+In order to specify a destination image different from the active
+(rightmost) one we can use its node name instead.
+
+In the second example above, the command would be:
+
+(qemu) block_stream node-D file-B.img
Live block copy
===============
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 12/19] qemu-iotests: Test streaming to an intermediate layer
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (10 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 11/19] docs: Document how to stream " Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 13/19] qemu-iotests: Test block-stream operations in parallel Alberto Garcia
` (7 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
This adds test_stream_intermediate(), similar to test_stream() but
streams to the intermediate image instead.
Signed-off-by: Alberto Garcia <berto@igalia.com>
---
tests/qemu-iotests/030 | 21 ++++++++++++++++++++-
tests/qemu-iotests/030.out | 4 ++--
2 files changed, 22 insertions(+), 3 deletions(-)
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index 107049b..8b0212c 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -36,7 +36,7 @@ class TestSingleDrive(iotests.QMPTestCase):
qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % mid_img, test_img)
qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 512', backing_img)
qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0x1 524288 512', mid_img)
- self.vm = iotests.VM().add_drive("blkdebug::" + test_img)
+ self.vm = iotests.VM().add_drive("blkdebug::" + test_img, "backing.node-name=mid")
self.vm.launch()
def tearDown(self):
@@ -60,6 +60,25 @@ class TestSingleDrive(iotests.QMPTestCase):
qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),
'image file map does not match backing file after streaming')
+ def test_stream_intermediate(self):
+ self.assert_no_active_block_jobs()
+
+ self.assertNotEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img),
+ 'image file map matches backing file before streaming')
+
+ result = self.vm.qmp('block-stream', device='mid', job_id='stream-mid')
+ self.assert_qmp(result, 'return', {})
+
+ self.wait_until_completed(drive='stream-mid')
+
+ self.assert_no_active_block_jobs()
+ self.vm.shutdown()
+
+ self.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img),
+ 'image file map does not match backing file after streaming')
+
def test_stream_pause(self):
self.assert_no_active_block_jobs()
diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out
index 6323079..96961ed 100644
--- a/tests/qemu-iotests/030.out
+++ b/tests/qemu-iotests/030.out
@@ -1,5 +1,5 @@
-..............
+...............
----------------------------------------------------------------------
-Ran 14 tests
+Ran 15 tests
OK
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 13/19] qemu-iotests: Test block-stream operations in parallel
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (11 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 12/19] qemu-iotests: Test streaming " Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 14/19] qemu-iotests: Test overlapping stream and commit operations Alberto Garcia
` (6 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
This test case checks that it's possible to launch several stream
operations in parallel in the same snapshot chain, each one involving
a different set of nodes.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
tests/qemu-iotests/030 | 80 ++++++++++++++++++++++++++++++++++++++++++++++
tests/qemu-iotests/030.out | 4 +--
2 files changed, 82 insertions(+), 2 deletions(-)
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index 8b0212c..ba9a541 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -148,6 +148,86 @@ class TestSingleDrive(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
+class TestParallelOps(iotests.QMPTestCase):
+ num_ops = 4 # Number of parallel block-stream operations
+ num_imgs = num_ops * 2 + 1
+ image_len = num_ops * 1024 * 1024
+ imgs = []
+
+ def setUp(self):
+ opts = []
+ self.imgs = []
+
+ # Initialize file names and command-line options
+ for i in range(self.num_imgs):
+ img_depth = self.num_imgs - i - 1
+ opts.append("backing." * img_depth + "node-name=node%d" % i)
+ self.imgs.append(os.path.join(iotests.test_dir, 'img-%d.img' % i))
+
+ # Create all images
+ iotests.create_image(self.imgs[0], self.image_len)
+ for i in range(1, self.num_imgs):
+ qemu_img('create', '-f', iotests.imgfmt,
+ '-o', 'backing_file=%s' % self.imgs[i-1], self.imgs[i])
+
+ # Put data into the images we are copying data from
+ for i in range(self.num_imgs / 2):
+ img_index = i * 2 + 1
+ # Alternate between 512k and 1M.
+ # This way jobs will not finish in the same order they were created
+ num_kb = 512 + 512 * (i % 2)
+ qemu_io('-f', iotests.imgfmt,
+ '-c', 'write -P %d %d %d' % (i, i*1024*1024, num_kb * 1024),
+ self.imgs[img_index])
+
+ # Attach the drive to the VM
+ self.vm = iotests.VM()
+ self.vm.add_drive(self.imgs[-1], ','.join(opts))
+ self.vm.launch()
+
+ def tearDown(self):
+ self.vm.shutdown()
+ for img in self.imgs:
+ os.remove(img)
+
+ # Test that it's possible to run several block-stream operations
+ # in parallel in the same snapshot chain
+ def test_stream_parallel(self):
+ self.assert_no_active_block_jobs()
+
+ # Check that the maps don't match before the streaming operations
+ for i in range(2, self.num_imgs, 2):
+ self.assertNotEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i]),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i-1]),
+ 'image file map matches backing file before streaming')
+
+ # Create all streaming jobs
+ pending_jobs = []
+ for i in range(2, self.num_imgs, 2):
+ node_name = 'node%d' % i
+ job_id = 'stream-%s' % node_name
+ pending_jobs.append(job_id)
+ result = self.vm.qmp('block-stream', device=node_name, job_id=job_id, base=self.imgs[i-2], speed=512*1024)
+ self.assert_qmp(result, 'return', {})
+
+ # Wait for all jobs to be finished.
+ while len(pending_jobs) > 0:
+ for event in self.vm.get_qmp_events(wait=True):
+ if event['event'] == 'BLOCK_JOB_COMPLETED':
+ job_id = self.dictpath(event, 'data/device')
+ self.assertTrue(job_id in pending_jobs)
+ self.assert_qmp_absent(event, 'data/error')
+ pending_jobs.remove(job_id)
+
+ self.assert_no_active_block_jobs()
+ self.vm.shutdown()
+
+ # Check that all maps match now
+ for i in range(2, self.num_imgs, 2):
+ self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i]),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i-1]),
+ 'image file map does not match backing file after streaming')
+
class TestSmallerBackingFile(iotests.QMPTestCase):
backing_len = 1 * 1024 * 1024 # MB
image_len = 2 * backing_len
diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out
index 96961ed..b6f2576 100644
--- a/tests/qemu-iotests/030.out
+++ b/tests/qemu-iotests/030.out
@@ -1,5 +1,5 @@
-...............
+................
----------------------------------------------------------------------
-Ran 15 tests
+Ran 16 tests
OK
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 14/19] qemu-iotests: Test overlapping stream and commit operations
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (12 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 13/19] qemu-iotests: Test block-stream operations in parallel Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 15/19] qemu-iotests: Test block-stream and block-commit in parallel Alberto Garcia
` (5 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
These test cases check that it's not possible to perform two
block-stream or block-commit operations if there are nodes involved in
both.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
tests/qemu-iotests/030 | 89 ++++++++++++++++++++++++++++++++++++++++++++++
tests/qemu-iotests/030.out | 4 +--
2 files changed, 91 insertions(+), 2 deletions(-)
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index ba9a541..3533495 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -228,6 +228,95 @@ class TestParallelOps(iotests.QMPTestCase):
qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i-1]),
'image file map does not match backing file after streaming')
+ # Test that it's not possible to perform two block-stream
+ # operations if there are nodes involved in both.
+ def test_overlapping_1(self):
+ self.assert_no_active_block_jobs()
+
+ # Set a speed limit to make sure that this job blocks the rest
+ result = self.vm.qmp('block-stream', device='node4', job_id='stream-node4', base=self.imgs[1], speed=1024*1024)
+ self.assert_qmp(result, 'return', {})
+
+ result = self.vm.qmp('block-stream', device='node5', job_id='stream-node5', base=self.imgs[2])
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ result = self.vm.qmp('block-stream', device='node3', job_id='stream-node3', base=self.imgs[2])
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ result = self.vm.qmp('block-stream', device='node4', job_id='stream-node4-v2')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # block-commit should also fail if it touches nodes used by the stream job
+ result = self.vm.qmp('block-commit', device='drive0', base=self.imgs[4], job_id='commit-node4')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ result = self.vm.qmp('block-commit', device='drive0', base=self.imgs[1], top=self.imgs[3], job_id='commit-node1')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # This fails because it needs to modify the backing string in node2, which is blocked
+ result = self.vm.qmp('block-commit', device='drive0', base=self.imgs[0], top=self.imgs[1], job_id='commit-node0')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ self.wait_until_completed(drive='stream-node4')
+ self.assert_no_active_block_jobs()
+
+ # Similar to test_overlapping_1, but with block-commit
+ # blocking the other jobs
+ def test_overlapping_2(self):
+ self.assertLessEqual(9, self.num_imgs)
+ self.assert_no_active_block_jobs()
+
+ # Set a speed limit to make sure that this job blocks the rest
+ result = self.vm.qmp('block-commit', device='drive0', top=self.imgs[5], base=self.imgs[3], job_id='commit-node3', speed=1024*1024)
+ self.assert_qmp(result, 'return', {})
+
+ result = self.vm.qmp('block-stream', device='node3', job_id='stream-node3')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ result = self.vm.qmp('block-stream', device='node6', base=self.imgs[2], job_id='stream-node6')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ result = self.vm.qmp('block-stream', device='node4', base=self.imgs[2], job_id='stream-node4')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ result = self.vm.qmp('block-stream', device='node6', base=self.imgs[4], job_id='stream-node6-v2')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # This fails because block-commit needs to block node6, the overlay of the 'top' image
+ result = self.vm.qmp('block-stream', device='node7', base=self.imgs[5], job_id='stream-node6-v3')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # This fails because block-commit currently blocks the active layer even if it's not used
+ result = self.vm.qmp('block-stream', device='drive0', base=self.imgs[5], job_id='stream-drive0')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ self.wait_until_completed(drive='commit-node3')
+
+ # Similar to test_overlapping_2, but here block-commit doesn't use the 'top' parameter.
+ # Internally this uses a mirror block job, hence the separate test case.
+ def test_overlapping_3(self):
+ self.assertLessEqual(8, self.num_imgs)
+ self.assert_no_active_block_jobs()
+
+ # Set a speed limit to make sure that this job blocks the rest
+ result = self.vm.qmp('block-commit', device='drive0', base=self.imgs[3], job_id='commit-drive0', speed=1024*1024)
+ self.assert_qmp(result, 'return', {})
+
+ result = self.vm.qmp('block-stream', device='node5', base=self.imgs[3], job_id='stream-node6')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ event = self.vm.get_qmp_event(wait=True)
+ self.assertEqual(event['event'], 'BLOCK_JOB_READY')
+ self.assert_qmp(event, 'data/device', 'commit-drive0')
+ self.assert_qmp(event, 'data/type', 'commit')
+ self.assert_qmp_absent(event, 'data/error')
+
+ result = self.vm.qmp('block-job-complete', device='commit-drive0')
+ self.assert_qmp(result, 'return', {})
+
+ self.wait_until_completed(drive='commit-drive0')
+ self.assert_no_active_block_jobs()
+
class TestSmallerBackingFile(iotests.QMPTestCase):
backing_len = 1 * 1024 * 1024 # MB
image_len = 2 * backing_len
diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out
index b6f2576..4176bb9 100644
--- a/tests/qemu-iotests/030.out
+++ b/tests/qemu-iotests/030.out
@@ -1,5 +1,5 @@
-................
+...................
----------------------------------------------------------------------
-Ran 16 tests
+Ran 19 tests
OK
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 15/19] qemu-iotests: Test block-stream and block-commit in parallel
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (13 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 14/19] qemu-iotests: Test overlapping stream and commit operations Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 16/19] qemu-iotests: Add iotests.supports_quorum() Alberto Garcia
` (4 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
As with test_stream_parallel(), we allow mixing block-stream and
block-commit operations in the same backing chain as long as there's
no overlap among the involved nodes.
Signed-off-by: Alberto Garcia <berto@igalia.com>
---
tests/qemu-iotests/030 | 30 ++++++++++++++++++++++++++++++
tests/qemu-iotests/030.out | 4 ++--
2 files changed, 32 insertions(+), 2 deletions(-)
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index 3533495..83aeaa6 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -315,6 +315,36 @@ class TestParallelOps(iotests.QMPTestCase):
self.assert_qmp(result, 'return', {})
self.wait_until_completed(drive='commit-drive0')
+
+ # Test a block-stream and a block-commit job in parallel
+ def test_stream_commit(self):
+ self.assertLessEqual(8, self.num_imgs)
+ self.assert_no_active_block_jobs()
+
+ # Stream from node0 into node2
+ result = self.vm.qmp('block-stream', device='node2', job_id='node2')
+ self.assert_qmp(result, 'return', {})
+
+ # Commit from the active layer into node3
+ result = self.vm.qmp('block-commit', device='drive0', base=self.imgs[3])
+ self.assert_qmp(result, 'return', {})
+
+ # Wait for all jobs to be finished.
+ pending_jobs = ['node2', 'drive0']
+ while len(pending_jobs) > 0:
+ for event in self.vm.get_qmp_events(wait=True):
+ if event['event'] == 'BLOCK_JOB_COMPLETED':
+ node_name = self.dictpath(event, 'data/device')
+ self.assertTrue(node_name in pending_jobs)
+ self.assert_qmp_absent(event, 'data/error')
+ pending_jobs.remove(node_name)
+ if event['event'] == 'BLOCK_JOB_READY':
+ self.assert_qmp(event, 'data/device', 'drive0')
+ self.assert_qmp(event, 'data/type', 'commit')
+ self.assert_qmp_absent(event, 'data/error')
+ self.assertTrue('drive0' in pending_jobs)
+ self.vm.qmp('block-job-complete', device='drive0')
+
self.assert_no_active_block_jobs()
class TestSmallerBackingFile(iotests.QMPTestCase):
diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out
index 4176bb9..3a89159 100644
--- a/tests/qemu-iotests/030.out
+++ b/tests/qemu-iotests/030.out
@@ -1,5 +1,5 @@
-...................
+....................
----------------------------------------------------------------------
-Ran 19 tests
+Ran 20 tests
OK
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 16/19] qemu-iotests: Add iotests.supports_quorum()
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (14 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 15/19] qemu-iotests: Test block-stream and block-commit in parallel Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 17/19] qemu-iotests: Test streaming to a Quorum child Alberto Garcia
` (3 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
There's many tests that need Quorum support in order to run. At the
moment each test implements its own check to see if Quorum is
enabled. This patch centralizes all those checks in a new function
called iotests.supports_quorum().
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
tests/qemu-iotests/041 | 27 ++++++++++++---------------
tests/qemu-iotests/139 | 3 ++-
tests/qemu-iotests/iotests.py | 5 ++++-
3 files changed, 18 insertions(+), 17 deletions(-)
diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
index 30e628f..bc6cf78 100755
--- a/tests/qemu-iotests/041
+++ b/tests/qemu-iotests/041
@@ -760,9 +760,6 @@ class TestRepairQuorum(iotests.QMPTestCase):
image_len = 1 * 1024 * 1024 # MB
IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ]
- def has_quorum(self):
- return 'quorum' in iotests.qemu_img_pipe('--help')
-
def setUp(self):
self.vm = iotests.VM()
@@ -783,7 +780,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
#assemble the quorum block device from the individual files
args = { "driver": "quorum", "node-name": "quorum0",
"vote-threshold": 2, "children": [ "img0", "img1", "img2" ] }
- if self.has_quorum():
+ if iotests.supports_quorum():
result = self.vm.qmp("blockdev-add", **args)
self.assert_qmp(result, 'return', {})
@@ -798,7 +795,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
pass
def test_complete(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
@@ -817,7 +814,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
'target image does not match source after mirroring')
def test_cancel(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
@@ -834,7 +831,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.vm.shutdown()
def test_cancel_after_ready(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
@@ -853,7 +850,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
'target image does not match source after mirroring')
def test_pause(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
@@ -883,7 +880,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
'target image does not match source after mirroring')
def test_medium_not_found(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
if iotests.qemu_default_machine != 'pc':
@@ -897,7 +894,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
def test_image_not_found(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
@@ -907,7 +904,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
def test_device_not_found(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('drive-mirror', job_id='job0',
@@ -918,7 +915,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
def test_wrong_sync_mode(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('drive-mirror', device='quorum0', job_id='job0',
@@ -928,7 +925,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
def test_no_node_name(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
@@ -937,7 +934,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
def test_nonexistent_replaces(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
@@ -946,7 +943,7 @@ class TestRepairQuorum(iotests.QMPTestCase):
self.assert_qmp(result, 'error/class', 'GenericError')
def test_after_a_quorum_snapshot(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1',
diff --git a/tests/qemu-iotests/139 b/tests/qemu-iotests/139
index 6a0f6ca..6d98e4f 100644
--- a/tests/qemu-iotests/139
+++ b/tests/qemu-iotests/139
@@ -336,8 +336,9 @@ class TestBlockdevDel(iotests.QMPTestCase):
self.checkBlockDriverState('node1', False)
def testQuorum(self):
- if not 'quorum' in iotests.qemu_img_pipe('--help'):
+ if not iotests.supports_quorum():
return
+
self.addQuorum('quorum0', 'node0', 'node1')
# We cannot remove the children of a Quorum device
self.delBlockDriverState('node0', expect_error = True)
diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index 3329bc1..ef63ee4 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -318,9 +318,12 @@ def verify_platform(supported_oses=['linux']):
if True not in [sys.platform.startswith(x) for x in supported_oses]:
notrun('not suitable for this OS: %s' % sys.platform)
+def supports_quorum():
+ return 'quorum' in qemu_img_pipe('--help')
+
def verify_quorum():
'''Skip test suite if quorum support is not available'''
- if 'quorum' not in qemu_img_pipe('--help'):
+ if not supports_quorum():
notrun('quorum support missing')
def main(supported_fmts=[], supported_oses=['linux']):
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 17/19] qemu-iotests: Test streaming to a Quorum child
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (15 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 16/19] qemu-iotests: Add iotests.supports_quorum() Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 18/19] block: Add 'base-node' parameter to the 'block-stream' command Alberto Garcia
` (2 subsequent siblings)
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
Quorum children are special in the sense that they're not directly
attached to a block backend but they're not used as backing images
either. However the intermediate block streaming code supports
streaming to them. This is a test case for that scenario.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
tests/qemu-iotests/030 | 56 ++++++++++++++++++++++++++++++++++++++++++++++
tests/qemu-iotests/030.out | 4 ++--
2 files changed, 58 insertions(+), 2 deletions(-)
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index 83aeaa6..783a1b8 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -347,6 +347,62 @@ class TestParallelOps(iotests.QMPTestCase):
self.assert_no_active_block_jobs()
+class TestQuorum(iotests.QMPTestCase):
+ num_children = 3
+ children = []
+ backing = []
+
+ def setUp(self):
+ opts = ['driver=quorum', 'vote-threshold=2']
+
+ # Initialize file names and command-line options
+ for i in range(self.num_children):
+ child_img = os.path.join(iotests.test_dir, 'img-%d.img' % i)
+ backing_img = os.path.join(iotests.test_dir, 'backing-%d.img' % i)
+ self.children.append(child_img)
+ self.backing.append(backing_img)
+ qemu_img('create', '-f', iotests.imgfmt, backing_img, '1M')
+ qemu_io('-f', iotests.imgfmt,
+ '-c', 'write -P 0x55 0 1024', backing_img)
+ qemu_img('create', '-f', iotests.imgfmt,
+ '-o', 'backing_file=%s' % backing_img, child_img)
+ opts.append("children.%d.file.filename=%s" % (i, child_img))
+ opts.append("children.%d.node-name=node%d" % (i, i))
+
+ # Attach the drive to the VM
+ self.vm = iotests.VM()
+ self.vm.add_drive(path = None, opts = ','.join(opts))
+ self.vm.launch()
+
+ def tearDown(self):
+ self.vm.shutdown()
+ for img in self.children:
+ os.remove(img)
+ for img in self.backing:
+ os.remove(img)
+
+ def test_stream_quorum(self):
+ if not iotests.supports_quorum():
+ return
+
+ self.assertNotEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.children[0]),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.backing[0]),
+ 'image file map matches backing file before streaming')
+
+ self.assert_no_active_block_jobs()
+
+ result = self.vm.qmp('block-stream', device='node0', job_id='stream-node0')
+ self.assert_qmp(result, 'return', {})
+
+ self.wait_until_completed(drive='stream-node0')
+
+ self.assert_no_active_block_jobs()
+ self.vm.shutdown()
+
+ self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.children[0]),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.backing[0]),
+ 'image file map does not match backing file after streaming')
+
class TestSmallerBackingFile(iotests.QMPTestCase):
backing_len = 1 * 1024 * 1024 # MB
image_len = 2 * backing_len
diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out
index 3a89159..c6a10f8 100644
--- a/tests/qemu-iotests/030.out
+++ b/tests/qemu-iotests/030.out
@@ -1,5 +1,5 @@
-....................
+.....................
----------------------------------------------------------------------
-Ran 20 tests
+Ran 21 tests
OK
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 18/19] block: Add 'base-node' parameter to the 'block-stream' command
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (16 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 17/19] qemu-iotests: Test streaming to a Quorum child Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 19/19] qemu-iotests: Test the 'base-node' parameter of 'block-stream' Alberto Garcia
2016-10-28 10:50 ` [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Kevin Wolf
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
The way to specify the node from which to copy data in the
block-stream operation is by using the 'base' parameter. This
parameter however takes a file name, not a node name.
Since we want to be able to perform this operation using only node
names, this patch adds a new 'base-node' parameter.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
---
blockdev.c | 21 +++++++++++++++++++++
docs/qmp-commands.txt | 7 +++++--
hmp.c | 2 +-
qapi/block-core.json | 8 ++++++--
4 files changed, 33 insertions(+), 5 deletions(-)
diff --git a/blockdev.c b/blockdev.c
index b5d4d69..ded1326 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -2932,6 +2932,7 @@ static void block_job_cb(void *opaque, int ret)
void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
bool has_base, const char *base,
+ bool has_base_node, const char *base_node,
bool has_backing_file, const char *backing_file,
bool has_speed, int64_t speed,
bool has_on_error, BlockdevOnError on_error,
@@ -2955,6 +2956,12 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
+ if (has_base && has_base_node) {
+ error_setg(errp, "'base' and 'base-node' cannot be specified "
+ "at the same time");
+ goto out;
+ }
+
if (has_base) {
base_bs = bdrv_find_backing_image(bs, base);
if (base_bs == NULL) {
@@ -2965,6 +2972,20 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
base_name = base;
}
+ if (has_base_node) {
+ base_bs = bdrv_lookup_bs(NULL, base_node, errp);
+ if (!base_bs) {
+ goto out;
+ }
+ if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) {
+ error_setg(errp, "Node '%s' is not a backing image of '%s'",
+ base_node, device);
+ goto out;
+ }
+ assert(bdrv_get_aio_context(base_bs) == aio_context);
+ base_name = base_bs->filename;
+ }
+
/* Check for op blockers in the whole chain between bs and base */
for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) {
if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
diff --git a/docs/qmp-commands.txt b/docs/qmp-commands.txt
index 284576d..0fde435 100644
--- a/docs/qmp-commands.txt
+++ b/docs/qmp-commands.txt
@@ -740,8 +740,11 @@ Arguments:
- "job-id": Identifier for the newly-created block job. If omitted,
the device name will be used. (json-string, optional)
- "device": The device name or node-name of a root node (json-string)
-- "base": The file name of the backing image above which copying starts
- (json-string, optional)
+- "base": The file name of the backing image above which copying starts.
+ It cannot be set if 'base-node' is also set (json-string, optional)
+- "base-node": the node name of the backing image above which copying starts.
+ It cannot be set if 'base' is also set.
+ (json-string, optional) (Since 2.8)
- "backing-file": The backing file string to write into the active layer. This
filename is not validated.
diff --git a/hmp.c b/hmp.c
index 3d60259..81447fa 100644
--- a/hmp.c
+++ b/hmp.c
@@ -1555,7 +1555,7 @@ void hmp_block_stream(Monitor *mon, const QDict *qdict)
int64_t speed = qdict_get_try_int(qdict, "speed", 0);
qmp_block_stream(false, NULL, device, base != NULL, base, false, NULL,
- qdict_haskey(qdict, "speed"), speed,
+ false, NULL, qdict_haskey(qdict, "speed"), speed,
true, BLOCKDEV_ON_ERROR_REPORT, &error);
hmp_handle_error(mon, &error);
diff --git a/qapi/block-core.json b/qapi/block-core.json
index 821762c..999a9bb 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -1484,7 +1484,11 @@
#
# @device: the device or node name of the top image
#
-# @base: #optional the common backing file name
+# @base: #optional the common backing file name.
+# It cannot be set if @base-node is also set.
+#
+# @base-node: #optional the node name of the backing file.
+# It cannot be set if @base is also set. (Since 2.8)
#
# @backing-file: #optional The backing file string to write into the top
# image. This filename is not validated.
@@ -1511,7 +1515,7 @@
##
{ 'command': 'block-stream',
'data': { '*job-id': 'str', 'device': 'str', '*base': 'str',
- '*backing-file': 'str', '*speed': 'int',
+ '*base-node': 'str', '*backing-file': 'str', '*speed': 'int',
'*on-error': 'BlockdevOnError' } }
##
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* [Qemu-devel] [PATCH v13 19/19] qemu-iotests: Test the 'base-node' parameter of 'block-stream'
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (17 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 18/19] block: Add 'base-node' parameter to the 'block-stream' command Alberto Garcia
@ 2016-10-28 7:08 ` Alberto Garcia
2016-10-28 10:50 ` [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Kevin Wolf
19 siblings, 0 replies; 21+ messages in thread
From: Alberto Garcia @ 2016-10-28 7:08 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Kevin Wolf, Eric Blake, Markus Armbruster, Max Reitz,
Alberto Garcia
The block-stream command has traditionally used the 'base' parameter
to indicate the image to copy the data from. This test checks that the
'base-node' parameter can also be used for the same purpose.
Signed-off-by: Alberto Garcia <berto@igalia.com>
---
tests/qemu-iotests/030 | 37 +++++++++++++++++++++++++++++++++++++
tests/qemu-iotests/030.out | 4 ++--
2 files changed, 39 insertions(+), 2 deletions(-)
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index 783a1b8..54db54a 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -347,6 +347,43 @@ class TestParallelOps(iotests.QMPTestCase):
self.assert_no_active_block_jobs()
+ # Test the base_node parameter
+ def test_stream_base_node_name(self):
+ self.assert_no_active_block_jobs()
+
+ self.assertNotEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[4]),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[3]),
+ 'image file map matches backing file before streaming')
+
+ # Error: the base node does not exist
+ result = self.vm.qmp('block-stream', device='node4', base_node='none', job_id='stream')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # Error: the base node is not a backing file of the top node
+ result = self.vm.qmp('block-stream', device='node4', base_node='node6', job_id='stream')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # Error: the base node is the same as the top node
+ result = self.vm.qmp('block-stream', device='node4', base_node='node4', job_id='stream')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # Error: cannot specify 'base' and 'base-node' at the same time
+ result = self.vm.qmp('block-stream', device='node4', base=self.imgs[2], base_node='node2', job_id='stream')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ # Success: the base node is a backing file of the top node
+ result = self.vm.qmp('block-stream', device='node4', base_node='node2', job_id='stream')
+ self.assert_qmp(result, 'return', {})
+
+ self.wait_until_completed(drive='stream')
+
+ self.assert_no_active_block_jobs()
+ self.vm.shutdown()
+
+ self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[4]),
+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[3]),
+ 'image file map matches backing file after streaming')
+
class TestQuorum(iotests.QMPTestCase):
num_children = 3
children = []
diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out
index c6a10f8..84bfd63 100644
--- a/tests/qemu-iotests/030.out
+++ b/tests/qemu-iotests/030.out
@@ -1,5 +1,5 @@
-.....................
+......................
----------------------------------------------------------------------
-Ran 21 tests
+Ran 22 tests
OK
--
2.9.3
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer
2016-10-28 7:08 [Qemu-devel] [PATCH v13 00/19] Support streaming to an intermediate layer Alberto Garcia
` (18 preceding siblings ...)
2016-10-28 7:08 ` [Qemu-devel] [PATCH v13 19/19] qemu-iotests: Test the 'base-node' parameter of 'block-stream' Alberto Garcia
@ 2016-10-28 10:50 ` Kevin Wolf
19 siblings, 0 replies; 21+ messages in thread
From: Kevin Wolf @ 2016-10-28 10:50 UTC (permalink / raw)
To: Alberto Garcia
Cc: qemu-devel, qemu-block, Eric Blake, Markus Armbruster, Max Reitz
Am 28.10.2016 um 09:08 hat Alberto Garcia geschrieben:
> Hi,
>
> thank you Kevin and Eric for your comments. I addressed them all in
> this series.
Thanks, applied to the block branch.
Kevin
^ permalink raw reply [flat|nested] 21+ messages in thread