LXR qemu/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
  31typedef struct BDRVTestState {
  32    int drain_count;
  33} BDRVTestState;
  34
  35static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
  36{
  37    BDRVTestState *s = bs->opaque;
  38    s->drain_count++;
  39}
  40
  41static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
  42{
  43    BDRVTestState *s = bs->opaque;
  44    s->drain_count--;
  45}
  46
  47static void bdrv_test_close(BlockDriverState *bs)
  48{
  49    BDRVTestState *s = bs->opaque;
  50    g_assert_cmpint(s->drain_count, >, 0);
  51}
  52
  53static 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
  66static 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
  79static void aio_ret_cb(void *opaque, int ret)
  80{
  81    int *aio_ret = opaque;
  82    *aio_ret = ret;
  83}
  84
  85typedef struct CallInCoroutineData {
  86    void (*entry)(void);
  87    bool done;
  88} CallInCoroutineData;
  89
  90static coroutine_fn void call_in_coroutine_entry(void *opaque)
  91{
  92    CallInCoroutineData *data = opaque;
  93
  94    data->entry();
  95    data->done = true;
  96}
  97
  98static 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
 113enum drain_type {
 114    BDRV_DRAIN_ALL,
 115    BDRV_DRAIN,
 116    BDRV_SUBTREE_DRAIN,
 117    DRAIN_TYPE_MAX,
 118};
 119
 120static 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
 130static 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
 140static 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
 204static void test_drv_cb_drain_all(void)
 205{
 206    test_drv_cb_common(BDRV_DRAIN_ALL, true);
 207}
 208
 209static void test_drv_cb_drain(void)
 210{
 211    test_drv_cb_common(BDRV_DRAIN, false);
 212}
 213
 214static void test_drv_cb_drain_subtree(void)
 215{
 216    test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
 217}
 218
 219static void test_drv_cb_co_drain(void)
 220{
 221    call_in_coroutine(test_drv_cb_drain);
 222}
 223
 224static void test_drv_cb_co_drain_subtree(void)
 225{
 226    call_in_coroutine(test_drv_cb_drain_subtree);
 227}
 228
 229static 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
 260static void test_quiesce_drain_all(void)
 261{
 262    // XXX drain_all doesn't quiesce
 263    //test_quiesce_common(BDRV_DRAIN_ALL, true);
 264}
 265
 266static void test_quiesce_drain(void)
 267{
 268    test_quiesce_common(BDRV_DRAIN, false);
 269}
 270
 271static void test_quiesce_drain_subtree(void)
 272{
 273    test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
 274}
 275
 276static void test_quiesce_co_drain(void)
 277{
 278    call_in_coroutine(test_quiesce_drain);
 279}
 280
 281static void test_quiesce_co_drain_subtree(void)
 282{
 283    call_in_coroutine(test_quiesce_drain_subtree);
 284}
 285
 286static 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
 341static 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
 414static 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
 494typedef struct TestBlockJob {
 495    BlockJob common;
 496    bool should_complete;
 497} TestBlockJob;
 498
 499static void test_job_completed(BlockJob *job, void *opaque)
 500{
 501    block_job_completed(job, 0);
 502}
 503
 504static void coroutine_fn test_job_start(void *opaque)
 505{
 506    TestBlockJob *s = opaque;
 507
 508    block_job_event_ready(&s->common);
 509    while (!s->should_complete) {
 510        block_job_sleep_ns(&s->common, 100000);
 511    }
 512
 513    block_job_defer_to_main_loop(&s->common, test_job_completed, NULL);
 514}
 515
 516static void test_job_complete(BlockJob *job, Error **errp)
 517{
 518    TestBlockJob *s = container_of(job, TestBlockJob, common);
 519    s->should_complete = true;
 520}
 521
 522BlockJobDriver test_job_driver = {
 523    .instance_size  = sizeof(TestBlockJob),
 524    .start          = test_job_start,
 525    .complete       = test_job_complete,
 526};
 527
 528static void test_blockjob_common(enum drain_type drain_type)
 529{
 530    BlockBackend *blk_src, *blk_target;
 531    BlockDriverState *src, *target;
 532    BlockJob *job;
 533    int ret;
 534
 535    src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
 536                               &error_abort);
 537    blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 538    blk_insert_bs(blk_src, src, &error_abort);
 539
 540    target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
 541                                  &error_abort);
 542    blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 543    blk_insert_bs(blk_target, target, &error_abort);
 544
 545    job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
 546                           0, 0, NULL, NULL, &error_abort);
 547    block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
 548    block_job_start(job);
 549
 550    g_assert_cmpint(job->pause_count, ==, 0);
 551    g_assert_false(job->paused);
 552    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
 553
 554    do_drain_begin(drain_type, src);
 555
 556    if (drain_type == BDRV_DRAIN_ALL) {
 557        /* bdrv_drain_all() drains both src and target */
 558        g_assert_cmpint(job->pause_count, ==, 2);
 559    } else {
 560        g_assert_cmpint(job->pause_count, ==, 1);
 561    }
 562    /* XXX We don't wait until the job is actually paused. Is this okay? */
 563    /* g_assert_true(job->paused); */
 564    g_assert_false(job->busy); /* The job is paused */
 565
 566    do_drain_end(drain_type, src);
 567
 568    g_assert_cmpint(job->pause_count, ==, 0);
 569    g_assert_false(job->paused);
 570    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
 571
 572    do_drain_begin(drain_type, target);
 573
 574    if (drain_type == BDRV_DRAIN_ALL) {
 575        /* bdrv_drain_all() drains both src and target */
 576        g_assert_cmpint(job->pause_count, ==, 2);
 577    } else {
 578        g_assert_cmpint(job->pause_count, ==, 1);
 579    }
 580    /* XXX We don't wait until the job is actually paused. Is this okay? */
 581    /* g_assert_true(job->paused); */
 582    g_assert_false(job->busy); /* The job is paused */
 583
 584    do_drain_end(drain_type, target);
 585
 586    g_assert_cmpint(job->pause_count, ==, 0);
 587    g_assert_false(job->paused);
 588    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
 589
 590    ret = block_job_complete_sync(job, &error_abort);
 591    g_assert_cmpint(ret, ==, 0);
 592
 593    blk_unref(blk_src);
 594    blk_unref(blk_target);
 595    bdrv_unref(src);
 596    bdrv_unref(target);
 597}
 598
 599static void test_blockjob_drain_all(void)
 600{
 601    test_blockjob_common(BDRV_DRAIN_ALL);
 602}
 603
 604static void test_blockjob_drain(void)
 605{
 606    test_blockjob_common(BDRV_DRAIN);
 607}
 608
 609static void test_blockjob_drain_subtree(void)
 610{
 611    test_blockjob_common(BDRV_SUBTREE_DRAIN);
 612}
 613
 614int main(int argc, char **argv)
 615{
 616    bdrv_init();
 617    qemu_init_main_loop(&error_abort);
 618
 619    g_test_init(&argc, &argv, NULL);
 620
 621    g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
 622    g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
 623    g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
 624                    test_drv_cb_drain_subtree);
 625
 626    // XXX bdrv_drain_all() doesn't work in coroutine context
 627    g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
 628    g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
 629                    test_drv_cb_co_drain_subtree);
 630
 631
 632    g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
 633    g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
 634    g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
 635                    test_quiesce_drain_subtree);
 636
 637    // XXX bdrv_drain_all() doesn't work in coroutine context
 638    g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
 639    g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
 640                    test_quiesce_co_drain_subtree);
 641
 642    g_test_add_func("/bdrv-drain/nested", test_nested);
 643    g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
 644    g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
 645
 646    g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
 647    g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 648    g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
 649                    test_blockjob_drain_subtree);
 650
 651    return g_test_run();
 652}
 653