242 lines
8.3 KiB
Diff
242 lines
8.3 KiB
Diff
|
From 10fbd3c89739a1879f47f2a2256831ce5e1ae7ad Mon Sep 17 00:00:00 2001
|
||
|
From: Kevin Wolf <kwolf@redhat.com>
|
||
|
Date: Wed, 10 Oct 2018 20:22:10 +0100
|
||
|
Subject: test-bdrv-drain: AIO_WAIT_WHILE() in job .commit/.abort
|
||
|
|
||
|
RH-Author: Kevin Wolf <kwolf@redhat.com>
|
||
|
Message-id: <20181010202213.7372-32-kwolf@redhat.com>
|
||
|
Patchwork-id: 82620
|
||
|
O-Subject: [RHEL-8 qemu-kvm PATCH 41/44] test-bdrv-drain: AIO_WAIT_WHILE() in job .commit/.abort
|
||
|
Bugzilla: 1637976
|
||
|
RH-Acked-by: Max Reitz <mreitz@redhat.com>
|
||
|
RH-Acked-by: John Snow <jsnow@redhat.com>
|
||
|
RH-Acked-by: Thomas Huth <thuth@redhat.com>
|
||
|
|
||
|
This adds tests for calling AIO_WAIT_WHILE() in the .commit and .abort
|
||
|
callbacks. Both reasons why .abort could be called for a single job are
|
||
|
tested: Either .run or .prepare could return an error.
|
||
|
|
||
|
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
|
||
|
Reviewed-by: Max Reitz <mreitz@redhat.com>
|
||
|
(cherry picked from commit d49725af46a7710cde02cc120b7f1e485154b483)
|
||
|
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
|
||
|
Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>
|
||
|
---
|
||
|
tests/test-bdrv-drain.c | 116 +++++++++++++++++++++++++++++++++++++++++++-----
|
||
|
1 file changed, 104 insertions(+), 12 deletions(-)
|
||
|
|
||
|
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
|
||
|
index f4b57f7..d6202b2 100644
|
||
|
--- a/tests/test-bdrv-drain.c
|
||
|
+++ b/tests/test-bdrv-drain.c
|
||
|
@@ -784,6 +784,8 @@ static void test_iothread_drain_subtree(void)
|
||
|
|
||
|
typedef struct TestBlockJob {
|
||
|
BlockJob common;
|
||
|
+ int run_ret;
|
||
|
+ int prepare_ret;
|
||
|
bool should_complete;
|
||
|
} TestBlockJob;
|
||
|
|
||
|
@@ -793,7 +795,23 @@ static int test_job_prepare(Job *job)
|
||
|
|
||
|
/* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
|
||
|
blk_flush(s->common.blk);
|
||
|
- return 0;
|
||
|
+ return s->prepare_ret;
|
||
|
+}
|
||
|
+
|
||
|
+static void test_job_commit(Job *job)
|
||
|
+{
|
||
|
+ TestBlockJob *s = container_of(job, TestBlockJob, common.job);
|
||
|
+
|
||
|
+ /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
|
||
|
+ blk_flush(s->common.blk);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_job_abort(Job *job)
|
||
|
+{
|
||
|
+ TestBlockJob *s = container_of(job, TestBlockJob, common.job);
|
||
|
+
|
||
|
+ /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
|
||
|
+ blk_flush(s->common.blk);
|
||
|
}
|
||
|
|
||
|
static int coroutine_fn test_job_run(Job *job, Error **errp)
|
||
|
@@ -809,7 +827,7 @@ static int coroutine_fn test_job_run(Job *job, Error **errp)
|
||
|
job_pause_point(&s->common.job);
|
||
|
}
|
||
|
|
||
|
- return 0;
|
||
|
+ return s->run_ret;
|
||
|
}
|
||
|
|
||
|
static void test_job_complete(Job *job, Error **errp)
|
||
|
@@ -827,14 +845,24 @@ BlockJobDriver test_job_driver = {
|
||
|
.run = test_job_run,
|
||
|
.complete = test_job_complete,
|
||
|
.prepare = test_job_prepare,
|
||
|
+ .commit = test_job_commit,
|
||
|
+ .abort = test_job_abort,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
-static void test_blockjob_common(enum drain_type drain_type, bool use_iothread)
|
||
|
+enum test_job_result {
|
||
|
+ TEST_JOB_SUCCESS,
|
||
|
+ TEST_JOB_FAIL_RUN,
|
||
|
+ TEST_JOB_FAIL_PREPARE,
|
||
|
+};
|
||
|
+
|
||
|
+static void test_blockjob_common(enum drain_type drain_type, bool use_iothread,
|
||
|
+ enum test_job_result result)
|
||
|
{
|
||
|
BlockBackend *blk_src, *blk_target;
|
||
|
BlockDriverState *src, *target;
|
||
|
BlockJob *job;
|
||
|
+ TestBlockJob *tjob;
|
||
|
IOThread *iothread = NULL;
|
||
|
AioContext *ctx;
|
||
|
int ret;
|
||
|
@@ -858,9 +886,23 @@ static void test_blockjob_common(enum drain_type drain_type, bool use_iothread)
|
||
|
blk_insert_bs(blk_target, target, &error_abort);
|
||
|
|
||
|
aio_context_acquire(ctx);
|
||
|
- job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
|
||
|
- 0, 0, NULL, NULL, &error_abort);
|
||
|
+ tjob = block_job_create("job0", &test_job_driver, NULL, src,
|
||
|
+ 0, BLK_PERM_ALL,
|
||
|
+ 0, 0, NULL, NULL, &error_abort);
|
||
|
+ job = &tjob->common;
|
||
|
block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
|
||
|
+
|
||
|
+ switch (result) {
|
||
|
+ case TEST_JOB_SUCCESS:
|
||
|
+ break;
|
||
|
+ case TEST_JOB_FAIL_RUN:
|
||
|
+ tjob->run_ret = -EIO;
|
||
|
+ break;
|
||
|
+ case TEST_JOB_FAIL_PREPARE:
|
||
|
+ tjob->prepare_ret = -EIO;
|
||
|
+ break;
|
||
|
+ }
|
||
|
+
|
||
|
job_start(&job->job);
|
||
|
aio_context_release(ctx);
|
||
|
|
||
|
@@ -918,7 +960,7 @@ static void test_blockjob_common(enum drain_type drain_type, bool use_iothread)
|
||
|
|
||
|
aio_context_acquire(ctx);
|
||
|
ret = job_complete_sync(&job->job, &error_abort);
|
||
|
- g_assert_cmpint(ret, ==, 0);
|
||
|
+ g_assert_cmpint(ret, ==, (result == TEST_JOB_SUCCESS ? 0 : -EIO));
|
||
|
|
||
|
if (use_iothread) {
|
||
|
blk_set_aio_context(blk_src, qemu_get_aio_context());
|
||
|
@@ -937,32 +979,68 @@ static void test_blockjob_common(enum drain_type drain_type, bool use_iothread)
|
||
|
|
||
|
static void test_blockjob_drain_all(void)
|
||
|
{
|
||
|
- test_blockjob_common(BDRV_DRAIN_ALL, false);
|
||
|
+ test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_SUCCESS);
|
||
|
}
|
||
|
|
||
|
static void test_blockjob_drain(void)
|
||
|
{
|
||
|
- test_blockjob_common(BDRV_DRAIN, false);
|
||
|
+ test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_SUCCESS);
|
||
|
}
|
||
|
|
||
|
static void test_blockjob_drain_subtree(void)
|
||
|
{
|
||
|
- test_blockjob_common(BDRV_SUBTREE_DRAIN, false);
|
||
|
+ test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_SUCCESS);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_blockjob_error_drain_all(void)
|
||
|
+{
|
||
|
+ test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_FAIL_RUN);
|
||
|
+ test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_FAIL_PREPARE);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_blockjob_error_drain(void)
|
||
|
+{
|
||
|
+ test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_FAIL_RUN);
|
||
|
+ test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_FAIL_PREPARE);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_blockjob_error_drain_subtree(void)
|
||
|
+{
|
||
|
+ test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_FAIL_RUN);
|
||
|
+ test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_FAIL_PREPARE);
|
||
|
}
|
||
|
|
||
|
static void test_blockjob_iothread_drain_all(void)
|
||
|
{
|
||
|
- test_blockjob_common(BDRV_DRAIN_ALL, true);
|
||
|
+ test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_SUCCESS);
|
||
|
}
|
||
|
|
||
|
static void test_blockjob_iothread_drain(void)
|
||
|
{
|
||
|
- test_blockjob_common(BDRV_DRAIN, true);
|
||
|
+ test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_SUCCESS);
|
||
|
}
|
||
|
|
||
|
static void test_blockjob_iothread_drain_subtree(void)
|
||
|
{
|
||
|
- test_blockjob_common(BDRV_SUBTREE_DRAIN, true);
|
||
|
+ test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_SUCCESS);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_blockjob_iothread_error_drain_all(void)
|
||
|
+{
|
||
|
+ test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_FAIL_RUN);
|
||
|
+ test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_FAIL_PREPARE);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_blockjob_iothread_error_drain(void)
|
||
|
+{
|
||
|
+ test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_FAIL_RUN);
|
||
|
+ test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_FAIL_PREPARE);
|
||
|
+}
|
||
|
+
|
||
|
+static void test_blockjob_iothread_error_drain_subtree(void)
|
||
|
+{
|
||
|
+ test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_FAIL_RUN);
|
||
|
+ test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_FAIL_PREPARE);
|
||
|
}
|
||
|
|
||
|
|
||
|
@@ -1433,6 +1511,13 @@ int main(int argc, char **argv)
|
||
|
g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
|
||
|
test_blockjob_drain_subtree);
|
||
|
|
||
|
+ g_test_add_func("/bdrv-drain/blockjob/error/drain_all",
|
||
|
+ test_blockjob_error_drain_all);
|
||
|
+ g_test_add_func("/bdrv-drain/blockjob/error/drain",
|
||
|
+ test_blockjob_error_drain);
|
||
|
+ g_test_add_func("/bdrv-drain/blockjob/error/drain_subtree",
|
||
|
+ test_blockjob_error_drain_subtree);
|
||
|
+
|
||
|
g_test_add_func("/bdrv-drain/blockjob/iothread/drain_all",
|
||
|
test_blockjob_iothread_drain_all);
|
||
|
g_test_add_func("/bdrv-drain/blockjob/iothread/drain",
|
||
|
@@ -1440,6 +1525,13 @@ int main(int argc, char **argv)
|
||
|
g_test_add_func("/bdrv-drain/blockjob/iothread/drain_subtree",
|
||
|
test_blockjob_iothread_drain_subtree);
|
||
|
|
||
|
+ g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_all",
|
||
|
+ test_blockjob_iothread_error_drain_all);
|
||
|
+ g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain",
|
||
|
+ test_blockjob_iothread_error_drain);
|
||
|
+ g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_subtree",
|
||
|
+ test_blockjob_iothread_error_drain_subtree);
|
||
|
+
|
||
|
g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain);
|
||
|
g_test_add_func("/bdrv-drain/detach/drain_all", test_detach_by_drain_all);
|
||
|
g_test_add_func("/bdrv-drain/detach/drain", test_detach_by_drain);
|
||
|
--
|
||
|
1.8.3.1
|
||
|
|