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 int bdrv_test_change_backing_file(BlockDriverState *bs,
 104                                          const char *backing_file,
 105                                          const char *backing_fmt)
 106 {
 107     return 0;
 108 }
 109
 110 static BlockDriver bdrv_test = {
 111     .format_name            = "test",
 112     .instance_size          = sizeof(BDRVTestState),
 113
 114     .bdrv_close             = bdrv_test_close,
 115     .bdrv_co_preadv         = bdrv_test_co_preadv,
 116
 117     .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
 118     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
 119
 120     .bdrv_child_perm        = bdrv_test_child_perm,
 121
 122     .bdrv_change_backing_file = bdrv_test_change_backing_file,
 123 };
 124
 125 static void aio_ret_cb(void *opaque, int ret)
 126 {
 127     int *aio_ret = opaque;
 128     *aio_ret = ret;
 129 }
 130
 131 typedef struct CallInCoroutineData {
 132     void (*entry)(void);
 133     bool done;
 134 } CallInCoroutineData;
 135
 136 static coroutine_fn void call_in_coroutine_entry(void *opaque)
 137 {
 138     CallInCoroutineData *data = opaque;
 139
 140     data->entry();
 141     data->done = true;
 142 }
 143
 144 static void call_in_coroutine(void (*entry)(void))
 145 {
 146     Coroutine *co;
 147     CallInCoroutineData data = {
 148         .entry  = entry,
 149         .done   = false,
 150     };
 151
 152     co = qemu_coroutine_create(call_in_coroutine_entry, &data);
 153     qemu_coroutine_enter(co);
 154     while (!data.done) {
 155         aio_poll(qemu_get_aio_context(), true);
 156     }
 157 }
 158
 159 enum drain_type {
 160     BDRV_DRAIN_ALL,
 161     BDRV_DRAIN,
 162     BDRV_SUBTREE_DRAIN,
 163     DRAIN_TYPE_MAX,
 164 };
 165
 166 static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
 167 {
 168     switch (drain_type) {
 169     case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
 170     case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
 171     case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_begin(bs); break;
 172     default:                    g_assert_not_reached();
 173     }
 174 }
 175
 176 static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
 177 {
 178     switch (drain_type) {
 179     case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
 180     case BDRV_DRAIN:            bdrv_drained_end(bs); break;
 181     case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_end(bs); break;
 182     default:                    g_assert_not_reached();
 183     }
 184 }
 185
 186 static void do_drain_begin_unlocked(enum drain_type drain_type, BlockDriverState *bs)
 187 {
 188     if (drain_type != BDRV_DRAIN_ALL) {
 189         aio_context_acquire(bdrv_get_aio_context(bs));
 190     }
 191     do_drain_begin(drain_type, bs);
 192     if (drain_type != BDRV_DRAIN_ALL) {
 193         aio_context_release(bdrv_get_aio_context(bs));
 194     }
 195 }
 196
 197 static void do_drain_end_unlocked(enum drain_type drain_type, BlockDriverState *bs)
 198 {
 199     if (drain_type != BDRV_DRAIN_ALL) {
 200         aio_context_acquire(bdrv_get_aio_context(bs));
 201     }
 202     do_drain_end(drain_type, bs);
 203     if (drain_type != BDRV_DRAIN_ALL) {
 204         aio_context_release(bdrv_get_aio_context(bs));
 205     }
 206 }
 207
 208 static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
 209 {
 210     BlockBackend *blk;
 211     BlockDriverState *bs, *backing;
 212     BDRVTestState *s, *backing_s;
 213     BlockAIOCB *acb;
 214     int aio_ret;
 215
 216     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
 217
 218     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 219     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 220                               &error_abort);
 221     s = bs->opaque;
 222     blk_insert_bs(blk, bs, &error_abort);
 223
 224     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 225     backing_s = backing->opaque;
 226     bdrv_set_backing_hd(bs, backing, &error_abort);
 227
 228     /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
 229     g_assert_cmpint(s->drain_count, ==, 0);
 230     g_assert_cmpint(backing_s->drain_count, ==, 0);
 231
 232     do_drain_begin(drain_type, bs);
 233
 234     g_assert_cmpint(s->drain_count, ==, 1);
 235     g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 236
 237     do_drain_end(drain_type, bs);
 238
 239     g_assert_cmpint(s->drain_count, ==, 0);
 240     g_assert_cmpint(backing_s->drain_count, ==, 0);
 241
 242     /* Now do the same while a request is pending */
 243     aio_ret = -EINPROGRESS;
 244     acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
 245     g_assert(acb != NULL);
 246     g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 247
 248     g_assert_cmpint(s->drain_count, ==, 0);
 249     g_assert_cmpint(backing_s->drain_count, ==, 0);
 250
 251     do_drain_begin(drain_type, bs);
 252
 253     g_assert_cmpint(aio_ret, ==, 0);
 254     g_assert_cmpint(s->drain_count, ==, 1);
 255     g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 256
 257     do_drain_end(drain_type, bs);
 258
 259     g_assert_cmpint(s->drain_count, ==, 0);
 260     g_assert_cmpint(backing_s->drain_count, ==, 0);
 261
 262     bdrv_unref(backing);
 263     bdrv_unref(bs);
 264     blk_unref(blk);
 265 }
 266
 267 static void test_drv_cb_drain_all(void)
 268 {
 269     test_drv_cb_common(BDRV_DRAIN_ALL, true);
 270 }
 271
 272 static void test_drv_cb_drain(void)
 273 {
 274     test_drv_cb_common(BDRV_DRAIN, false);
 275 }
 276
 277 static void test_drv_cb_drain_subtree(void)
 278 {
 279     test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
 280 }
 281
 282 static void test_drv_cb_co_drain_all(void)
 283 {
 284     call_in_coroutine(test_drv_cb_drain_all);
 285 }
 286
 287 static void test_drv_cb_co_drain(void)
 288 {
 289     call_in_coroutine(test_drv_cb_drain);
 290 }
 291
 292 static void test_drv_cb_co_drain_subtree(void)
 293 {
 294     call_in_coroutine(test_drv_cb_drain_subtree);
 295 }
 296
 297 static void test_quiesce_common(enum drain_type drain_type, bool recursive)
 298 {
 299     BlockBackend *blk;
 300     BlockDriverState *bs, *backing;
 301
 302     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 303     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 304                               &error_abort);
 305     blk_insert_bs(blk, bs, &error_abort);
 306
 307     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 308     bdrv_set_backing_hd(bs, backing, &error_abort);
 309
 310     g_assert_cmpint(bs->quiesce_counter, ==, 0);
 311     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 312
 313     do_drain_begin(drain_type, bs);
 314
 315     g_assert_cmpint(bs->quiesce_counter, ==, 1);
 316     g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
 317
 318     do_drain_end(drain_type, bs);
 319
 320     g_assert_cmpint(bs->quiesce_counter, ==, 0);
 321     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 322
 323     bdrv_unref(backing);
 324     bdrv_unref(bs);
 325     blk_unref(blk);
 326 }
 327
 328 static void test_quiesce_drain_all(void)
 329 {
 330     test_quiesce_common(BDRV_DRAIN_ALL, true);
 331 }
 332
 333 static void test_quiesce_drain(void)
 334 {
 335     test_quiesce_common(BDRV_DRAIN, false);
 336 }
 337
 338 static void test_quiesce_drain_subtree(void)
 339 {
 340     test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
 341 }
 342
 343 static void test_quiesce_co_drain_all(void)
 344 {
 345     call_in_coroutine(test_quiesce_drain_all);
 346 }
 347
 348 static void test_quiesce_co_drain(void)
 349 {
 350     call_in_coroutine(test_quiesce_drain);
 351 }
 352
 353 static void test_quiesce_co_drain_subtree(void)
 354 {
 355     call_in_coroutine(test_quiesce_drain_subtree);
 356 }
 357
 358 static void test_nested(void)
 359 {
 360     BlockBackend *blk;
 361     BlockDriverState *bs, *backing;
 362     BDRVTestState *s, *backing_s;
 363     enum drain_type outer, inner;
 364
 365     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 366     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 367                               &error_abort);
 368     s = bs->opaque;
 369     blk_insert_bs(blk, bs, &error_abort);
 370
 371     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 372     backing_s = backing->opaque;
 373     bdrv_set_backing_hd(bs, backing, &error_abort);
 374
 375     for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
 376         for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
 377             int backing_quiesce = (outer != BDRV_DRAIN) +
 378                                   (inner != BDRV_DRAIN);
 379
 380             g_assert_cmpint(bs->quiesce_counter, ==, 0);
 381             g_assert_cmpint(backing->quiesce_counter, ==, 0);
 382             g_assert_cmpint(s->drain_count, ==, 0);
 383             g_assert_cmpint(backing_s->drain_count, ==, 0);
 384
 385             do_drain_begin(outer, bs);
 386             do_drain_begin(inner, bs);
 387
 388             g_assert_cmpint(bs->quiesce_counter, ==, 2);
 389             g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
 390             g_assert_cmpint(s->drain_count, ==, 2);
 391             g_assert_cmpint(backing_s->drain_count, ==, backing_quiesce);
 392
 393             do_drain_end(inner, bs);
 394             do_drain_end(outer, bs);
 395
 396             g_assert_cmpint(bs->quiesce_counter, ==, 0);
 397             g_assert_cmpint(backing->quiesce_counter, ==, 0);
 398             g_assert_cmpint(s->drain_count, ==, 0);
 399             g_assert_cmpint(backing_s->drain_count, ==, 0);
 400         }
 401     }
 402
 403     bdrv_unref(backing);
 404     bdrv_unref(bs);
 405     blk_unref(blk);
 406 }
 407
 408 static void test_multiparent(void)
 409 {
 410     BlockBackend *blk_a, *blk_b;
 411     BlockDriverState *bs_a, *bs_b, *backing;
 412     BDRVTestState *a_s, *b_s, *backing_s;
 413
 414     blk_a = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 415     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 416                                 &error_abort);
 417     a_s = bs_a->opaque;
 418     blk_insert_bs(blk_a, bs_a, &error_abort);
 419
 420     blk_b = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 421     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 422                                 &error_abort);
 423     b_s = bs_b->opaque;
 424     blk_insert_bs(blk_b, bs_b, &error_abort);
 425
 426     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 427     backing_s = backing->opaque;
 428     bdrv_set_backing_hd(bs_a, backing, &error_abort);
 429     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 430
 431     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 432     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 433     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 434     g_assert_cmpint(a_s->drain_count, ==, 0);
 435     g_assert_cmpint(b_s->drain_count, ==, 0);
 436     g_assert_cmpint(backing_s->drain_count, ==, 0);
 437
 438     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 439
 440     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 441     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 442     g_assert_cmpint(backing->quiesce_counter, ==, 1);
 443     g_assert_cmpint(a_s->drain_count, ==, 1);
 444     g_assert_cmpint(b_s->drain_count, ==, 1);
 445     g_assert_cmpint(backing_s->drain_count, ==, 1);
 446
 447     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 448
 449     g_assert_cmpint(bs_a->quiesce_counter, ==, 2);
 450     g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 451     g_assert_cmpint(backing->quiesce_counter, ==, 2);
 452     g_assert_cmpint(a_s->drain_count, ==, 2);
 453     g_assert_cmpint(b_s->drain_count, ==, 2);
 454     g_assert_cmpint(backing_s->drain_count, ==, 2);
 455
 456     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 457
 458     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 459     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 460     g_assert_cmpint(backing->quiesce_counter, ==, 1);
 461     g_assert_cmpint(a_s->drain_count, ==, 1);
 462     g_assert_cmpint(b_s->drain_count, ==, 1);
 463     g_assert_cmpint(backing_s->drain_count, ==, 1);
 464
 465     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 466
 467     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 468     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 469     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 470     g_assert_cmpint(a_s->drain_count, ==, 0);
 471     g_assert_cmpint(b_s->drain_count, ==, 0);
 472     g_assert_cmpint(backing_s->drain_count, ==, 0);
 473
 474     bdrv_unref(backing);
 475     bdrv_unref(bs_a);
 476     bdrv_unref(bs_b);
 477     blk_unref(blk_a);
 478     blk_unref(blk_b);
 479 }
 480
 481 static void test_graph_change_drain_subtree(void)
 482 {
 483     BlockBackend *blk_a, *blk_b;
 484     BlockDriverState *bs_a, *bs_b, *backing;
 485     BDRVTestState *a_s, *b_s, *backing_s;
 486
 487     blk_a = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 488     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 489                                 &error_abort);
 490     a_s = bs_a->opaque;
 491     blk_insert_bs(blk_a, bs_a, &error_abort);
 492
 493     blk_b = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 494     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 495                                 &error_abort);
 496     b_s = bs_b->opaque;
 497     blk_insert_bs(blk_b, bs_b, &error_abort);
 498
 499     backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 500     backing_s = backing->opaque;
 501     bdrv_set_backing_hd(bs_a, backing, &error_abort);
 502
 503     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 504     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 505     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 506     g_assert_cmpint(a_s->drain_count, ==, 0);
 507     g_assert_cmpint(b_s->drain_count, ==, 0);
 508     g_assert_cmpint(backing_s->drain_count, ==, 0);
 509
 510     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 511     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 512     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 513     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 514     do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 515
 516     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 517     g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 518     g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 519     g_assert_cmpint(backing->quiesce_counter, ==, 5);
 520     g_assert_cmpint(a_s->drain_count, ==, 5);
 521     g_assert_cmpint(b_s->drain_count, ==, 5);
 522     g_assert_cmpint(backing_s->drain_count, ==, 5);
 523
 524     bdrv_set_backing_hd(bs_b, NULL, &error_abort);
 525     g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
 526     g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 527     g_assert_cmpint(backing->quiesce_counter, ==, 3);
 528     g_assert_cmpint(a_s->drain_count, ==, 3);
 529     g_assert_cmpint(b_s->drain_count, ==, 2);
 530     g_assert_cmpint(backing_s->drain_count, ==, 3);
 531
 532     bdrv_set_backing_hd(bs_b, backing, &error_abort);
 533     g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 534     g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 535     g_assert_cmpint(backing->quiesce_counter, ==, 5);
 536     g_assert_cmpint(a_s->drain_count, ==, 5);
 537     g_assert_cmpint(b_s->drain_count, ==, 5);
 538     g_assert_cmpint(backing_s->drain_count, ==, 5);
 539
 540     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 541     do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 542     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 543     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 544     do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 545
 546     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 547     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 548     g_assert_cmpint(backing->quiesce_counter, ==, 0);
 549     g_assert_cmpint(a_s->drain_count, ==, 0);
 550     g_assert_cmpint(b_s->drain_count, ==, 0);
 551     g_assert_cmpint(backing_s->drain_count, ==, 0);
 552
 553     bdrv_unref(backing);
 554     bdrv_unref(bs_a);
 555     bdrv_unref(bs_b);
 556     blk_unref(blk_a);
 557     blk_unref(blk_b);
 558 }
 559
 560 static void test_graph_change_drain_all(void)
 561 {
 562     BlockBackend *blk_a, *blk_b;
 563     BlockDriverState *bs_a, *bs_b;
 564     BDRVTestState *a_s, *b_s;
 565
 566     /* Create node A with a BlockBackend */
 567     blk_a = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 568     bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
 569                                 &error_abort);
 570     a_s = bs_a->opaque;
 571     blk_insert_bs(blk_a, bs_a, &error_abort);
 572
 573     g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 574     g_assert_cmpint(a_s->drain_count, ==, 0);
 575
 576     /* Call bdrv_drain_all_begin() */
 577     bdrv_drain_all_begin();
 578
 579     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 580     g_assert_cmpint(a_s->drain_count, ==, 1);
 581
 582     /* Create node B with a BlockBackend */
 583     blk_b = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 584     bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 585                                 &error_abort);
 586     b_s = bs_b->opaque;
 587     blk_insert_bs(blk_b, bs_b, &error_abort);
 588
 589     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 590     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 591     g_assert_cmpint(a_s->drain_count, ==, 1);
 592     g_assert_cmpint(b_s->drain_count, ==, 1);
 593
 594     /* Unref and finally delete node A */
 595     blk_unref(blk_a);
 596
 597     g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 598     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 599     g_assert_cmpint(a_s->drain_count, ==, 1);
 600     g_assert_cmpint(b_s->drain_count, ==, 1);
 601
 602     bdrv_unref(bs_a);
 603
 604     g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 605     g_assert_cmpint(b_s->drain_count, ==, 1);
 606
 607     /* End the drained section */
 608     bdrv_drain_all_end();
 609
 610     g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 611     g_assert_cmpint(b_s->drain_count, ==, 0);
 612
 613     bdrv_unref(bs_b);
 614     blk_unref(blk_b);
 615 }
 616
 617 struct test_iothread_data {
 618     BlockDriverState *bs;
 619     enum drain_type drain_type;
 620     int *aio_ret;
 621 };
 622
 623 static void test_iothread_drain_entry(void *opaque)
 624 {
 625     struct test_iothread_data *data = opaque;
 626
 627     aio_context_acquire(bdrv_get_aio_context(data->bs));
 628     do_drain_begin(data->drain_type, data->bs);
 629     g_assert_cmpint(*data->aio_ret, ==, 0);
 630     do_drain_end(data->drain_type, data->bs);
 631     aio_context_release(bdrv_get_aio_context(data->bs));
 632
 633     qemu_event_set(&done_event);
 634 }
 635
 636 static void test_iothread_aio_cb(void *opaque, int ret)
 637 {
 638     int *aio_ret = opaque;
 639     *aio_ret = ret;
 640     qemu_event_set(&done_event);
 641 }
 642
 643 static void test_iothread_main_thread_bh(void *opaque)
 644 {
 645     struct test_iothread_data *data = opaque;
 646
 647     /* Test that the AioContext is not yet locked in a random BH that is
 648      * executed during drain, otherwise this would deadlock. */
 649     aio_context_acquire(bdrv_get_aio_context(data->bs));
 650     bdrv_flush(data->bs);
 651     aio_context_release(bdrv_get_aio_context(data->bs));
 652 }
 653
 654 /*
 655  * Starts an AIO request on a BDS that runs in the AioContext of iothread 1.
 656  * The request involves a BH on iothread 2 before it can complete.
 657  *
 658  * @drain_thread = 0 means that do_drain_begin/end are called from the main
 659  * thread, @drain_thread = 1 means that they are called from iothread 1. Drain
 660  * for this BDS cannot be called from iothread 2 because only the main thread
 661  * may do cross-AioContext polling.
 662  */
 663 static void test_iothread_common(enum drain_type drain_type, int drain_thread)
 664 {
 665     BlockBackend *blk;
 666     BlockDriverState *bs;
 667     BDRVTestState *s;
 668     BlockAIOCB *acb;
 669     int aio_ret;
 670     struct test_iothread_data data;
 671
 672     IOThread *a = iothread_new();
 673     IOThread *b = iothread_new();
 674     AioContext *ctx_a = iothread_get_aio_context(a);
 675     AioContext *ctx_b = iothread_get_aio_context(b);
 676
 677     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
 678
 679     /* bdrv_drain_all() may only be called from the main loop thread */
 680     if (drain_type == BDRV_DRAIN_ALL && drain_thread != 0) {
 681         goto out;
 682     }
 683
 684     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 685     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 686                               &error_abort);
 687     s = bs->opaque;
 688     blk_insert_bs(blk, bs, &error_abort);
 689
 690     blk_set_aio_context(blk, ctx_a, &error_abort);
 691     aio_context_acquire(ctx_a);
 692
 693     s->bh_indirection_ctx = ctx_b;
 694
 695     aio_ret = -EINPROGRESS;
 696     qemu_event_reset(&done_event);
 697
 698     if (drain_thread == 0) {
 699         acb = blk_aio_preadv(blk, 0, &qiov, 0, test_iothread_aio_cb, &aio_ret);
 700     } else {
 701         acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
 702     }
 703     g_assert(acb != NULL);
 704     g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 705
 706     aio_context_release(ctx_a);
 707
 708     data = (struct test_iothread_data) {
 709         .bs         = bs,
 710         .drain_type = drain_type,
 711         .aio_ret    = &aio_ret,
 712     };
 713
 714     switch (drain_thread) {
 715     case 0:
 716         if (drain_type != BDRV_DRAIN_ALL) {
 717             aio_context_acquire(ctx_a);
 718         }
 719
 720         aio_bh_schedule_oneshot(ctx_a, test_iothread_main_thread_bh, &data);
 721
 722         /* The request is running on the IOThread a. Draining its block device
 723          * will make sure that it has completed as far as the BDS is concerned,
 724          * but the drain in this thread can continue immediately after
 725          * bdrv_dec_in_flight() and aio_ret might be assigned only slightly
 726          * later. */
 727         do_drain_begin(drain_type, bs);
 728         g_assert_cmpint(bs->in_flight, ==, 0);
 729
 730         if (drain_type != BDRV_DRAIN_ALL) {
 731             aio_context_release(ctx_a);
 732         }
 733         qemu_event_wait(&done_event);
 734         if (drain_type != BDRV_DRAIN_ALL) {
 735             aio_context_acquire(ctx_a);
 736         }
 737
 738         g_assert_cmpint(aio_ret, ==, 0);
 739         do_drain_end(drain_type, bs);
 740
 741         if (drain_type != BDRV_DRAIN_ALL) {
 742             aio_context_release(ctx_a);
 743         }
 744         break;
 745     case 1:
 746         aio_bh_schedule_oneshot(ctx_a, test_iothread_drain_entry, &data);
 747         qemu_event_wait(&done_event);
 748         break;
 749     default:
 750         g_assert_not_reached();
 751     }
 752
 753     aio_context_acquire(ctx_a);
 754     blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
 755     aio_context_release(ctx_a);
 756
 757     bdrv_unref(bs);
 758     blk_unref(blk);
 759
 760 out:
 761     iothread_join(a);
 762     iothread_join(b);
 763 }
 764
 765 static void test_iothread_drain_all(void)
 766 {
 767     test_iothread_common(BDRV_DRAIN_ALL, 0);
 768     test_iothread_common(BDRV_DRAIN_ALL, 1);
 769 }
 770
 771 static void test_iothread_drain(void)
 772 {
 773     test_iothread_common(BDRV_DRAIN, 0);
 774     test_iothread_common(BDRV_DRAIN, 1);
 775 }
 776
 777 static void test_iothread_drain_subtree(void)
 778 {
 779     test_iothread_common(BDRV_SUBTREE_DRAIN, 0);
 780     test_iothread_common(BDRV_SUBTREE_DRAIN, 1);
 781 }
 782
 783
 784 typedef struct TestBlockJob {
 785     BlockJob common;
 786     int run_ret;
 787     int prepare_ret;
 788     bool running;
 789     bool should_complete;
 790 } TestBlockJob;
 791
 792 static int test_job_prepare(Job *job)
 793 {
 794     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 795
 796     /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
 797     blk_flush(s->common.blk);
 798     return s->prepare_ret;
 799 }
 800
 801 static void test_job_commit(Job *job)
 802 {
 803     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 804
 805     /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
 806     blk_flush(s->common.blk);
 807 }
 808
 809 static void test_job_abort(Job *job)
 810 {
 811     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 812
 813     /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
 814     blk_flush(s->common.blk);
 815 }
 816
 817 static int coroutine_fn test_job_run(Job *job, Error **errp)
 818 {
 819     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 820
 821     /* We are running the actual job code past the pause point in
 822      * job_co_entry(). */
 823     s->running = true;
 824
 825     job_transition_to_ready(&s->common.job);
 826     while (!s->should_complete) {
 827         /* Avoid job_sleep_ns() because it marks the job as !busy. We want to
 828          * emulate some actual activity (probably some I/O) here so that drain
 829          * has to wait for this activity to stop. */
 830         qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000);
 831
 832         job_pause_point(&s->common.job);
 833     }
 834
 835     return s->run_ret;
 836 }
 837
 838 static void test_job_complete(Job *job, Error **errp)
 839 {
 840     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 841     s->should_complete = true;
 842 }
 843
 844 BlockJobDriver test_job_driver = {
 845     .job_driver = {
 846         .instance_size  = sizeof(TestBlockJob),
 847         .free           = block_job_free,
 848         .user_resume    = block_job_user_resume,
 849         .drain          = block_job_drain,
 850         .run            = test_job_run,
 851         .complete       = test_job_complete,
 852         .prepare        = test_job_prepare,
 853         .commit         = test_job_commit,
 854         .abort          = test_job_abort,
 855     },
 856 };
 857
 858 enum test_job_result {
 859     TEST_JOB_SUCCESS,
 860     TEST_JOB_FAIL_RUN,
 861     TEST_JOB_FAIL_PREPARE,
 862 };
 863
 864 enum test_job_drain_node {
 865     TEST_JOB_DRAIN_SRC,
 866     TEST_JOB_DRAIN_SRC_CHILD,
 867     TEST_JOB_DRAIN_SRC_PARENT,
 868 };
 869
 870 static void test_blockjob_common_drain_node(enum drain_type drain_type,
 871                                             bool use_iothread,
 872                                             enum test_job_result result,
 873                                             enum test_job_drain_node drain_node)
 874 {
 875     BlockBackend *blk_src, *blk_target;
 876     BlockDriverState *src, *src_backing, *src_overlay, *target, *drain_bs;
 877     BlockJob *job;
 878     TestBlockJob *tjob;
 879     IOThread *iothread = NULL;
 880     AioContext *ctx;
 881     int ret;
 882
 883     src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
 884                                &error_abort);
 885     src_backing = bdrv_new_open_driver(&bdrv_test, "source-backing",
 886                                        BDRV_O_RDWR, &error_abort);
 887     src_overlay = bdrv_new_open_driver(&bdrv_test, "source-overlay",
 888                                        BDRV_O_RDWR, &error_abort);
 889
 890     bdrv_set_backing_hd(src_overlay, src, &error_abort);
 891     bdrv_unref(src);
 892     bdrv_set_backing_hd(src, src_backing, &error_abort);
 893     bdrv_unref(src_backing);
 894
 895     blk_src = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 896     blk_insert_bs(blk_src, src_overlay, &error_abort);
 897
 898     switch (drain_node) {
 899     case TEST_JOB_DRAIN_SRC:
 900         drain_bs = src;
 901         break;
 902     case TEST_JOB_DRAIN_SRC_CHILD:
 903         drain_bs = src_backing;
 904         break;
 905     case TEST_JOB_DRAIN_SRC_PARENT:
 906         drain_bs = src_overlay;
 907         break;
 908     default:
 909         g_assert_not_reached();
 910     }
 911
 912     if (use_iothread) {
 913         iothread = iothread_new();
 914         ctx = iothread_get_aio_context(iothread);
 915         blk_set_aio_context(blk_src, ctx, &error_abort);
 916     } else {
 917         ctx = qemu_get_aio_context();
 918     }
 919
 920     target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
 921                                   &error_abort);
 922     blk_target = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
 923     blk_insert_bs(blk_target, target, &error_abort);
 924     blk_set_allow_aio_context_change(blk_target, true);
 925
 926     aio_context_acquire(ctx);
 927     tjob = block_job_create("job0", &test_job_driver, NULL, src,
 928                             0, BLK_PERM_ALL,
 929                             0, 0, NULL, NULL, &error_abort);
 930     job = &tjob->common;
 931     block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
 932
 933     switch (result) {
 934     case TEST_JOB_SUCCESS:
 935         break;
 936     case TEST_JOB_FAIL_RUN:
 937         tjob->run_ret = -EIO;
 938         break;
 939     case TEST_JOB_FAIL_PREPARE:
 940         tjob->prepare_ret = -EIO;
 941         break;
 942     }
 943
 944     job_start(&job->job);
 945     aio_context_release(ctx);
 946
 947     if (use_iothread) {
 948         /* job_co_entry() is run in the I/O thread, wait for the actual job
 949          * code to start (we don't want to catch the job in the pause point in
 950          * job_co_entry(). */
 951         while (!tjob->running) {
 952             aio_poll(qemu_get_aio_context(), false);
 953         }
 954     }
 955
 956     g_assert_cmpint(job->job.pause_count, ==, 0);
 957     g_assert_false(job->job.paused);
 958     g_assert_true(tjob->running);
 959     g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */
 960
 961     do_drain_begin_unlocked(drain_type, drain_bs);
 962
 963     if (drain_type == BDRV_DRAIN_ALL) {
 964         /* bdrv_drain_all() drains both src and target */
 965         g_assert_cmpint(job->job.pause_count, ==, 2);
 966     } else {
 967         g_assert_cmpint(job->job.pause_count, ==, 1);
 968     }
 969     g_assert_true(job->job.paused);
 970     g_assert_false(job->job.busy); /* The job is paused */
 971
 972     do_drain_end_unlocked(drain_type, drain_bs);
 973
 974     if (use_iothread) {
 975         /* paused is reset in the I/O thread, wait for it */
 976         while (job->job.paused) {
 977             aio_poll(qemu_get_aio_context(), false);
 978         }
 979     }
 980
 981     g_assert_cmpint(job->job.pause_count, ==, 0);
 982     g_assert_false(job->job.paused);
 983     g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */
 984
 985     do_drain_begin_unlocked(drain_type, target);
 986
 987     if (drain_type == BDRV_DRAIN_ALL) {
 988         /* bdrv_drain_all() drains both src and target */
 989         g_assert_cmpint(job->job.pause_count, ==, 2);
 990     } else {
 991         g_assert_cmpint(job->job.pause_count, ==, 1);
 992     }
 993     g_assert_true(job->job.paused);
 994     g_assert_false(job->job.busy); /* The job is paused */
 995
 996     do_drain_end_unlocked(drain_type, target);
 997
 998     if (use_iothread) {
 999         /* paused is reset in the I/O thread, wait for it */
1000         while (job->job.paused) {
1001             aio_poll(qemu_get_aio_context(), false);
1002         }
1003     }
1004
1005     g_assert_cmpint(job->job.pause_count, ==, 0);
1006     g_assert_false(job->job.paused);
1007     g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */
1008
1009     aio_context_acquire(ctx);
1010     ret = job_complete_sync(&job->job, &error_abort);
1011     g_assert_cmpint(ret, ==, (result == TEST_JOB_SUCCESS ? 0 : -EIO));
1012
1013     if (use_iothread) {
1014         blk_set_aio_context(blk_src, qemu_get_aio_context(), &error_abort);
1015         assert(blk_get_aio_context(blk_target) == qemu_get_aio_context());
1016     }
1017     aio_context_release(ctx);
1018
1019     blk_unref(blk_src);
1020     blk_unref(blk_target);
1021     bdrv_unref(src_overlay);
1022     bdrv_unref(target);
1023
1024     if (iothread) {
1025         iothread_join(iothread);
1026     }
1027 }
1028
1029 static void test_blockjob_common(enum drain_type drain_type, bool use_iothread,
1030                                  enum test_job_result result)
1031 {
1032     test_blockjob_common_drain_node(drain_type, use_iothread, result,
1033                                     TEST_JOB_DRAIN_SRC);
1034     test_blockjob_common_drain_node(drain_type, use_iothread, result,
1035                                     TEST_JOB_DRAIN_SRC_CHILD);
1036     if (drain_type == BDRV_SUBTREE_DRAIN) {
1037         test_blockjob_common_drain_node(drain_type, use_iothread, result,
1038                                         TEST_JOB_DRAIN_SRC_PARENT);
1039     }
1040 }
1041
1042 static void test_blockjob_drain_all(void)
1043 {
1044     test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_SUCCESS);
1045 }
1046
1047 static void test_blockjob_drain(void)
1048 {
1049     test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_SUCCESS);
1050 }
1051
1052 static void test_blockjob_drain_subtree(void)
1053 {
1054     test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_SUCCESS);
1055 }
1056
1057 static void test_blockjob_error_drain_all(void)
1058 {
1059     test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_FAIL_RUN);
1060     test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_FAIL_PREPARE);
1061 }
1062
1063 static void test_blockjob_error_drain(void)
1064 {
1065     test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_FAIL_RUN);
1066     test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_FAIL_PREPARE);
1067 }
1068
1069 static void test_blockjob_error_drain_subtree(void)
1070 {
1071     test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_FAIL_RUN);
1072     test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_FAIL_PREPARE);
1073 }
1074
1075 static void test_blockjob_iothread_drain_all(void)
1076 {
1077     test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_SUCCESS);
1078 }
1079
1080 static void test_blockjob_iothread_drain(void)
1081 {
1082     test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_SUCCESS);
1083 }
1084
1085 static void test_blockjob_iothread_drain_subtree(void)
1086 {
1087     test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_SUCCESS);
1088 }
1089
1090 static void test_blockjob_iothread_error_drain_all(void)
1091 {
1092     test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_FAIL_RUN);
1093     test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_FAIL_PREPARE);
1094 }
1095
1096 static void test_blockjob_iothread_error_drain(void)
1097 {
1098     test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_FAIL_RUN);
1099     test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_FAIL_PREPARE);
1100 }
1101
1102 static void test_blockjob_iothread_error_drain_subtree(void)
1103 {
1104     test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_FAIL_RUN);
1105     test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_FAIL_PREPARE);
1106 }
1107
1108
1109 typedef struct BDRVTestTopState {
1110     BdrvChild *wait_child;
1111 } BDRVTestTopState;
1112
1113 static void bdrv_test_top_close(BlockDriverState *bs)
1114 {
1115     BdrvChild *c, *next_c;
1116     QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) {
1117         bdrv_unref_child(bs, c);
1118     }
1119 }
1120
1121 static int coroutine_fn bdrv_test_top_co_preadv(BlockDriverState *bs,
1122                                                 uint64_t offset, uint64_t bytes,
1123                                                 QEMUIOVector *qiov, int flags)
1124 {
1125     BDRVTestTopState *tts = bs->opaque;
1126     return bdrv_co_preadv(tts->wait_child, offset, bytes, qiov, flags);
1127 }
1128
1129 static BlockDriver bdrv_test_top_driver = {
1130     .format_name            = "test_top_driver",
1131     .instance_size          = sizeof(BDRVTestTopState),
1132
1133     .bdrv_close             = bdrv_test_top_close,
1134     .bdrv_co_preadv         = bdrv_test_top_co_preadv,
1135
1136     .bdrv_child_perm        = bdrv_format_default_perms,
1137 };
1138
1139 typedef struct TestCoDeleteByDrainData {
1140     BlockBackend *blk;
1141     bool detach_instead_of_delete;
1142     bool done;
1143 } TestCoDeleteByDrainData;
1144
1145 static void coroutine_fn test_co_delete_by_drain(void *opaque)
1146 {
1147     TestCoDeleteByDrainData *dbdd = opaque;
1148     BlockBackend *blk = dbdd->blk;
1149     BlockDriverState *bs = blk_bs(blk);
1150     BDRVTestTopState *tts = bs->opaque;
1151     void *buffer = g_malloc(65536);
1152     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buffer, 65536);
1153
1154     /* Pretend some internal write operation from parent to child.
1155      * Important: We have to read from the child, not from the parent!
1156      * Draining works by first propagating it all up the tree to the
1157      * root and then waiting for drainage from root to the leaves
1158      * (protocol nodes).  If we have a request waiting on the root,
1159      * everything will be drained before we go back down the tree, but
1160      * we do not want that.  We want to be in the middle of draining
1161      * when this following requests returns. */
1162     bdrv_co_preadv(tts->wait_child, 0, 65536, &qiov, 0);
1163
1164     g_assert_cmpint(bs->refcnt, ==, 1);
1165
1166     if (!dbdd->detach_instead_of_delete) {
1167         blk_unref(blk);
1168     } else {
1169         BdrvChild *c, *next_c;
1170         QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) {
1171             bdrv_unref_child(bs, c);
1172         }
1173     }
1174
1175     dbdd->done = true;
1176     g_free(buffer);
1177 }
1178
1179 /**
1180  * Test what happens when some BDS has some children, you drain one of
1181  * them and this results in the BDS being deleted.
1182  *
1183  * If @detach_instead_of_delete is set, the BDS is not going to be
1184  * deleted but will only detach all of its children.
1185  */
1186 static void do_test_delete_by_drain(bool detach_instead_of_delete,
1187                                     enum drain_type drain_type)
1188 {
1189     BlockBackend *blk;
1190     BlockDriverState *bs, *child_bs, *null_bs;
1191     BDRVTestTopState *tts;
1192     TestCoDeleteByDrainData dbdd;
1193     Coroutine *co;
1194
1195     bs = bdrv_new_open_driver(&bdrv_test_top_driver, "top", BDRV_O_RDWR,
1196                               &error_abort);
1197     bs->total_sectors = 65536 >> BDRV_SECTOR_BITS;
1198     tts = bs->opaque;
1199
1200     null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
1201                         &error_abort);
1202     bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort);
1203
1204     /* This child will be the one to pass to requests through to, and
1205      * it will stall until a drain occurs */
1206     child_bs = bdrv_new_open_driver(&bdrv_test, "child", BDRV_O_RDWR,
1207                                     &error_abort);
1208     child_bs->total_sectors = 65536 >> BDRV_SECTOR_BITS;
1209     /* Takes our reference to child_bs */
1210     tts->wait_child = bdrv_attach_child(bs, child_bs, "wait-child", &child_file,
1211                                         &error_abort);
1212
1213     /* This child is just there to be deleted
1214      * (for detach_instead_of_delete == true) */
1215     null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
1216                         &error_abort);
1217     bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort);
1218
1219     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
1220     blk_insert_bs(blk, bs, &error_abort);
1221
1222     /* Referenced by blk now */
1223     bdrv_unref(bs);
1224
1225     g_assert_cmpint(bs->refcnt, ==, 1);
1226     g_assert_cmpint(child_bs->refcnt, ==, 1);
1227     g_assert_cmpint(null_bs->refcnt, ==, 1);
1228
1229
1230     dbdd = (TestCoDeleteByDrainData){
1231         .blk = blk,
1232         .detach_instead_of_delete = detach_instead_of_delete,
1233         .done = false,
1234     };
1235     co = qemu_coroutine_create(test_co_delete_by_drain, &dbdd);
1236     qemu_coroutine_enter(co);
1237
1238     /* Drain the child while the read operation is still pending.
1239      * This should result in the operation finishing and
1240      * test_co_delete_by_drain() resuming.  Thus, @bs will be deleted
1241      * and the coroutine will exit while this drain operation is still
1242      * in progress. */
1243     switch (drain_type) {
1244     case BDRV_DRAIN:
1245         bdrv_ref(child_bs);
1246         bdrv_drain(child_bs);
1247         bdrv_unref(child_bs);
1248         break;
1249     case BDRV_SUBTREE_DRAIN:
1250         /* Would have to ref/unref bs here for !detach_instead_of_delete, but
1251          * then the whole test becomes pointless because the graph changes
1252          * don't occur during the drain any more. */
1253         assert(detach_instead_of_delete);
1254         bdrv_subtree_drained_begin(bs);
1255         bdrv_subtree_drained_end(bs);
1256         break;
1257     case BDRV_DRAIN_ALL:
1258         bdrv_drain_all_begin();
1259         bdrv_drain_all_end();
1260         break;
1261     default:
1262         g_assert_not_reached();
1263     }
1264
1265     while (!dbdd.done) {
1266         aio_poll(qemu_get_aio_context(), true);
1267     }
1268
1269     if (detach_instead_of_delete) {
1270         /* Here, the reference has not passed over to the coroutine,
1271          * so we have to delete the BB ourselves */
1272         blk_unref(blk);
1273     }
1274 }
1275
1276 static void test_delete_by_drain(void)
1277 {
1278     do_test_delete_by_drain(false, BDRV_DRAIN);
1279 }
1280
1281 static void test_detach_by_drain_all(void)
1282 {
1283     do_test_delete_by_drain(true, BDRV_DRAIN_ALL);
1284 }
1285
1286 static void test_detach_by_drain(void)
1287 {
1288     do_test_delete_by_drain(true, BDRV_DRAIN);
1289 }
1290
1291 static void test_detach_by_drain_subtree(void)
1292 {
1293     do_test_delete_by_drain(true, BDRV_SUBTREE_DRAIN);
1294 }
1295
1296
1297 struct detach_by_parent_data {
1298     BlockDriverState *parent_b;
1299     BdrvChild *child_b;
1300     BlockDriverState *c;
1301     BdrvChild *child_c;
1302     bool by_parent_cb;
1303 };
1304 static struct detach_by_parent_data detach_by_parent_data;
1305
1306 static void detach_indirect_bh(void *opaque)
1307 {
1308     struct detach_by_parent_data *data = opaque;
1309
1310     bdrv_unref_child(data->parent_b, data->child_b);
1311
1312     bdrv_ref(data->c);
1313     data->child_c = bdrv_attach_child(data->parent_b, data->c, "PB-C",
1314                                       &child_file, &error_abort);
1315 }
1316
1317 static void detach_by_parent_aio_cb(void *opaque, int ret)
1318 {
1319     struct detach_by_parent_data *data = &detach_by_parent_data;
1320
1321     g_assert_cmpint(ret, ==, 0);
1322     if (data->by_parent_cb) {
1323         detach_indirect_bh(data);
1324     }
1325 }
1326
1327 static void detach_by_driver_cb_drained_begin(BdrvChild *child)
1328 {
1329     aio_bh_schedule_oneshot(qemu_get_current_aio_context(),
1330                             detach_indirect_bh, &detach_by_parent_data);
1331     child_file.drained_begin(child);
1332 }
1333
1334 static BdrvChildRole detach_by_driver_cb_role;
1335
1336 /*
1337  * Initial graph:
1338  *
1339  * PA     PB
1340  *    \ /   \
1341  *     A     B     C
1342  *
1343  * by_parent_cb == true:  Test that parent callbacks don't poll
1344  *
1345  *     PA has a pending write request whose callback changes the child nodes of
1346  *     PB: It removes B and adds C instead. The subtree of PB is drained, which
1347  *     will indirectly drain the write request, too.
1348  *
1349  * by_parent_cb == false: Test that bdrv_drain_invoke() doesn't poll
1350  *
1351  *     PA's BdrvChildRole has a .drained_begin callback that schedules a BH
1352  *     that does the same graph change. If bdrv_drain_invoke() calls it, the
1353  *     state is messed up, but if it is only polled in the single
1354  *     BDRV_POLL_WHILE() at the end of the drain, this should work fine.
1355  */
1356 static void test_detach_indirect(bool by_parent_cb)
1357 {
1358     BlockBackend *blk;
1359     BlockDriverState *parent_a, *parent_b, *a, *b, *c;
1360     BdrvChild *child_a, *child_b;
1361     BlockAIOCB *acb;
1362
1363     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
1364
1365     if (!by_parent_cb) {
1366         detach_by_driver_cb_role = child_file;
1367         detach_by_driver_cb_role.drained_begin =
1368             detach_by_driver_cb_drained_begin;
1369     }
1370
1371     /* Create all involved nodes */
1372     parent_a = bdrv_new_open_driver(&bdrv_test, "parent-a", BDRV_O_RDWR,
1373                                     &error_abort);
1374     parent_b = bdrv_new_open_driver(&bdrv_test, "parent-b", 0,
1375                                     &error_abort);
1376
1377     a = bdrv_new_open_driver(&bdrv_test, "a", BDRV_O_RDWR, &error_abort);
1378     b = bdrv_new_open_driver(&bdrv_test, "b", BDRV_O_RDWR, &error_abort);
1379     c = bdrv_new_open_driver(&bdrv_test, "c", BDRV_O_RDWR, &error_abort);
1380
1381     /* blk is a BB for parent-a */
1382     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
1383     blk_insert_bs(blk, parent_a, &error_abort);
1384     bdrv_unref(parent_a);
1385
1386     /* If we want to get bdrv_drain_invoke() to call aio_poll(), the driver
1387      * callback must not return immediately. */
1388     if (!by_parent_cb) {
1389         BDRVTestState *s = parent_a->opaque;
1390         s->sleep_in_drain_begin = true;
1391     }
1392
1393     /* Set child relationships */
1394     bdrv_ref(b);
1395     bdrv_ref(a);
1396     child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, &error_abort);
1397     child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_backing, &error_abort);
1398
1399     bdrv_ref(a);
1400     bdrv_attach_child(parent_a, a, "PA-A",
1401                       by_parent_cb ? &child_file : &detach_by_driver_cb_role,
1402                       &error_abort);
1403
1404     g_assert_cmpint(parent_a->refcnt, ==, 1);
1405     g_assert_cmpint(parent_b->refcnt, ==, 1);
1406     g_assert_cmpint(a->refcnt, ==, 3);
1407     g_assert_cmpint(b->refcnt, ==, 2);
1408     g_assert_cmpint(c->refcnt, ==, 1);
1409
1410     g_assert(QLIST_FIRST(&parent_b->children) == child_a);
1411     g_assert(QLIST_NEXT(child_a, next) == child_b);
1412     g_assert(QLIST_NEXT(child_b, next) == NULL);
1413
1414     /* Start the evil write request */
1415     detach_by_parent_data = (struct detach_by_parent_data) {
1416         .parent_b = parent_b,
1417         .child_b = child_b,
1418         .c = c,
1419         .by_parent_cb = by_parent_cb,
1420     };
1421     acb = blk_aio_preadv(blk, 0, &qiov, 0, detach_by_parent_aio_cb, NULL);
1422     g_assert(acb != NULL);
1423
1424     /* Drain and check the expected result */
1425     bdrv_subtree_drained_begin(parent_b);
1426
1427     g_assert(detach_by_parent_data.child_c != NULL);
1428
1429     g_assert_cmpint(parent_a->refcnt, ==, 1);
1430     g_assert_cmpint(parent_b->refcnt, ==, 1);
1431     g_assert_cmpint(a->refcnt, ==, 3);
1432     g_assert_cmpint(b->refcnt, ==, 1);
1433     g_assert_cmpint(c->refcnt, ==, 2);
1434
1435     g_assert(QLIST_FIRST(&parent_b->children) == detach_by_parent_data.child_c);
1436     g_assert(QLIST_NEXT(detach_by_parent_data.child_c, next) == child_a);
1437     g_assert(QLIST_NEXT(child_a, next) == NULL);
1438
1439     g_assert_cmpint(parent_a->quiesce_counter, ==, 1);
1440     g_assert_cmpint(parent_b->quiesce_counter, ==, 1);
1441     g_assert_cmpint(a->quiesce_counter, ==, 1);
1442     g_assert_cmpint(b->quiesce_counter, ==, 0);
1443     g_assert_cmpint(c->quiesce_counter, ==, 1);
1444
1445     bdrv_subtree_drained_end(parent_b);
1446
1447     bdrv_unref(parent_b);
1448     blk_unref(blk);
1449
1450     g_assert_cmpint(a->refcnt, ==, 1);
1451     g_assert_cmpint(b->refcnt, ==, 1);
1452     g_assert_cmpint(c->refcnt, ==, 1);
1453     bdrv_unref(a);
1454     bdrv_unref(b);
1455     bdrv_unref(c);
1456 }
1457
1458 static void test_detach_by_parent_cb(void)
1459 {
1460     test_detach_indirect(true);
1461 }
1462
1463 static void test_detach_by_driver_cb(void)
1464 {
1465     test_detach_indirect(false);
1466 }
1467
1468 static void test_append_to_drained(void)
1469 {
1470     BlockBackend *blk;
1471     BlockDriverState *base, *overlay;
1472     BDRVTestState *base_s, *overlay_s;
1473
1474     blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
1475     base = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
1476     base_s = base->opaque;
1477     blk_insert_bs(blk, base, &error_abort);
1478
1479     overlay = bdrv_new_open_driver(&bdrv_test, "overlay", BDRV_O_RDWR,
1480                                    &error_abort);
1481     overlay_s = overlay->opaque;
1482
1483     do_drain_begin(BDRV_DRAIN, base);
1484     g_assert_cmpint(base->quiesce_counter, ==, 1);
1485     g_assert_cmpint(base_s->drain_count, ==, 1);
1486     g_assert_cmpint(base->in_flight, ==, 0);
1487
1488     /* Takes ownership of overlay, so we don't have to unref it later */
1489     bdrv_append(overlay, base, &error_abort);
1490     g_assert_cmpint(base->in_flight, ==, 0);
1491     g_assert_cmpint(overlay->in_flight, ==, 0);
1492
1493     g_assert_cmpint(base->quiesce_counter, ==, 1);
1494     g_assert_cmpint(base_s->drain_count, ==, 1);
1495     g_assert_cmpint(overlay->quiesce_counter, ==, 1);
1496     g_assert_cmpint(overlay_s->drain_count, ==, 1);
1497
1498     do_drain_end(BDRV_DRAIN, base);
1499
1500     g_assert_cmpint(base->quiesce_counter, ==, 0);
1501     g_assert_cmpint(base_s->drain_count, ==, 0);
1502     g_assert_cmpint(overlay->quiesce_counter, ==, 0);
1503     g_assert_cmpint(overlay_s->drain_count, ==, 0);
1504
1505     bdrv_unref(base);
1506     blk_unref(blk);
1507 }
1508
1509 static void test_set_aio_context(void)
1510 {
1511     BlockDriverState *bs;
1512     IOThread *a = iothread_new();
1513     IOThread *b = iothread_new();
1514     AioContext *ctx_a = iothread_get_aio_context(a);
1515     AioContext *ctx_b = iothread_get_aio_context(b);
1516
1517     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
1518                               &error_abort);
1519
1520     bdrv_drained_begin(bs);
1521     bdrv_try_set_aio_context(bs, ctx_a, &error_abort);
1522
1523     aio_context_acquire(ctx_a);
1524     bdrv_drained_end(bs);
1525
1526     bdrv_drained_begin(bs);
1527     bdrv_try_set_aio_context(bs, ctx_b, &error_abort);
1528     aio_context_release(ctx_a);
1529     aio_context_acquire(ctx_b);
1530     bdrv_try_set_aio_context(bs, qemu_get_aio_context(), &error_abort);
1531     aio_context_release(ctx_b);
1532     bdrv_drained_end(bs);
1533
1534     bdrv_unref(bs);
1535     iothread_join(a);
1536     iothread_join(b);
1537 }
1538
1539
1540 typedef struct TestDropBackingBlockJob {
1541     BlockJob common;
1542     bool should_complete;
1543     bool *did_complete;
1544     BlockDriverState *detach_also;
1545 } TestDropBackingBlockJob;
1546
1547 static int coroutine_fn test_drop_backing_job_run(Job *job, Error **errp)
1548 {
1549     TestDropBackingBlockJob *s =
1550         container_of(job, TestDropBackingBlockJob, common.job);
1551
1552     while (!s->should_complete) {
1553         job_sleep_ns(job, 0);
1554     }
1555
1556     return 0;
1557 }
1558
1559 static void test_drop_backing_job_commit(Job *job)
1560 {
1561     TestDropBackingBlockJob *s =
1562         container_of(job, TestDropBackingBlockJob, common.job);
1563
1564     bdrv_set_backing_hd(blk_bs(s->common.blk), NULL, &error_abort);
1565     bdrv_set_backing_hd(s->detach_also, NULL, &error_abort);
1566
1567     *s->did_complete = true;
1568 }
1569
1570 static const BlockJobDriver test_drop_backing_job_driver = {
1571     .job_driver = {
1572         .instance_size  = sizeof(TestDropBackingBlockJob),
1573         .free           = block_job_free,
1574         .user_resume    = block_job_user_resume,
1575         .drain          = block_job_drain,
1576         .run            = test_drop_backing_job_run,
1577         .commit         = test_drop_backing_job_commit,
1578     }
1579 };
1580
1581 /**
1582  * Creates a child node with three parent nodes on it, and then runs a
1583  * block job on the final one, parent-node-2.
1584  *
1585  * The job is then asked to complete before a section where the child
1586  * is drained.
1587  *
1588  * Ending this section will undrain the child's parents, first
1589  * parent-node-2, then parent-node-1, then parent-node-0 -- the parent
1590  * list is in reverse order of how they were added.  Ending the drain
1591  * on parent-node-2 will resume the job, thus completing it and
1592  * scheduling job_exit().
1593  *
1594  * Ending the drain on parent-node-1 will poll the AioContext, which
1595  * lets job_exit() and thus test_drop_backing_job_commit() run.  That
1596  * function first removes the child as parent-node-2's backing file.
1597  *
1598  * In old (and buggy) implementations, there are two problems with
1599  * that:
1600  * (A) bdrv_drain_invoke() polls for every node that leaves the
1601  *     drained section.  This means that job_exit() is scheduled
1602  *     before the child has left the drained section.  Its
1603  *     quiesce_counter is therefore still 1 when it is removed from
1604  *     parent-node-2.
1605  *
1606  * (B) bdrv_replace_child_noperm() calls drained_end() on the old
1607  *     child's parents as many times as the child is quiesced.  This
1608  *     means it will call drained_end() on parent-node-2 once.
1609  *     Because parent-node-2 is no longer quiesced at this point, this
1610  *     will fail.
1611  *
1612  * bdrv_replace_child_noperm() therefore must call drained_end() on
1613  * the parent only if it really is still drained because the child is
1614  * drained.
1615  *
1616  * If removing child from parent-node-2 was successful (as it should
1617  * be), test_drop_backing_job_commit() will then also remove the child
1618  * from parent-node-0.
1619  *
1620  * With an old version of our drain infrastructure ((A) above), that
1621  * resulted in the following flow:
1622  *
1623  * 1. child attempts to leave its drained section.  The call recurses
1624  *    to its parents.
1625  *
1626  * 2. parent-node-2 leaves the drained section.  Polling in
1627  *    bdrv_drain_invoke() will schedule job_exit().
1628  *
1629  * 3. parent-node-1 leaves the drained section.  Polling in
1630  *    bdrv_drain_invoke() will run job_exit(), thus disconnecting
1631  *    parent-node-0 from the child node.
1632  *
1633  * 4. bdrv_parent_drained_end() uses a QLIST_FOREACH_SAFE() loop to
1634  *    iterate over the parents.  Thus, it now accesses the BdrvChild
1635  *    object that used to connect parent-node-0 and the child node.
1636  *    However, that object no longer exists, so it accesses a dangling
1637  *    pointer.
1638  *
1639  * The solution is to only poll once when running a bdrv_drained_end()
1640  * operation, specifically at the end when all drained_end()
1641  * operations for all involved nodes have been scheduled.
1642  * Note that this also solves (A) above, thus hiding (B).
1643  */
1644 static void test_blockjob_commit_by_drained_end(void)
1645 {
1646     BlockDriverState *bs_child, *bs_parents[3];
1647     TestDropBackingBlockJob *job;
1648     bool job_has_completed = false;
1649     int i;
1650
1651     bs_child = bdrv_new_open_driver(&bdrv_test, "child-node", BDRV_O_RDWR,
1652                                     &error_abort);
1653
1654     for (i = 0; i < 3; i++) {
1655         char name[32];
1656         snprintf(name, sizeof(name), "parent-node-%i", i);
1657         bs_parents[i] = bdrv_new_open_driver(&bdrv_test, name, BDRV_O_RDWR,
1658                                              &error_abort);
1659         bdrv_set_backing_hd(bs_parents[i], bs_child, &error_abort);
1660     }
1661
1662     job = block_job_create("job", &test_drop_backing_job_driver, NULL,
1663                            bs_parents[2], 0, BLK_PERM_ALL, 0, 0, NULL, NULL,
1664                            &error_abort);
1665
1666     job->detach_also = bs_parents[0];
1667     job->did_complete = &job_has_completed;
1668
1669     job_start(&job->common.job);
1670
1671     job->should_complete = true;
1672     bdrv_drained_begin(bs_child);
1673     g_assert(!job_has_completed);
1674     bdrv_drained_end(bs_child);
1675     g_assert(job_has_completed);
1676
1677     bdrv_unref(bs_parents[0]);
1678     bdrv_unref(bs_parents[1]);
1679     bdrv_unref(bs_parents[2]);
1680     bdrv_unref(bs_child);
1681 }
1682
1683
1684 typedef struct TestSimpleBlockJob {
1685     BlockJob common;
1686     bool should_complete;
1687     bool *did_complete;
1688 } TestSimpleBlockJob;
1689
1690 static int coroutine_fn test_simple_job_run(Job *job, Error **errp)
1691 {
1692     TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job);
1693
1694     while (!s->should_complete) {
1695         job_sleep_ns(job, 0);
1696     }
1697
1698     return 0;
1699 }
1700
1701 static void test_simple_job_clean(Job *job)
1702 {
1703     TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job);
1704     *s->did_complete = true;
1705 }
1706
1707 static const BlockJobDriver test_simple_job_driver = {
1708     .job_driver = {
1709         .instance_size  = sizeof(TestSimpleBlockJob),
1710         .free           = block_job_free,
1711         .user_resume    = block_job_user_resume,
1712         .drain          = block_job_drain,
1713         .run            = test_simple_job_run,
1714         .clean          = test_simple_job_clean,
1715     },
1716 };
1717
1718 static int drop_intermediate_poll_update_filename(BdrvChild *child,
1719                                                   BlockDriverState *new_base,
1720                                                   const char *filename,
1721                                                   Error **errp)
1722 {
1723     /*
1724      * We are free to poll here, which may change the block graph, if
1725      * it is not drained.
1726      */
1727
1728     /* If the job is not drained: Complete it, schedule job_exit() */
1729     aio_poll(qemu_get_current_aio_context(), false);
1730     /* If the job is not drained: Run job_exit(), finish the job */
1731     aio_poll(qemu_get_current_aio_context(), false);
1732
1733     return 0;
1734 }
1735
1736 /**
1737  * Test a poll in the midst of bdrv_drop_intermediate().
1738  *
1739  * bdrv_drop_intermediate() calls BdrvChildRole.update_filename(),
1740  * which can yield or poll.  This may lead to graph changes, unless
1741  * the whole subtree in question is drained.
1742  *
1743  * We test this on the following graph:
1744  *
1745  *                    Job
1746  *
1747  *                     |
1748  *                  job-node
1749  *                     |
1750  *                     v
1751  *
1752  *                  job-node
1753  *
1754  *                     |
1755  *                  backing
1756  *                     |
1757  *                     v
1758  *
1759  * node-2 --chain--> node-1 --chain--> node-0
1760  *
1761  * We drop node-1 with bdrv_drop_intermediate(top=node-1, base=node-0).
1762  *
1763  * This first updates node-2's backing filename by invoking
1764  * drop_intermediate_poll_update_filename(), which polls twice.  This
1765  * causes the job to finish, which in turns causes the job-node to be
1766  * deleted.
1767  *
1768  * bdrv_drop_intermediate() uses a QLIST_FOREACH_SAFE() loop, so it
1769  * already has a pointer to the BdrvChild edge between job-node and
1770  * node-1.  When it tries to handle that edge, we probably get a
1771  * segmentation fault because the object no longer exists.
1772  *
1773  *
1774  * The solution is for bdrv_drop_intermediate() to drain top's
1775  * subtree.  This prevents graph changes from happening just because
1776  * BdrvChildRole.update_filename() yields or polls.  Thus, the block
1777  * job is paused during that drained section and must finish before or
1778  * after.
1779  *
1780  * (In addition, bdrv_replace_child() must keep the job paused.)
1781  */
1782 static void test_drop_intermediate_poll(void)
1783 {
1784     static BdrvChildRole chain_child_role;
1785     BlockDriverState *chain[3];
1786     TestSimpleBlockJob *job;
1787     BlockDriverState *job_node;
1788     bool job_has_completed = false;
1789     int i;
1790     int ret;
1791
1792     chain_child_role = child_backing;
1793     chain_child_role.update_filename = drop_intermediate_poll_update_filename;
1794
1795     for (i = 0; i < 3; i++) {
1796         char name[32];
1797         snprintf(name, 32, "node-%i", i);
1798
1799         chain[i] = bdrv_new_open_driver(&bdrv_test, name, 0, &error_abort);
1800     }
1801
1802     job_node = bdrv_new_open_driver(&bdrv_test, "job-node", BDRV_O_RDWR,
1803                                     &error_abort);
1804     bdrv_set_backing_hd(job_node, chain[1], &error_abort);
1805
1806     /*
1807      * Establish the chain last, so the chain links are the first
1808      * elements in the BDS.parents lists
1809      */
1810     for (i = 0; i < 3; i++) {
1811         if (i) {
1812             /* Takes the reference to chain[i - 1] */
1813             chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1],
1814                                                   "chain", &chain_child_role,
1815                                                   &error_abort);
1816         }
1817     }
1818
1819     job = block_job_create("job", &test_simple_job_driver, NULL, job_node,
1820                            0, BLK_PERM_ALL, 0, 0, NULL, NULL, &error_abort);
1821
1822     /* The job has a reference now */
1823     bdrv_unref(job_node);
1824
1825     job->did_complete = &job_has_completed;
1826
1827     job_start(&job->common.job);
1828     job->should_complete = true;
1829
1830     g_assert(!job_has_completed);
1831     ret = bdrv_drop_intermediate(chain[1], chain[0], NULL);
1832     g_assert(ret == 0);
1833     g_assert(job_has_completed);
1834
1835     bdrv_unref(chain[2]);
1836 }
1837
1838
1839 typedef struct BDRVReplaceTestState {
1840     bool was_drained;
1841     bool was_undrained;
1842     bool has_read;
1843
1844     int drain_count;
1845
1846     bool yield_before_read;
1847     Coroutine *io_co;
1848     Coroutine *drain_co;
1849 } BDRVReplaceTestState;
1850
1851 static void bdrv_replace_test_close(BlockDriverState *bs)
1852 {
1853 }
1854
1855 /**
1856  * If @bs has a backing file:
1857  *   Yield if .yield_before_read is true (and wait for drain_begin to
1858  *   wake us up).
1859  *   Forward the read to bs->backing.  Set .has_read to true.
1860  *   If drain_begin has woken us, wake it in turn.
1861  *
1862  * Otherwise:
1863  *   Set .has_read to true and return success.
1864  */
1865 static int coroutine_fn bdrv_replace_test_co_preadv(BlockDriverState *bs,
1866                                                     uint64_t offset,
1867                                                     uint64_t bytes,
1868                                                     QEMUIOVector *qiov,
1869                                                     int flags)
1870 {
1871     BDRVReplaceTestState *s = bs->opaque;
1872
1873     if (bs->backing) {
1874         int ret;
1875
1876         g_assert(!s->drain_count);
1877
1878         s->io_co = qemu_coroutine_self();
1879         if (s->yield_before_read) {
1880             s->yield_before_read = false;
1881             qemu_coroutine_yield();
1882         }
1883         s->io_co = NULL;
1884
1885         ret = bdrv_preadv(bs->backing, offset, qiov);
1886         s->has_read = true;
1887
1888         /* Wake up drain_co if it runs */
1889         if (s->drain_co) {
1890             aio_co_wake(s->drain_co);
1891         }
1892
1893         return ret;
1894     }
1895
1896     s->has_read = true;
1897     return 0;
1898 }
1899
1900 /**
1901  * If .drain_count is 0, wake up .io_co if there is one; and set
1902  * .was_drained.
1903  * Increment .drain_count.
1904  */
1905 static void coroutine_fn bdrv_replace_test_co_drain_begin(BlockDriverState *bs)
1906 {
1907     BDRVReplaceTestState *s = bs->opaque;
1908
1909     if (!s->drain_count) {
1910         /* Keep waking io_co up until it is done */
1911         s->drain_co = qemu_coroutine_self();
1912         while (s->io_co) {
1913             aio_co_wake(s->io_co);
1914             s->io_co = NULL;
1915             qemu_coroutine_yield();
1916         }
1917         s->drain_co = NULL;
1918
1919         s->was_drained = true;
1920     }
1921     s->drain_count++;
1922 }
1923
1924 /**
1925  * Reduce .drain_count, set .was_undrained once it reaches 0.
1926  * If .drain_count reaches 0 and the node has a backing file, issue a
1927  * read request.
1928  */
1929 static void coroutine_fn bdrv_replace_test_co_drain_end(BlockDriverState *bs)
1930 {
1931     BDRVReplaceTestState *s = bs->opaque;
1932
1933     g_assert(s->drain_count > 0);
1934     if (!--s->drain_count) {
1935         int ret;
1936
1937         s->was_undrained = true;
1938
1939         if (bs->backing) {
1940             char data;
1941             QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, &data, 1);
1942
1943             /* Queue a read request post-drain */
1944             ret = bdrv_replace_test_co_preadv(bs, 0, 1, &qiov, 0);
1945             g_assert(ret >= 0);
1946         }
1947     }
1948 }
1949
1950 static BlockDriver bdrv_replace_test = {
1951     .format_name            = "replace_test",
1952     .instance_size          = sizeof(BDRVReplaceTestState),
1953
1954     .bdrv_close             = bdrv_replace_test_close,
1955     .bdrv_co_preadv         = bdrv_replace_test_co_preadv,
1956
1957     .bdrv_co_drain_begin    = bdrv_replace_test_co_drain_begin,
1958     .bdrv_co_drain_end      = bdrv_replace_test_co_drain_end,
1959
1960     .bdrv_child_perm        = bdrv_format_default_perms,
1961 };
1962
1963 static void coroutine_fn test_replace_child_mid_drain_read_co(void *opaque)
1964 {
1965     int ret;
1966     char data;
1967
1968     ret = blk_co_pread(opaque, 0, 1, &data, 0);
1969     g_assert(ret >= 0);
1970 }
1971
1972 /**
1973  * We test two things:
1974  * (1) bdrv_replace_child_noperm() must not undrain the parent if both
1975  *     children are drained.
1976  * (2) bdrv_replace_child_noperm() must never flush I/O requests to a
1977  *     drained child.  If the old child is drained, it must flush I/O
1978  *     requests after the new one has been attached.  If the new child
1979  *     is drained, it must flush I/O requests before the old one is
1980  *     detached.
1981  *
1982  * To do so, we create one parent node and two child nodes; then
1983  * attach one of the children (old_child_bs) to the parent, then
1984  * drain both old_child_bs and new_child_bs according to
1985  * old_drain_count and new_drain_count, respectively, and finally
1986  * we invoke bdrv_replace_node() to replace old_child_bs by
1987  * new_child_bs.
1988  *
1989  * The test block driver we use here (bdrv_replace_test) has a read
1990  * function that:
1991  * - For the parent node, can optionally yield, and then forwards the
1992  *   read to bdrv_preadv(),
1993  * - For the child node, just returns immediately.
1994  *
1995  * If the read yields, the drain_begin function will wake it up.
1996  *
1997  * The drain_end function issues a read on the parent once it is fully
1998  * undrained (which simulates requests starting to come in again).
1999  */
2000 static void do_test_replace_child_mid_drain(int old_drain_count,
2001                                             int new_drain_count)
2002 {
2003     BlockBackend *parent_blk;
2004     BlockDriverState *parent_bs;
2005     BlockDriverState *old_child_bs, *new_child_bs;
2006     BDRVReplaceTestState *parent_s;
2007     BDRVReplaceTestState *old_child_s, *new_child_s;
2008     Coroutine *io_co;
2009     int i;
2010
2011     parent_bs = bdrv_new_open_driver(&bdrv_replace_test, "parent", 0,
2012                                      &error_abort);
2013     parent_s = parent_bs->opaque;
2014
2015     parent_blk = blk_new(qemu_get_aio_context(),
2016                          BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
2017     blk_insert_bs(parent_blk, parent_bs, &error_abort);
2018
2019     old_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "old-child", 0,
2020                                         &error_abort);
2021     new_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "new-child", 0,
2022                                         &error_abort);
2023     old_child_s = old_child_bs->opaque;
2024     new_child_s = new_child_bs->opaque;
2025
2026     /* So that we can read something */
2027     parent_bs->total_sectors = 1;
2028     old_child_bs->total_sectors = 1;
2029     new_child_bs->total_sectors = 1;
2030
2031     bdrv_ref(old_child_bs);
2032     parent_bs->backing = bdrv_attach_child(parent_bs, old_child_bs, "child",
2033                                            &child_backing, &error_abort);
2034
2035     for (i = 0; i < old_drain_count; i++) {
2036         bdrv_drained_begin(old_child_bs);
2037     }
2038     for (i = 0; i < new_drain_count; i++) {
2039         bdrv_drained_begin(new_child_bs);
2040     }
2041
2042     if (!old_drain_count) {
2043         /*
2044          * Start a read operation that will yield, so it will not
2045          * complete before the node is drained.
2046          */
2047         parent_s->yield_before_read = true;
2048         io_co = qemu_coroutine_create(test_replace_child_mid_drain_read_co,
2049                                       parent_blk);
2050         qemu_coroutine_enter(io_co);
2051     }
2052
2053     /* If we have started a read operation, it should have yielded */
2054     g_assert(!parent_s->has_read);
2055
2056     /* Reset drained status so we can see what bdrv_replace_node() does */
2057     parent_s->was_drained = false;
2058     parent_s->was_undrained = false;
2059
2060     g_assert(parent_bs->quiesce_counter == old_drain_count);
2061     bdrv_replace_node(old_child_bs, new_child_bs, &error_abort);
2062     g_assert(parent_bs->quiesce_counter == new_drain_count);
2063
2064     if (!old_drain_count && !new_drain_count) {
2065         /*
2066          * From undrained to undrained drains and undrains the parent,
2067          * because bdrv_replace_node() contains a drained section for
2068          * @old_child_bs.
2069          */
2070         g_assert(parent_s->was_drained && parent_s->was_undrained);
2071     } else if (!old_drain_count && new_drain_count) {
2072         /*
2073          * From undrained to drained should drain the parent and keep
2074          * it that way.
2075          */
2076         g_assert(parent_s->was_drained && !parent_s->was_undrained);
2077     } else if (old_drain_count && !new_drain_count) {
2078         /*
2079          * From drained to undrained should undrain the parent and
2080          * keep it that way.
2081          */
2082         g_assert(!parent_s->was_drained && parent_s->was_undrained);
2083     } else /* if (old_drain_count && new_drain_count) */ {
2084         /*
2085          * From drained to drained must not undrain the parent at any
2086          * point
2087          */
2088         g_assert(!parent_s->was_drained && !parent_s->was_undrained);
2089     }
2090
2091     if (!old_drain_count || !new_drain_count) {
2092         /*
2093          * If !old_drain_count, we have started a read request before
2094          * bdrv_replace_node().  If !new_drain_count, the parent must
2095          * have been undrained at some point, and
2096          * bdrv_replace_test_co_drain_end() starts a read request
2097          * then.
2098          */
2099         g_assert(parent_s->has_read);
2100     } else {
2101         /*
2102          * If the parent was never undrained, there is no way to start
2103          * a read request.
2104          */
2105         g_assert(!parent_s->has_read);
2106     }
2107
2108     /* A drained child must have not received any request */
2109     g_assert(!(old_drain_count && old_child_s->has_read));
2110     g_assert(!(new_drain_count && new_child_s->has_read));
2111
2112     for (i = 0; i < new_drain_count; i++) {
2113         bdrv_drained_end(new_child_bs);
2114     }
2115     for (i = 0; i < old_drain_count; i++) {
2116         bdrv_drained_end(old_child_bs);
2117     }
2118
2119     /*
2120      * By now, bdrv_replace_test_co_drain_end() must have been called
2121      * at some point while the new child was attached to the parent.
2122      */
2123     g_assert(parent_s->has_read);
2124     g_assert(new_child_s->has_read);
2125
2126     blk_unref(parent_blk);
2127     bdrv_unref(parent_bs);
2128     bdrv_unref(old_child_bs);
2129     bdrv_unref(new_child_bs);
2130 }
2131
2132 static void test_replace_child_mid_drain(void)
2133 {
2134     int old_drain_count, new_drain_count;
2135
2136     for (old_drain_count = 0; old_drain_count < 2; old_drain_count++) {
2137         for (new_drain_count = 0; new_drain_count < 2; new_drain_count++) {
2138             do_test_replace_child_mid_drain(old_drain_count, new_drain_count);
2139         }
2140     }
2141 }
2142
2143 int main(int argc, char **argv)
2144 {
2145     int ret;
2146
2147     bdrv_init();
2148     qemu_init_main_loop(&error_abort);
2149
2150     g_test_init(&argc, &argv, NULL);
2151     qemu_event_init(&done_event, false);
2152
2153     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
2154     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
2155     g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
2156                     test_drv_cb_drain_subtree);
2157
2158     g_test_add_func("/bdrv-drain/driver-cb/co/drain_all",
2159                     test_drv_cb_co_drain_all);
2160     g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
2161     g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
2162                     test_drv_cb_co_drain_subtree);
2163
2164
2165     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
2166     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
2167     g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
2168                     test_quiesce_drain_subtree);
2169
2170     g_test_add_func("/bdrv-drain/quiesce/co/drain_all",
2171                     test_quiesce_co_drain_all);
2172     g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
2173     g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
2174                     test_quiesce_co_drain_subtree);
2175
2176     g_test_add_func("/bdrv-drain/nested", test_nested);
2177     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
2178
2179     g_test_add_func("/bdrv-drain/graph-change/drain_subtree",
2180                     test_graph_change_drain_subtree);
2181     g_test_add_func("/bdrv-drain/graph-change/drain_all",
2182                     test_graph_change_drain_all);
2183
2184     g_test_add_func("/bdrv-drain/iothread/drain_all", test_iothread_drain_all);
2185     g_test_add_func("/bdrv-drain/iothread/drain", test_iothread_drain);
2186     g_test_add_func("/bdrv-drain/iothread/drain_subtree",
2187                     test_iothread_drain_subtree);
2188
2189     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
2190     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
2191     g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
2192                     test_blockjob_drain_subtree);
2193
2194     g_test_add_func("/bdrv-drain/blockjob/error/drain_all",
2195                     test_blockjob_error_drain_all);
2196     g_test_add_func("/bdrv-drain/blockjob/error/drain",
2197                     test_blockjob_error_drain);
2198     g_test_add_func("/bdrv-drain/blockjob/error/drain_subtree",
2199                     test_blockjob_error_drain_subtree);
2200
2201     g_test_add_func("/bdrv-drain/blockjob/iothread/drain_all",
2202                     test_blockjob_iothread_drain_all);
2203     g_test_add_func("/bdrv-drain/blockjob/iothread/drain",
2204                     test_blockjob_iothread_drain);
2205     g_test_add_func("/bdrv-drain/blockjob/iothread/drain_subtree",
2206                     test_blockjob_iothread_drain_subtree);
2207
2208     g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_all",
2209                     test_blockjob_iothread_error_drain_all);
2210     g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain",
2211                     test_blockjob_iothread_error_drain);
2212     g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_subtree",
2213                     test_blockjob_iothread_error_drain_subtree);
2214
2215     g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain);
2216     g_test_add_func("/bdrv-drain/detach/drain_all", test_detach_by_drain_all);
2217     g_test_add_func("/bdrv-drain/detach/drain", test_detach_by_drain);
2218     g_test_add_func("/bdrv-drain/detach/drain_subtree", test_detach_by_drain_subtree);
2219     g_test_add_func("/bdrv-drain/detach/parent_cb", test_detach_by_parent_cb);
2220     g_test_add_func("/bdrv-drain/detach/driver_cb", test_detach_by_driver_cb);
2221
2222     g_test_add_func("/bdrv-drain/attach/drain", test_append_to_drained);
2223
2224     g_test_add_func("/bdrv-drain/set_aio_context", test_set_aio_context);
2225
2226     g_test_add_func("/bdrv-drain/blockjob/commit_by_drained_end",
2227                     test_blockjob_commit_by_drained_end);
2228
2229     g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll",
2230                     test_drop_intermediate_poll);
2231
2232     g_test_add_func("/bdrv-drain/replace_child/mid-drain",
2233                     test_replace_child_mid_drain);
2234
2235     ret = g_test_run();
2236     qemu_event_destroy(&done_event);
2237     return ret;
2238 }