tests/unit/test-block-iothread.c

   1 /*
   2  * Block tests for iothreads
   3  *
   4  * Copyright (c) 2018 Kevin Wolf <kwolf@redhat.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "block/block.h"
  27 #include "block/blockjob_int.h"
  28 #include "sysemu/block-backend.h"
  29 #include "qapi/error.h"
  30 #include "qapi/qmp/qdict.h"
  31 #include "qemu/main-loop.h"
  32 #include "iothread.h"
  33
  34 static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
  35                                             int64_t offset, int64_t bytes,
  36                                             QEMUIOVector *qiov,
  37                                             BdrvRequestFlags flags)
  38 {
  39     return 0;
  40 }
  41
  42 static int coroutine_fn bdrv_test_co_pwritev(BlockDriverState *bs,
  43                                              int64_t offset, int64_t bytes,
  44                                              QEMUIOVector *qiov,
  45                                              BdrvRequestFlags flags)
  46 {
  47     return 0;
  48 }
  49
  50 static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
  51                                               int64_t offset, int64_t bytes)
  52 {
  53     return 0;
  54 }
  55
  56 static int coroutine_fn
  57 bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
  58                       PreallocMode prealloc, BdrvRequestFlags flags,
  59                       Error **errp)
  60 {
  61     return 0;
  62 }
  63
  64 static int coroutine_fn bdrv_test_co_block_status(BlockDriverState *bs,
  65                                                   bool want_zero,
  66                                                   int64_t offset, int64_t count,
  67                                                   int64_t *pnum, int64_t *map,
  68                                                   BlockDriverState **file)
  69 {
  70     *pnum = count;
  71     return 0;
  72 }
  73
  74 static BlockDriver bdrv_test = {
  75     .format_name            = "test",
  76     .instance_size          = 1,
  77
  78     .bdrv_co_preadv         = bdrv_test_co_preadv,
  79     .bdrv_co_pwritev        = bdrv_test_co_pwritev,
  80     .bdrv_co_pdiscard       = bdrv_test_co_pdiscard,
  81     .bdrv_co_truncate       = bdrv_test_co_truncate,
  82     .bdrv_co_block_status   = bdrv_test_co_block_status,
  83 };
  84
  85 static void test_sync_op_pread(BdrvChild *c)
  86 {
  87     uint8_t buf[512];
  88     int ret;
  89
  90     /* Success */
  91     ret = bdrv_pread(c, 0, buf, sizeof(buf));
  92     g_assert_cmpint(ret, ==, 512);
  93
  94     /* Early error: Negative offset */
  95     ret = bdrv_pread(c, -2, buf, sizeof(buf));
  96     g_assert_cmpint(ret, ==, -EIO);
  97 }
  98
  99 static void test_sync_op_pwrite(BdrvChild *c)
 100 {
 101     uint8_t buf[512] = { 0 };
 102     int ret;
 103
 104     /* Success */
 105     ret = bdrv_pwrite(c, 0, buf, sizeof(buf));
 106     g_assert_cmpint(ret, ==, 512);
 107
 108     /* Early error: Negative offset */
 109     ret = bdrv_pwrite(c, -2, buf, sizeof(buf));
 110     g_assert_cmpint(ret, ==, -EIO);
 111 }
 112
 113 static void test_sync_op_blk_pread(BlockBackend *blk)
 114 {
 115     uint8_t buf[512];
 116     int ret;
 117
 118     /* Success */
 119     ret = blk_pread(blk, 0, buf, sizeof(buf));
 120     g_assert_cmpint(ret, ==, 512);
 121
 122     /* Early error: Negative offset */
 123     ret = blk_pread(blk, -2, buf, sizeof(buf));
 124     g_assert_cmpint(ret, ==, -EIO);
 125 }
 126
 127 static void test_sync_op_blk_pwrite(BlockBackend *blk)
 128 {
 129     uint8_t buf[512] = { 0 };
 130     int ret;
 131
 132     /* Success */
 133     ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
 134     g_assert_cmpint(ret, ==, 512);
 135
 136     /* Early error: Negative offset */
 137     ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
 138     g_assert_cmpint(ret, ==, -EIO);
 139 }
 140
 141 static void test_sync_op_load_vmstate(BdrvChild *c)
 142 {
 143     uint8_t buf[512];
 144     int ret;
 145
 146     /* Error: Driver does not support snapshots */
 147     ret = bdrv_load_vmstate(c->bs, buf, 0, sizeof(buf));
 148     g_assert_cmpint(ret, ==, -ENOTSUP);
 149 }
 150
 151 static void test_sync_op_save_vmstate(BdrvChild *c)
 152 {
 153     uint8_t buf[512] = { 0 };
 154     int ret;
 155
 156     /* Error: Driver does not support snapshots */
 157     ret = bdrv_save_vmstate(c->bs, buf, 0, sizeof(buf));
 158     g_assert_cmpint(ret, ==, -ENOTSUP);
 159 }
 160
 161 static void test_sync_op_pdiscard(BdrvChild *c)
 162 {
 163     int ret;
 164
 165     /* Normal success path */
 166     c->bs->open_flags |= BDRV_O_UNMAP;
 167     ret = bdrv_pdiscard(c, 0, 512);
 168     g_assert_cmpint(ret, ==, 0);
 169
 170     /* Early success: UNMAP not supported */
 171     c->bs->open_flags &= ~BDRV_O_UNMAP;
 172     ret = bdrv_pdiscard(c, 0, 512);
 173     g_assert_cmpint(ret, ==, 0);
 174
 175     /* Early error: Negative offset */
 176     ret = bdrv_pdiscard(c, -2, 512);
 177     g_assert_cmpint(ret, ==, -EIO);
 178 }
 179
 180 static void test_sync_op_blk_pdiscard(BlockBackend *blk)
 181 {
 182     int ret;
 183
 184     /* Early success: UNMAP not supported */
 185     ret = blk_pdiscard(blk, 0, 512);
 186     g_assert_cmpint(ret, ==, 0);
 187
 188     /* Early error: Negative offset */
 189     ret = blk_pdiscard(blk, -2, 512);
 190     g_assert_cmpint(ret, ==, -EIO);
 191 }
 192
 193 static void test_sync_op_truncate(BdrvChild *c)
 194 {
 195     int ret;
 196
 197     /* Normal success path */
 198     ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
 199     g_assert_cmpint(ret, ==, 0);
 200
 201     /* Early error: Negative offset */
 202     ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
 203     g_assert_cmpint(ret, ==, -EINVAL);
 204
 205     /* Error: Read-only image */
 206     c->bs->open_flags &= ~BDRV_O_RDWR;
 207
 208     ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
 209     g_assert_cmpint(ret, ==, -EACCES);
 210
 211     c->bs->open_flags |= BDRV_O_RDWR;
 212 }
 213
 214 static void test_sync_op_block_status(BdrvChild *c)
 215 {
 216     int ret;
 217     int64_t n;
 218
 219     /* Normal success path */
 220     ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
 221     g_assert_cmpint(ret, ==, 0);
 222
 223     /* Early success: No driver support */
 224     bdrv_test.bdrv_co_block_status = NULL;
 225     ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
 226     g_assert_cmpint(ret, ==, 1);
 227
 228     /* Early success: bytes = 0 */
 229     ret = bdrv_is_allocated(c->bs, 0, 0, &n);
 230     g_assert_cmpint(ret, ==, 0);
 231
 232     /* Early success: Offset > image size*/
 233     ret = bdrv_is_allocated(c->bs, 0x1000000, 0x1000000, &n);
 234     g_assert_cmpint(ret, ==, 0);
 235 }
 236
 237 static void test_sync_op_flush(BdrvChild *c)
 238 {
 239     int ret;
 240
 241     /* Normal success path */
 242     ret = bdrv_flush(c->bs);
 243     g_assert_cmpint(ret, ==, 0);
 244
 245     /* Early success: Read-only image */
 246     c->bs->open_flags &= ~BDRV_O_RDWR;
 247
 248     ret = bdrv_flush(c->bs);
 249     g_assert_cmpint(ret, ==, 0);
 250
 251     c->bs->open_flags |= BDRV_O_RDWR;
 252 }
 253
 254 static void test_sync_op_blk_flush(BlockBackend *blk)
 255 {
 256     BlockDriverState *bs = blk_bs(blk);
 257     int ret;
 258
 259     /* Normal success path */
 260     ret = blk_flush(blk);
 261     g_assert_cmpint(ret, ==, 0);
 262
 263     /* Early success: Read-only image */
 264     bs->open_flags &= ~BDRV_O_RDWR;
 265
 266     ret = blk_flush(blk);
 267     g_assert_cmpint(ret, ==, 0);
 268
 269     bs->open_flags |= BDRV_O_RDWR;
 270 }
 271
 272 static void test_sync_op_check(BdrvChild *c)
 273 {
 274     BdrvCheckResult result;
 275     int ret;
 276
 277     /* Error: Driver does not implement check */
 278     ret = bdrv_check(c->bs, &result, 0);
 279     g_assert_cmpint(ret, ==, -ENOTSUP);
 280 }
 281
 282 static void test_sync_op_activate(BdrvChild *c)
 283 {
 284     /* Early success: Image is not inactive */
 285     bdrv_activate(c->bs, NULL);
 286 }
 287
 288
 289 typedef struct SyncOpTest {
 290     const char *name;
 291     void (*fn)(BdrvChild *c);
 292     void (*blkfn)(BlockBackend *blk);
 293 } SyncOpTest;
 294
 295 const SyncOpTest sync_op_tests[] = {
 296     {
 297         .name   = "/sync-op/pread",
 298         .fn     = test_sync_op_pread,
 299         .blkfn  = test_sync_op_blk_pread,
 300     }, {
 301         .name   = "/sync-op/pwrite",
 302         .fn     = test_sync_op_pwrite,
 303         .blkfn  = test_sync_op_blk_pwrite,
 304     }, {
 305         .name   = "/sync-op/load_vmstate",
 306         .fn     = test_sync_op_load_vmstate,
 307     }, {
 308         .name   = "/sync-op/save_vmstate",
 309         .fn     = test_sync_op_save_vmstate,
 310     }, {
 311         .name   = "/sync-op/pdiscard",
 312         .fn     = test_sync_op_pdiscard,
 313         .blkfn  = test_sync_op_blk_pdiscard,
 314     }, {
 315         .name   = "/sync-op/truncate",
 316         .fn     = test_sync_op_truncate,
 317     }, {
 318         .name   = "/sync-op/block_status",
 319         .fn     = test_sync_op_block_status,
 320     }, {
 321         .name   = "/sync-op/flush",
 322         .fn     = test_sync_op_flush,
 323         .blkfn  = test_sync_op_blk_flush,
 324     }, {
 325         .name   = "/sync-op/check",
 326         .fn     = test_sync_op_check,
 327     }, {
 328         .name   = "/sync-op/activate",
 329         .fn     = test_sync_op_activate,
 330     },
 331 };
 332
 333 /* Test synchronous operations that run in a different iothread, so we have to
 334  * poll for the coroutine there to return. */
 335 static void test_sync_op(const void *opaque)
 336 {
 337     const SyncOpTest *t = opaque;
 338     IOThread *iothread = iothread_new();
 339     AioContext *ctx = iothread_get_aio_context(iothread);
 340     BlockBackend *blk;
 341     BlockDriverState *bs;
 342     BdrvChild *c;
 343
 344     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 345     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
 346     bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
 347     blk_insert_bs(blk, bs, &error_abort);
 348     c = QLIST_FIRST(&bs->parents);
 349
 350     blk_set_aio_context(blk, ctx, &error_abort);
 351     aio_context_acquire(ctx);
 352     t->fn(c);
 353     if (t->blkfn) {
 354         t->blkfn(blk);
 355     }
 356     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
 357     aio_context_release(ctx);
 358
 359     bdrv_unref(bs);
 360     blk_unref(blk);
 361 }
 362
 363 typedef struct TestBlockJob {
 364     BlockJob common;
 365     bool should_complete;
 366     int n;
 367 } TestBlockJob;
 368
 369 static int test_job_prepare(Job *job)
 370 {
 371     g_assert(qemu_get_current_aio_context() == qemu_get_aio_context());
 372     return 0;
 373 }
 374
 375 static int coroutine_fn test_job_run(Job *job, Error **errp)
 376 {
 377     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 378
 379     job_transition_to_ready(&s->common.job);
 380     while (!s->should_complete) {
 381         s->n++;
 382         g_assert(qemu_get_current_aio_context() == job->aio_context);
 383
 384         /* Avoid job_sleep_ns() because it marks the job as !busy. We want to
 385          * emulate some actual activity (probably some I/O) here so that the
 386          * drain involved in AioContext switches has to wait for this activity
 387          * to stop. */
 388         qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000);
 389
 390         job_pause_point(&s->common.job);
 391     }
 392
 393     g_assert(qemu_get_current_aio_context() == job->aio_context);
 394     return 0;
 395 }
 396
 397 static void test_job_complete(Job *job, Error **errp)
 398 {
 399     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 400     s->should_complete = true;
 401 }
 402
 403 BlockJobDriver test_job_driver = {
 404     .job_driver = {
 405         .instance_size  = sizeof(TestBlockJob),
 406         .free           = block_job_free,
 407         .user_resume    = block_job_user_resume,
 408         .run            = test_job_run,
 409         .complete       = test_job_complete,
 410         .prepare        = test_job_prepare,
 411     },
 412 };
 413
 414 static void test_attach_blockjob(void)
 415 {
 416     IOThread *iothread = iothread_new();
 417     AioContext *ctx = iothread_get_aio_context(iothread);
 418     BlockBackend *blk;
 419     BlockDriverState *bs;
 420     TestBlockJob *tjob;
 421
 422     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 423     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
 424     blk_insert_bs(blk, bs, &error_abort);
 425
 426     tjob = block_job_create("job0", &test_job_driver, NULL, bs,
 427                             0, BLK_PERM_ALL,
 428                             0, 0, NULL, NULL, &error_abort);
 429     job_start(&tjob->common.job);
 430
 431     while (tjob->n == 0) {
 432         aio_poll(qemu_get_aio_context(), false);
 433     }
 434
 435     blk_set_aio_context(blk, ctx, &error_abort);
 436
 437     tjob->n = 0;
 438     while (tjob->n == 0) {
 439         aio_poll(qemu_get_aio_context(), false);
 440     }
 441
 442     aio_context_acquire(ctx);
 443     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
 444     aio_context_release(ctx);
 445
 446     tjob->n = 0;
 447     while (tjob->n == 0) {
 448         aio_poll(qemu_get_aio_context(), false);
 449     }
 450
 451     blk_set_aio_context(blk, ctx, &error_abort);
 452
 453     tjob->n = 0;
 454     while (tjob->n == 0) {
 455         aio_poll(qemu_get_aio_context(), false);
 456     }
 457
 458     aio_context_acquire(ctx);
 459     job_complete_sync(&tjob->common.job, &error_abort);
 460     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
 461     aio_context_release(ctx);
 462
 463     bdrv_unref(bs);
 464     blk_unref(blk);
 465 }
 466
 467 /*
 468  * Test that changing the AioContext for one node in a tree (here through blk)
 469  * changes all other nodes as well:
 470  *
 471  *  blk
 472  *   |
 473  *   |  bs_verify [blkverify]
 474  *   |   /               \
 475  *   |  /                 \
 476  *  bs_a [bdrv_test]    bs_b [bdrv_test]
 477  *
 478  */
 479 static void test_propagate_basic(void)
 480 {
 481     IOThread *iothread = iothread_new();
 482     AioContext *ctx = iothread_get_aio_context(iothread);
 483     AioContext *main_ctx;
 484     BlockBackend *blk;
 485     BlockDriverState *bs_a, *bs_b, *bs_verify;
 486     QDict *options;
 487
 488     /*
 489      * Create bs_a and its BlockBackend.  We cannot take the RESIZE
 490      * permission because blkverify will not share it on the test
 491      * image.
 492      */
 493     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
 494                   BLK_PERM_ALL);
 495     bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
 496     blk_insert_bs(blk, bs_a, &error_abort);
 497
 498     /* Create bs_b */
 499     bs_b = bdrv_new_open_driver(&bdrv_test, "bs_b", BDRV_O_RDWR, &error_abort);
 500
 501     /* Create blkverify filter that references both bs_a and bs_b */
 502     options = qdict_new();
 503     qdict_put_str(options, "driver", "blkverify");
 504     qdict_put_str(options, "test", "bs_a");
 505     qdict_put_str(options, "raw", "bs_b");
 506
 507     bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
 508
 509     /* Switch the AioContext */
 510     blk_set_aio_context(blk, ctx, &error_abort);
 511     g_assert(blk_get_aio_context(blk) == ctx);
 512     g_assert(bdrv_get_aio_context(bs_a) == ctx);
 513     g_assert(bdrv_get_aio_context(bs_verify) == ctx);
 514     g_assert(bdrv_get_aio_context(bs_b) == ctx);
 515
 516     /* Switch the AioContext back */
 517     main_ctx = qemu_get_aio_context();
 518     aio_context_acquire(ctx);
 519     blk_set_aio_context(blk, main_ctx, &error_abort);
 520     aio_context_release(ctx);
 521     g_assert(blk_get_aio_context(blk) == main_ctx);
 522     g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
 523     g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
 524     g_assert(bdrv_get_aio_context(bs_b) == main_ctx);
 525
 526     bdrv_unref(bs_verify);
 527     bdrv_unref(bs_b);
 528     bdrv_unref(bs_a);
 529     blk_unref(blk);
 530 }
 531
 532 /*
 533  * Test that diamonds in the graph don't lead to endless recursion:
 534  *
 535  *              blk
 536  *               |
 537  *      bs_verify [blkverify]
 538  *       /              \
 539  *      /                \
 540  *   bs_b [raw]         bs_c[raw]
 541  *      \                /
 542  *       \              /
 543  *       bs_a [bdrv_test]
 544  */
 545 static void test_propagate_diamond(void)
 546 {
 547     IOThread *iothread = iothread_new();
 548     AioContext *ctx = iothread_get_aio_context(iothread);
 549     AioContext *main_ctx;
 550     BlockBackend *blk;
 551     BlockDriverState *bs_a, *bs_b, *bs_c, *bs_verify;
 552     QDict *options;
 553
 554     /* Create bs_a */
 555     bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
 556
 557     /* Create bs_b and bc_c */
 558     options = qdict_new();
 559     qdict_put_str(options, "driver", "raw");
 560     qdict_put_str(options, "file", "bs_a");
 561     qdict_put_str(options, "node-name", "bs_b");
 562     bs_b = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
 563
 564     options = qdict_new();
 565     qdict_put_str(options, "driver", "raw");
 566     qdict_put_str(options, "file", "bs_a");
 567     qdict_put_str(options, "node-name", "bs_c");
 568     bs_c = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
 569
 570     /* Create blkverify filter that references both bs_b and bs_c */
 571     options = qdict_new();
 572     qdict_put_str(options, "driver", "blkverify");
 573     qdict_put_str(options, "test", "bs_b");
 574     qdict_put_str(options, "raw", "bs_c");
 575
 576     bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
 577     /*
 578      * Do not take the RESIZE permission: This would require the same
 579      * from bs_c and thus from bs_a; however, blkverify will not share
 580      * it on bs_b, and thus it will not be available for bs_a.
 581      */
 582     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
 583                   BLK_PERM_ALL);
 584     blk_insert_bs(blk, bs_verify, &error_abort);
 585
 586     /* Switch the AioContext */
 587     blk_set_aio_context(blk, ctx, &error_abort);
 588     g_assert(blk_get_aio_context(blk) == ctx);
 589     g_assert(bdrv_get_aio_context(bs_verify) == ctx);
 590     g_assert(bdrv_get_aio_context(bs_a) == ctx);
 591     g_assert(bdrv_get_aio_context(bs_b) == ctx);
 592     g_assert(bdrv_get_aio_context(bs_c) == ctx);
 593
 594     /* Switch the AioContext back */
 595     main_ctx = qemu_get_aio_context();
 596     aio_context_acquire(ctx);
 597     blk_set_aio_context(blk, main_ctx, &error_abort);
 598     aio_context_release(ctx);
 599     g_assert(blk_get_aio_context(blk) == main_ctx);
 600     g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
 601     g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
 602     g_assert(bdrv_get_aio_context(bs_b) == main_ctx);
 603     g_assert(bdrv_get_aio_context(bs_c) == main_ctx);
 604
 605     blk_unref(blk);
 606     bdrv_unref(bs_verify);
 607     bdrv_unref(bs_c);
 608     bdrv_unref(bs_b);
 609     bdrv_unref(bs_a);
 610 }
 611
 612 static void test_propagate_mirror(void)
 613 {
 614     IOThread *iothread = iothread_new();
 615     AioContext *ctx = iothread_get_aio_context(iothread);
 616     AioContext *main_ctx = qemu_get_aio_context();
 617     BlockDriverState *src, *target, *filter;
 618     BlockBackend *blk;
 619     Job *job;
 620     Error *local_err = NULL;
 621
 622     /* Create src and target*/
 623     src = bdrv_new_open_driver(&bdrv_test, "src", BDRV_O_RDWR, &error_abort);
 624     target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
 625                                   &error_abort);
 626
 627     /* Start a mirror job */
 628     mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
 629                  MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
 630                  BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
 631                  false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
 632                  &error_abort);
 633     job = job_get("job0");
 634     filter = bdrv_find_node("filter_node");
 635
 636     /* Change the AioContext of src */
 637     bdrv_try_set_aio_context(src, ctx, &error_abort);
 638     g_assert(bdrv_get_aio_context(src) == ctx);
 639     g_assert(bdrv_get_aio_context(target) == ctx);
 640     g_assert(bdrv_get_aio_context(filter) == ctx);
 641     g_assert(job->aio_context == ctx);
 642
 643     /* Change the AioContext of target */
 644     aio_context_acquire(ctx);
 645     bdrv_try_set_aio_context(target, main_ctx, &error_abort);
 646     aio_context_release(ctx);
 647     g_assert(bdrv_get_aio_context(src) == main_ctx);
 648     g_assert(bdrv_get_aio_context(target) == main_ctx);
 649     g_assert(bdrv_get_aio_context(filter) == main_ctx);
 650
 651     /* With a BlockBackend on src, changing target must fail */
 652     blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
 653     blk_insert_bs(blk, src, &error_abort);
 654
 655     bdrv_try_set_aio_context(target, ctx, &local_err);
 656     error_free_or_abort(&local_err);
 657
 658     g_assert(blk_get_aio_context(blk) == main_ctx);
 659     g_assert(bdrv_get_aio_context(src) == main_ctx);
 660     g_assert(bdrv_get_aio_context(target) == main_ctx);
 661     g_assert(bdrv_get_aio_context(filter) == main_ctx);
 662
 663     /* ...unless we explicitly allow it */
 664     aio_context_acquire(ctx);
 665     blk_set_allow_aio_context_change(blk, true);
 666     bdrv_try_set_aio_context(target, ctx, &error_abort);
 667     aio_context_release(ctx);
 668
 669     g_assert(blk_get_aio_context(blk) == ctx);
 670     g_assert(bdrv_get_aio_context(src) == ctx);
 671     g_assert(bdrv_get_aio_context(target) == ctx);
 672     g_assert(bdrv_get_aio_context(filter) == ctx);
 673
 674     job_cancel_sync_all();
 675
 676     aio_context_acquire(ctx);
 677     blk_set_aio_context(blk, main_ctx, &error_abort);
 678     bdrv_try_set_aio_context(target, main_ctx, &error_abort);
 679     aio_context_release(ctx);
 680
 681     blk_unref(blk);
 682     bdrv_unref(src);
 683     bdrv_unref(target);
 684 }
 685
 686 static void test_attach_second_node(void)
 687 {
 688     IOThread *iothread = iothread_new();
 689     AioContext *ctx = iothread_get_aio_context(iothread);
 690     AioContext *main_ctx = qemu_get_aio_context();
 691     BlockBackend *blk;
 692     BlockDriverState *bs, *filter;
 693     QDict *options;
 694
 695     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
 696     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
 697     blk_insert_bs(blk, bs, &error_abort);
 698
 699     options = qdict_new();
 700     qdict_put_str(options, "driver", "raw");
 701     qdict_put_str(options, "file", "base");
 702
 703     filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
 704     g_assert(blk_get_aio_context(blk) == ctx);
 705     g_assert(bdrv_get_aio_context(bs) == ctx);
 706     g_assert(bdrv_get_aio_context(filter) == ctx);
 707
 708     aio_context_acquire(ctx);
 709     blk_set_aio_context(blk, main_ctx, &error_abort);
 710     aio_context_release(ctx);
 711     g_assert(blk_get_aio_context(blk) == main_ctx);
 712     g_assert(bdrv_get_aio_context(bs) == main_ctx);
 713     g_assert(bdrv_get_aio_context(filter) == main_ctx);
 714
 715     bdrv_unref(filter);
 716     bdrv_unref(bs);
 717     blk_unref(blk);
 718 }
 719
 720 static void test_attach_preserve_blk_ctx(void)
 721 {
 722     IOThread *iothread = iothread_new();
 723     AioContext *ctx = iothread_get_aio_context(iothread);
 724     BlockBackend *blk;
 725     BlockDriverState *bs;
 726
 727     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
 728     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
 729     bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
 730
 731     /* Add node to BlockBackend that has an iothread context assigned */
 732     blk_insert_bs(blk, bs, &error_abort);
 733     g_assert(blk_get_aio_context(blk) == ctx);
 734     g_assert(bdrv_get_aio_context(bs) == ctx);
 735
 736     /* Remove the node again */
 737     aio_context_acquire(ctx);
 738     blk_remove_bs(blk);
 739     aio_context_release(ctx);
 740     g_assert(blk_get_aio_context(blk) == ctx);
 741     g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());
 742
 743     /* Re-attach the node */
 744     blk_insert_bs(blk, bs, &error_abort);
 745     g_assert(blk_get_aio_context(blk) == ctx);
 746     g_assert(bdrv_get_aio_context(bs) == ctx);
 747
 748     aio_context_acquire(ctx);
 749     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
 750     aio_context_release(ctx);
 751     bdrv_unref(bs);
 752     blk_unref(blk);
 753 }
 754
 755 int main(int argc, char **argv)
 756 {
 757     int i;
 758
 759     bdrv_init();
 760     qemu_init_main_loop(&error_abort);
 761
 762     g_test_init(&argc, &argv, NULL);
 763
 764     for (i = 0; i < ARRAY_SIZE(sync_op_tests); i++) {
 765         const SyncOpTest *t = &sync_op_tests[i];
 766         g_test_add_data_func(t->name, t, test_sync_op);
 767     }
 768
 769     g_test_add_func("/attach/blockjob", test_attach_blockjob);
 770     g_test_add_func("/attach/second_node", test_attach_second_node);
 771     g_test_add_func("/attach/preserve_blk_ctx", test_attach_preserve_blk_ctx);
 772     g_test_add_func("/propagate/basic", test_propagate_basic);
 773     g_test_add_func("/propagate/diamond", test_propagate_diamond);
 774     g_test_add_func("/propagate/mirror", test_propagate_mirror);
 775
 776     return g_test_run();
 777 }