tests/test-bdrv-drain.c

   1 /*
   2  * Block node draining tests
   3  *
   4  * Copyright (c) 2017 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
  31 typedef struct BDRVTestState {
  32     int drain_count;
  33 } BDRVTestState;
  34
  35 static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
  36 {
  37     BDRVTestState *s = bs->opaque;
  38     s->drain_count++;
  39 }
  40
  41 static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
  42 {
  43     BDRVTestState *s = bs->opaque;
  44     s->drain_count--;
  45 }
  46
  47 static void bdrv_test_close(BlockDriverState *bs)
  48 {
  49     BDRVTestState *s = bs->opaque;
  50     g_assert_cmpint(s->drain_count, >, 0);
  51 }
  52
  53 static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
  54                                             uint64_t offset, uint64_t bytes,
  55                                             QEMUIOVector *qiov, int flags)
  56 {
  57     /* We want this request to stay until the polling loop in drain waits for
  58      * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
  59      * first and polls its result, too, but it shouldn't accidentally complete
  60      * this request yet. */
  61     qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
  62
  63     return 0;
  64 }
  65
  66 static BlockDriver bdrv_test = {
  67     .format_name            = "test",
  68     .instance_size          = sizeof(BDRVTestState),
  69
  70     .bdrv_close             = bdrv_test_close,
  71     .bdrv_co_preadv         = bdrv_test_co_preadv,
  72
  73     .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
  74     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
  75
  76     .bdrv_child_perm        = bdrv_format_default_perms,
  77 };
  78
  79 static void aio_ret_cb(void *opaque, int ret)
  80 {
  81     int *aio_ret = opaque;
  82     *aio_ret = ret;
  83 }
  84
  85 typedef struct CallInCoroutineData {
  86     void (*entry)(void);
  87     bool done;
  88 } CallInCoroutineData;
  89
  90 static coroutine_fn void call_in_coroutine_entry(void *opaque)
  91 {
  92     CallInCoroutineData *data = opaque;
  93
  94     data->entry();
  95     data->done = true;
  96 }
  97
  98 static void call_in_coroutine(void (*entry)(void))
  99 {
 100     Coroutine *co;
 101     CallInCoroutineData data = {
 102         .entry  = entry,
 103         .done   = false,
 104     };
 105
 106     co = qemu_coroutine_create(call_in_coroutine_entry, &data);
 107     qemu_coroutine_enter(co);
 108     while (!data.done) {
 109         aio_poll(qemu_get_aio_context(), true);
 110     }
 111 }
 112
 113 enum drain_type {
 114     BDRV_DRAIN_ALL,
 115     BDRV_DRAIN,
 116     BDRV_SUBTREE_DRAIN,
 117     DRAIN_TYPE_MAX,
 118 };
 119
 120 static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
 121 {
 122     switch (drain_type) {
 123     case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
 124     case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
 125     case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_begin(bs); break;
 126     default:                    g_assert_not_reached();
 127     }
 128 }
 129
 130 static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
 131 {
 132     switch (drain_type) {
 133     case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
 134     case BDRV_DRAIN:            bdrv_drained_end(bs); break;
 135     case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_end(bs); break;
 136     default:                    g_assert_not_reached();
 137     }
 138 }
 139
 140 static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
 141 {
 142     BlockBackend *blk;
 143     BlockDriverState *bs, *backing;
 144     BDRVTestState *s, *backing_s;
 145     BlockAIOCB *acb;
 146     int aio_ret;
 147
 148     QEMUIOVector qiov;
 149     struct iovec iov = {
 150         .iov_base = NULL,
 151         .iov_len = 0,
 152     };
 153     qemu_iovec_init_external(&qiov, &iov, 1);
 154
 155     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 156     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 157                               &error_abort);
 158     s = bs->opaque;
 159     blk_insert_bs(blk, bs, &error_abort);
 160
 161     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 162     backing_s = backing->opaque;
 163     bdrv_set_backing_hd(bs, backing, &error_abort);
 164
 165     /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
 166     g_assert_cmpint(s->drain_count, ==, 0);
 167     g_assert_cmpint(backing_s->drain_count, ==, 0);
 168
 169     do_drain_begin(drain_type, bs);
 170
 171     g_assert_cmpint(s->drain_count, ==, 1);
 172     g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 173
 174     do_drain_end(drain_type, bs);
 175
 176     g_assert_cmpint(s->drain_count, ==, 0);
 177     g_assert_cmpint(backing_s->drain_count, ==, 0);
 178
 179     /* Now do the same while a request is pending */
 180     aio_ret = -EINPROGRESS;
 181     acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
 182     g_assert(acb != NULL);
 183     g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 184
 185     g_assert_cmpint(s->drain_count, ==, 0);
 186     g_assert_cmpint(backing_s->drain_count, ==, 0);
 187
 188     do_drain_begin(drain_type, bs);
 189
 190     g_assert_cmpint(aio_ret, ==, 0);
 191     g_assert_cmpint(s->drain_count, ==, 1);
 192     g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 193
 194     do_drain_end(drain_type, bs);
 195
 196     g_assert_cmpint(s->drain_count, ==, 0);
 197     g_assert_cmpint(backing_s->drain_count, ==, 0);
 198
 199     bdrv_unref(backing);
 200     bdrv_unref(bs);
 201     blk_unref(blk);
 202 }
 203
 204 static void test_drv_cb_drain_all(void)
 205 {
 206     test_drv_cb_common(BDRV_DRAIN_ALL, true);
 207 }
 208
 209 static void test_drv_cb_drain(void)
 210 {
 211     test_drv_cb_common(BDRV_DRAIN, false);
 212 }
 213
 214 static void test_drv_cb_drain_subtree(void)
 215 {
 216     test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
 217 }
 218
 219 static void test_drv_cb_co_drain(void)
 220 {
 221     call_in_coroutine(test_drv_cb_drain);
 222 }
 223
 224 static void test_drv_cb_co_drain_subtree(void)
 225 {
 226     call_in_coroutine(test_drv_cb_drain_subtree);
 227 }
 228
 229 static void test_quiesce_common(enum drain_type drain_type, bool recursive)
 230 {
 231     BlockBackend *blk;
 232     BlockDriverState *bs, *backing;
 233
 234     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 235     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 236                               &error_abort);
 237     blk_insert_bs(blk, bs, &error_abort);
 238
 239     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 240     bdrv_set_backing_hd(bs, backing, &error_abort);
 241
 242     g_assert_cmpint(bs->quiesce_counter, ==, 0);
 243     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 244
 245     do_drain_begin(drain_type, bs);
 246
 247     g_assert_cmpint(bs->quiesce_counter, ==, 1);
 248     g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
 249
 250     do_drain_end(drain_type, bs);
 251
 252     g_assert_cmpint(bs->quiesce_counter, ==, 0);
 253     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 254
 255     bdrv_unref(backing);
 256     bdrv_unref(bs);
 257     blk_unref(blk);
 258 }
 259
 260 static void test_quiesce_drain_all(void)
 261 {
 262     // XXX drain_all doesn't quiesce
 263     //test_quiesce_common(BDRV_DRAIN_ALL, true);
 264 }
 265
 266 static void test_quiesce_drain(void)
 267 {
 268     test_quiesce_common(BDRV_DRAIN, false);
 269 }
 270
 271 static void test_quiesce_drain_subtree(void)
 272 {
 273     test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
 274 }
 275
 276 static void test_quiesce_co_drain(void)
 277 {
 278     call_in_coroutine(test_quiesce_drain);
 279 }
 280
 281 static void test_quiesce_co_drain_subtree(void)
 282 {
 283     call_in_coroutine(test_quiesce_drain_subtree);
 284 }
 285
 286 static void test_nested(void)
 287 {
 288     BlockBackend *blk;
 289     BlockDriverState *bs, *backing;
 290     BDRVTestState *s, *backing_s;
 291     enum drain_type outer, inner;
 292
 293     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 294     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 295                               &error_abort);
 296     s = bs->opaque;
 297     blk_insert_bs(blk, bs, &error_abort);
 298
 299     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 300     backing_s = backing->opaque;
 301     bdrv_set_backing_hd(bs, backing, &error_abort);
 302
 303     for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
 304         for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
 305             /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
 306             int bs_quiesce      = (outer != BDRV_DRAIN_ALL) +
 307                                   (inner != BDRV_DRAIN_ALL);
 308             int backing_quiesce = (outer == BDRV_SUBTREE_DRAIN) +
 309                                   (inner == BDRV_SUBTREE_DRAIN);
 310             int backing_cb_cnt  = (outer != BDRV_DRAIN) +
 311                                   (inner != BDRV_DRAIN);
 312
 313             g_assert_cmpint(bs->quiesce_counter, ==, 0);
 314             g_assert_cmpint(backing->quiesce_counter, ==, 0);
 315             g_assert_cmpint(s->drain_count, ==, 0);
 316             g_assert_cmpint(backing_s->drain_count, ==, 0);
 317
 318             do_drain_begin(outer, bs);
 319             do_drain_begin(inner, bs);
 320
 321             g_assert_cmpint(bs->quiesce_counter, ==, bs_quiesce);
 322             g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
 323             g_assert_cmpint(s->drain_count, ==, 2);
 324             g_assert_cmpint(backing_s->drain_count, ==, backing_cb_cnt);
 325
 326             do_drain_end(inner, bs);
 327             do_drain_end(outer, bs);
 328
 329             g_assert_cmpint(bs->quiesce_counter, ==, 0);
 330             g_assert_cmpint(backing->quiesce_counter, ==, 0);
 331             g_assert_cmpint(s->drain_count, ==, 0);
 332             g_assert_cmpint(backing_s->drain_count, ==, 0);
 333         }
 334     }
 335
 336     bdrv_unref(backing);
 337     bdrv_unref(bs);
 338     blk_unref(blk);
 339 }
 340
 341 static void test_multiparent(void)
 342 {
 343     BlockBackend *blk_a, *blk_b;
 344     BlockDriverState *bs_a, *bs_b, *backing;
 345     BDRVTestState *a_s, *b_s, *backing_s;
 346
 347     blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 348     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 349                                 &error_abort);
 350     a_s = bs_a->opaque;
 351     blk_insert_bs(blk_a, bs_a, &error_abort);
 352
 353     blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 354     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 355                                 &error_abort);
 356     b_s = bs_b->opaque;
 357     blk_insert_bs(blk_b, bs_b, &error_abort);
 358
 359     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 360     backing_s = backing->opaque;
 361     bdrv_set_backing_hd(bs_a, backing, &error_abort);
 362     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 363
 364     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 365     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 366     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 367     g_assert_cmpint(a_s->drain_count, ==, 0);
 368     g_assert_cmpint(b_s->drain_count, ==, 0);
 369     g_assert_cmpint(backing_s->drain_count, ==, 0);
 370
 371     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 372
 373     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 374     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 375     g_assert_cmpint(backing->quiesce_counter, ==, 1);
 376     g_assert_cmpint(a_s->drain_count, ==, 1);
 377     g_assert_cmpint(b_s->drain_count, ==, 1);
 378     g_assert_cmpint(backing_s->drain_count, ==, 1);
 379
 380     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 381
 382     g_assert_cmpint(bs_a->quiesce_counter, ==, 2);
 383     g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 384     g_assert_cmpint(backing->quiesce_counter, ==, 2);
 385     g_assert_cmpint(a_s->drain_count, ==, 2);
 386     g_assert_cmpint(b_s->drain_count, ==, 2);
 387     g_assert_cmpint(backing_s->drain_count, ==, 2);
 388
 389     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 390
 391     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 392     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 393     g_assert_cmpint(backing->quiesce_counter, ==, 1);
 394     g_assert_cmpint(a_s->drain_count, ==, 1);
 395     g_assert_cmpint(b_s->drain_count, ==, 1);
 396     g_assert_cmpint(backing_s->drain_count, ==, 1);
 397
 398     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 399
 400     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 401     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 402     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 403     g_assert_cmpint(a_s->drain_count, ==, 0);
 404     g_assert_cmpint(b_s->drain_count, ==, 0);
 405     g_assert_cmpint(backing_s->drain_count, ==, 0);
 406
 407     bdrv_unref(backing);
 408     bdrv_unref(bs_a);
 409     bdrv_unref(bs_b);
 410     blk_unref(blk_a);
 411     blk_unref(blk_b);
 412 }
 413
 414 static void test_graph_change(void)
 415 {
 416     BlockBackend *blk_a, *blk_b;
 417     BlockDriverState *bs_a, *bs_b, *backing;
 418     BDRVTestState *a_s, *b_s, *backing_s;
 419
 420     blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 421     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 422                                 &error_abort);
 423     a_s = bs_a->opaque;
 424     blk_insert_bs(blk_a, bs_a, &error_abort);
 425
 426     blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 427     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 428                                 &error_abort);
 429     b_s = bs_b->opaque;
 430     blk_insert_bs(blk_b, bs_b, &error_abort);
 431
 432     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 433     backing_s = backing->opaque;
 434     bdrv_set_backing_hd(bs_a, backing, &error_abort);
 435
 436     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 437     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 438     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 439     g_assert_cmpint(a_s->drain_count, ==, 0);
 440     g_assert_cmpint(b_s->drain_count, ==, 0);
 441     g_assert_cmpint(backing_s->drain_count, ==, 0);
 442
 443     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 444     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 445     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 446     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 447     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 448
 449     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 450     g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 451     g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 452     g_assert_cmpint(backing->quiesce_counter, ==, 5);
 453     g_assert_cmpint(a_s->drain_count, ==, 5);
 454     g_assert_cmpint(b_s->drain_count, ==, 5);
 455     g_assert_cmpint(backing_s->drain_count, ==, 5);
 456
 457     bdrv_set_backing_hd(bs_b, NULL, &error_abort);
 458     g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
 459     g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 460     g_assert_cmpint(backing->quiesce_counter, ==, 3);
 461     g_assert_cmpint(a_s->drain_count, ==, 3);
 462     g_assert_cmpint(b_s->drain_count, ==, 2);
 463     g_assert_cmpint(backing_s->drain_count, ==, 3);
 464
 465     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 466     g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 467     g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 468     g_assert_cmpint(backing->quiesce_counter, ==, 5);
 469     g_assert_cmpint(a_s->drain_count, ==, 5);
 470     g_assert_cmpint(b_s->drain_count, ==, 5);
 471     g_assert_cmpint(backing_s->drain_count, ==, 5);
 472
 473     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 474     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 475     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 476     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 477     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 478
 479     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 480     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 481     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 482     g_assert_cmpint(a_s->drain_count, ==, 0);
 483     g_assert_cmpint(b_s->drain_count, ==, 0);
 484     g_assert_cmpint(backing_s->drain_count, ==, 0);
 485
 486     bdrv_unref(backing);
 487     bdrv_unref(bs_a);
 488     bdrv_unref(bs_b);
 489     blk_unref(blk_a);
 490     blk_unref(blk_b);
 491 }
 492
 493
 494 typedef struct TestBlockJob {
 495     BlockJob common;
 496     bool should_complete;
 497 } TestBlockJob;
 498
 499 static void test_job_completed(Job *job, void *opaque)
 500 {
 501     BlockJob *bjob = container_of(job, BlockJob, job);
 502     block_job_completed(bjob, 0);
 503 }
 504
 505 static void coroutine_fn test_job_start(void *opaque)
 506 {
 507     TestBlockJob *s = opaque;
 508
 509     block_job_event_ready(&s->common);
 510     while (!s->should_complete) {
 511         job_sleep_ns(&s->common.job, 100000);
 512     }
 513
 514     job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
 515 }
 516
 517 static void test_job_complete(BlockJob *job, Error **errp)
 518 {
 519     TestBlockJob *s = container_of(job, TestBlockJob, common);
 520     s->should_complete = true;
 521 }
 522
 523 BlockJobDriver test_job_driver = {
 524     .job_driver = {
 525         .instance_size  = sizeof(TestBlockJob),
 526         .free           = block_job_free,
 527         .user_resume    = block_job_user_resume,
 528         .drain          = block_job_drain,
 529         .start          = test_job_start,
 530     },
 531     .complete       = test_job_complete,
 532 };
 533
 534 static void test_blockjob_common(enum drain_type drain_type)
 535 {
 536     BlockBackend *blk_src, *blk_target;
 537     BlockDriverState *src, *target;
 538     BlockJob *job;
 539     int ret;
 540
 541     src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
 542                                &error_abort);
 543     blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 544     blk_insert_bs(blk_src, src, &error_abort);
 545
 546     target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
 547                                   &error_abort);
 548     blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 549     blk_insert_bs(blk_target, target, &error_abort);
 550
 551     job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
 552                            0, 0, NULL, NULL, &error_abort);
 553     block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
 554     job_start(&job->job);
 555
 556     g_assert_cmpint(job->job.pause_count, ==, 0);
 557     g_assert_false(job->job.paused);
 558     g_assert_false(job->job.busy); /* We're in job_sleep_ns() */
 559
 560     do_drain_begin(drain_type, src);
 561
 562     if (drain_type == BDRV_DRAIN_ALL) {
 563         /* bdrv_drain_all() drains both src and target */
 564         g_assert_cmpint(job->job.pause_count, ==, 2);
 565     } else {
 566         g_assert_cmpint(job->job.pause_count, ==, 1);
 567     }
 568     /* XXX We don't wait until the job is actually paused. Is this okay? */
 569     /* g_assert_true(job->job.paused); */
 570     g_assert_false(job->job.busy); /* The job is paused */
 571
 572     do_drain_end(drain_type, src);
 573
 574     g_assert_cmpint(job->job.pause_count, ==, 0);
 575     g_assert_false(job->job.paused);
 576     g_assert_false(job->job.busy); /* We're in job_sleep_ns() */
 577
 578     do_drain_begin(drain_type, target);
 579
 580     if (drain_type == BDRV_DRAIN_ALL) {
 581         /* bdrv_drain_all() drains both src and target */
 582         g_assert_cmpint(job->job.pause_count, ==, 2);
 583     } else {
 584         g_assert_cmpint(job->job.pause_count, ==, 1);
 585     }
 586     /* XXX We don't wait until the job is actually paused. Is this okay? */
 587     /* g_assert_true(job->job.paused); */
 588     g_assert_false(job->job.busy); /* The job is paused */
 589
 590     do_drain_end(drain_type, target);
 591
 592     g_assert_cmpint(job->job.pause_count, ==, 0);
 593     g_assert_false(job->job.paused);
 594     g_assert_false(job->job.busy); /* We're in job_sleep_ns() */
 595
 596     ret = block_job_complete_sync(job, &error_abort);
 597     g_assert_cmpint(ret, ==, 0);
 598
 599     blk_unref(blk_src);
 600     blk_unref(blk_target);
 601     bdrv_unref(src);
 602     bdrv_unref(target);
 603 }
 604
 605 static void test_blockjob_drain_all(void)
 606 {
 607     test_blockjob_common(BDRV_DRAIN_ALL);
 608 }
 609
 610 static void test_blockjob_drain(void)
 611 {
 612     test_blockjob_common(BDRV_DRAIN);
 613 }
 614
 615 static void test_blockjob_drain_subtree(void)
 616 {
 617     test_blockjob_common(BDRV_SUBTREE_DRAIN);
 618 }
 619
 620 int main(int argc, char **argv)
 621 {
 622     bdrv_init();
 623     qemu_init_main_loop(&error_abort);
 624
 625     g_test_init(&argc, &argv, NULL);
 626
 627     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
 628     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
 629     g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
 630                     test_drv_cb_drain_subtree);
 631
 632     // XXX bdrv_drain_all() doesn't work in coroutine context
 633     g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
 634     g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
 635                     test_drv_cb_co_drain_subtree);
 636
 637
 638     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
 639     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
 640     g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
 641                     test_quiesce_drain_subtree);
 642
 643     // XXX bdrv_drain_all() doesn't work in coroutine context
 644     g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
 645     g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
 646                     test_quiesce_co_drain_subtree);
 647
 648     g_test_add_func("/bdrv-drain/nested", test_nested);
 649     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
 650     g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
 651
 652     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
 653     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 654     g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
 655                     test_blockjob_drain_subtree);
 656
 657     return g_test_run();
 658 }