2 * Block node draining tests
4 * Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com>
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "block/block_int.h"
27 #include "block/blockjob_int.h"
28 #include "sysemu/block-backend.h"
29 #include "qapi/error.h"
30 #include "qemu/main-loop.h"
33 static QemuEvent done_event
;
35 typedef struct BDRVTestState
{
37 AioContext
*bh_indirection_ctx
;
38 bool sleep_in_drain_begin
;
41 static void coroutine_fn
sleep_in_drain_begin(void *opaque
)
43 BlockDriverState
*bs
= opaque
;
45 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME
, 100000);
46 bdrv_dec_in_flight(bs
);
49 static void bdrv_test_drain_begin(BlockDriverState
*bs
)
51 BDRVTestState
*s
= bs
->opaque
;
53 if (s
->sleep_in_drain_begin
) {
54 Coroutine
*co
= qemu_coroutine_create(sleep_in_drain_begin
, bs
);
55 bdrv_inc_in_flight(bs
);
56 aio_co_enter(bdrv_get_aio_context(bs
), co
);
60 static void bdrv_test_drain_end(BlockDriverState
*bs
)
62 BDRVTestState
*s
= bs
->opaque
;
66 static void bdrv_test_close(BlockDriverState
*bs
)
68 BDRVTestState
*s
= bs
->opaque
;
69 g_assert_cmpint(s
->drain_count
, >, 0);
72 static void co_reenter_bh(void *opaque
)
77 static int coroutine_fn
bdrv_test_co_preadv(BlockDriverState
*bs
,
78 int64_t offset
, int64_t bytes
,
80 BdrvRequestFlags flags
)
82 BDRVTestState
*s
= bs
->opaque
;
84 /* We want this request to stay until the polling loop in drain waits for
85 * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
86 * first and polls its result, too, but it shouldn't accidentally complete
87 * this request yet. */
88 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME
, 100000);
90 if (s
->bh_indirection_ctx
) {
91 aio_bh_schedule_oneshot(s
->bh_indirection_ctx
, co_reenter_bh
,
92 qemu_coroutine_self());
93 qemu_coroutine_yield();
99 static int bdrv_test_change_backing_file(BlockDriverState
*bs
,
100 const char *backing_file
,
101 const char *backing_fmt
)
106 static BlockDriver bdrv_test
= {
107 .format_name
= "test",
108 .instance_size
= sizeof(BDRVTestState
),
109 .supports_backing
= true,
111 .bdrv_close
= bdrv_test_close
,
112 .bdrv_co_preadv
= bdrv_test_co_preadv
,
114 .bdrv_drain_begin
= bdrv_test_drain_begin
,
115 .bdrv_drain_end
= bdrv_test_drain_end
,
117 .bdrv_child_perm
= bdrv_default_perms
,
119 .bdrv_change_backing_file
= bdrv_test_change_backing_file
,
122 static void aio_ret_cb(void *opaque
, int ret
)
124 int *aio_ret
= opaque
;
128 typedef struct CallInCoroutineData
{
131 } CallInCoroutineData
;
133 static coroutine_fn
void call_in_coroutine_entry(void *opaque
)
135 CallInCoroutineData
*data
= opaque
;
141 static void call_in_coroutine(void (*entry
)(void))
144 CallInCoroutineData data
= {
149 co
= qemu_coroutine_create(call_in_coroutine_entry
, &data
);
150 qemu_coroutine_enter(co
);
152 aio_poll(qemu_get_aio_context(), true);
162 static void do_drain_begin(enum drain_type drain_type
, BlockDriverState
*bs
)
164 switch (drain_type
) {
165 case BDRV_DRAIN_ALL
: bdrv_drain_all_begin(); break;
166 case BDRV_DRAIN
: bdrv_drained_begin(bs
); break;
167 default: g_assert_not_reached();
171 static void do_drain_end(enum drain_type drain_type
, BlockDriverState
*bs
)
173 switch (drain_type
) {
174 case BDRV_DRAIN_ALL
: bdrv_drain_all_end(); break;
175 case BDRV_DRAIN
: bdrv_drained_end(bs
); break;
176 default: g_assert_not_reached();
180 static void do_drain_begin_unlocked(enum drain_type drain_type
, BlockDriverState
*bs
)
182 if (drain_type
!= BDRV_DRAIN_ALL
) {
183 aio_context_acquire(bdrv_get_aio_context(bs
));
185 do_drain_begin(drain_type
, bs
);
186 if (drain_type
!= BDRV_DRAIN_ALL
) {
187 aio_context_release(bdrv_get_aio_context(bs
));
191 static BlockBackend
* no_coroutine_fn
test_setup(void)
194 BlockDriverState
*bs
, *backing
;
196 blk
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
197 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
199 blk_insert_bs(blk
, bs
, &error_abort
);
201 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
202 bdrv_set_backing_hd(bs
, backing
, &error_abort
);
210 static void do_drain_end_unlocked(enum drain_type drain_type
, BlockDriverState
*bs
)
212 if (drain_type
!= BDRV_DRAIN_ALL
) {
213 aio_context_acquire(bdrv_get_aio_context(bs
));
215 do_drain_end(drain_type
, bs
);
216 if (drain_type
!= BDRV_DRAIN_ALL
) {
217 aio_context_release(bdrv_get_aio_context(bs
));
221 static void test_drv_cb_common(BlockBackend
*blk
, enum drain_type drain_type
,
224 BlockDriverState
*bs
= blk_bs(blk
);
225 BlockDriverState
*backing
= bs
->backing
->bs
;
226 BDRVTestState
*s
, *backing_s
;
230 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, NULL
, 0);
233 backing_s
= backing
->opaque
;
235 /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
236 g_assert_cmpint(s
->drain_count
, ==, 0);
237 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
239 do_drain_begin(drain_type
, bs
);
241 g_assert_cmpint(s
->drain_count
, ==, 1);
242 g_assert_cmpint(backing_s
->drain_count
, ==, !!recursive
);
244 do_drain_end(drain_type
, bs
);
246 g_assert_cmpint(s
->drain_count
, ==, 0);
247 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
249 /* Now do the same while a request is pending */
250 aio_ret
= -EINPROGRESS
;
251 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, aio_ret_cb
, &aio_ret
);
252 g_assert(acb
!= NULL
);
253 g_assert_cmpint(aio_ret
, ==, -EINPROGRESS
);
255 g_assert_cmpint(s
->drain_count
, ==, 0);
256 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
258 do_drain_begin(drain_type
, bs
);
260 g_assert_cmpint(aio_ret
, ==, 0);
261 g_assert_cmpint(s
->drain_count
, ==, 1);
262 g_assert_cmpint(backing_s
->drain_count
, ==, !!recursive
);
264 do_drain_end(drain_type
, bs
);
266 g_assert_cmpint(s
->drain_count
, ==, 0);
267 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
270 static void test_drv_cb_drain_all(void)
272 BlockBackend
*blk
= test_setup();
273 test_drv_cb_common(blk
, BDRV_DRAIN_ALL
, true);
277 static void test_drv_cb_drain(void)
279 BlockBackend
*blk
= test_setup();
280 test_drv_cb_common(blk
, BDRV_DRAIN
, false);
284 static void coroutine_fn
test_drv_cb_co_drain_all_entry(void)
286 BlockBackend
*blk
= blk_all_next(NULL
);
287 test_drv_cb_common(blk
, BDRV_DRAIN_ALL
, true);
290 static void test_drv_cb_co_drain_all(void)
292 BlockBackend
*blk
= test_setup();
293 call_in_coroutine(test_drv_cb_co_drain_all_entry
);
297 static void coroutine_fn
test_drv_cb_co_drain_entry(void)
299 BlockBackend
*blk
= blk_all_next(NULL
);
300 test_drv_cb_common(blk
, BDRV_DRAIN
, false);
303 static void test_drv_cb_co_drain(void)
305 BlockBackend
*blk
= test_setup();
306 call_in_coroutine(test_drv_cb_co_drain_entry
);
310 static void test_quiesce_common(BlockBackend
*blk
, enum drain_type drain_type
,
313 BlockDriverState
*bs
= blk_bs(blk
);
314 BlockDriverState
*backing
= bs
->backing
->bs
;
316 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
317 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
319 do_drain_begin(drain_type
, bs
);
321 if (drain_type
== BDRV_DRAIN_ALL
) {
322 g_assert_cmpint(bs
->quiesce_counter
, ==, 2);
324 g_assert_cmpint(bs
->quiesce_counter
, ==, 1);
326 g_assert_cmpint(backing
->quiesce_counter
, ==, !!recursive
);
328 do_drain_end(drain_type
, bs
);
330 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
331 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
334 static void test_quiesce_drain_all(void)
336 BlockBackend
*blk
= test_setup();
337 test_quiesce_common(blk
, BDRV_DRAIN_ALL
, true);
341 static void test_quiesce_drain(void)
343 BlockBackend
*blk
= test_setup();
344 test_quiesce_common(blk
, BDRV_DRAIN
, false);
348 static void coroutine_fn
test_quiesce_co_drain_all_entry(void)
350 BlockBackend
*blk
= blk_all_next(NULL
);
351 test_quiesce_common(blk
, BDRV_DRAIN_ALL
, true);
354 static void test_quiesce_co_drain_all(void)
356 BlockBackend
*blk
= test_setup();
357 call_in_coroutine(test_quiesce_co_drain_all_entry
);
361 static void coroutine_fn
test_quiesce_co_drain_entry(void)
363 BlockBackend
*blk
= blk_all_next(NULL
);
364 test_quiesce_common(blk
, BDRV_DRAIN
, false);
367 static void test_quiesce_co_drain(void)
369 BlockBackend
*blk
= test_setup();
370 call_in_coroutine(test_quiesce_co_drain_entry
);
374 static void test_nested(void)
377 BlockDriverState
*bs
, *backing
;
378 BDRVTestState
*s
, *backing_s
;
379 enum drain_type outer
, inner
;
381 blk
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
382 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
385 blk_insert_bs(blk
, bs
, &error_abort
);
387 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
388 backing_s
= backing
->opaque
;
389 bdrv_set_backing_hd(bs
, backing
, &error_abort
);
391 for (outer
= 0; outer
< DRAIN_TYPE_MAX
; outer
++) {
392 for (inner
= 0; inner
< DRAIN_TYPE_MAX
; inner
++) {
393 int backing_quiesce
= (outer
== BDRV_DRAIN_ALL
) +
394 (inner
== BDRV_DRAIN_ALL
);
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);
401 do_drain_begin(outer
, bs
);
402 do_drain_begin(inner
, bs
);
404 g_assert_cmpint(bs
->quiesce_counter
, ==, 2 + !!backing_quiesce
);
405 g_assert_cmpint(backing
->quiesce_counter
, ==, backing_quiesce
);
406 g_assert_cmpint(s
->drain_count
, ==, 1);
407 g_assert_cmpint(backing_s
->drain_count
, ==, !!backing_quiesce
);
409 do_drain_end(inner
, bs
);
410 do_drain_end(outer
, bs
);
412 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
413 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
414 g_assert_cmpint(s
->drain_count
, ==, 0);
415 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
424 static void test_graph_change_drain_all(void)
426 BlockBackend
*blk_a
, *blk_b
;
427 BlockDriverState
*bs_a
, *bs_b
;
428 BDRVTestState
*a_s
, *b_s
;
430 /* Create node A with a BlockBackend */
431 blk_a
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
432 bs_a
= bdrv_new_open_driver(&bdrv_test
, "test-node-a", BDRV_O_RDWR
,
435 blk_insert_bs(blk_a
, bs_a
, &error_abort
);
437 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 0);
438 g_assert_cmpint(a_s
->drain_count
, ==, 0);
440 /* Call bdrv_drain_all_begin() */
441 bdrv_drain_all_begin();
443 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
444 g_assert_cmpint(a_s
->drain_count
, ==, 1);
446 /* Create node B with a BlockBackend */
447 blk_b
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
448 bs_b
= bdrv_new_open_driver(&bdrv_test
, "test-node-b", BDRV_O_RDWR
,
451 blk_insert_bs(blk_b
, bs_b
, &error_abort
);
453 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
454 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
455 g_assert_cmpint(a_s
->drain_count
, ==, 1);
456 g_assert_cmpint(b_s
->drain_count
, ==, 1);
458 /* Unref and finally delete node A */
461 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
462 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
463 g_assert_cmpint(a_s
->drain_count
, ==, 1);
464 g_assert_cmpint(b_s
->drain_count
, ==, 1);
468 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
469 g_assert_cmpint(b_s
->drain_count
, ==, 1);
471 /* End the drained section */
472 bdrv_drain_all_end();
474 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 0);
475 g_assert_cmpint(b_s
->drain_count
, ==, 0);
481 struct test_iothread_data
{
482 BlockDriverState
*bs
;
483 enum drain_type drain_type
;
488 static void coroutine_fn
test_iothread_drain_co_entry(void *opaque
)
490 struct test_iothread_data
*data
= opaque
;
492 do_drain_begin(data
->drain_type
, data
->bs
);
493 g_assert_cmpint(*data
->aio_ret
, ==, 0);
494 do_drain_end(data
->drain_type
, data
->bs
);
496 data
->co_done
= true;
500 static void test_iothread_aio_cb(void *opaque
, int ret
)
502 int *aio_ret
= opaque
;
504 qemu_event_set(&done_event
);
507 static void test_iothread_main_thread_bh(void *opaque
)
509 struct test_iothread_data
*data
= opaque
;
511 /* Test that the AioContext is not yet locked in a random BH that is
512 * executed during drain, otherwise this would deadlock. */
513 aio_context_acquire(bdrv_get_aio_context(data
->bs
));
514 bdrv_flush(data
->bs
);
515 bdrv_dec_in_flight(data
->bs
); /* incremented by test_iothread_common() */
516 aio_context_release(bdrv_get_aio_context(data
->bs
));
520 * Starts an AIO request on a BDS that runs in the AioContext of iothread 1.
521 * The request involves a BH on iothread 2 before it can complete.
523 * @drain_thread = 0 means that do_drain_begin/end are called from the main
524 * thread, @drain_thread = 1 means that they are called from iothread 1. Drain
525 * for this BDS cannot be called from iothread 2 because only the main thread
526 * may do cross-AioContext polling.
528 static void test_iothread_common(enum drain_type drain_type
, int drain_thread
)
531 BlockDriverState
*bs
;
536 struct test_iothread_data data
;
538 IOThread
*a
= iothread_new();
539 IOThread
*b
= iothread_new();
540 AioContext
*ctx_a
= iothread_get_aio_context(a
);
541 AioContext
*ctx_b
= iothread_get_aio_context(b
);
543 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, NULL
, 0);
545 /* bdrv_drain_all() may only be called from the main loop thread */
546 if (drain_type
== BDRV_DRAIN_ALL
&& drain_thread
!= 0) {
550 blk
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
551 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
554 blk_insert_bs(blk
, bs
, &error_abort
);
555 blk_set_disable_request_queuing(blk
, true);
557 blk_set_aio_context(blk
, ctx_a
, &error_abort
);
558 aio_context_acquire(ctx_a
);
560 s
->bh_indirection_ctx
= ctx_b
;
562 aio_ret
= -EINPROGRESS
;
563 qemu_event_reset(&done_event
);
565 if (drain_thread
== 0) {
566 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, test_iothread_aio_cb
, &aio_ret
);
568 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, aio_ret_cb
, &aio_ret
);
570 g_assert(acb
!= NULL
);
571 g_assert_cmpint(aio_ret
, ==, -EINPROGRESS
);
573 aio_context_release(ctx_a
);
575 data
= (struct test_iothread_data
) {
577 .drain_type
= drain_type
,
581 switch (drain_thread
) {
583 if (drain_type
!= BDRV_DRAIN_ALL
) {
584 aio_context_acquire(ctx_a
);
588 * Increment in_flight so that do_drain_begin() waits for
589 * test_iothread_main_thread_bh(). This prevents the race between
590 * test_iothread_main_thread_bh() in IOThread a and do_drain_begin() in
591 * this thread. test_iothread_main_thread_bh() decrements in_flight.
593 bdrv_inc_in_flight(bs
);
594 aio_bh_schedule_oneshot(ctx_a
, test_iothread_main_thread_bh
, &data
);
596 /* The request is running on the IOThread a. Draining its block device
597 * will make sure that it has completed as far as the BDS is concerned,
598 * but the drain in this thread can continue immediately after
599 * bdrv_dec_in_flight() and aio_ret might be assigned only slightly
601 do_drain_begin(drain_type
, bs
);
602 g_assert_cmpint(bs
->in_flight
, ==, 0);
604 if (drain_type
!= BDRV_DRAIN_ALL
) {
605 aio_context_release(ctx_a
);
607 qemu_event_wait(&done_event
);
608 if (drain_type
!= BDRV_DRAIN_ALL
) {
609 aio_context_acquire(ctx_a
);
612 g_assert_cmpint(aio_ret
, ==, 0);
613 do_drain_end(drain_type
, bs
);
615 if (drain_type
!= BDRV_DRAIN_ALL
) {
616 aio_context_release(ctx_a
);
620 co
= qemu_coroutine_create(test_iothread_drain_co_entry
, &data
);
621 aio_co_enter(ctx_a
, co
);
622 AIO_WAIT_WHILE_UNLOCKED(NULL
, !data
.co_done
);
625 g_assert_not_reached();
628 aio_context_acquire(ctx_a
);
629 blk_set_aio_context(blk
, qemu_get_aio_context(), &error_abort
);
630 aio_context_release(ctx_a
);
640 static void test_iothread_drain_all(void)
642 test_iothread_common(BDRV_DRAIN_ALL
, 0);
643 test_iothread_common(BDRV_DRAIN_ALL
, 1);
646 static void test_iothread_drain(void)
648 test_iothread_common(BDRV_DRAIN
, 0);
649 test_iothread_common(BDRV_DRAIN
, 1);
653 typedef struct TestBlockJob
{
655 BlockDriverState
*bs
;
659 bool should_complete
;
662 static int test_job_prepare(Job
*job
)
664 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
666 /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
668 return s
->prepare_ret
;
671 static void test_job_commit(Job
*job
)
673 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
675 /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
679 static void test_job_abort(Job
*job
)
681 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
683 /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
687 static int coroutine_fn
test_job_run(Job
*job
, Error
**errp
)
689 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
691 /* We are running the actual job code past the pause point in
695 job_transition_to_ready(&s
->common
.job
);
696 while (!s
->should_complete
) {
697 /* Avoid job_sleep_ns() because it marks the job as !busy. We want to
698 * emulate some actual activity (probably some I/O) here so that drain
699 * has to wait for this activity to stop. */
700 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME
, 1000000);
702 job_pause_point(&s
->common
.job
);
708 static void test_job_complete(Job
*job
, Error
**errp
)
710 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
711 s
->should_complete
= true;
714 BlockJobDriver test_job_driver
= {
716 .instance_size
= sizeof(TestBlockJob
),
717 .free
= block_job_free
,
718 .user_resume
= block_job_user_resume
,
720 .complete
= test_job_complete
,
721 .prepare
= test_job_prepare
,
722 .commit
= test_job_commit
,
723 .abort
= test_job_abort
,
727 enum test_job_result
{
730 TEST_JOB_FAIL_PREPARE
,
733 enum test_job_drain_node
{
735 TEST_JOB_DRAIN_SRC_CHILD
,
738 static void test_blockjob_common_drain_node(enum drain_type drain_type
,
740 enum test_job_result result
,
741 enum test_job_drain_node drain_node
)
743 BlockBackend
*blk_src
, *blk_target
;
744 BlockDriverState
*src
, *src_backing
, *src_overlay
, *target
, *drain_bs
;
747 IOThread
*iothread
= NULL
;
751 src
= bdrv_new_open_driver(&bdrv_test
, "source", BDRV_O_RDWR
,
753 src_backing
= bdrv_new_open_driver(&bdrv_test
, "source-backing",
754 BDRV_O_RDWR
, &error_abort
);
755 src_overlay
= bdrv_new_open_driver(&bdrv_test
, "source-overlay",
756 BDRV_O_RDWR
, &error_abort
);
758 bdrv_set_backing_hd(src_overlay
, src
, &error_abort
);
760 bdrv_set_backing_hd(src
, src_backing
, &error_abort
);
761 bdrv_unref(src_backing
);
763 blk_src
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
764 blk_insert_bs(blk_src
, src_overlay
, &error_abort
);
766 switch (drain_node
) {
767 case TEST_JOB_DRAIN_SRC
:
770 case TEST_JOB_DRAIN_SRC_CHILD
:
771 drain_bs
= src_backing
;
774 g_assert_not_reached();
778 iothread
= iothread_new();
779 ctx
= iothread_get_aio_context(iothread
);
780 blk_set_aio_context(blk_src
, ctx
, &error_abort
);
782 ctx
= qemu_get_aio_context();
785 target
= bdrv_new_open_driver(&bdrv_test
, "target", BDRV_O_RDWR
,
787 blk_target
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
788 blk_insert_bs(blk_target
, target
, &error_abort
);
789 blk_set_allow_aio_context_change(blk_target
, true);
791 aio_context_acquire(ctx
);
792 tjob
= block_job_create("job0", &test_job_driver
, NULL
, src
,
794 0, 0, NULL
, NULL
, &error_abort
);
798 bdrv_graph_wrlock(target
);
799 block_job_add_bdrv(job
, "target", target
, 0, BLK_PERM_ALL
, &error_abort
);
800 bdrv_graph_wrunlock();
803 case TEST_JOB_SUCCESS
:
805 case TEST_JOB_FAIL_RUN
:
806 tjob
->run_ret
= -EIO
;
808 case TEST_JOB_FAIL_PREPARE
:
809 tjob
->prepare_ret
= -EIO
;
812 aio_context_release(ctx
);
814 job_start(&job
->job
);
817 /* job_co_entry() is run in the I/O thread, wait for the actual job
818 * code to start (we don't want to catch the job in the pause point in
820 while (!tjob
->running
) {
821 aio_poll(qemu_get_aio_context(), false);
825 WITH_JOB_LOCK_GUARD() {
826 g_assert_cmpint(job
->job
.pause_count
, ==, 0);
827 g_assert_false(job
->job
.paused
);
828 g_assert_true(tjob
->running
);
829 g_assert_true(job
->job
.busy
); /* We're in qemu_co_sleep_ns() */
832 do_drain_begin_unlocked(drain_type
, drain_bs
);
834 WITH_JOB_LOCK_GUARD() {
835 if (drain_type
== BDRV_DRAIN_ALL
) {
836 /* bdrv_drain_all() drains both src and target */
837 g_assert_cmpint(job
->job
.pause_count
, ==, 2);
839 g_assert_cmpint(job
->job
.pause_count
, ==, 1);
841 g_assert_true(job
->job
.paused
);
842 g_assert_false(job
->job
.busy
); /* The job is paused */
845 do_drain_end_unlocked(drain_type
, drain_bs
);
849 * Here we are waiting for the paused status to change,
850 * so don't bother protecting the read every time.
852 * paused is reset in the I/O thread, wait for it
854 while (job
->job
.paused
) {
855 aio_poll(qemu_get_aio_context(), false);
859 WITH_JOB_LOCK_GUARD() {
860 g_assert_cmpint(job
->job
.pause_count
, ==, 0);
861 g_assert_false(job
->job
.paused
);
862 g_assert_true(job
->job
.busy
); /* We're in qemu_co_sleep_ns() */
865 do_drain_begin_unlocked(drain_type
, target
);
867 WITH_JOB_LOCK_GUARD() {
868 if (drain_type
== BDRV_DRAIN_ALL
) {
869 /* bdrv_drain_all() drains both src and target */
870 g_assert_cmpint(job
->job
.pause_count
, ==, 2);
872 g_assert_cmpint(job
->job
.pause_count
, ==, 1);
874 g_assert_true(job
->job
.paused
);
875 g_assert_false(job
->job
.busy
); /* The job is paused */
878 do_drain_end_unlocked(drain_type
, target
);
882 * Here we are waiting for the paused status to change,
883 * so don't bother protecting the read every time.
885 * paused is reset in the I/O thread, wait for it
887 while (job
->job
.paused
) {
888 aio_poll(qemu_get_aio_context(), false);
892 WITH_JOB_LOCK_GUARD() {
893 g_assert_cmpint(job
->job
.pause_count
, ==, 0);
894 g_assert_false(job
->job
.paused
);
895 g_assert_true(job
->job
.busy
); /* We're in qemu_co_sleep_ns() */
898 WITH_JOB_LOCK_GUARD() {
899 ret
= job_complete_sync_locked(&job
->job
, &error_abort
);
901 g_assert_cmpint(ret
, ==, (result
== TEST_JOB_SUCCESS
? 0 : -EIO
));
903 aio_context_acquire(ctx
);
905 blk_set_aio_context(blk_src
, qemu_get_aio_context(), &error_abort
);
906 assert(blk_get_aio_context(blk_target
) == qemu_get_aio_context());
908 aio_context_release(ctx
);
911 blk_unref(blk_target
);
912 bdrv_unref(src_overlay
);
916 iothread_join(iothread
);
920 static void test_blockjob_common(enum drain_type drain_type
, bool use_iothread
,
921 enum test_job_result result
)
923 test_blockjob_common_drain_node(drain_type
, use_iothread
, result
,
925 test_blockjob_common_drain_node(drain_type
, use_iothread
, result
,
926 TEST_JOB_DRAIN_SRC_CHILD
);
929 static void test_blockjob_drain_all(void)
931 test_blockjob_common(BDRV_DRAIN_ALL
, false, TEST_JOB_SUCCESS
);
934 static void test_blockjob_drain(void)
936 test_blockjob_common(BDRV_DRAIN
, false, TEST_JOB_SUCCESS
);
939 static void test_blockjob_error_drain_all(void)
941 test_blockjob_common(BDRV_DRAIN_ALL
, false, TEST_JOB_FAIL_RUN
);
942 test_blockjob_common(BDRV_DRAIN_ALL
, false, TEST_JOB_FAIL_PREPARE
);
945 static void test_blockjob_error_drain(void)
947 test_blockjob_common(BDRV_DRAIN
, false, TEST_JOB_FAIL_RUN
);
948 test_blockjob_common(BDRV_DRAIN
, false, TEST_JOB_FAIL_PREPARE
);
951 static void test_blockjob_iothread_drain_all(void)
953 test_blockjob_common(BDRV_DRAIN_ALL
, true, TEST_JOB_SUCCESS
);
956 static void test_blockjob_iothread_drain(void)
958 test_blockjob_common(BDRV_DRAIN
, true, TEST_JOB_SUCCESS
);
961 static void test_blockjob_iothread_error_drain_all(void)
963 test_blockjob_common(BDRV_DRAIN_ALL
, true, TEST_JOB_FAIL_RUN
);
964 test_blockjob_common(BDRV_DRAIN_ALL
, true, TEST_JOB_FAIL_PREPARE
);
967 static void test_blockjob_iothread_error_drain(void)
969 test_blockjob_common(BDRV_DRAIN
, true, TEST_JOB_FAIL_RUN
);
970 test_blockjob_common(BDRV_DRAIN
, true, TEST_JOB_FAIL_PREPARE
);
974 typedef struct BDRVTestTopState
{
975 BdrvChild
*wait_child
;
978 static void bdrv_test_top_close(BlockDriverState
*bs
)
980 BdrvChild
*c
, *next_c
;
982 bdrv_graph_wrlock(NULL
);
983 QLIST_FOREACH_SAFE(c
, &bs
->children
, next
, next_c
) {
984 bdrv_unref_child(bs
, c
);
986 bdrv_graph_wrunlock();
989 static int coroutine_fn GRAPH_RDLOCK
990 bdrv_test_top_co_preadv(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
,
991 QEMUIOVector
*qiov
, BdrvRequestFlags flags
)
993 BDRVTestTopState
*tts
= bs
->opaque
;
994 return bdrv_co_preadv(tts
->wait_child
, offset
, bytes
, qiov
, flags
);
997 static BlockDriver bdrv_test_top_driver
= {
998 .format_name
= "test_top_driver",
999 .instance_size
= sizeof(BDRVTestTopState
),
1001 .bdrv_close
= bdrv_test_top_close
,
1002 .bdrv_co_preadv
= bdrv_test_top_co_preadv
,
1004 .bdrv_child_perm
= bdrv_default_perms
,
1007 typedef struct TestCoDeleteByDrainData
{
1009 bool detach_instead_of_delete
;
1011 } TestCoDeleteByDrainData
;
1013 static void coroutine_fn
test_co_delete_by_drain(void *opaque
)
1015 TestCoDeleteByDrainData
*dbdd
= opaque
;
1016 BlockBackend
*blk
= dbdd
->blk
;
1017 BlockDriverState
*bs
= blk_bs(blk
);
1018 BDRVTestTopState
*tts
= bs
->opaque
;
1019 void *buffer
= g_malloc(65536);
1020 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, buffer
, 65536);
1022 /* Pretend some internal write operation from parent to child.
1023 * Important: We have to read from the child, not from the parent!
1024 * Draining works by first propagating it all up the tree to the
1025 * root and then waiting for drainage from root to the leaves
1026 * (protocol nodes). If we have a request waiting on the root,
1027 * everything will be drained before we go back down the tree, but
1028 * we do not want that. We want to be in the middle of draining
1029 * when this following requests returns. */
1030 bdrv_graph_co_rdlock();
1031 bdrv_co_preadv(tts
->wait_child
, 0, 65536, &qiov
, 0);
1032 bdrv_graph_co_rdunlock();
1034 g_assert_cmpint(bs
->refcnt
, ==, 1);
1036 if (!dbdd
->detach_instead_of_delete
) {
1039 BdrvChild
*c
, *next_c
;
1040 bdrv_graph_co_rdlock();
1041 QLIST_FOREACH_SAFE(c
, &bs
->children
, next
, next_c
) {
1042 bdrv_graph_co_rdunlock();
1043 bdrv_co_unref_child(bs
, c
);
1044 bdrv_graph_co_rdlock();
1046 bdrv_graph_co_rdunlock();
1054 * Test what happens when some BDS has some children, you drain one of
1055 * them and this results in the BDS being deleted.
1057 * If @detach_instead_of_delete is set, the BDS is not going to be
1058 * deleted but will only detach all of its children.
1060 static void do_test_delete_by_drain(bool detach_instead_of_delete
,
1061 enum drain_type drain_type
)
1064 BlockDriverState
*bs
, *child_bs
, *null_bs
;
1065 BDRVTestTopState
*tts
;
1066 TestCoDeleteByDrainData dbdd
;
1069 bs
= bdrv_new_open_driver(&bdrv_test_top_driver
, "top", BDRV_O_RDWR
,
1071 bs
->total_sectors
= 65536 >> BDRV_SECTOR_BITS
;
1074 null_bs
= bdrv_open("null-co://", NULL
, NULL
, BDRV_O_RDWR
| BDRV_O_PROTOCOL
,
1076 bdrv_graph_wrlock(NULL
);
1077 bdrv_attach_child(bs
, null_bs
, "null-child", &child_of_bds
,
1078 BDRV_CHILD_DATA
, &error_abort
);
1079 bdrv_graph_wrunlock();
1081 /* This child will be the one to pass to requests through to, and
1082 * it will stall until a drain occurs */
1083 child_bs
= bdrv_new_open_driver(&bdrv_test
, "child", BDRV_O_RDWR
,
1085 child_bs
->total_sectors
= 65536 >> BDRV_SECTOR_BITS
;
1086 /* Takes our reference to child_bs */
1087 bdrv_graph_wrlock(NULL
);
1088 tts
->wait_child
= bdrv_attach_child(bs
, child_bs
, "wait-child",
1090 BDRV_CHILD_DATA
| BDRV_CHILD_PRIMARY
,
1092 bdrv_graph_wrunlock();
1094 /* This child is just there to be deleted
1095 * (for detach_instead_of_delete == true) */
1096 null_bs
= bdrv_open("null-co://", NULL
, NULL
, BDRV_O_RDWR
| BDRV_O_PROTOCOL
,
1098 bdrv_graph_wrlock(NULL
);
1099 bdrv_attach_child(bs
, null_bs
, "null-child", &child_of_bds
, BDRV_CHILD_DATA
,
1101 bdrv_graph_wrunlock();
1103 blk
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
1104 blk_insert_bs(blk
, bs
, &error_abort
);
1106 /* Referenced by blk now */
1109 g_assert_cmpint(bs
->refcnt
, ==, 1);
1110 g_assert_cmpint(child_bs
->refcnt
, ==, 1);
1111 g_assert_cmpint(null_bs
->refcnt
, ==, 1);
1114 dbdd
= (TestCoDeleteByDrainData
){
1116 .detach_instead_of_delete
= detach_instead_of_delete
,
1119 co
= qemu_coroutine_create(test_co_delete_by_drain
, &dbdd
);
1120 qemu_coroutine_enter(co
);
1122 /* Drain the child while the read operation is still pending.
1123 * This should result in the operation finishing and
1124 * test_co_delete_by_drain() resuming. Thus, @bs will be deleted
1125 * and the coroutine will exit while this drain operation is still
1127 switch (drain_type
) {
1130 bdrv_drain(child_bs
);
1131 bdrv_unref(child_bs
);
1133 case BDRV_DRAIN_ALL
:
1134 bdrv_drain_all_begin();
1135 bdrv_drain_all_end();
1138 g_assert_not_reached();
1141 while (!dbdd
.done
) {
1142 aio_poll(qemu_get_aio_context(), true);
1145 if (detach_instead_of_delete
) {
1146 /* Here, the reference has not passed over to the coroutine,
1147 * so we have to delete the BB ourselves */
1152 static void test_delete_by_drain(void)
1154 do_test_delete_by_drain(false, BDRV_DRAIN
);
1157 static void test_detach_by_drain_all(void)
1159 do_test_delete_by_drain(true, BDRV_DRAIN_ALL
);
1162 static void test_detach_by_drain(void)
1164 do_test_delete_by_drain(true, BDRV_DRAIN
);
1168 struct detach_by_parent_data
{
1169 BlockDriverState
*parent_b
;
1171 BlockDriverState
*c
;
1174 bool detach_on_drain
;
1176 static struct detach_by_parent_data detach_by_parent_data
;
1178 static void no_coroutine_fn
detach_indirect_bh(void *opaque
)
1180 struct detach_by_parent_data
*data
= opaque
;
1182 bdrv_dec_in_flight(data
->child_b
->bs
);
1184 bdrv_graph_wrlock(NULL
);
1185 bdrv_unref_child(data
->parent_b
, data
->child_b
);
1188 data
->child_c
= bdrv_attach_child(data
->parent_b
, data
->c
, "PB-C",
1189 &child_of_bds
, BDRV_CHILD_DATA
,
1191 bdrv_graph_wrunlock();
1194 static void coroutine_mixed_fn
detach_by_parent_aio_cb(void *opaque
, int ret
)
1196 struct detach_by_parent_data
*data
= &detach_by_parent_data
;
1198 g_assert_cmpint(ret
, ==, 0);
1199 if (data
->by_parent_cb
) {
1200 bdrv_inc_in_flight(data
->child_b
->bs
);
1201 aio_bh_schedule_oneshot(qemu_get_current_aio_context(),
1202 detach_indirect_bh
, &detach_by_parent_data
);
1206 static void GRAPH_RDLOCK
detach_by_driver_cb_drained_begin(BdrvChild
*child
)
1208 struct detach_by_parent_data
*data
= &detach_by_parent_data
;
1210 if (!data
->detach_on_drain
) {
1213 data
->detach_on_drain
= false;
1215 bdrv_inc_in_flight(data
->child_b
->bs
);
1216 aio_bh_schedule_oneshot(qemu_get_current_aio_context(),
1217 detach_indirect_bh
, &detach_by_parent_data
);
1218 child_of_bds
.drained_begin(child
);
1221 static BdrvChildClass detach_by_driver_cb_class
;
1230 * by_parent_cb == true: Test that parent callbacks don't poll
1232 * PA has a pending write request whose callback changes the child nodes of
1233 * PB: It removes B and adds C instead. The subtree of PB is drained, which
1234 * will indirectly drain the write request, too.
1236 * by_parent_cb == false: Test that bdrv_drain_invoke() doesn't poll
1238 * PA's BdrvChildClass has a .drained_begin callback that schedules a BH
1239 * that does the same graph change. If bdrv_drain_invoke() calls it, the
1240 * state is messed up, but if it is only polled in the single
1241 * BDRV_POLL_WHILE() at the end of the drain, this should work fine.
1243 static void TSA_NO_TSA
test_detach_indirect(bool by_parent_cb
)
1246 BlockDriverState
*parent_a
, *parent_b
, *a
, *b
, *c
;
1247 BdrvChild
*child_a
, *child_b
;
1250 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, NULL
, 0);
1252 if (!by_parent_cb
) {
1253 detach_by_driver_cb_class
= child_of_bds
;
1254 detach_by_driver_cb_class
.drained_begin
=
1255 detach_by_driver_cb_drained_begin
;
1256 detach_by_driver_cb_class
.drained_end
= NULL
;
1257 detach_by_driver_cb_class
.drained_poll
= NULL
;
1260 detach_by_parent_data
= (struct detach_by_parent_data
) {
1261 .detach_on_drain
= false,
1264 /* Create all involved nodes */
1265 parent_a
= bdrv_new_open_driver(&bdrv_test
, "parent-a", BDRV_O_RDWR
,
1267 parent_b
= bdrv_new_open_driver(&bdrv_test
, "parent-b", 0,
1270 a
= bdrv_new_open_driver(&bdrv_test
, "a", BDRV_O_RDWR
, &error_abort
);
1271 b
= bdrv_new_open_driver(&bdrv_test
, "b", BDRV_O_RDWR
, &error_abort
);
1272 c
= bdrv_new_open_driver(&bdrv_test
, "c", BDRV_O_RDWR
, &error_abort
);
1274 /* blk is a BB for parent-a */
1275 blk
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
1276 blk_insert_bs(blk
, parent_a
, &error_abort
);
1277 bdrv_unref(parent_a
);
1279 /* If we want to get bdrv_drain_invoke() to call aio_poll(), the driver
1280 * callback must not return immediately. */
1281 if (!by_parent_cb
) {
1282 BDRVTestState
*s
= parent_a
->opaque
;
1283 s
->sleep_in_drain_begin
= true;
1286 /* Set child relationships */
1289 bdrv_graph_wrlock(NULL
);
1290 child_b
= bdrv_attach_child(parent_b
, b
, "PB-B", &child_of_bds
,
1291 BDRV_CHILD_DATA
, &error_abort
);
1292 child_a
= bdrv_attach_child(parent_b
, a
, "PB-A", &child_of_bds
,
1293 BDRV_CHILD_COW
, &error_abort
);
1296 bdrv_attach_child(parent_a
, a
, "PA-A",
1297 by_parent_cb
? &child_of_bds
: &detach_by_driver_cb_class
,
1298 BDRV_CHILD_DATA
, &error_abort
);
1299 bdrv_graph_wrunlock();
1301 g_assert_cmpint(parent_a
->refcnt
, ==, 1);
1302 g_assert_cmpint(parent_b
->refcnt
, ==, 1);
1303 g_assert_cmpint(a
->refcnt
, ==, 3);
1304 g_assert_cmpint(b
->refcnt
, ==, 2);
1305 g_assert_cmpint(c
->refcnt
, ==, 1);
1307 g_assert(QLIST_FIRST(&parent_b
->children
) == child_a
);
1308 g_assert(QLIST_NEXT(child_a
, next
) == child_b
);
1309 g_assert(QLIST_NEXT(child_b
, next
) == NULL
);
1311 /* Start the evil write request */
1312 detach_by_parent_data
= (struct detach_by_parent_data
) {
1313 .parent_b
= parent_b
,
1316 .by_parent_cb
= by_parent_cb
,
1317 .detach_on_drain
= true,
1319 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, detach_by_parent_aio_cb
, NULL
);
1320 g_assert(acb
!= NULL
);
1322 /* Drain and check the expected result */
1323 bdrv_drained_begin(parent_b
);
1324 bdrv_drained_begin(a
);
1325 bdrv_drained_begin(b
);
1326 bdrv_drained_begin(c
);
1328 g_assert(detach_by_parent_data
.child_c
!= NULL
);
1330 g_assert_cmpint(parent_a
->refcnt
, ==, 1);
1331 g_assert_cmpint(parent_b
->refcnt
, ==, 1);
1332 g_assert_cmpint(a
->refcnt
, ==, 3);
1333 g_assert_cmpint(b
->refcnt
, ==, 1);
1334 g_assert_cmpint(c
->refcnt
, ==, 2);
1336 g_assert(QLIST_FIRST(&parent_b
->children
) == detach_by_parent_data
.child_c
);
1337 g_assert(QLIST_NEXT(detach_by_parent_data
.child_c
, next
) == child_a
);
1338 g_assert(QLIST_NEXT(child_a
, next
) == NULL
);
1340 g_assert_cmpint(parent_a
->quiesce_counter
, ==, 1);
1341 g_assert_cmpint(parent_b
->quiesce_counter
, ==, 3);
1342 g_assert_cmpint(a
->quiesce_counter
, ==, 1);
1343 g_assert_cmpint(b
->quiesce_counter
, ==, 1);
1344 g_assert_cmpint(c
->quiesce_counter
, ==, 1);
1346 bdrv_drained_end(parent_b
);
1347 bdrv_drained_end(a
);
1348 bdrv_drained_end(b
);
1349 bdrv_drained_end(c
);
1351 bdrv_unref(parent_b
);
1354 g_assert_cmpint(a
->refcnt
, ==, 1);
1355 g_assert_cmpint(b
->refcnt
, ==, 1);
1356 g_assert_cmpint(c
->refcnt
, ==, 1);
1362 static void test_detach_by_parent_cb(void)
1364 test_detach_indirect(true);
1367 static void test_detach_by_driver_cb(void)
1369 test_detach_indirect(false);
1372 static void test_append_to_drained(void)
1375 BlockDriverState
*base
, *overlay
;
1376 BDRVTestState
*base_s
, *overlay_s
;
1378 blk
= blk_new(qemu_get_aio_context(), BLK_PERM_ALL
, BLK_PERM_ALL
);
1379 base
= bdrv_new_open_driver(&bdrv_test
, "base", BDRV_O_RDWR
, &error_abort
);
1380 base_s
= base
->opaque
;
1381 blk_insert_bs(blk
, base
, &error_abort
);
1383 overlay
= bdrv_new_open_driver(&bdrv_test
, "overlay", BDRV_O_RDWR
,
1385 overlay_s
= overlay
->opaque
;
1387 do_drain_begin(BDRV_DRAIN
, base
);
1388 g_assert_cmpint(base
->quiesce_counter
, ==, 1);
1389 g_assert_cmpint(base_s
->drain_count
, ==, 1);
1390 g_assert_cmpint(base
->in_flight
, ==, 0);
1392 aio_context_acquire(qemu_get_aio_context());
1393 bdrv_append(overlay
, base
, &error_abort
);
1394 aio_context_release(qemu_get_aio_context());
1396 g_assert_cmpint(base
->in_flight
, ==, 0);
1397 g_assert_cmpint(overlay
->in_flight
, ==, 0);
1399 g_assert_cmpint(base
->quiesce_counter
, ==, 1);
1400 g_assert_cmpint(base_s
->drain_count
, ==, 1);
1401 g_assert_cmpint(overlay
->quiesce_counter
, ==, 1);
1402 g_assert_cmpint(overlay_s
->drain_count
, ==, 1);
1404 do_drain_end(BDRV_DRAIN
, base
);
1406 g_assert_cmpint(base
->quiesce_counter
, ==, 0);
1407 g_assert_cmpint(base_s
->drain_count
, ==, 0);
1408 g_assert_cmpint(overlay
->quiesce_counter
, ==, 0);
1409 g_assert_cmpint(overlay_s
->drain_count
, ==, 0);
1411 bdrv_unref(overlay
);
1416 static void test_set_aio_context(void)
1418 BlockDriverState
*bs
;
1419 IOThread
*a
= iothread_new();
1420 IOThread
*b
= iothread_new();
1421 AioContext
*ctx_a
= iothread_get_aio_context(a
);
1422 AioContext
*ctx_b
= iothread_get_aio_context(b
);
1424 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
1427 bdrv_drained_begin(bs
);
1428 bdrv_try_change_aio_context(bs
, ctx_a
, NULL
, &error_abort
);
1430 aio_context_acquire(ctx_a
);
1431 bdrv_drained_end(bs
);
1433 bdrv_drained_begin(bs
);
1434 bdrv_try_change_aio_context(bs
, ctx_b
, NULL
, &error_abort
);
1435 aio_context_release(ctx_a
);
1436 aio_context_acquire(ctx_b
);
1437 bdrv_try_change_aio_context(bs
, qemu_get_aio_context(), NULL
, &error_abort
);
1438 aio_context_release(ctx_b
);
1439 bdrv_drained_end(bs
);
1447 typedef struct TestDropBackingBlockJob
{
1449 bool should_complete
;
1451 BlockDriverState
*detach_also
;
1452 BlockDriverState
*bs
;
1453 } TestDropBackingBlockJob
;
1455 static int coroutine_fn
test_drop_backing_job_run(Job
*job
, Error
**errp
)
1457 TestDropBackingBlockJob
*s
=
1458 container_of(job
, TestDropBackingBlockJob
, common
.job
);
1460 while (!s
->should_complete
) {
1461 job_sleep_ns(job
, 0);
1467 static void test_drop_backing_job_commit(Job
*job
)
1469 TestDropBackingBlockJob
*s
=
1470 container_of(job
, TestDropBackingBlockJob
, common
.job
);
1472 bdrv_set_backing_hd(s
->bs
, NULL
, &error_abort
);
1473 bdrv_set_backing_hd(s
->detach_also
, NULL
, &error_abort
);
1475 *s
->did_complete
= true;
1478 static const BlockJobDriver test_drop_backing_job_driver
= {
1480 .instance_size
= sizeof(TestDropBackingBlockJob
),
1481 .free
= block_job_free
,
1482 .user_resume
= block_job_user_resume
,
1483 .run
= test_drop_backing_job_run
,
1484 .commit
= test_drop_backing_job_commit
,
1489 * Creates a child node with three parent nodes on it, and then runs a
1490 * block job on the final one, parent-node-2.
1492 * The job is then asked to complete before a section where the child
1495 * Ending this section will undrain the child's parents, first
1496 * parent-node-2, then parent-node-1, then parent-node-0 -- the parent
1497 * list is in reverse order of how they were added. Ending the drain
1498 * on parent-node-2 will resume the job, thus completing it and
1499 * scheduling job_exit().
1501 * Ending the drain on parent-node-1 will poll the AioContext, which
1502 * lets job_exit() and thus test_drop_backing_job_commit() run. That
1503 * function first removes the child as parent-node-2's backing file.
1505 * In old (and buggy) implementations, there are two problems with
1507 * (A) bdrv_drain_invoke() polls for every node that leaves the
1508 * drained section. This means that job_exit() is scheduled
1509 * before the child has left the drained section. Its
1510 * quiesce_counter is therefore still 1 when it is removed from
1513 * (B) bdrv_replace_child_noperm() calls drained_end() on the old
1514 * child's parents as many times as the child is quiesced. This
1515 * means it will call drained_end() on parent-node-2 once.
1516 * Because parent-node-2 is no longer quiesced at this point, this
1519 * bdrv_replace_child_noperm() therefore must call drained_end() on
1520 * the parent only if it really is still drained because the child is
1523 * If removing child from parent-node-2 was successful (as it should
1524 * be), test_drop_backing_job_commit() will then also remove the child
1525 * from parent-node-0.
1527 * With an old version of our drain infrastructure ((A) above), that
1528 * resulted in the following flow:
1530 * 1. child attempts to leave its drained section. The call recurses
1533 * 2. parent-node-2 leaves the drained section. Polling in
1534 * bdrv_drain_invoke() will schedule job_exit().
1536 * 3. parent-node-1 leaves the drained section. Polling in
1537 * bdrv_drain_invoke() will run job_exit(), thus disconnecting
1538 * parent-node-0 from the child node.
1540 * 4. bdrv_parent_drained_end() uses a QLIST_FOREACH_SAFE() loop to
1541 * iterate over the parents. Thus, it now accesses the BdrvChild
1542 * object that used to connect parent-node-0 and the child node.
1543 * However, that object no longer exists, so it accesses a dangling
1546 * The solution is to only poll once when running a bdrv_drained_end()
1547 * operation, specifically at the end when all drained_end()
1548 * operations for all involved nodes have been scheduled.
1549 * Note that this also solves (A) above, thus hiding (B).
1551 static void test_blockjob_commit_by_drained_end(void)
1553 BlockDriverState
*bs_child
, *bs_parents
[3];
1554 TestDropBackingBlockJob
*job
;
1555 bool job_has_completed
= false;
1558 bs_child
= bdrv_new_open_driver(&bdrv_test
, "child-node", BDRV_O_RDWR
,
1561 for (i
= 0; i
< 3; i
++) {
1563 snprintf(name
, sizeof(name
), "parent-node-%i", i
);
1564 bs_parents
[i
] = bdrv_new_open_driver(&bdrv_test
, name
, BDRV_O_RDWR
,
1566 bdrv_set_backing_hd(bs_parents
[i
], bs_child
, &error_abort
);
1569 job
= block_job_create("job", &test_drop_backing_job_driver
, NULL
,
1570 bs_parents
[2], 0, BLK_PERM_ALL
, 0, 0, NULL
, NULL
,
1572 job
->bs
= bs_parents
[2];
1574 job
->detach_also
= bs_parents
[0];
1575 job
->did_complete
= &job_has_completed
;
1577 job_start(&job
->common
.job
);
1579 job
->should_complete
= true;
1580 bdrv_drained_begin(bs_child
);
1581 g_assert(!job_has_completed
);
1582 bdrv_drained_end(bs_child
);
1583 aio_poll(qemu_get_aio_context(), false);
1584 g_assert(job_has_completed
);
1586 bdrv_unref(bs_parents
[0]);
1587 bdrv_unref(bs_parents
[1]);
1588 bdrv_unref(bs_parents
[2]);
1589 bdrv_unref(bs_child
);
1593 typedef struct TestSimpleBlockJob
{
1595 bool should_complete
;
1597 } TestSimpleBlockJob
;
1599 static int coroutine_fn
test_simple_job_run(Job
*job
, Error
**errp
)
1601 TestSimpleBlockJob
*s
= container_of(job
, TestSimpleBlockJob
, common
.job
);
1603 while (!s
->should_complete
) {
1604 job_sleep_ns(job
, 0);
1610 static void test_simple_job_clean(Job
*job
)
1612 TestSimpleBlockJob
*s
= container_of(job
, TestSimpleBlockJob
, common
.job
);
1613 *s
->did_complete
= true;
1616 static const BlockJobDriver test_simple_job_driver
= {
1618 .instance_size
= sizeof(TestSimpleBlockJob
),
1619 .free
= block_job_free
,
1620 .user_resume
= block_job_user_resume
,
1621 .run
= test_simple_job_run
,
1622 .clean
= test_simple_job_clean
,
1626 static int drop_intermediate_poll_update_filename(BdrvChild
*child
,
1627 BlockDriverState
*new_base
,
1628 const char *filename
,
1632 * We are free to poll here, which may change the block graph, if
1633 * it is not drained.
1636 /* If the job is not drained: Complete it, schedule job_exit() */
1637 aio_poll(qemu_get_current_aio_context(), false);
1638 /* If the job is not drained: Run job_exit(), finish the job */
1639 aio_poll(qemu_get_current_aio_context(), false);
1645 * Test a poll in the midst of bdrv_drop_intermediate().
1647 * bdrv_drop_intermediate() calls BdrvChildClass.update_filename(),
1648 * which can yield or poll. This may lead to graph changes, unless
1649 * the whole subtree in question is drained.
1651 * We test this on the following graph:
1667 * node-2 --chain--> node-1 --chain--> node-0
1669 * We drop node-1 with bdrv_drop_intermediate(top=node-1, base=node-0).
1671 * This first updates node-2's backing filename by invoking
1672 * drop_intermediate_poll_update_filename(), which polls twice. This
1673 * causes the job to finish, which in turns causes the job-node to be
1676 * bdrv_drop_intermediate() uses a QLIST_FOREACH_SAFE() loop, so it
1677 * already has a pointer to the BdrvChild edge between job-node and
1678 * node-1. When it tries to handle that edge, we probably get a
1679 * segmentation fault because the object no longer exists.
1682 * The solution is for bdrv_drop_intermediate() to drain top's
1683 * subtree. This prevents graph changes from happening just because
1684 * BdrvChildClass.update_filename() yields or polls. Thus, the block
1685 * job is paused during that drained section and must finish before or
1688 * (In addition, bdrv_replace_child() must keep the job paused.)
1690 static void test_drop_intermediate_poll(void)
1692 static BdrvChildClass chain_child_class
;
1693 BlockDriverState
*chain
[3];
1694 TestSimpleBlockJob
*job
;
1695 BlockDriverState
*job_node
;
1696 bool job_has_completed
= false;
1700 chain_child_class
= child_of_bds
;
1701 chain_child_class
.update_filename
= drop_intermediate_poll_update_filename
;
1703 for (i
= 0; i
< 3; i
++) {
1705 snprintf(name
, 32, "node-%i", i
);
1707 chain
[i
] = bdrv_new_open_driver(&bdrv_test
, name
, 0, &error_abort
);
1710 job_node
= bdrv_new_open_driver(&bdrv_test
, "job-node", BDRV_O_RDWR
,
1712 bdrv_set_backing_hd(job_node
, chain
[1], &error_abort
);
1715 * Establish the chain last, so the chain links are the first
1716 * elements in the BDS.parents lists
1718 bdrv_graph_wrlock(NULL
);
1719 for (i
= 0; i
< 3; i
++) {
1721 /* Takes the reference to chain[i - 1] */
1722 bdrv_attach_child(chain
[i
], chain
[i
- 1], "chain",
1723 &chain_child_class
, BDRV_CHILD_COW
, &error_abort
);
1726 bdrv_graph_wrunlock();
1728 job
= block_job_create("job", &test_simple_job_driver
, NULL
, job_node
,
1729 0, BLK_PERM_ALL
, 0, 0, NULL
, NULL
, &error_abort
);
1731 /* The job has a reference now */
1732 bdrv_unref(job_node
);
1734 job
->did_complete
= &job_has_completed
;
1736 job_start(&job
->common
.job
);
1737 job
->should_complete
= true;
1739 g_assert(!job_has_completed
);
1740 ret
= bdrv_drop_intermediate(chain
[1], chain
[0], NULL
);
1741 aio_poll(qemu_get_aio_context(), false);
1743 g_assert(job_has_completed
);
1745 bdrv_unref(chain
[2]);
1749 typedef struct BDRVReplaceTestState
{
1750 bool setup_completed
;
1757 bool yield_before_read
;
1759 Coroutine
*drain_co
;
1760 } BDRVReplaceTestState
;
1762 static void bdrv_replace_test_close(BlockDriverState
*bs
)
1767 * If @bs has a backing file:
1768 * Yield if .yield_before_read is true (and wait for drain_begin to
1770 * Forward the read to bs->backing. Set .has_read to true.
1771 * If drain_begin has woken us, wake it in turn.
1774 * Set .has_read to true and return success.
1776 static int coroutine_fn GRAPH_RDLOCK
1777 bdrv_replace_test_co_preadv(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
,
1778 QEMUIOVector
*qiov
, BdrvRequestFlags flags
)
1780 BDRVReplaceTestState
*s
= bs
->opaque
;
1785 g_assert(!s
->drain_count
);
1787 s
->io_co
= qemu_coroutine_self();
1788 if (s
->yield_before_read
) {
1789 s
->yield_before_read
= false;
1790 qemu_coroutine_yield();
1794 ret
= bdrv_co_preadv(bs
->backing
, offset
, bytes
, qiov
, 0);
1797 /* Wake up drain_co if it runs */
1799 aio_co_wake(s
->drain_co
);
1809 static void coroutine_fn
bdrv_replace_test_drain_co(void *opaque
)
1811 BlockDriverState
*bs
= opaque
;
1812 BDRVReplaceTestState
*s
= bs
->opaque
;
1814 /* Keep waking io_co up until it is done */
1816 aio_co_wake(s
->io_co
);
1818 qemu_coroutine_yield();
1821 bdrv_dec_in_flight(bs
);
1825 * If .drain_count is 0, wake up .io_co if there is one; and set
1827 * Increment .drain_count.
1829 static void bdrv_replace_test_drain_begin(BlockDriverState
*bs
)
1831 BDRVReplaceTestState
*s
= bs
->opaque
;
1833 if (!s
->setup_completed
) {
1837 if (!s
->drain_count
) {
1838 s
->drain_co
= qemu_coroutine_create(bdrv_replace_test_drain_co
, bs
);
1839 bdrv_inc_in_flight(bs
);
1840 aio_co_enter(bdrv_get_aio_context(bs
), s
->drain_co
);
1841 s
->was_drained
= true;
1846 static void coroutine_fn
bdrv_replace_test_read_entry(void *opaque
)
1848 BlockDriverState
*bs
= opaque
;
1850 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, &data
, 1);
1853 /* Queue a read request post-drain */
1854 bdrv_graph_co_rdlock();
1855 ret
= bdrv_replace_test_co_preadv(bs
, 0, 1, &qiov
, 0);
1856 bdrv_graph_co_rdunlock();
1859 bdrv_dec_in_flight(bs
);
1863 * Reduce .drain_count, set .was_undrained once it reaches 0.
1864 * If .drain_count reaches 0 and the node has a backing file, issue a
1867 static void bdrv_replace_test_drain_end(BlockDriverState
*bs
)
1869 BDRVReplaceTestState
*s
= bs
->opaque
;
1871 if (!s
->setup_completed
) {
1875 g_assert(s
->drain_count
> 0);
1876 if (!--s
->drain_count
) {
1877 s
->was_undrained
= true;
1880 Coroutine
*co
= qemu_coroutine_create(bdrv_replace_test_read_entry
,
1882 bdrv_inc_in_flight(bs
);
1883 aio_co_enter(bdrv_get_aio_context(bs
), co
);
1888 static BlockDriver bdrv_replace_test
= {
1889 .format_name
= "replace_test",
1890 .instance_size
= sizeof(BDRVReplaceTestState
),
1891 .supports_backing
= true,
1893 .bdrv_close
= bdrv_replace_test_close
,
1894 .bdrv_co_preadv
= bdrv_replace_test_co_preadv
,
1896 .bdrv_drain_begin
= bdrv_replace_test_drain_begin
,
1897 .bdrv_drain_end
= bdrv_replace_test_drain_end
,
1899 .bdrv_child_perm
= bdrv_default_perms
,
1902 static void coroutine_fn
test_replace_child_mid_drain_read_co(void *opaque
)
1907 ret
= blk_co_pread(opaque
, 0, 1, &data
, 0);
1912 * We test two things:
1913 * (1) bdrv_replace_child_noperm() must not undrain the parent if both
1914 * children are drained.
1915 * (2) bdrv_replace_child_noperm() must never flush I/O requests to a
1916 * drained child. If the old child is drained, it must flush I/O
1917 * requests after the new one has been attached. If the new child
1918 * is drained, it must flush I/O requests before the old one is
1921 * To do so, we create one parent node and two child nodes; then
1922 * attach one of the children (old_child_bs) to the parent, then
1923 * drain both old_child_bs and new_child_bs according to
1924 * old_drain_count and new_drain_count, respectively, and finally
1925 * we invoke bdrv_replace_node() to replace old_child_bs by
1928 * The test block driver we use here (bdrv_replace_test) has a read
1930 * - For the parent node, can optionally yield, and then forwards the
1931 * read to bdrv_preadv(),
1932 * - For the child node, just returns immediately.
1934 * If the read yields, the drain_begin function will wake it up.
1936 * The drain_end function issues a read on the parent once it is fully
1937 * undrained (which simulates requests starting to come in again).
1939 static void do_test_replace_child_mid_drain(int old_drain_count
,
1940 int new_drain_count
)
1942 BlockBackend
*parent_blk
;
1943 BlockDriverState
*parent_bs
;
1944 BlockDriverState
*old_child_bs
, *new_child_bs
;
1945 BDRVReplaceTestState
*parent_s
;
1946 BDRVReplaceTestState
*old_child_s
, *new_child_s
;
1950 parent_bs
= bdrv_new_open_driver(&bdrv_replace_test
, "parent", 0,
1952 parent_s
= parent_bs
->opaque
;
1954 parent_blk
= blk_new(qemu_get_aio_context(),
1955 BLK_PERM_CONSISTENT_READ
, BLK_PERM_ALL
);
1956 blk_insert_bs(parent_blk
, parent_bs
, &error_abort
);
1958 old_child_bs
= bdrv_new_open_driver(&bdrv_replace_test
, "old-child", 0,
1960 new_child_bs
= bdrv_new_open_driver(&bdrv_replace_test
, "new-child", 0,
1962 old_child_s
= old_child_bs
->opaque
;
1963 new_child_s
= new_child_bs
->opaque
;
1965 /* So that we can read something */
1966 parent_bs
->total_sectors
= 1;
1967 old_child_bs
->total_sectors
= 1;
1968 new_child_bs
->total_sectors
= 1;
1970 bdrv_ref(old_child_bs
);
1971 bdrv_graph_wrlock(NULL
);
1972 bdrv_attach_child(parent_bs
, old_child_bs
, "child", &child_of_bds
,
1973 BDRV_CHILD_COW
, &error_abort
);
1974 bdrv_graph_wrunlock();
1975 parent_s
->setup_completed
= true;
1977 for (i
= 0; i
< old_drain_count
; i
++) {
1978 bdrv_drained_begin(old_child_bs
);
1980 for (i
= 0; i
< new_drain_count
; i
++) {
1981 bdrv_drained_begin(new_child_bs
);
1984 if (!old_drain_count
) {
1986 * Start a read operation that will yield, so it will not
1987 * complete before the node is drained.
1989 parent_s
->yield_before_read
= true;
1990 io_co
= qemu_coroutine_create(test_replace_child_mid_drain_read_co
,
1992 qemu_coroutine_enter(io_co
);
1995 /* If we have started a read operation, it should have yielded */
1996 g_assert(!parent_s
->has_read
);
1998 /* Reset drained status so we can see what bdrv_replace_node() does */
1999 parent_s
->was_drained
= false;
2000 parent_s
->was_undrained
= false;
2002 g_assert(parent_bs
->quiesce_counter
== old_drain_count
);
2003 bdrv_drained_begin(old_child_bs
);
2004 bdrv_drained_begin(new_child_bs
);
2005 bdrv_graph_wrlock(NULL
);
2006 bdrv_replace_node(old_child_bs
, new_child_bs
, &error_abort
);
2007 bdrv_graph_wrunlock();
2008 bdrv_drained_end(new_child_bs
);
2009 bdrv_drained_end(old_child_bs
);
2010 g_assert(parent_bs
->quiesce_counter
== new_drain_count
);
2012 if (!old_drain_count
&& !new_drain_count
) {
2014 * From undrained to undrained drains and undrains the parent,
2015 * because bdrv_replace_node() contains a drained section for
2018 g_assert(parent_s
->was_drained
&& parent_s
->was_undrained
);
2019 } else if (!old_drain_count
&& new_drain_count
) {
2021 * From undrained to drained should drain the parent and keep
2024 g_assert(parent_s
->was_drained
&& !parent_s
->was_undrained
);
2025 } else if (old_drain_count
&& !new_drain_count
) {
2027 * From drained to undrained should undrain the parent and
2030 g_assert(!parent_s
->was_drained
&& parent_s
->was_undrained
);
2031 } else /* if (old_drain_count && new_drain_count) */ {
2033 * From drained to drained must not undrain the parent at any
2036 g_assert(!parent_s
->was_drained
&& !parent_s
->was_undrained
);
2039 if (!old_drain_count
|| !new_drain_count
) {
2041 * If !old_drain_count, we have started a read request before
2042 * bdrv_replace_node(). If !new_drain_count, the parent must
2043 * have been undrained at some point, and
2044 * bdrv_replace_test_co_drain_end() starts a read request
2047 g_assert(parent_s
->has_read
);
2050 * If the parent was never undrained, there is no way to start
2053 g_assert(!parent_s
->has_read
);
2056 /* A drained child must have not received any request */
2057 g_assert(!(old_drain_count
&& old_child_s
->has_read
));
2058 g_assert(!(new_drain_count
&& new_child_s
->has_read
));
2060 for (i
= 0; i
< new_drain_count
; i
++) {
2061 bdrv_drained_end(new_child_bs
);
2063 for (i
= 0; i
< old_drain_count
; i
++) {
2064 bdrv_drained_end(old_child_bs
);
2068 * By now, bdrv_replace_test_co_drain_end() must have been called
2069 * at some point while the new child was attached to the parent.
2071 g_assert(parent_s
->has_read
);
2072 g_assert(new_child_s
->has_read
);
2074 blk_unref(parent_blk
);
2075 bdrv_unref(parent_bs
);
2076 bdrv_unref(old_child_bs
);
2077 bdrv_unref(new_child_bs
);
2080 static void test_replace_child_mid_drain(void)
2082 int old_drain_count
, new_drain_count
;
2084 for (old_drain_count
= 0; old_drain_count
< 2; old_drain_count
++) {
2085 for (new_drain_count
= 0; new_drain_count
< 2; new_drain_count
++) {
2086 do_test_replace_child_mid_drain(old_drain_count
, new_drain_count
);
2091 int main(int argc
, char **argv
)
2096 qemu_init_main_loop(&error_abort
);
2098 g_test_init(&argc
, &argv
, NULL
);
2099 qemu_event_init(&done_event
, false);
2101 g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all
);
2102 g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain
);
2104 g_test_add_func("/bdrv-drain/driver-cb/co/drain_all",
2105 test_drv_cb_co_drain_all
);
2106 g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain
);
2108 g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all
);
2109 g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain
);
2111 g_test_add_func("/bdrv-drain/quiesce/co/drain_all",
2112 test_quiesce_co_drain_all
);
2113 g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain
);
2115 g_test_add_func("/bdrv-drain/nested", test_nested
);
2117 g_test_add_func("/bdrv-drain/graph-change/drain_all",
2118 test_graph_change_drain_all
);
2120 g_test_add_func("/bdrv-drain/iothread/drain_all", test_iothread_drain_all
);
2121 g_test_add_func("/bdrv-drain/iothread/drain", test_iothread_drain
);
2123 g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all
);
2124 g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain
);
2126 g_test_add_func("/bdrv-drain/blockjob/error/drain_all",
2127 test_blockjob_error_drain_all
);
2128 g_test_add_func("/bdrv-drain/blockjob/error/drain",
2129 test_blockjob_error_drain
);
2131 g_test_add_func("/bdrv-drain/blockjob/iothread/drain_all",
2132 test_blockjob_iothread_drain_all
);
2133 g_test_add_func("/bdrv-drain/blockjob/iothread/drain",
2134 test_blockjob_iothread_drain
);
2136 g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_all",
2137 test_blockjob_iothread_error_drain_all
);
2138 g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain",
2139 test_blockjob_iothread_error_drain
);
2141 g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain
);
2142 g_test_add_func("/bdrv-drain/detach/drain_all", test_detach_by_drain_all
);
2143 g_test_add_func("/bdrv-drain/detach/drain", test_detach_by_drain
);
2144 g_test_add_func("/bdrv-drain/detach/parent_cb", test_detach_by_parent_cb
);
2145 g_test_add_func("/bdrv-drain/detach/driver_cb", test_detach_by_driver_cb
);
2147 g_test_add_func("/bdrv-drain/attach/drain", test_append_to_drained
);
2149 g_test_add_func("/bdrv-drain/set_aio_context", test_set_aio_context
);
2151 g_test_add_func("/bdrv-drain/blockjob/commit_by_drained_end",
2152 test_blockjob_commit_by_drained_end
);
2154 g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll",
2155 test_drop_intermediate_poll
);
2157 g_test_add_func("/bdrv-drain/replace_child/mid-drain",
2158 test_replace_child_mid_drain
);
2161 qemu_event_destroy(&done_event
);