yeahuh / rpms / qemu-kvm

Forked from rpms/qemu-kvm 2 years ago
Clone

Blame SOURCES/kvm-test-bdrv-drain-bdrv_drain-works-with-cross-AioConte.patch

26ba25
From ae1deee29ac316ea755c96f15b739db7a59e5c61 Mon Sep 17 00:00:00 2001
26ba25
From: Kevin Wolf <kwolf@redhat.com>
26ba25
Date: Wed, 10 Oct 2018 20:08:35 +0100
26ba25
Subject: [PATCH 04/49] test-bdrv-drain: bdrv_drain() works with
26ba25
 cross-AioContext events
26ba25
26ba25
RH-Author: Kevin Wolf <kwolf@redhat.com>
26ba25
Message-id: <20181010200843.6710-2-kwolf@redhat.com>
26ba25
Patchwork-id: 82581
26ba25
O-Subject: [RHEL-8 qemu-kvm PATCH 01/44] test-bdrv-drain: bdrv_drain() works with cross-AioContext events
26ba25
Bugzilla: 1637976
26ba25
RH-Acked-by: Max Reitz <mreitz@redhat.com>
26ba25
RH-Acked-by: John Snow <jsnow@redhat.com>
26ba25
RH-Acked-by: Thomas Huth <thuth@redhat.com>
26ba25
26ba25
As long as nobody keeps the other I/O thread from working, there is no
26ba25
reason why bdrv_drain() wouldn't work with cross-AioContext events. The
26ba25
key is that the root request we're waiting for is in the AioContext
26ba25
we're polling (which it always is for bdrv_drain()) so that aio_poll()
26ba25
is woken up in the end.
26ba25
26ba25
Add a test case that shows that it works. Remove the comment in
26ba25
bdrv_drain() that claims otherwise.
26ba25
26ba25
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
26ba25
(cherry picked from commit bb6756895459f181e2f25e877d3d7a10c297b5c8)
26ba25
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
26ba25
Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>
26ba25
---
26ba25
 block/io.c              |   4 --
26ba25
 tests/test-bdrv-drain.c | 187 +++++++++++++++++++++++++++++++++++++++++++++++-
26ba25
 2 files changed, 186 insertions(+), 5 deletions(-)
26ba25
26ba25
diff --git a/block/io.c b/block/io.c
26ba25
index bb617de..7e0a169 100644
26ba25
--- a/block/io.c
26ba25
+++ b/block/io.c
26ba25
@@ -369,10 +369,6 @@ void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent)
26ba25
  *
26ba25
  * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
26ba25
  * AioContext.
26ba25
- *
26ba25
- * Only this BlockDriverState's AioContext is run, so in-flight requests must
26ba25
- * not depend on events in other AioContexts.  In that case, use
26ba25
- * bdrv_drain_all() instead.
26ba25
  */
26ba25
 void coroutine_fn bdrv_co_drain(BlockDriverState *bs)
26ba25
 {
26ba25
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
26ba25
index 403446e..dee0a10 100644
26ba25
--- a/tests/test-bdrv-drain.c
26ba25
+++ b/tests/test-bdrv-drain.c
26ba25
@@ -27,9 +27,13 @@
26ba25
 #include "block/blockjob_int.h"
26ba25
 #include "sysemu/block-backend.h"
26ba25
 #include "qapi/error.h"
26ba25
+#include "iothread.h"
26ba25
+
26ba25
+static QemuEvent done_event;
26ba25
 
26ba25
 typedef struct BDRVTestState {
26ba25
     int drain_count;
26ba25
+    AioContext *bh_indirection_ctx;
26ba25
 } BDRVTestState;
26ba25
 
26ba25
 static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
26ba25
@@ -50,16 +54,29 @@ static void bdrv_test_close(BlockDriverState *bs)
26ba25
     g_assert_cmpint(s->drain_count, >, 0);
26ba25
 }
26ba25
 
26ba25
+static void co_reenter_bh(void *opaque)
26ba25
+{
26ba25
+    aio_co_wake(opaque);
26ba25
+}
26ba25
+
26ba25
 static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
26ba25
                                             uint64_t offset, uint64_t bytes,
26ba25
                                             QEMUIOVector *qiov, int flags)
26ba25
 {
26ba25
+    BDRVTestState *s = bs->opaque;
26ba25
+
26ba25
     /* We want this request to stay until the polling loop in drain waits for
26ba25
      * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
26ba25
      * first and polls its result, too, but it shouldn't accidentally complete
26ba25
      * this request yet. */
26ba25
     qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
26ba25
 
26ba25
+    if (s->bh_indirection_ctx) {
26ba25
+        aio_bh_schedule_oneshot(s->bh_indirection_ctx, co_reenter_bh,
26ba25
+                                qemu_coroutine_self());
26ba25
+        qemu_coroutine_yield();
26ba25
+    }
26ba25
+
26ba25
     return 0;
26ba25
 }
26ba25
 
26ba25
@@ -490,6 +507,164 @@ static void test_graph_change(void)
26ba25
     blk_unref(blk_b);
26ba25
 }
26ba25
 
26ba25
+struct test_iothread_data {
26ba25
+    BlockDriverState *bs;
26ba25
+    enum drain_type drain_type;
26ba25
+    int *aio_ret;
26ba25
+};
26ba25
+
26ba25
+static void test_iothread_drain_entry(void *opaque)
26ba25
+{
26ba25
+    struct test_iothread_data *data = opaque;
26ba25
+
26ba25
+    aio_context_acquire(bdrv_get_aio_context(data->bs));
26ba25
+    do_drain_begin(data->drain_type, data->bs);
26ba25
+    g_assert_cmpint(*data->aio_ret, ==, 0);
26ba25
+    do_drain_end(data->drain_type, data->bs);
26ba25
+    aio_context_release(bdrv_get_aio_context(data->bs));
26ba25
+
26ba25
+    qemu_event_set(&done_event);
26ba25
+}
26ba25
+
26ba25
+static void test_iothread_aio_cb(void *opaque, int ret)
26ba25
+{
26ba25
+    int *aio_ret = opaque;
26ba25
+    *aio_ret = ret;
26ba25
+    qemu_event_set(&done_event);
26ba25
+}
26ba25
+
26ba25
+/*
26ba25
+ * Starts an AIO request on a BDS that runs in the AioContext of iothread 1.
26ba25
+ * The request involves a BH on iothread 2 before it can complete.
26ba25
+ *
26ba25
+ * @drain_thread = 0 means that do_drain_begin/end are called from the main
26ba25
+ * thread, @drain_thread = 1 means that they are called from iothread 1. Drain
26ba25
+ * for this BDS cannot be called from iothread 2 because only the main thread
26ba25
+ * may do cross-AioContext polling.
26ba25
+ */
26ba25
+static void test_iothread_common(enum drain_type drain_type, int drain_thread)
26ba25
+{
26ba25
+    BlockBackend *blk;
26ba25
+    BlockDriverState *bs;
26ba25
+    BDRVTestState *s;
26ba25
+    BlockAIOCB *acb;
26ba25
+    int aio_ret;
26ba25
+    struct test_iothread_data data;
26ba25
+
26ba25
+    IOThread *a = iothread_new();
26ba25
+    IOThread *b = iothread_new();
26ba25
+    AioContext *ctx_a = iothread_get_aio_context(a);
26ba25
+    AioContext *ctx_b = iothread_get_aio_context(b);
26ba25
+
26ba25
+    QEMUIOVector qiov;
26ba25
+    struct iovec iov = {
26ba25
+        .iov_base = NULL,
26ba25
+        .iov_len = 0,
26ba25
+    };
26ba25
+    qemu_iovec_init_external(&qiov, &iov, 1);
26ba25
+
26ba25
+    /* bdrv_drain_all() may only be called from the main loop thread */
26ba25
+    if (drain_type == BDRV_DRAIN_ALL && drain_thread != 0) {
26ba25
+        goto out;
26ba25
+    }
26ba25
+
26ba25
+    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
26ba25
+    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
26ba25
+                              &error_abort);
26ba25
+    s = bs->opaque;
26ba25
+    blk_insert_bs(blk, bs, &error_abort);
26ba25
+
26ba25
+    blk_set_aio_context(blk, ctx_a);
26ba25
+    aio_context_acquire(ctx_a);
26ba25
+
26ba25
+    s->bh_indirection_ctx = ctx_b;
26ba25
+
26ba25
+    aio_ret = -EINPROGRESS;
26ba25
+    if (drain_thread == 0) {
26ba25
+        acb = blk_aio_preadv(blk, 0, &qiov, 0, test_iothread_aio_cb, &aio_ret);
26ba25
+    } else {
26ba25
+        acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
26ba25
+    }
26ba25
+    g_assert(acb != NULL);
26ba25
+    g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
26ba25
+
26ba25
+    aio_context_release(ctx_a);
26ba25
+
26ba25
+    data = (struct test_iothread_data) {
26ba25
+        .bs         = bs,
26ba25
+        .drain_type = drain_type,
26ba25
+        .aio_ret    = &aio_ret,
26ba25
+    };
26ba25
+
26ba25
+    switch (drain_thread) {
26ba25
+    case 0:
26ba25
+        if (drain_type != BDRV_DRAIN_ALL) {
26ba25
+            aio_context_acquire(ctx_a);
26ba25
+        }
26ba25
+
26ba25
+        /* The request is running on the IOThread a. Draining its block device
26ba25
+         * will make sure that it has completed as far as the BDS is concerned,
26ba25
+         * but the drain in this thread can continue immediately after
26ba25
+         * bdrv_dec_in_flight() and aio_ret might be assigned only slightly
26ba25
+         * later. */
26ba25
+        qemu_event_reset(&done_event);
26ba25
+        do_drain_begin(drain_type, bs);
26ba25
+        g_assert_cmpint(bs->in_flight, ==, 0);
26ba25
+
26ba25
+        if (drain_type != BDRV_DRAIN_ALL) {
26ba25
+            aio_context_release(ctx_a);
26ba25
+        }
26ba25
+        qemu_event_wait(&done_event);
26ba25
+        if (drain_type != BDRV_DRAIN_ALL) {
26ba25
+            aio_context_acquire(ctx_a);
26ba25
+        }
26ba25
+
26ba25
+        g_assert_cmpint(aio_ret, ==, 0);
26ba25
+        do_drain_end(drain_type, bs);
26ba25
+
26ba25
+        if (drain_type != BDRV_DRAIN_ALL) {
26ba25
+            aio_context_release(ctx_a);
26ba25
+        }
26ba25
+        break;
26ba25
+    case 1:
26ba25
+        qemu_event_reset(&done_event);
26ba25
+        aio_bh_schedule_oneshot(ctx_a, test_iothread_drain_entry, &data);
26ba25
+        qemu_event_wait(&done_event);
26ba25
+        break;
26ba25
+    default:
26ba25
+        g_assert_not_reached();
26ba25
+    }
26ba25
+
26ba25
+    aio_context_acquire(ctx_a);
26ba25
+    blk_set_aio_context(blk, qemu_get_aio_context());
26ba25
+    aio_context_release(ctx_a);
26ba25
+
26ba25
+    bdrv_unref(bs);
26ba25
+    blk_unref(blk);
26ba25
+
26ba25
+out:
26ba25
+    iothread_join(a);
26ba25
+    iothread_join(b);
26ba25
+}
26ba25
+
26ba25
+static void test_iothread_drain_all(void)
26ba25
+{
26ba25
+    test_iothread_common(BDRV_DRAIN_ALL, 0);
26ba25
+    test_iothread_common(BDRV_DRAIN_ALL, 1);
26ba25
+}
26ba25
+
26ba25
+static void test_iothread_drain(void)
26ba25
+{
26ba25
+    test_iothread_common(BDRV_DRAIN, 0);
26ba25
+    test_iothread_common(BDRV_DRAIN, 1);
26ba25
+}
26ba25
+
26ba25
+static void test_iothread_drain_subtree(void)
26ba25
+{
26ba25
+    test_iothread_common(BDRV_SUBTREE_DRAIN, 0);
26ba25
+    test_iothread_common(BDRV_SUBTREE_DRAIN, 1);
26ba25
+}
26ba25
+
26ba25
 
26ba25
 typedef struct TestBlockJob {
26ba25
     BlockJob common;
26ba25
@@ -613,10 +788,13 @@ static void test_blockjob_drain_subtree(void)
26ba25
 
26ba25
 int main(int argc, char **argv)
26ba25
 {
26ba25
+    int ret;
26ba25
+
26ba25
     bdrv_init();
26ba25
     qemu_init_main_loop(&error_abort);
26ba25
 
26ba25
     g_test_init(&argc, &argv, NULL);
26ba25
+    qemu_event_init(&done_event, false);
26ba25
 
26ba25
     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
26ba25
     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
26ba25
@@ -643,10 +821,17 @@ int main(int argc, char **argv)
26ba25
     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
26ba25
     g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
26ba25
 
26ba25
+    g_test_add_func("/bdrv-drain/iothread/drain_all", test_iothread_drain_all);
26ba25
+    g_test_add_func("/bdrv-drain/iothread/drain", test_iothread_drain);
26ba25
+    g_test_add_func("/bdrv-drain/iothread/drain_subtree",
26ba25
+                    test_iothread_drain_subtree);
26ba25
+
26ba25
     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
26ba25
     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
26ba25
     g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
26ba25
                     test_blockjob_drain_subtree);
26ba25
 
26ba25
-    return g_test_run();
26ba25
+    ret = g_test_run();
26ba25
+    qemu_event_destroy(&done_event);
26ba25
+    return ret;
26ba25
 }
26ba25
-- 
26ba25
1.8.3.1
26ba25