tests/test-block-iothread.c - qemu - Git at Google

 /*
  * Block tests for iothreads
  *
  * Copyright (c) 2018 Kevin Wolf <kwolf@redhat.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */

 #include "qemu/osdep.h"
 #include "block/block.h"
 #include "block/blockjob_int.h"
 #include "sysemu/block-backend.h"
 #include "qapi/error.h"
 #include "qapi/qmp/qdict.h"
 #include "qemu/main-loop.h"
 #include "iothread.h"

 static int coroutine_fn bdrv_test_co_prwv(BlockDriverState *bs,
                                           uint64_t offset, uint64_t bytes,
                                           QEMUIOVector *qiov, int flags)
 {
     return 0;
 }

 static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
                                               int64_t offset, int bytes)
 {
     return 0;
 }

 static int coroutine_fn
 bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
                       PreallocMode prealloc, BdrvRequestFlags flags,
                       Error **errp)
 {
     return 0;
 }

 static int coroutine_fn bdrv_test_co_block_status(BlockDriverState *bs,
                                                   bool want_zero,
                                                   int64_t offset, int64_t count,
                                                   int64_t *pnum, int64_t *map,
                                                   BlockDriverState **file)
 {
     *pnum = count;
     return 0;
 }

 static BlockDriver bdrv_test = {
     .format_name            = "test",
     .instance_size          = 1,

     .bdrv_co_preadv         = bdrv_test_co_prwv,
     .bdrv_co_pwritev        = bdrv_test_co_prwv,
     .bdrv_co_pdiscard       = bdrv_test_co_pdiscard,
     .bdrv_co_truncate       = bdrv_test_co_truncate,
     .bdrv_co_block_status   = bdrv_test_co_block_status,
 };

 static void test_sync_op_pread(BdrvChild *c)
 {
     uint8_t buf[512];
     int ret;

     /* Success */
     ret = bdrv_pread(c, 0, buf, sizeof(buf));
     g_assert_cmpint(ret, ==, 512);

     /* Early error: Negative offset */
     ret = bdrv_pread(c, -2, buf, sizeof(buf));
     g_assert_cmpint(ret, ==, -EIO);
 }

 static void test_sync_op_pwrite(BdrvChild *c)
 {
     uint8_t buf[512];
     int ret;

     /* Success */
     ret = bdrv_pwrite(c, 0, buf, sizeof(buf));
     g_assert_cmpint(ret, ==, 512);

     /* Early error: Negative offset */
     ret = bdrv_pwrite(c, -2, buf, sizeof(buf));
     g_assert_cmpint(ret, ==, -EIO);
 }

 static void test_sync_op_blk_pread(BlockBackend *blk)
 {
     uint8_t buf[512];
     int ret;

     /* Success */
     ret = blk_pread(blk, 0, buf, sizeof(buf));
     g_assert_cmpint(ret, ==, 512);

     /* Early error: Negative offset */
     ret = blk_pread(blk, -2, buf, sizeof(buf));
     g_assert_cmpint(ret, ==, -EIO);
 }

 static void test_sync_op_blk_pwrite(BlockBackend *blk)
 {
     uint8_t buf[512];
     int ret;

     /* Success */
     ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
     g_assert_cmpint(ret, ==, 512);

     /* Early error: Negative offset */
     ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
     g_assert_cmpint(ret, ==, -EIO);
 }

 static void test_sync_op_load_vmstate(BdrvChild *c)
 {
     uint8_t buf[512];
     int ret;

     /* Error: Driver does not support snapshots */
     ret = bdrv_load_vmstate(c->bs, buf, 0, sizeof(buf));
     g_assert_cmpint(ret, ==, -ENOTSUP);
 }

 static void test_sync_op_save_vmstate(BdrvChild *c)
 {
     uint8_t buf[512];
     int ret;

     /* Error: Driver does not support snapshots */
     ret = bdrv_save_vmstate(c->bs, buf, 0, sizeof(buf));
     g_assert_cmpint(ret, ==, -ENOTSUP);
 }

 static void test_sync_op_pdiscard(BdrvChild *c)
 {
     int ret;

     /* Normal success path */
     c->bs->open_flags |= BDRV_O_UNMAP;
     ret = bdrv_pdiscard(c, 0, 512);
     g_assert_cmpint(ret, ==, 0);

     /* Early success: UNMAP not supported */
     c->bs->open_flags &= ~BDRV_O_UNMAP;
     ret = bdrv_pdiscard(c, 0, 512);
     g_assert_cmpint(ret, ==, 0);

     /* Early error: Negative offset */
     ret = bdrv_pdiscard(c, -2, 512);
     g_assert_cmpint(ret, ==, -EIO);
 }

 static void test_sync_op_blk_pdiscard(BlockBackend *blk)
 {
     int ret;

     /* Early success: UNMAP not supported */
     ret = blk_pdiscard(blk, 0, 512);
     g_assert_cmpint(ret, ==, 0);

     /* Early error: Negative offset */
     ret = blk_pdiscard(blk, -2, 512);
     g_assert_cmpint(ret, ==, -EIO);
 }

 static void test_sync_op_truncate(BdrvChild *c)
 {
     int ret;

     /* Normal success path */
     ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, 0);

     /* Early error: Negative offset */
     ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EINVAL);

     /* Error: Read-only image */
     c->bs->read_only = true;
     c->bs->open_flags &= ~BDRV_O_RDWR;

     ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EACCES);

     c->bs->read_only = false;
     c->bs->open_flags |= BDRV_O_RDWR;
 }

 static void test_sync_op_block_status(BdrvChild *c)
 {
     int ret;
     int64_t n;

     /* Normal success path */
     ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
     g_assert_cmpint(ret, ==, 0);

     /* Early success: No driver support */
     bdrv_test.bdrv_co_block_status = NULL;
     ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
     g_assert_cmpint(ret, ==, 1);

     /* Early success: bytes = 0 */
     ret = bdrv_is_allocated(c->bs, 0, 0, &n);
     g_assert_cmpint(ret, ==, 0);

     /* Early success: Offset > image size*/
     ret = bdrv_is_allocated(c->bs, 0x1000000, 0x1000000, &n);
     g_assert_cmpint(ret, ==, 0);
 }

 static void test_sync_op_flush(BdrvChild *c)
 {
     int ret;

     /* Normal success path */
     ret = bdrv_flush(c->bs);
     g_assert_cmpint(ret, ==, 0);

     /* Early success: Read-only image */
     c->bs->read_only = true;
     c->bs->open_flags &= ~BDRV_O_RDWR;

     ret = bdrv_flush(c->bs);
     g_assert_cmpint(ret, ==, 0);

     c->bs->read_only = false;
     c->bs->open_flags |= BDRV_O_RDWR;
 }

 static void test_sync_op_blk_flush(BlockBackend *blk)
 {
     BlockDriverState *bs = blk_bs(blk);
     int ret;

     /* Normal success path */
     ret = blk_flush(blk);
     g_assert_cmpint(ret, ==, 0);

     /* Early success: Read-only image */
     bs->read_only = true;
     bs->open_flags &= ~BDRV_O_RDWR;

     ret = blk_flush(blk);
     g_assert_cmpint(ret, ==, 0);

     bs->read_only = false;
     bs->open_flags |= BDRV_O_RDWR;
 }

 static void test_sync_op_check(BdrvChild *c)
 {
     BdrvCheckResult result;
     int ret;

     /* Error: Driver does not implement check */
     ret = bdrv_check(c->bs, &result, 0);
     g_assert_cmpint(ret, ==, -ENOTSUP);
 }

 static void test_sync_op_invalidate_cache(BdrvChild *c)
 {
     /* Early success: Image is not inactive */
     bdrv_invalidate_cache(c->bs, NULL);
 }


 typedef struct SyncOpTest {
     const char *name;
     void (*fn)(BdrvChild *c);
     void (*blkfn)(BlockBackend *blk);
 } SyncOpTest;

 const SyncOpTest sync_op_tests[] = {
     {
         .name   = "/sync-op/pread",
         .fn     = test_sync_op_pread,
         .blkfn  = test_sync_op_blk_pread,
     }, {
         .name   = "/sync-op/pwrite",
         .fn     = test_sync_op_pwrite,
         .blkfn  = test_sync_op_blk_pwrite,
     }, {
         .name   = "/sync-op/load_vmstate",
         .fn     = test_sync_op_load_vmstate,
     }, {
         .name   = "/sync-op/save_vmstate",
         .fn     = test_sync_op_save_vmstate,
     }, {
         .name   = "/sync-op/pdiscard",
         .fn     = test_sync_op_pdiscard,
         .blkfn  = test_sync_op_blk_pdiscard,
     }, {
         .name   = "/sync-op/truncate",
         .fn     = test_sync_op_truncate,
     }, {
         .name   = "/sync-op/block_status",
         .fn     = test_sync_op_block_status,
     }, {
         .name   = "/sync-op/flush",
         .fn     = test_sync_op_flush,
         .blkfn  = test_sync_op_blk_flush,
     }, {
         .name   = "/sync-op/check",
         .fn     = test_sync_op_check,
     }, {
         .name   = "/sync-op/invalidate_cache",
         .fn     = test_sync_op_invalidate_cache,
     },
 };

 /* Test synchronous operations that run in a different iothread, so we have to
  * poll for the coroutine there to return. */
 static void test_sync_op(const void *opaque)
 {
     const SyncOpTest *t = opaque;
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     BlockBackend *blk;
     BlockDriverState *bs;
     BdrvChild *c;

     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
     bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
     blk_insert_bs(blk, bs, &error_abort);
     c = QLIST_FIRST(&bs->parents);

     blk_set_aio_context(blk, ctx, &error_abort);
     aio_context_acquire(ctx);
     t->fn(c);
     if (t->blkfn) {
         t->blkfn(blk);
     }
     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
     aio_context_release(ctx);

     bdrv_unref(bs);
     blk_unref(blk);
 }

 typedef struct TestBlockJob {
     BlockJob common;
     bool should_complete;
     int n;
 } TestBlockJob;

 static int test_job_prepare(Job *job)
 {
     g_assert(qemu_get_current_aio_context() == qemu_get_aio_context());
     return 0;
 }

 static int coroutine_fn test_job_run(Job *job, Error **errp)
 {
     TestBlockJob *s = container_of(job, TestBlockJob, common.job);

     job_transition_to_ready(&s->common.job);
     while (!s->should_complete) {
         s->n++;
         g_assert(qemu_get_current_aio_context() == job->aio_context);

         /* Avoid job_sleep_ns() because it marks the job as !busy. We want to
          * emulate some actual activity (probably some I/O) here so that the
          * drain involved in AioContext switches has to wait for this activity
          * to stop. */
         qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000);

         job_pause_point(&s->common.job);
     }

     g_assert(qemu_get_current_aio_context() == job->aio_context);
     return 0;
 }

 static void test_job_complete(Job *job, Error **errp)
 {
     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
     s->should_complete = true;
 }

 BlockJobDriver test_job_driver = {
     .job_driver = {
         .instance_size  = sizeof(TestBlockJob),
         .free           = block_job_free,
         .user_resume    = block_job_user_resume,
         .run            = test_job_run,
         .complete       = test_job_complete,
         .prepare        = test_job_prepare,
     },
 };

 static void test_attach_blockjob(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     BlockBackend *blk;
     BlockDriverState *bs;
     TestBlockJob *tjob;

     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
     blk_insert_bs(blk, bs, &error_abort);

     tjob = block_job_create("job0", &test_job_driver, NULL, bs,
                             0, BLK_PERM_ALL,
                             0, 0, NULL, NULL, &error_abort);
     job_start(&tjob->common.job);

     while (tjob->n == 0) {
         aio_poll(qemu_get_aio_context(), false);
     }

     blk_set_aio_context(blk, ctx, &error_abort);

     tjob->n = 0;
     while (tjob->n == 0) {
         aio_poll(qemu_get_aio_context(), false);
     }

     aio_context_acquire(ctx);
     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
     aio_context_release(ctx);

     tjob->n = 0;
     while (tjob->n == 0) {
         aio_poll(qemu_get_aio_context(), false);
     }

     blk_set_aio_context(blk, ctx, &error_abort);

     tjob->n = 0;
     while (tjob->n == 0) {
         aio_poll(qemu_get_aio_context(), false);
     }

     aio_context_acquire(ctx);
     job_complete_sync(&tjob->common.job, &error_abort);
     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
     aio_context_release(ctx);

     bdrv_unref(bs);
     blk_unref(blk);
 }

 /*
  * Test that changing the AioContext for one node in a tree (here through blk)
  * changes all other nodes as well:
  *
  *  blk
  *   |
  *   |  bs_verify [blkverify]
  *   |   /               \
  *   |  /                 \
  *  bs_a [bdrv_test]    bs_b [bdrv_test]
  *
  */
 static void test_propagate_basic(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     AioContext *main_ctx;
     BlockBackend *blk;
     BlockDriverState *bs_a, *bs_b, *bs_verify;
     QDict *options;

     /*
      * Create bs_a and its BlockBackend.  We cannot take the RESIZE
      * permission because blkverify will not share it on the test
      * image.
      */
     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
                   BLK_PERM_ALL);
     bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
     blk_insert_bs(blk, bs_a, &error_abort);

     /* Create bs_b */
     bs_b = bdrv_new_open_driver(&bdrv_test, "bs_b", BDRV_O_RDWR, &error_abort);

     /* Create blkverify filter that references both bs_a and bs_b */
     options = qdict_new();
     qdict_put_str(options, "driver", "blkverify");
     qdict_put_str(options, "test", "bs_a");
     qdict_put_str(options, "raw", "bs_b");

     bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);

     /* Switch the AioContext */
     blk_set_aio_context(blk, ctx, &error_abort);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs_a) == ctx);
     g_assert(bdrv_get_aio_context(bs_verify) == ctx);
     g_assert(bdrv_get_aio_context(bs_b) == ctx);

     /* Switch the AioContext back */
     main_ctx = qemu_get_aio_context();
     aio_context_acquire(ctx);
     blk_set_aio_context(blk, main_ctx, &error_abort);
     aio_context_release(ctx);
     g_assert(blk_get_aio_context(blk) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_b) == main_ctx);

     bdrv_unref(bs_verify);
     bdrv_unref(bs_b);
     bdrv_unref(bs_a);
     blk_unref(blk);
 }

 /*
  * Test that diamonds in the graph don't lead to endless recursion:
  *
  *              blk
  *               |
  *      bs_verify [blkverify]
  *       /              \
  *      /                \
  *   bs_b [raw]         bs_c[raw]
  *      \                /
  *       \              /
  *       bs_a [bdrv_test]
  */
 static void test_propagate_diamond(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     AioContext *main_ctx;
     BlockBackend *blk;
     BlockDriverState *bs_a, *bs_b, *bs_c, *bs_verify;
     QDict *options;

     /* Create bs_a */
     bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);

     /* Create bs_b and bc_c */
     options = qdict_new();
     qdict_put_str(options, "driver", "raw");
     qdict_put_str(options, "file", "bs_a");
     qdict_put_str(options, "node-name", "bs_b");
     bs_b = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);

     options = qdict_new();
     qdict_put_str(options, "driver", "raw");
     qdict_put_str(options, "file", "bs_a");
     qdict_put_str(options, "node-name", "bs_c");
     bs_c = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);

     /* Create blkverify filter that references both bs_b and bs_c */
     options = qdict_new();
     qdict_put_str(options, "driver", "blkverify");
     qdict_put_str(options, "test", "bs_b");
     qdict_put_str(options, "raw", "bs_c");

     bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
     /*
      * Do not take the RESIZE permission: This would require the same
      * from bs_c and thus from bs_a; however, blkverify will not share
      * it on bs_b, and thus it will not be available for bs_a.
      */
     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
                   BLK_PERM_ALL);
     blk_insert_bs(blk, bs_verify, &error_abort);

     /* Switch the AioContext */
     blk_set_aio_context(blk, ctx, &error_abort);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs_verify) == ctx);
     g_assert(bdrv_get_aio_context(bs_a) == ctx);
     g_assert(bdrv_get_aio_context(bs_b) == ctx);
     g_assert(bdrv_get_aio_context(bs_c) == ctx);

     /* Switch the AioContext back */
     main_ctx = qemu_get_aio_context();
     aio_context_acquire(ctx);
     blk_set_aio_context(blk, main_ctx, &error_abort);
     aio_context_release(ctx);
     g_assert(blk_get_aio_context(blk) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_b) == main_ctx);
     g_assert(bdrv_get_aio_context(bs_c) == main_ctx);

     blk_unref(blk);
     bdrv_unref(bs_verify);
     bdrv_unref(bs_c);
     bdrv_unref(bs_b);
     bdrv_unref(bs_a);
 }

 static void test_propagate_mirror(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     AioContext *main_ctx = qemu_get_aio_context();
     BlockDriverState *src, *target, *filter;
     BlockBackend *blk;
     Job *job;
     Error *local_err = NULL;

     /* Create src and target*/
     src = bdrv_new_open_driver(&bdrv_test, "src", BDRV_O_RDWR, &error_abort);
     target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
                                   &error_abort);

     /* Start a mirror job */
     mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
                  MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
                  BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
                  false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
                  &error_abort);
     job = job_get("job0");
     filter = bdrv_find_node("filter_node");

     /* Change the AioContext of src */
     bdrv_try_set_aio_context(src, ctx, &error_abort);
     g_assert(bdrv_get_aio_context(src) == ctx);
     g_assert(bdrv_get_aio_context(target) == ctx);
     g_assert(bdrv_get_aio_context(filter) == ctx);
     g_assert(job->aio_context == ctx);

     /* Change the AioContext of target */
     aio_context_acquire(ctx);
     bdrv_try_set_aio_context(target, main_ctx, &error_abort);
     aio_context_release(ctx);
     g_assert(bdrv_get_aio_context(src) == main_ctx);
     g_assert(bdrv_get_aio_context(target) == main_ctx);
     g_assert(bdrv_get_aio_context(filter) == main_ctx);

     /* With a BlockBackend on src, changing target must fail */
     blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
     blk_insert_bs(blk, src, &error_abort);

     bdrv_try_set_aio_context(target, ctx, &local_err);
     error_free_or_abort(&local_err);

     g_assert(blk_get_aio_context(blk) == main_ctx);
     g_assert(bdrv_get_aio_context(src) == main_ctx);
     g_assert(bdrv_get_aio_context(target) == main_ctx);
     g_assert(bdrv_get_aio_context(filter) == main_ctx);

     /* ...unless we explicitly allow it */
     aio_context_acquire(ctx);
     blk_set_allow_aio_context_change(blk, true);
     bdrv_try_set_aio_context(target, ctx, &error_abort);
     aio_context_release(ctx);

     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(src) == ctx);
     g_assert(bdrv_get_aio_context(target) == ctx);
     g_assert(bdrv_get_aio_context(filter) == ctx);

     job_cancel_sync_all();

     aio_context_acquire(ctx);
     blk_set_aio_context(blk, main_ctx, &error_abort);
     bdrv_try_set_aio_context(target, main_ctx, &error_abort);
     aio_context_release(ctx);

     blk_unref(blk);
     bdrv_unref(src);
     bdrv_unref(target);
 }

 static void test_attach_second_node(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     AioContext *main_ctx = qemu_get_aio_context();
     BlockBackend *blk;
     BlockDriverState *bs, *filter;
     QDict *options;

     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
     blk_insert_bs(blk, bs, &error_abort);

     options = qdict_new();
     qdict_put_str(options, "driver", "raw");
     qdict_put_str(options, "file", "base");

     filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs) == ctx);
     g_assert(bdrv_get_aio_context(filter) == ctx);

     aio_context_acquire(ctx);
     blk_set_aio_context(blk, main_ctx, &error_abort);
     aio_context_release(ctx);
     g_assert(blk_get_aio_context(blk) == main_ctx);
     g_assert(bdrv_get_aio_context(bs) == main_ctx);
     g_assert(bdrv_get_aio_context(filter) == main_ctx);

     bdrv_unref(filter);
     bdrv_unref(bs);
     blk_unref(blk);
 }

 static void test_attach_preserve_blk_ctx(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
     BlockBackend *blk;
     BlockDriverState *bs;

     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
     bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;

     /* Add node to BlockBackend that has an iothread context assigned */
     blk_insert_bs(blk, bs, &error_abort);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs) == ctx);

     /* Remove the node again */
     aio_context_acquire(ctx);
     blk_remove_bs(blk);
     aio_context_release(ctx);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());

     /* Re-attach the node */
     blk_insert_bs(blk, bs, &error_abort);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs) == ctx);

     aio_context_acquire(ctx);
     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
     aio_context_release(ctx);
     bdrv_unref(bs);
     blk_unref(blk);
 }

 int main(int argc, char **argv)
 {
     int i;

     bdrv_init();
     qemu_init_main_loop(&error_abort);

     g_test_init(&argc, &argv, NULL);

     for (i = 0; i < ARRAY_SIZE(sync_op_tests); i++) {
         const SyncOpTest *t = &sync_op_tests[i];
         g_test_add_data_func(t->name, t, test_sync_op);
     }

     g_test_add_func("/attach/blockjob", test_attach_blockjob);
     g_test_add_func("/attach/second_node", test_attach_second_node);
     g_test_add_func("/attach/preserve_blk_ctx", test_attach_preserve_blk_ctx);
     g_test_add_func("/propagate/basic", test_propagate_basic);
     g_test_add_func("/propagate/diamond", test_propagate_diamond);
     g_test_add_func("/propagate/mirror", test_propagate_mirror);

     return g_test_run();
 }
	/*
	* Block tests for iothreads
	*
	* Copyright (c) 2018 Kevin Wolf <kwolf@redhat.com>
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	*/

	#include "qemu/osdep.h"
	#include "block/block.h"
	#include "block/blockjob_int.h"
	#include "sysemu/block-backend.h"
	#include "qapi/error.h"
	#include "qapi/qmp/qdict.h"
	#include "qemu/main-loop.h"
	#include "iothread.h"

	static int coroutine_fn bdrv_test_co_prwv(BlockDriverState *bs,
	uint64_t offset, uint64_t bytes,
	QEMUIOVector *qiov, int flags)
	{
	return 0;
	}

	static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
	int64_t offset, int bytes)
	{
	return 0;
	}

	static int coroutine_fn
	bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
	PreallocMode prealloc, BdrvRequestFlags flags,
	Error **errp)
	{
	return 0;
	}

	static int coroutine_fn bdrv_test_co_block_status(BlockDriverState *bs,
	bool want_zero,
	int64_t offset, int64_t count,
	int64_t pnum, int64_t map,
	BlockDriverState **file)
	{
	*pnum = count;
	return 0;
	}

	static BlockDriver bdrv_test = {
	.format_name = "test",
	.instance_size = 1,

	.bdrv_co_preadv = bdrv_test_co_prwv,
	.bdrv_co_pwritev = bdrv_test_co_prwv,
	.bdrv_co_pdiscard = bdrv_test_co_pdiscard,
	.bdrv_co_truncate = bdrv_test_co_truncate,
	.bdrv_co_block_status = bdrv_test_co_block_status,
	};

	static void test_sync_op_pread(BdrvChild *c)
	{
	uint8_t buf[512];
	int ret;

	/* Success */
	ret = bdrv_pread(c, 0, buf, sizeof(buf));
	g_assert_cmpint(ret, ==, 512);

	/* Early error: Negative offset */
	ret = bdrv_pread(c, -2, buf, sizeof(buf));
	g_assert_cmpint(ret, ==, -EIO);
	}

	static void test_sync_op_pwrite(BdrvChild *c)
	{
	uint8_t buf[512];
	int ret;

	/* Success */
	ret = bdrv_pwrite(c, 0, buf, sizeof(buf));
	g_assert_cmpint(ret, ==, 512);

	/* Early error: Negative offset */
	ret = bdrv_pwrite(c, -2, buf, sizeof(buf));
	g_assert_cmpint(ret, ==, -EIO);
	}

	static void test_sync_op_blk_pread(BlockBackend *blk)
	{
	uint8_t buf[512];
	int ret;

	/* Success */
	ret = blk_pread(blk, 0, buf, sizeof(buf));
	g_assert_cmpint(ret, ==, 512);

	/* Early error: Negative offset */
	ret = blk_pread(blk, -2, buf, sizeof(buf));
	g_assert_cmpint(ret, ==, -EIO);
	}

	static void test_sync_op_blk_pwrite(BlockBackend *blk)
	{
	uint8_t buf[512];
	int ret;

	/* Success */
	ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
	g_assert_cmpint(ret, ==, 512);

	/* Early error: Negative offset */
	ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
	g_assert_cmpint(ret, ==, -EIO);
	}

	static void test_sync_op_load_vmstate(BdrvChild *c)
	{
	uint8_t buf[512];
	int ret;

	/* Error: Driver does not support snapshots */
	ret = bdrv_load_vmstate(c->bs, buf, 0, sizeof(buf));
	g_assert_cmpint(ret, ==, -ENOTSUP);
	}

	static void test_sync_op_save_vmstate(BdrvChild *c)
	{
	uint8_t buf[512];
	int ret;

	/* Error: Driver does not support snapshots */
	ret = bdrv_save_vmstate(c->bs, buf, 0, sizeof(buf));
	g_assert_cmpint(ret, ==, -ENOTSUP);
	}

	static void test_sync_op_pdiscard(BdrvChild *c)
	{
	int ret;

	/* Normal success path */
	c->bs->open_flags \|= BDRV_O_UNMAP;
	ret = bdrv_pdiscard(c, 0, 512);
	g_assert_cmpint(ret, ==, 0);

	/* Early success: UNMAP not supported */
	c->bs->open_flags &= ~BDRV_O_UNMAP;
	ret = bdrv_pdiscard(c, 0, 512);
	g_assert_cmpint(ret, ==, 0);

	/* Early error: Negative offset */
	ret = bdrv_pdiscard(c, -2, 512);
	g_assert_cmpint(ret, ==, -EIO);
	}

	static void test_sync_op_blk_pdiscard(BlockBackend *blk)
	{
	int ret;

	/* Early success: UNMAP not supported */
	ret = blk_pdiscard(blk, 0, 512);
	g_assert_cmpint(ret, ==, 0);

	/* Early error: Negative offset */
	ret = blk_pdiscard(blk, -2, 512);
	g_assert_cmpint(ret, ==, -EIO);
	}

	static void test_sync_op_truncate(BdrvChild *c)
	{
	int ret;

	/* Normal success path */
	ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
	g_assert_cmpint(ret, ==, 0);

	/* Early error: Negative offset */
	ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
	g_assert_cmpint(ret, ==, -EINVAL);

	/* Error: Read-only image */
	c->bs->read_only = true;
	c->bs->open_flags &= ~BDRV_O_RDWR;

	ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
	g_assert_cmpint(ret, ==, -EACCES);

	c->bs->read_only = false;
	c->bs->open_flags \|= BDRV_O_RDWR;
	}

	static void test_sync_op_block_status(BdrvChild *c)
	{
	int ret;
	int64_t n;

	/* Normal success path */
	ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
	g_assert_cmpint(ret, ==, 0);

	/* Early success: No driver support */
	bdrv_test.bdrv_co_block_status = NULL;
	ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
	g_assert_cmpint(ret, ==, 1);

	/* Early success: bytes = 0 */
	ret = bdrv_is_allocated(c->bs, 0, 0, &n);
	g_assert_cmpint(ret, ==, 0);

	/* Early success: Offset > image size*/
	ret = bdrv_is_allocated(c->bs, 0x1000000, 0x1000000, &n);
	g_assert_cmpint(ret, ==, 0);
	}

	static void test_sync_op_flush(BdrvChild *c)
	{
	int ret;

	/* Normal success path */
	ret = bdrv_flush(c->bs);
	g_assert_cmpint(ret, ==, 0);

	/* Early success: Read-only image */
	c->bs->read_only = true;
	c->bs->open_flags &= ~BDRV_O_RDWR;

	ret = bdrv_flush(c->bs);
	g_assert_cmpint(ret, ==, 0);

	c->bs->read_only = false;
	c->bs->open_flags \|= BDRV_O_RDWR;
	}

	static void test_sync_op_blk_flush(BlockBackend *blk)
	{
	BlockDriverState *bs = blk_bs(blk);
	int ret;

	/* Normal success path */
	ret = blk_flush(blk);
	g_assert_cmpint(ret, ==, 0);

	/* Early success: Read-only image */
	bs->read_only = true;
	bs->open_flags &= ~BDRV_O_RDWR;

	ret = blk_flush(blk);
	g_assert_cmpint(ret, ==, 0);

	bs->read_only = false;
	bs->open_flags \|= BDRV_O_RDWR;
	}

	static void test_sync_op_check(BdrvChild *c)
	{
	BdrvCheckResult result;
	int ret;

	/* Error: Driver does not implement check */
	ret = bdrv_check(c->bs, &result, 0);
	g_assert_cmpint(ret, ==, -ENOTSUP);
	}

	static void test_sync_op_invalidate_cache(BdrvChild *c)
	{
	/* Early success: Image is not inactive */
	bdrv_invalidate_cache(c->bs, NULL);
	}


	typedef struct SyncOpTest {
	const char *name;
	void (fn)(BdrvChild c);
	void (blkfn)(BlockBackend blk);
	} SyncOpTest;

	const SyncOpTest sync_op_tests[] = {
	{
	.name = "/sync-op/pread",
	.fn = test_sync_op_pread,
	.blkfn = test_sync_op_blk_pread,
	}, {
	.name = "/sync-op/pwrite",
	.fn = test_sync_op_pwrite,
	.blkfn = test_sync_op_blk_pwrite,
	}, {
	.name = "/sync-op/load_vmstate",
	.fn = test_sync_op_load_vmstate,
	}, {
	.name = "/sync-op/save_vmstate",
	.fn = test_sync_op_save_vmstate,
	}, {
	.name = "/sync-op/pdiscard",
	.fn = test_sync_op_pdiscard,
	.blkfn = test_sync_op_blk_pdiscard,
	}, {
	.name = "/sync-op/truncate",
	.fn = test_sync_op_truncate,
	}, {
	.name = "/sync-op/block_status",
	.fn = test_sync_op_block_status,
	}, {
	.name = "/sync-op/flush",
	.fn = test_sync_op_flush,
	.blkfn = test_sync_op_blk_flush,
	}, {
	.name = "/sync-op/check",
	.fn = test_sync_op_check,
	}, {
	.name = "/sync-op/invalidate_cache",
	.fn = test_sync_op_invalidate_cache,
	},
	};

	/* Test synchronous operations that run in a different iothread, so we have to
	* poll for the coroutine there to return. */
	static void test_sync_op(const void *opaque)
	{
	const SyncOpTest *t = opaque;
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	BlockBackend *blk;
	BlockDriverState *bs;
	BdrvChild *c;

	blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
	bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
	bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
	blk_insert_bs(blk, bs, &error_abort);
	c = QLIST_FIRST(&bs->parents);

	blk_set_aio_context(blk, ctx, &error_abort);
	aio_context_acquire(ctx);
	t->fn(c);
	if (t->blkfn) {
	t->blkfn(blk);
	}
	blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
	aio_context_release(ctx);

	bdrv_unref(bs);
	blk_unref(blk);
	}

	typedef struct TestBlockJob {
	BlockJob common;
	bool should_complete;
	int n;
	} TestBlockJob;

	static int test_job_prepare(Job *job)
	{
	g_assert(qemu_get_current_aio_context() == qemu_get_aio_context());
	return 0;
	}

	static int coroutine_fn test_job_run(Job job, Error *errp)
	{
	TestBlockJob *s = container_of(job, TestBlockJob, common.job);

	job_transition_to_ready(&s->common.job);
	while (!s->should_complete) {
	s->n++;
	g_assert(qemu_get_current_aio_context() == job->aio_context);

	/* Avoid job_sleep_ns() because it marks the job as !busy. We want to
	* emulate some actual activity (probably some I/O) here so that the
	* drain involved in AioContext switches has to wait for this activity
	* to stop. */
	qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000);

	job_pause_point(&s->common.job);
	}

	g_assert(qemu_get_current_aio_context() == job->aio_context);
	return 0;
	}

	static void test_job_complete(Job job, Error *errp)
	{
	TestBlockJob *s = container_of(job, TestBlockJob, common.job);
	s->should_complete = true;
	}

	BlockJobDriver test_job_driver = {
	.job_driver = {
	.instance_size = sizeof(TestBlockJob),
	.free = block_job_free,
	.user_resume = block_job_user_resume,
	.run = test_job_run,
	.complete = test_job_complete,
	.prepare = test_job_prepare,
	},
	};

	static void test_attach_blockjob(void)
	{
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	BlockBackend *blk;
	BlockDriverState *bs;
	TestBlockJob *tjob;

	blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
	bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
	blk_insert_bs(blk, bs, &error_abort);

	tjob = block_job_create("job0", &test_job_driver, NULL, bs,
	0, BLK_PERM_ALL,
	0, 0, NULL, NULL, &error_abort);
	job_start(&tjob->common.job);

	while (tjob->n == 0) {
	aio_poll(qemu_get_aio_context(), false);
	}

	blk_set_aio_context(blk, ctx, &error_abort);

	tjob->n = 0;
	while (tjob->n == 0) {
	aio_poll(qemu_get_aio_context(), false);
	}

	aio_context_acquire(ctx);
	blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
	aio_context_release(ctx);

	tjob->n = 0;
	while (tjob->n == 0) {
	aio_poll(qemu_get_aio_context(), false);
	}

	blk_set_aio_context(blk, ctx, &error_abort);

	tjob->n = 0;
	while (tjob->n == 0) {
	aio_poll(qemu_get_aio_context(), false);
	}

	aio_context_acquire(ctx);
	job_complete_sync(&tjob->common.job, &error_abort);
	blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
	aio_context_release(ctx);

	bdrv_unref(bs);
	blk_unref(blk);
	}

	/*
	* Test that changing the AioContext for one node in a tree (here through blk)
	* changes all other nodes as well:
	*
	* blk
	* \|
	* \| bs_verify [blkverify]
	* \| / \
	* \| / \
	* bs_a [bdrv_test] bs_b [bdrv_test]
	*
	*/
	static void test_propagate_basic(void)
	{
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	AioContext *main_ctx;
	BlockBackend *blk;
	BlockDriverState bs_a, bs_b, *bs_verify;
	QDict *options;

	/*
	* Create bs_a and its BlockBackend. We cannot take the RESIZE
	* permission because blkverify will not share it on the test
	* image.
	*/
	blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
	BLK_PERM_ALL);
	bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
	blk_insert_bs(blk, bs_a, &error_abort);

	/* Create bs_b */
	bs_b = bdrv_new_open_driver(&bdrv_test, "bs_b", BDRV_O_RDWR, &error_abort);

	/* Create blkverify filter that references both bs_a and bs_b */
	options = qdict_new();
	qdict_put_str(options, "driver", "blkverify");
	qdict_put_str(options, "test", "bs_a");
	qdict_put_str(options, "raw", "bs_b");

	bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);

	/* Switch the AioContext */
	blk_set_aio_context(blk, ctx, &error_abort);
	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(bs_a) == ctx);
	g_assert(bdrv_get_aio_context(bs_verify) == ctx);
	g_assert(bdrv_get_aio_context(bs_b) == ctx);

	/* Switch the AioContext back */
	main_ctx = qemu_get_aio_context();
	aio_context_acquire(ctx);
	blk_set_aio_context(blk, main_ctx, &error_abort);
	aio_context_release(ctx);
	g_assert(blk_get_aio_context(blk) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_b) == main_ctx);

	bdrv_unref(bs_verify);
	bdrv_unref(bs_b);
	bdrv_unref(bs_a);
	blk_unref(blk);
	}

	/*
	* Test that diamonds in the graph don't lead to endless recursion:
	*
	* blk
	* \|
	* bs_verify [blkverify]
	* / \
	* / \
	* bs_b [raw] bs_c[raw]
	* \ /
	* \ /
	* bs_a [bdrv_test]
	*/
	static void test_propagate_diamond(void)
	{
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	AioContext *main_ctx;
	BlockBackend *blk;
	BlockDriverState bs_a, bs_b, bs_c, bs_verify;
	QDict *options;

	/* Create bs_a */
	bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);

	/* Create bs_b and bc_c */
	options = qdict_new();
	qdict_put_str(options, "driver", "raw");
	qdict_put_str(options, "file", "bs_a");
	qdict_put_str(options, "node-name", "bs_b");
	bs_b = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);

	options = qdict_new();
	qdict_put_str(options, "driver", "raw");
	qdict_put_str(options, "file", "bs_a");
	qdict_put_str(options, "node-name", "bs_c");
	bs_c = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);

	/* Create blkverify filter that references both bs_b and bs_c */
	options = qdict_new();
	qdict_put_str(options, "driver", "blkverify");
	qdict_put_str(options, "test", "bs_b");
	qdict_put_str(options, "raw", "bs_c");

	bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
	/*
	* Do not take the RESIZE permission: This would require the same
	* from bs_c and thus from bs_a; however, blkverify will not share
	* it on bs_b, and thus it will not be available for bs_a.
	*/
	blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
	BLK_PERM_ALL);
	blk_insert_bs(blk, bs_verify, &error_abort);

	/* Switch the AioContext */
	blk_set_aio_context(blk, ctx, &error_abort);
	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(bs_verify) == ctx);
	g_assert(bdrv_get_aio_context(bs_a) == ctx);
	g_assert(bdrv_get_aio_context(bs_b) == ctx);
	g_assert(bdrv_get_aio_context(bs_c) == ctx);

	/* Switch the AioContext back */
	main_ctx = qemu_get_aio_context();
	aio_context_acquire(ctx);
	blk_set_aio_context(blk, main_ctx, &error_abort);
	aio_context_release(ctx);
	g_assert(blk_get_aio_context(blk) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_b) == main_ctx);
	g_assert(bdrv_get_aio_context(bs_c) == main_ctx);

	blk_unref(blk);
	bdrv_unref(bs_verify);
	bdrv_unref(bs_c);
	bdrv_unref(bs_b);
	bdrv_unref(bs_a);
	}

	static void test_propagate_mirror(void)
	{
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	AioContext *main_ctx = qemu_get_aio_context();
	BlockDriverState src, target, *filter;
	BlockBackend *blk;
	Job *job;
	Error *local_err = NULL;

	/* Create src and target*/
	src = bdrv_new_open_driver(&bdrv_test, "src", BDRV_O_RDWR, &error_abort);
	target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
	&error_abort);

	/* Start a mirror job */
	mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
	MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
	BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
	false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
	&error_abort);
	job = job_get("job0");
	filter = bdrv_find_node("filter_node");

	/* Change the AioContext of src */
	bdrv_try_set_aio_context(src, ctx, &error_abort);
	g_assert(bdrv_get_aio_context(src) == ctx);
	g_assert(bdrv_get_aio_context(target) == ctx);
	g_assert(bdrv_get_aio_context(filter) == ctx);
	g_assert(job->aio_context == ctx);

	/* Change the AioContext of target */
	aio_context_acquire(ctx);
	bdrv_try_set_aio_context(target, main_ctx, &error_abort);
	aio_context_release(ctx);
	g_assert(bdrv_get_aio_context(src) == main_ctx);
	g_assert(bdrv_get_aio_context(target) == main_ctx);
	g_assert(bdrv_get_aio_context(filter) == main_ctx);

	/* With a BlockBackend on src, changing target must fail */
	blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
	blk_insert_bs(blk, src, &error_abort);

	bdrv_try_set_aio_context(target, ctx, &local_err);
	error_free_or_abort(&local_err);

	g_assert(blk_get_aio_context(blk) == main_ctx);
	g_assert(bdrv_get_aio_context(src) == main_ctx);
	g_assert(bdrv_get_aio_context(target) == main_ctx);
	g_assert(bdrv_get_aio_context(filter) == main_ctx);

	/* ...unless we explicitly allow it */
	aio_context_acquire(ctx);
	blk_set_allow_aio_context_change(blk, true);
	bdrv_try_set_aio_context(target, ctx, &error_abort);
	aio_context_release(ctx);

	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(src) == ctx);
	g_assert(bdrv_get_aio_context(target) == ctx);
	g_assert(bdrv_get_aio_context(filter) == ctx);

	job_cancel_sync_all();

	aio_context_acquire(ctx);
	blk_set_aio_context(blk, main_ctx, &error_abort);
	bdrv_try_set_aio_context(target, main_ctx, &error_abort);
	aio_context_release(ctx);

	blk_unref(blk);
	bdrv_unref(src);
	bdrv_unref(target);
	}

	static void test_attach_second_node(void)
	{
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	AioContext *main_ctx = qemu_get_aio_context();
	BlockBackend *blk;
	BlockDriverState bs, filter;
	QDict *options;

	blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
	bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
	blk_insert_bs(blk, bs, &error_abort);

	options = qdict_new();
	qdict_put_str(options, "driver", "raw");
	qdict_put_str(options, "file", "base");

	filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(bs) == ctx);
	g_assert(bdrv_get_aio_context(filter) == ctx);

	aio_context_acquire(ctx);
	blk_set_aio_context(blk, main_ctx, &error_abort);
	aio_context_release(ctx);
	g_assert(blk_get_aio_context(blk) == main_ctx);
	g_assert(bdrv_get_aio_context(bs) == main_ctx);
	g_assert(bdrv_get_aio_context(filter) == main_ctx);

	bdrv_unref(filter);
	bdrv_unref(bs);
	blk_unref(blk);
	}

	static void test_attach_preserve_blk_ctx(void)
	{
	IOThread *iothread = iothread_new();
	AioContext *ctx = iothread_get_aio_context(iothread);
	BlockBackend *blk;
	BlockDriverState *bs;

	blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
	bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
	bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;

	/* Add node to BlockBackend that has an iothread context assigned */
	blk_insert_bs(blk, bs, &error_abort);
	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(bs) == ctx);

	/* Remove the node again */
	aio_context_acquire(ctx);
	blk_remove_bs(blk);
	aio_context_release(ctx);
	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());

	/* Re-attach the node */
	blk_insert_bs(blk, bs, &error_abort);
	g_assert(blk_get_aio_context(blk) == ctx);
	g_assert(bdrv_get_aio_context(bs) == ctx);

	aio_context_acquire(ctx);
	blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
	aio_context_release(ctx);
	bdrv_unref(bs);
	blk_unref(blk);
	}

	int main(int argc, char **argv)
	{
	int i;

	bdrv_init();
	qemu_init_main_loop(&error_abort);

	g_test_init(&argc, &argv, NULL);

	for (i = 0; i < ARRAY_SIZE(sync_op_tests); i++) {
	const SyncOpTest *t = &sync_op_tests[i];
	g_test_add_data_func(t->name, t, test_sync_op);
	}

	g_test_add_func("/attach/blockjob", test_attach_blockjob);
	g_test_add_func("/attach/second_node", test_attach_second_node);
	g_test_add_func("/attach/preserve_blk_ctx", test_attach_preserve_blk_ctx);
	g_test_add_func("/propagate/basic", test_propagate_basic);
	g_test_add_func("/propagate/diamond", test_propagate_diamond);
	g_test_add_func("/propagate/mirror", test_propagate_mirror);

	return g_test_run();
	}