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 #include "iothread.h"
  31
  32 static QemuEvent done_event;
  33
  34 typedef struct BDRVTestState {
  35     int drain_count;
  36     AioContext *bh_indirection_ctx;
  37     bool sleep_in_drain_begin;
  38 } BDRVTestState;
  39
  40 static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
  41 {
  42     BDRVTestState *s = bs->opaque;
  43     s->drain_count++;
  44     if (s->sleep_in_drain_begin) {
  45         qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
  46     }
  47 }
  48
  49 static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
  50 {
  51     BDRVTestState *s = bs->opaque;
  52     s->drain_count--;
  53 }
  54
  55 static void bdrv_test_close(BlockDriverState *bs)
  56 {
  57     BDRVTestState *s = bs->opaque;
  58     g_assert_cmpint(s->drain_count, >, 0);
  59 }
  60
  61 static void co_reenter_bh(void *opaque)
  62 {
  63     aio_co_wake(opaque);
  64 }
  65
  66 static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
  67                                             uint64_t offset, uint64_t bytes,
  68                                             QEMUIOVector *qiov, int flags)
  69 {
  70     BDRVTestState *s = bs->opaque;
  71
  72     /* We want this request to stay until the polling loop in drain waits for
  73      * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
  74      * first and polls its result, too, but it shouldn't accidentally complete
  75      * this request yet. */
  76     qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
  77
  78     if (s->bh_indirection_ctx) {
  79         aio_bh_schedule_oneshot(s->bh_indirection_ctx, co_reenter_bh,
  80                                 qemu_coroutine_self());
  81         qemu_coroutine_yield();
  82     }
  83
  84     return 0;
  85 }
  86
  87 static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
  88                                  const BdrvChildRole *role,
  89                                  BlockReopenQueue *reopen_queue,
  90                                  uint64_t perm, uint64_t shared,
  91                                  uint64_t *nperm, uint64_t *nshared)
  92 {
  93     /* bdrv_format_default_perms() accepts only these two, so disguise
  94      * detach_by_driver_cb_role as one of them. */
  95     if (role != &child_file && role != &child_backing) {
  96         role = &child_file;
  97     }
  98
  99     bdrv_format_default_perms(bs, c, role, reopen_queue, perm, shared,
 100                               nperm, nshared);
 101 }
 102
 103 static BlockDriver bdrv_test = {
 104     .format_name            = "test",
 105     .instance_size          = sizeof(BDRVTestState),
 106
 107     .bdrv_close             = bdrv_test_close,
 108     .bdrv_co_preadv         = bdrv_test_co_preadv,
 109
 110     .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
 111     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
 112
 113     .bdrv_child_perm        = bdrv_test_child_perm,
 114 };
 115
 116 static void aio_ret_cb(void *opaque, int ret)
 117 {
 118     int *aio_ret = opaque;
 119     *aio_ret = ret;
 120 }
 121
 122 typedef struct CallInCoroutineData {
 123     void (*entry)(void);
 124     bool done;
 125 } CallInCoroutineData;
 126
 127 static coroutine_fn void call_in_coroutine_entry(void *opaque)
 128 {
 129     CallInCoroutineData *data = opaque;
 130
 131     data->entry();
 132     data->done = true;
 133 }
 134
 135 static void call_in_coroutine(void (*entry)(void))
 136 {
 137     Coroutine *co;
 138     CallInCoroutineData data = {
 139         .entry  = entry,
 140         .done   = false,
 141     };
 142
 143     co = qemu_coroutine_create(call_in_coroutine_entry, &data);
 144     qemu_coroutine_enter(co);
 145     while (!data.done) {
 146         aio_poll(qemu_get_aio_context(), true);
 147     }
 148 }
 149
 150 enum drain_type {
 151     BDRV_DRAIN_ALL,
 152     BDRV_DRAIN,
 153     BDRV_SUBTREE_DRAIN,
 154     DRAIN_TYPE_MAX,
 155 };
 156
 157 static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
 158 {
 159     switch (drain_type) {
 160     case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
 161     case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
 162     case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_begin(bs); break;
 163     default:                    g_assert_not_reached();
 164     }
 165 }
 166
 167 static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
 168 {
 169     switch (drain_type) {
 170     case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
 171     case BDRV_DRAIN:            bdrv_drained_end(bs); break;
 172     case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_end(bs); break;
 173     default:                    g_assert_not_reached();
 174     }
 175 }
 176
 177 static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
 178 {
 179     BlockBackend *blk;
 180     BlockDriverState *bs, *backing;
 181     BDRVTestState *s, *backing_s;
 182     BlockAIOCB *acb;
 183     int aio_ret;
 184
 185     QEMUIOVector qiov;
 186     struct iovec iov = {
 187         .iov_base = NULL,
 188         .iov_len = 0,
 189     };
 190     qemu_iovec_init_external(&qiov, &iov, 1);
 191
 192     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 193     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 194                               &error_abort);
 195     s = bs->opaque;
 196     blk_insert_bs(blk, bs, &error_abort);
 197
 198     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 199     backing_s = backing->opaque;
 200     bdrv_set_backing_hd(bs, backing, &error_abort);
 201
 202     /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
 203     g_assert_cmpint(s->drain_count, ==, 0);
 204     g_assert_cmpint(backing_s->drain_count, ==, 0);
 205
 206     do_drain_begin(drain_type, bs);
 207
 208     g_assert_cmpint(s->drain_count, ==, 1);
 209     g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 210
 211     do_drain_end(drain_type, bs);
 212
 213     g_assert_cmpint(s->drain_count, ==, 0);
 214     g_assert_cmpint(backing_s->drain_count, ==, 0);
 215
 216     /* Now do the same while a request is pending */
 217     aio_ret = -EINPROGRESS;
 218     acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
 219     g_assert(acb != NULL);
 220     g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 221
 222     g_assert_cmpint(s->drain_count, ==, 0);
 223     g_assert_cmpint(backing_s->drain_count, ==, 0);
 224
 225     do_drain_begin(drain_type, bs);
 226
 227     g_assert_cmpint(aio_ret, ==, 0);
 228     g_assert_cmpint(s->drain_count, ==, 1);
 229     g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 230
 231     do_drain_end(drain_type, bs);
 232
 233     g_assert_cmpint(s->drain_count, ==, 0);
 234     g_assert_cmpint(backing_s->drain_count, ==, 0);
 235
 236     bdrv_unref(backing);
 237     bdrv_unref(bs);
 238     blk_unref(blk);
 239 }
 240
 241 static void test_drv_cb_drain_all(void)
 242 {
 243     test_drv_cb_common(BDRV_DRAIN_ALL, true);
 244 }
 245
 246 static void test_drv_cb_drain(void)
 247 {
 248     test_drv_cb_common(BDRV_DRAIN, false);
 249 }
 250
 251 static void test_drv_cb_drain_subtree(void)
 252 {
 253     test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
 254 }
 255
 256 static void test_drv_cb_co_drain_all(void)
 257 {
 258     call_in_coroutine(test_drv_cb_drain_all);
 259 }
 260
 261 static void test_drv_cb_co_drain(void)
 262 {
 263     call_in_coroutine(test_drv_cb_drain);
 264 }
 265
 266 static void test_drv_cb_co_drain_subtree(void)
 267 {
 268     call_in_coroutine(test_drv_cb_drain_subtree);
 269 }
 270
 271 static void test_quiesce_common(enum drain_type drain_type, bool recursive)
 272 {
 273     BlockBackend *blk;
 274     BlockDriverState *bs, *backing;
 275
 276     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 277     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 278                               &error_abort);
 279     blk_insert_bs(blk, bs, &error_abort);
 280
 281     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 282     bdrv_set_backing_hd(bs, backing, &error_abort);
 283
 284     g_assert_cmpint(bs->quiesce_counter, ==, 0);
 285     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 286
 287     do_drain_begin(drain_type, bs);
 288
 289     g_assert_cmpint(bs->quiesce_counter, ==, 1);
 290     g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
 291
 292     do_drain_end(drain_type, bs);
 293
 294     g_assert_cmpint(bs->quiesce_counter, ==, 0);
 295     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 296
 297     bdrv_unref(backing);
 298     bdrv_unref(bs);
 299     blk_unref(blk);
 300 }
 301
 302 static void test_quiesce_drain_all(void)
 303 {
 304     test_quiesce_common(BDRV_DRAIN_ALL, true);
 305 }
 306
 307 static void test_quiesce_drain(void)
 308 {
 309     test_quiesce_common(BDRV_DRAIN, false);
 310 }
 311
 312 static void test_quiesce_drain_subtree(void)
 313 {
 314     test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
 315 }
 316
 317 static void test_quiesce_co_drain_all(void)
 318 {
 319     call_in_coroutine(test_quiesce_drain_all);
 320 }
 321
 322 static void test_quiesce_co_drain(void)
 323 {
 324     call_in_coroutine(test_quiesce_drain);
 325 }
 326
 327 static void test_quiesce_co_drain_subtree(void)
 328 {
 329     call_in_coroutine(test_quiesce_drain_subtree);
 330 }
 331
 332 static void test_nested(void)
 333 {
 334     BlockBackend *blk;
 335     BlockDriverState *bs, *backing;
 336     BDRVTestState *s, *backing_s;
 337     enum drain_type outer, inner;
 338
 339     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 340     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 341                               &error_abort);
 342     s = bs->opaque;
 343     blk_insert_bs(blk, bs, &error_abort);
 344
 345     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 346     backing_s = backing->opaque;
 347     bdrv_set_backing_hd(bs, backing, &error_abort);
 348
 349     for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
 350         for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
 351             int backing_quiesce = (outer != BDRV_DRAIN) +
 352                                   (inner != BDRV_DRAIN);
 353
 354             g_assert_cmpint(bs->quiesce_counter, ==, 0);
 355             g_assert_cmpint(backing->quiesce_counter, ==, 0);
 356             g_assert_cmpint(s->drain_count, ==, 0);
 357             g_assert_cmpint(backing_s->drain_count, ==, 0);
 358
 359             do_drain_begin(outer, bs);
 360             do_drain_begin(inner, bs);
 361
 362             g_assert_cmpint(bs->quiesce_counter, ==, 2);
 363             g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
 364             g_assert_cmpint(s->drain_count, ==, 2);
 365             g_assert_cmpint(backing_s->drain_count, ==, backing_quiesce);
 366
 367             do_drain_end(inner, bs);
 368             do_drain_end(outer, bs);
 369
 370             g_assert_cmpint(bs->quiesce_counter, ==, 0);
 371             g_assert_cmpint(backing->quiesce_counter, ==, 0);
 372             g_assert_cmpint(s->drain_count, ==, 0);
 373             g_assert_cmpint(backing_s->drain_count, ==, 0);
 374         }
 375     }
 376
 377     bdrv_unref(backing);
 378     bdrv_unref(bs);
 379     blk_unref(blk);
 380 }
 381
 382 static void test_multiparent(void)
 383 {
 384     BlockBackend *blk_a, *blk_b;
 385     BlockDriverState *bs_a, *bs_b, *backing;
 386     BDRVTestState *a_s, *b_s, *backing_s;
 387
 388     blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 389     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 390                                 &error_abort);
 391     a_s = bs_a->opaque;
 392     blk_insert_bs(blk_a, bs_a, &error_abort);
 393
 394     blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 395     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 396                                 &error_abort);
 397     b_s = bs_b->opaque;
 398     blk_insert_bs(blk_b, bs_b, &error_abort);
 399
 400     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 401     backing_s = backing->opaque;
 402     bdrv_set_backing_hd(bs_a, backing, &error_abort);
 403     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 404
 405     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 406     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 407     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 408     g_assert_cmpint(a_s->drain_count, ==, 0);
 409     g_assert_cmpint(b_s->drain_count, ==, 0);
 410     g_assert_cmpint(backing_s->drain_count, ==, 0);
 411
 412     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 413
 414     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 415     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 416     g_assert_cmpint(backing->quiesce_counter, ==, 1);
 417     g_assert_cmpint(a_s->drain_count, ==, 1);
 418     g_assert_cmpint(b_s->drain_count, ==, 1);
 419     g_assert_cmpint(backing_s->drain_count, ==, 1);
 420
 421     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 422
 423     g_assert_cmpint(bs_a->quiesce_counter, ==, 2);
 424     g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 425     g_assert_cmpint(backing->quiesce_counter, ==, 2);
 426     g_assert_cmpint(a_s->drain_count, ==, 2);
 427     g_assert_cmpint(b_s->drain_count, ==, 2);
 428     g_assert_cmpint(backing_s->drain_count, ==, 2);
 429
 430     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 431
 432     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 433     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 434     g_assert_cmpint(backing->quiesce_counter, ==, 1);
 435     g_assert_cmpint(a_s->drain_count, ==, 1);
 436     g_assert_cmpint(b_s->drain_count, ==, 1);
 437     g_assert_cmpint(backing_s->drain_count, ==, 1);
 438
 439     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 440
 441     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 442     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 443     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 444     g_assert_cmpint(a_s->drain_count, ==, 0);
 445     g_assert_cmpint(b_s->drain_count, ==, 0);
 446     g_assert_cmpint(backing_s->drain_count, ==, 0);
 447
 448     bdrv_unref(backing);
 449     bdrv_unref(bs_a);
 450     bdrv_unref(bs_b);
 451     blk_unref(blk_a);
 452     blk_unref(blk_b);
 453 }
 454
 455 static void test_graph_change_drain_subtree(void)
 456 {
 457     BlockBackend *blk_a, *blk_b;
 458     BlockDriverState *bs_a, *bs_b, *backing;
 459     BDRVTestState *a_s, *b_s, *backing_s;
 460
 461     blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 462     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 463                                 &error_abort);
 464     a_s = bs_a->opaque;
 465     blk_insert_bs(blk_a, bs_a, &error_abort);
 466
 467     blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 468     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 469                                 &error_abort);
 470     b_s = bs_b->opaque;
 471     blk_insert_bs(blk_b, bs_b, &error_abort);
 472
 473     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 474     backing_s = backing->opaque;
 475     bdrv_set_backing_hd(bs_a, backing, &error_abort);
 476
 477     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 478     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 479     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 480     g_assert_cmpint(a_s->drain_count, ==, 0);
 481     g_assert_cmpint(b_s->drain_count, ==, 0);
 482     g_assert_cmpint(backing_s->drain_count, ==, 0);
 483
 484     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 485     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 486     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 487     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 488     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 489
 490     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 491     g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 492     g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 493     g_assert_cmpint(backing->quiesce_counter, ==, 5);
 494     g_assert_cmpint(a_s->drain_count, ==, 5);
 495     g_assert_cmpint(b_s->drain_count, ==, 5);
 496     g_assert_cmpint(backing_s->drain_count, ==, 5);
 497
 498     bdrv_set_backing_hd(bs_b, NULL, &error_abort);
 499     g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
 500     g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 501     g_assert_cmpint(backing->quiesce_counter, ==, 3);
 502     g_assert_cmpint(a_s->drain_count, ==, 3);
 503     g_assert_cmpint(b_s->drain_count, ==, 2);
 504     g_assert_cmpint(backing_s->drain_count, ==, 3);
 505
 506     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 507     g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 508     g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 509     g_assert_cmpint(backing->quiesce_counter, ==, 5);
 510     g_assert_cmpint(a_s->drain_count, ==, 5);
 511     g_assert_cmpint(b_s->drain_count, ==, 5);
 512     g_assert_cmpint(backing_s->drain_count, ==, 5);
 513
 514     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 515     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 516     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 517     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 518     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 519
 520     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 521     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 522     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 523     g_assert_cmpint(a_s->drain_count, ==, 0);
 524     g_assert_cmpint(b_s->drain_count, ==, 0);
 525     g_assert_cmpint(backing_s->drain_count, ==, 0);
 526
 527     bdrv_unref(backing);
 528     bdrv_unref(bs_a);
 529     bdrv_unref(bs_b);
 530     blk_unref(blk_a);
 531     blk_unref(blk_b);
 532 }
 533
 534 static void test_graph_change_drain_all(void)
 535 {
 536     BlockBackend *blk_a, *blk_b;
 537     BlockDriverState *bs_a, *bs_b;
 538     BDRVTestState *a_s, *b_s;
 539
 540     /* Create node A with a BlockBackend */
 541     blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 542     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 543                                 &error_abort);
 544     a_s = bs_a->opaque;
 545     blk_insert_bs(blk_a, bs_a, &error_abort);
 546
 547     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 548     g_assert_cmpint(a_s->drain_count, ==, 0);
 549
 550     /* Call bdrv_drain_all_begin() */
 551     bdrv_drain_all_begin();
 552
 553     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 554     g_assert_cmpint(a_s->drain_count, ==, 1);
 555
 556     /* Create node B with a BlockBackend */
 557     blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 558     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 559                                 &error_abort);
 560     b_s = bs_b->opaque;
 561     blk_insert_bs(blk_b, bs_b, &error_abort);
 562
 563     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 564     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 565     g_assert_cmpint(a_s->drain_count, ==, 1);
 566     g_assert_cmpint(b_s->drain_count, ==, 1);
 567
 568     /* Unref and finally delete node A */
 569     blk_unref(blk_a);
 570
 571     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 572     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 573     g_assert_cmpint(a_s->drain_count, ==, 1);
 574     g_assert_cmpint(b_s->drain_count, ==, 1);
 575
 576     bdrv_unref(bs_a);
 577
 578     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 579     g_assert_cmpint(b_s->drain_count, ==, 1);
 580
 581     /* End the drained section */
 582     bdrv_drain_all_end();
 583
 584     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 585     g_assert_cmpint(b_s->drain_count, ==, 0);
 586
 587     bdrv_unref(bs_b);
 588     blk_unref(blk_b);
 589 }
 590
 591 struct test_iothread_data {
 592     BlockDriverState *bs;
 593     enum drain_type drain_type;
 594     int *aio_ret;
 595 };
 596
 597 static void test_iothread_drain_entry(void *opaque)
 598 {
 599     struct test_iothread_data *data = opaque;
 600
 601     aio_context_acquire(bdrv_get_aio_context(data->bs));
 602     do_drain_begin(data->drain_type, data->bs);
 603     g_assert_cmpint(*data->aio_ret, ==, 0);
 604     do_drain_end(data->drain_type, data->bs);
 605     aio_context_release(bdrv_get_aio_context(data->bs));
 606
 607     qemu_event_set(&done_event);
 608 }
 609
 610 static void test_iothread_aio_cb(void *opaque, int ret)
 611 {
 612     int *aio_ret = opaque;
 613     *aio_ret = ret;
 614     qemu_event_set(&done_event);
 615 }
 616
 617 /*
 618  * Starts an AIO request on a BDS that runs in the AioContext of iothread 1.
 619  * The request involves a BH on iothread 2 before it can complete.
 620  *
 621  * @drain_thread = 0 means that do_drain_begin/end are called from the main
 622  * thread, @drain_thread = 1 means that they are called from iothread 1. Drain
 623  * for this BDS cannot be called from iothread 2 because only the main thread
 624  * may do cross-AioContext polling.
 625  */
 626 static void test_iothread_common(enum drain_type drain_type, int drain_thread)
 627 {
 628     BlockBackend *blk;
 629     BlockDriverState *bs;
 630     BDRVTestState *s;
 631     BlockAIOCB *acb;
 632     int aio_ret;
 633     struct test_iothread_data data;
 634
 635     IOThread *a = iothread_new();
 636     IOThread *b = iothread_new();
 637     AioContext *ctx_a = iothread_get_aio_context(a);
 638     AioContext *ctx_b = iothread_get_aio_context(b);
 639
 640     QEMUIOVector qiov;
 641     struct iovec iov = {
 642         .iov_base = NULL,
 643         .iov_len = 0,
 644     };
 645     qemu_iovec_init_external(&qiov, &iov, 1);
 646
 647     /* bdrv_drain_all() may only be called from the main loop thread */
 648     if (drain_type == BDRV_DRAIN_ALL && drain_thread != 0) {
 649         goto out;
 650     }
 651
 652     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 653     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 654                               &error_abort);
 655     s = bs->opaque;
 656     blk_insert_bs(blk, bs, &error_abort);
 657
 658     blk_set_aio_context(blk, ctx_a);
 659     aio_context_acquire(ctx_a);
 660
 661     s->bh_indirection_ctx = ctx_b;
 662
 663     aio_ret = -EINPROGRESS;
 664     if (drain_thread == 0) {
 665         acb = blk_aio_preadv(blk, 0, &qiov, 0, test_iothread_aio_cb, &aio_ret);
 666     } else {
 667         acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
 668     }
 669     g_assert(acb != NULL);
 670     g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 671
 672     aio_context_release(ctx_a);
 673
 674     data = (struct test_iothread_data) {
 675         .bs         = bs,
 676         .drain_type = drain_type,
 677         .aio_ret    = &aio_ret,
 678     };
 679
 680     switch (drain_thread) {
 681     case 0:
 682         if (drain_type != BDRV_DRAIN_ALL) {
 683             aio_context_acquire(ctx_a);
 684         }
 685
 686         /* The request is running on the IOThread a. Draining its block device
 687          * will make sure that it has completed as far as the BDS is concerned,
 688          * but the drain in this thread can continue immediately after
 689          * bdrv_dec_in_flight() and aio_ret might be assigned only slightly
 690          * later. */
 691         qemu_event_reset(&done_event);
 692         do_drain_begin(drain_type, bs);
 693         g_assert_cmpint(bs->in_flight, ==, 0);
 694
 695         if (drain_type != BDRV_DRAIN_ALL) {
 696             aio_context_release(ctx_a);
 697         }
 698         qemu_event_wait(&done_event);
 699         if (drain_type != BDRV_DRAIN_ALL) {
 700             aio_context_acquire(ctx_a);
 701         }
 702
 703         g_assert_cmpint(aio_ret, ==, 0);
 704         do_drain_end(drain_type, bs);
 705
 706         if (drain_type != BDRV_DRAIN_ALL) {
 707             aio_context_release(ctx_a);
 708         }
 709         break;
 710     case 1:
 711         qemu_event_reset(&done_event);
 712         aio_bh_schedule_oneshot(ctx_a, test_iothread_drain_entry, &data);
 713         qemu_event_wait(&done_event);
 714         break;
 715     default:
 716         g_assert_not_reached();
 717     }
 718
 719     aio_context_acquire(ctx_a);
 720     blk_set_aio_context(blk, qemu_get_aio_context());
 721     aio_context_release(ctx_a);
 722
 723     bdrv_unref(bs);
 724     blk_unref(blk);
 725
 726 out:
 727     iothread_join(a);
 728     iothread_join(b);
 729 }
 730
 731 static void test_iothread_drain_all(void)
 732 {
 733     test_iothread_common(BDRV_DRAIN_ALL, 0);
 734     test_iothread_common(BDRV_DRAIN_ALL, 1);
 735 }
 736
 737 static void test_iothread_drain(void)
 738 {
 739     test_iothread_common(BDRV_DRAIN, 0);
 740     test_iothread_common(BDRV_DRAIN, 1);
 741 }
 742
 743 static void test_iothread_drain_subtree(void)
 744 {
 745     test_iothread_common(BDRV_SUBTREE_DRAIN, 0);
 746     test_iothread_common(BDRV_SUBTREE_DRAIN, 1);
 747 }
 748
 749
 750 typedef struct TestBlockJob {
 751     BlockJob common;
 752     bool should_complete;
 753 } TestBlockJob;
 754
 755 static void test_job_completed(Job *job, void *opaque)
 756 {
 757     job_completed(job, 0, NULL);
 758 }
 759
 760 static int coroutine_fn test_job_run(Job *job, Error **errp)
 761 {
 762     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 763
 764     job_transition_to_ready(&s->common.job);
 765     while (!s->should_complete) {
 766         /* Avoid block_job_sleep_ns() because it marks the job as !busy. We
 767          * want to emulate some actual activity (probably some I/O) here so
 768          * that drain has to wait for this acitivity to stop. */
 769         qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
 770         job_pause_point(&s->common.job);
 771     }
 772
 773     job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
 774     return 0;
 775 }
 776
 777 static void test_job_complete(Job *job, Error **errp)
 778 {
 779     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 780     s->should_complete = true;
 781 }
 782
 783 BlockJobDriver test_job_driver = {
 784     .job_driver = {
 785         .instance_size  = sizeof(TestBlockJob),
 786         .free           = block_job_free,
 787         .user_resume    = block_job_user_resume,
 788         .drain          = block_job_drain,
 789         .run            = test_job_run,
 790         .complete       = test_job_complete,
 791     },
 792 };
 793
 794 static void test_blockjob_common(enum drain_type drain_type)
 795 {
 796     BlockBackend *blk_src, *blk_target;
 797     BlockDriverState *src, *target;
 798     BlockJob *job;
 799     int ret;
 800
 801     src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
 802                                &error_abort);
 803     blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 804     blk_insert_bs(blk_src, src, &error_abort);
 805
 806     target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
 807                                   &error_abort);
 808     blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 809     blk_insert_bs(blk_target, target, &error_abort);
 810
 811     job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
 812                            0, 0, NULL, NULL, &error_abort);
 813     block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
 814     job_start(&job->job);
 815
 816     g_assert_cmpint(job->job.pause_count, ==, 0);
 817     g_assert_false(job->job.paused);
 818     g_assert_true(job->job.busy); /* We're in job_sleep_ns() */
 819
 820     do_drain_begin(drain_type, src);
 821
 822     if (drain_type == BDRV_DRAIN_ALL) {
 823         /* bdrv_drain_all() drains both src and target */
 824         g_assert_cmpint(job->job.pause_count, ==, 2);
 825     } else {
 826         g_assert_cmpint(job->job.pause_count, ==, 1);
 827     }
 828     g_assert_true(job->job.paused);
 829     g_assert_false(job->job.busy); /* The job is paused */
 830
 831     do_drain_end(drain_type, src);
 832
 833     g_assert_cmpint(job->job.pause_count, ==, 0);
 834     g_assert_false(job->job.paused);
 835     g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */
 836
 837     do_drain_begin(drain_type, target);
 838
 839     if (drain_type == BDRV_DRAIN_ALL) {
 840         /* bdrv_drain_all() drains both src and target */
 841         g_assert_cmpint(job->job.pause_count, ==, 2);
 842     } else {
 843         g_assert_cmpint(job->job.pause_count, ==, 1);
 844     }
 845     g_assert_true(job->job.paused);
 846     g_assert_false(job->job.busy); /* The job is paused */
 847
 848     do_drain_end(drain_type, target);
 849
 850     g_assert_cmpint(job->job.pause_count, ==, 0);
 851     g_assert_false(job->job.paused);
 852     g_assert_true(job->job.busy); /* We're in job_sleep_ns() */
 853
 854     ret = job_complete_sync(&job->job, &error_abort);
 855     g_assert_cmpint(ret, ==, 0);
 856
 857     blk_unref(blk_src);
 858     blk_unref(blk_target);
 859     bdrv_unref(src);
 860     bdrv_unref(target);
 861 }
 862
 863 static void test_blockjob_drain_all(void)
 864 {
 865     test_blockjob_common(BDRV_DRAIN_ALL);
 866 }
 867
 868 static void test_blockjob_drain(void)
 869 {
 870     test_blockjob_common(BDRV_DRAIN);
 871 }
 872
 873 static void test_blockjob_drain_subtree(void)
 874 {
 875     test_blockjob_common(BDRV_SUBTREE_DRAIN);
 876 }
 877
 878
 879 typedef struct BDRVTestTopState {
 880     BdrvChild *wait_child;
 881 } BDRVTestTopState;
 882
 883 static void bdrv_test_top_close(BlockDriverState *bs)
 884 {
 885     BdrvChild *c, *next_c;
 886     QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) {
 887         bdrv_unref_child(bs, c);
 888     }
 889 }
 890
 891 static int coroutine_fn bdrv_test_top_co_preadv(BlockDriverState *bs,
 892                                                 uint64_t offset, uint64_t bytes,
 893                                                 QEMUIOVector *qiov, int flags)
 894 {
 895     BDRVTestTopState *tts = bs->opaque;
 896     return bdrv_co_preadv(tts->wait_child, offset, bytes, qiov, flags);
 897 }
 898
 899 static BlockDriver bdrv_test_top_driver = {
 900     .format_name            = "test_top_driver",
 901     .instance_size          = sizeof(BDRVTestTopState),
 902
 903     .bdrv_close             = bdrv_test_top_close,
 904     .bdrv_co_preadv         = bdrv_test_top_co_preadv,
 905
 906     .bdrv_child_perm        = bdrv_format_default_perms,
 907 };
 908
 909 typedef struct TestCoDeleteByDrainData {
 910     BlockBackend *blk;
 911     bool detach_instead_of_delete;
 912     bool done;
 913 } TestCoDeleteByDrainData;
 914
 915 static void coroutine_fn test_co_delete_by_drain(void *opaque)
 916 {
 917     TestCoDeleteByDrainData *dbdd = opaque;
 918     BlockBackend *blk = dbdd->blk;
 919     BlockDriverState *bs = blk_bs(blk);
 920     BDRVTestTopState *tts = bs->opaque;
 921     void *buffer = g_malloc(65536);
 922     QEMUIOVector qiov;
 923     struct iovec iov = {
 924         .iov_base = buffer,
 925         .iov_len  = 65536,
 926     };
 927
 928     qemu_iovec_init_external(&qiov, &iov, 1);
 929
 930     /* Pretend some internal write operation from parent to child.
 931      * Important: We have to read from the child, not from the parent!
 932      * Draining works by first propagating it all up the tree to the
 933      * root and then waiting for drainage from root to the leaves
 934      * (protocol nodes).  If we have a request waiting on the root,
 935      * everything will be drained before we go back down the tree, but
 936      * we do not want that.  We want to be in the middle of draining
 937      * when this following requests returns. */
 938     bdrv_co_preadv(tts->wait_child, 0, 65536, &qiov, 0);
 939
 940     g_assert_cmpint(bs->refcnt, ==, 1);
 941
 942     if (!dbdd->detach_instead_of_delete) {
 943         blk_unref(blk);
 944     } else {
 945         BdrvChild *c, *next_c;
 946         QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) {
 947             bdrv_unref_child(bs, c);
 948         }
 949     }
 950
 951     dbdd->done = true;
 952     g_free(buffer);
 953 }
 954
 955 /**
 956  * Test what happens when some BDS has some children, you drain one of
 957  * them and this results in the BDS being deleted.
 958  *
 959  * If @detach_instead_of_delete is set, the BDS is not going to be
 960  * deleted but will only detach all of its children.
 961  */
 962 static void do_test_delete_by_drain(bool detach_instead_of_delete,
 963                                     enum drain_type drain_type)
 964 {
 965     BlockBackend *blk;
 966     BlockDriverState *bs, *child_bs, *null_bs;
 967     BDRVTestTopState *tts;
 968     TestCoDeleteByDrainData dbdd;
 969     Coroutine *co;
 970
 971     bs = bdrv_new_open_driver(&bdrv_test_top_driver, "top", BDRV_O_RDWR,
 972                               &error_abort);
 973     bs->total_sectors = 65536 >> BDRV_SECTOR_BITS;
 974     tts = bs->opaque;
 975
 976     null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
 977                         &error_abort);
 978     bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort);
 979
 980     /* This child will be the one to pass to requests through to, and
 981      * it will stall until a drain occurs */
 982     child_bs = bdrv_new_open_driver(&bdrv_test, "child", BDRV_O_RDWR,
 983                                     &error_abort);
 984     child_bs->total_sectors = 65536 >> BDRV_SECTOR_BITS;
 985     /* Takes our reference to child_bs */
 986     tts->wait_child = bdrv_attach_child(bs, child_bs, "wait-child", &child_file,
 987                                         &error_abort);
 988
 989     /* This child is just there to be deleted
 990      * (for detach_instead_of_delete == true) */
 991     null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
 992                         &error_abort);
 993     bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort);
 994
 995     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 996     blk_insert_bs(blk, bs, &error_abort);
 997
 998     /* Referenced by blk now */
 999     bdrv_unref(bs);
1000
1001     g_assert_cmpint(bs->refcnt, ==, 1);
1002     g_assert_cmpint(child_bs->refcnt, ==, 1);
1003     g_assert_cmpint(null_bs->refcnt, ==, 1);
1004
1005
1006     dbdd = (TestCoDeleteByDrainData){
1007         .blk = blk,
1008         .detach_instead_of_delete = detach_instead_of_delete,
1009         .done = false,
1010     };
1011     co = qemu_coroutine_create(test_co_delete_by_drain, &dbdd);
1012     qemu_coroutine_enter(co);
1013
1014     /* Drain the child while the read operation is still pending.
1015      * This should result in the operation finishing and
1016      * test_co_delete_by_drain() resuming.  Thus, @bs will be deleted
1017      * and the coroutine will exit while this drain operation is still
1018      * in progress. */
1019     switch (drain_type) {
1020     case BDRV_DRAIN:
1021         bdrv_ref(child_bs);
1022         bdrv_drain(child_bs);
1023         bdrv_unref(child_bs);
1024         break;
1025     case BDRV_SUBTREE_DRAIN:
1026         /* Would have to ref/unref bs here for !detach_instead_of_delete, but
1027          * then the whole test becomes pointless because the graph changes
1028          * don't occur during the drain any more. */
1029         assert(detach_instead_of_delete);
1030         bdrv_subtree_drained_begin(bs);
1031         bdrv_subtree_drained_end(bs);
1032         break;
1033     case BDRV_DRAIN_ALL:
1034         bdrv_drain_all_begin();
1035         bdrv_drain_all_end();
1036         break;
1037     default:
1038         g_assert_not_reached();
1039     }
1040
1041     while (!dbdd.done) {
1042         aio_poll(qemu_get_aio_context(), true);
1043     }
1044
1045     if (detach_instead_of_delete) {
1046         /* Here, the reference has not passed over to the coroutine,
1047          * so we have to delete the BB ourselves */
1048         blk_unref(blk);
1049     }
1050 }
1051
1052 static void test_delete_by_drain(void)
1053 {
1054     do_test_delete_by_drain(false, BDRV_DRAIN);
1055 }
1056
1057 static void test_detach_by_drain_all(void)
1058 {
1059     do_test_delete_by_drain(true, BDRV_DRAIN_ALL);
1060 }
1061
1062 static void test_detach_by_drain(void)
1063 {
1064     do_test_delete_by_drain(true, BDRV_DRAIN);
1065 }
1066
1067 static void test_detach_by_drain_subtree(void)
1068 {
1069     do_test_delete_by_drain(true, BDRV_SUBTREE_DRAIN);
1070 }
1071
1072
1073 struct detach_by_parent_data {
1074     BlockDriverState *parent_b;
1075     BdrvChild *child_b;
1076     BlockDriverState *c;
1077     BdrvChild *child_c;
1078     bool by_parent_cb;
1079 };
1080 static struct detach_by_parent_data detach_by_parent_data;
1081
1082 static void detach_indirect_bh(void *opaque)
1083 {
1084     struct detach_by_parent_data *data = opaque;
1085
1086     bdrv_unref_child(data->parent_b, data->child_b);
1087
1088     bdrv_ref(data->c);
1089     data->child_c = bdrv_attach_child(data->parent_b, data->c, "PB-C",
1090                                       &child_file, &error_abort);
1091 }
1092
1093 static void detach_by_parent_aio_cb(void *opaque, int ret)
1094 {
1095     struct detach_by_parent_data *data = &detach_by_parent_data;
1096
1097     g_assert_cmpint(ret, ==, 0);
1098     if (data->by_parent_cb) {
1099         detach_indirect_bh(data);
1100     }
1101 }
1102
1103 static void detach_by_driver_cb_drained_begin(BdrvChild *child)
1104 {
1105     aio_bh_schedule_oneshot(qemu_get_current_aio_context(),
1106                             detach_indirect_bh, &detach_by_parent_data);
1107     child_file.drained_begin(child);
1108 }
1109
1110 static BdrvChildRole detach_by_driver_cb_role;
1111
1112 /*
1113  * Initial graph:
1114  *
1115  * PA     PB
1116  *    \ /   \
1117  *     A     B     C
1118  *
1119  * by_parent_cb == true:  Test that parent callbacks don't poll
1120  *
1121  *     PA has a pending write request whose callback changes the child nodes of
1122  *     PB: It removes B and adds C instead. The subtree of PB is drained, which
1123  *     will indirectly drain the write request, too.
1124  *
1125  * by_parent_cb == false: Test that bdrv_drain_invoke() doesn't poll
1126  *
1127  *     PA's BdrvChildRole has a .drained_begin callback that schedules a BH
1128  *     that does the same graph change. If bdrv_drain_invoke() calls it, the
1129  *     state is messed up, but if it is only polled in the single
1130  *     BDRV_POLL_WHILE() at the end of the drain, this should work fine.
1131  */
1132 static void test_detach_indirect(bool by_parent_cb)
1133 {
1134     BlockBackend *blk;
1135     BlockDriverState *parent_a, *parent_b, *a, *b, *c;
1136     BdrvChild *child_a, *child_b;
1137     BlockAIOCB *acb;
1138
1139     QEMUIOVector qiov;
1140     struct iovec iov = {
1141         .iov_base = NULL,
1142         .iov_len = 0,
1143     };
1144     qemu_iovec_init_external(&qiov, &iov, 1);
1145
1146     if (!by_parent_cb) {
1147         detach_by_driver_cb_role = child_file;
1148         detach_by_driver_cb_role.drained_begin =
1149             detach_by_driver_cb_drained_begin;
1150     }
1151
1152     /* Create all involved nodes */
1153     parent_a = bdrv_new_open_driver(&bdrv_test, "parent-a", BDRV_O_RDWR,
1154                                     &error_abort);
1155     parent_b = bdrv_new_open_driver(&bdrv_test, "parent-b", 0,
1156                                     &error_abort);
1157
1158     a = bdrv_new_open_driver(&bdrv_test, "a", BDRV_O_RDWR, &error_abort);
1159     b = bdrv_new_open_driver(&bdrv_test, "b", BDRV_O_RDWR, &error_abort);
1160     c = bdrv_new_open_driver(&bdrv_test, "c", BDRV_O_RDWR, &error_abort);
1161
1162     /* blk is a BB for parent-a */
1163     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
1164     blk_insert_bs(blk, parent_a, &error_abort);
1165     bdrv_unref(parent_a);
1166
1167     /* If we want to get bdrv_drain_invoke() to call aio_poll(), the driver
1168      * callback must not return immediately. */
1169     if (!by_parent_cb) {
1170         BDRVTestState *s = parent_a->opaque;
1171         s->sleep_in_drain_begin = true;
1172     }
1173
1174     /* Set child relationships */
1175     bdrv_ref(b);
1176     bdrv_ref(a);
1177     child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, &error_abort);
1178     child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_backing, &error_abort);
1179
1180     bdrv_ref(a);
1181     bdrv_attach_child(parent_a, a, "PA-A",
1182                       by_parent_cb ? &child_file : &detach_by_driver_cb_role,
1183                       &error_abort);
1184
1185     g_assert_cmpint(parent_a->refcnt, ==, 1);
1186     g_assert_cmpint(parent_b->refcnt, ==, 1);
1187     g_assert_cmpint(a->refcnt, ==, 3);
1188     g_assert_cmpint(b->refcnt, ==, 2);
1189     g_assert_cmpint(c->refcnt, ==, 1);
1190
1191     g_assert(QLIST_FIRST(&parent_b->children) == child_a);
1192     g_assert(QLIST_NEXT(child_a, next) == child_b);
1193     g_assert(QLIST_NEXT(child_b, next) == NULL);
1194
1195     /* Start the evil write request */
1196     detach_by_parent_data = (struct detach_by_parent_data) {
1197         .parent_b = parent_b,
1198         .child_b = child_b,
1199         .c = c,
1200         .by_parent_cb = by_parent_cb,
1201     };
1202     acb = blk_aio_preadv(blk, 0, &qiov, 0, detach_by_parent_aio_cb, NULL);
1203     g_assert(acb != NULL);
1204
1205     /* Drain and check the expected result */
1206     bdrv_subtree_drained_begin(parent_b);
1207
1208     g_assert(detach_by_parent_data.child_c != NULL);
1209
1210     g_assert_cmpint(parent_a->refcnt, ==, 1);
1211     g_assert_cmpint(parent_b->refcnt, ==, 1);
1212     g_assert_cmpint(a->refcnt, ==, 3);
1213     g_assert_cmpint(b->refcnt, ==, 1);
1214     g_assert_cmpint(c->refcnt, ==, 2);
1215
1216     g_assert(QLIST_FIRST(&parent_b->children) == detach_by_parent_data.child_c);
1217     g_assert(QLIST_NEXT(detach_by_parent_data.child_c, next) == child_a);
1218     g_assert(QLIST_NEXT(child_a, next) == NULL);
1219
1220     g_assert_cmpint(parent_a->quiesce_counter, ==, 1);
1221     g_assert_cmpint(parent_b->quiesce_counter, ==, 1);
1222     g_assert_cmpint(a->quiesce_counter, ==, 1);
1223     g_assert_cmpint(b->quiesce_counter, ==, 0);
1224     g_assert_cmpint(c->quiesce_counter, ==, 1);
1225
1226     bdrv_subtree_drained_end(parent_b);
1227
1228     bdrv_unref(parent_b);
1229     blk_unref(blk);
1230
1231     /* XXX Once bdrv_close() unref's children instead of just detaching them,
1232      * this won't be necessary any more. */
1233     bdrv_unref(a);
1234     bdrv_unref(a);
1235     bdrv_unref(c);
1236
1237     g_assert_cmpint(a->refcnt, ==, 1);
1238     g_assert_cmpint(b->refcnt, ==, 1);
1239     g_assert_cmpint(c->refcnt, ==, 1);
1240     bdrv_unref(a);
1241     bdrv_unref(b);
1242     bdrv_unref(c);
1243 }
1244
1245 static void test_detach_by_parent_cb(void)
1246 {
1247     test_detach_indirect(true);
1248 }
1249
1250 static void test_detach_by_driver_cb(void)
1251 {
1252     test_detach_indirect(false);
1253 }
1254
1255 static void test_append_to_drained(void)
1256 {
1257     BlockBackend *blk;
1258     BlockDriverState *base, *overlay;
1259     BDRVTestState *base_s, *overlay_s;
1260
1261     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
1262     base = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
1263     base_s = base->opaque;
1264     blk_insert_bs(blk, base, &error_abort);
1265
1266     overlay = bdrv_new_open_driver(&bdrv_test, "overlay", BDRV_O_RDWR,
1267                                    &error_abort);
1268     overlay_s = overlay->opaque;
1269
1270     do_drain_begin(BDRV_DRAIN, base);
1271     g_assert_cmpint(base->quiesce_counter, ==, 1);
1272     g_assert_cmpint(base_s->drain_count, ==, 1);
1273     g_assert_cmpint(base->in_flight, ==, 0);
1274
1275     /* Takes ownership of overlay, so we don't have to unref it later */
1276     bdrv_append(overlay, base, &error_abort);
1277     g_assert_cmpint(base->in_flight, ==, 0);
1278     g_assert_cmpint(overlay->in_flight, ==, 0);
1279
1280     g_assert_cmpint(base->quiesce_counter, ==, 1);
1281     g_assert_cmpint(base_s->drain_count, ==, 1);
1282     g_assert_cmpint(overlay->quiesce_counter, ==, 1);
1283     g_assert_cmpint(overlay_s->drain_count, ==, 1);
1284
1285     do_drain_end(BDRV_DRAIN, base);
1286
1287     g_assert_cmpint(base->quiesce_counter, ==, 0);
1288     g_assert_cmpint(base_s->drain_count, ==, 0);
1289     g_assert_cmpint(overlay->quiesce_counter, ==, 0);
1290     g_assert_cmpint(overlay_s->drain_count, ==, 0);
1291
1292     bdrv_unref(base);
1293     blk_unref(blk);
1294 }
1295
1296 int main(int argc, char **argv)
1297 {
1298     int ret;
1299
1300     bdrv_init();
1301     qemu_init_main_loop(&error_abort);
1302
1303     g_test_init(&argc, &argv, NULL);
1304     qemu_event_init(&done_event, false);
1305
1306     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
1307     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
1308     g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
1309                     test_drv_cb_drain_subtree);
1310
1311     g_test_add_func("/bdrv-drain/driver-cb/co/drain_all",
1312                     test_drv_cb_co_drain_all);
1313     g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
1314     g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
1315                     test_drv_cb_co_drain_subtree);
1316
1317
1318     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
1319     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
1320     g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
1321                     test_quiesce_drain_subtree);
1322
1323     g_test_add_func("/bdrv-drain/quiesce/co/drain_all",
1324                     test_quiesce_co_drain_all);
1325     g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
1326     g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
1327                     test_quiesce_co_drain_subtree);
1328
1329     g_test_add_func("/bdrv-drain/nested", test_nested);
1330     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
1331
1332     g_test_add_func("/bdrv-drain/graph-change/drain_subtree",
1333                     test_graph_change_drain_subtree);
1334     g_test_add_func("/bdrv-drain/graph-change/drain_all",
1335                     test_graph_change_drain_all);
1336
1337     g_test_add_func("/bdrv-drain/iothread/drain_all", test_iothread_drain_all);
1338     g_test_add_func("/bdrv-drain/iothread/drain", test_iothread_drain);
1339     g_test_add_func("/bdrv-drain/iothread/drain_subtree",
1340                     test_iothread_drain_subtree);
1341
1342     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
1343     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
1344     g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
1345                     test_blockjob_drain_subtree);
1346
1347     g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain);
1348     g_test_add_func("/bdrv-drain/detach/drain_all", test_detach_by_drain_all);
1349     g_test_add_func("/bdrv-drain/detach/drain", test_detach_by_drain);
1350     g_test_add_func("/bdrv-drain/detach/drain_subtree", test_detach_by_drain_subtree);
1351     g_test_add_func("/bdrv-drain/detach/parent_cb", test_detach_by_parent_cb);
1352     g_test_add_func("/bdrv-drain/detach/driver_cb", test_detach_by_driver_cb);
1353
1354     g_test_add_func("/bdrv-drain/attach/drain", test_append_to_drained);
1355
1356     ret = g_test_run();
1357     qemu_event_destroy(&done_event);
1358     return ret;
1359 }