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