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.h"
27 #include "block/blockjob_int.h"
28 #include "sysemu/block-backend.h"
29 #include "qapi/error.h"
32 static QemuEvent done_event
;
34 typedef struct BDRVTestState
{
36 AioContext
*bh_indirection_ctx
;
37 bool sleep_in_drain_begin
;
40 static void coroutine_fn
bdrv_test_co_drain_begin(BlockDriverState
*bs
)
42 BDRVTestState
*s
= bs
->opaque
;
44 if (s
->sleep_in_drain_begin
) {
45 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME
, 100000);
49 static void coroutine_fn
bdrv_test_co_drain_end(BlockDriverState
*bs
)
51 BDRVTestState
*s
= bs
->opaque
;
55 static void bdrv_test_close(BlockDriverState
*bs
)
57 BDRVTestState
*s
= bs
->opaque
;
58 g_assert_cmpint(s
->drain_count
, >, 0);
61 static void co_reenter_bh(void *opaque
)
66 static int coroutine_fn
bdrv_test_co_preadv(BlockDriverState
*bs
,
67 uint64_t offset
, uint64_t bytes
,
68 QEMUIOVector
*qiov
, int flags
)
70 BDRVTestState
*s
= bs
->opaque
;
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);
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();
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
)
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
) {
99 bdrv_format_default_perms(bs
, c
, role
, reopen_queue
, perm
, shared
,
103 static BlockDriver bdrv_test
= {
104 .format_name
= "test",
105 .instance_size
= sizeof(BDRVTestState
),
107 .bdrv_close
= bdrv_test_close
,
108 .bdrv_co_preadv
= bdrv_test_co_preadv
,
110 .bdrv_co_drain_begin
= bdrv_test_co_drain_begin
,
111 .bdrv_co_drain_end
= bdrv_test_co_drain_end
,
113 .bdrv_child_perm
= bdrv_test_child_perm
,
116 static void aio_ret_cb(void *opaque
, int ret
)
118 int *aio_ret
= opaque
;
122 typedef struct CallInCoroutineData
{
125 } CallInCoroutineData
;
127 static coroutine_fn
void call_in_coroutine_entry(void *opaque
)
129 CallInCoroutineData
*data
= opaque
;
135 static void call_in_coroutine(void (*entry
)(void))
138 CallInCoroutineData data
= {
143 co
= qemu_coroutine_create(call_in_coroutine_entry
, &data
);
144 qemu_coroutine_enter(co
);
146 aio_poll(qemu_get_aio_context(), true);
157 static void do_drain_begin(enum drain_type drain_type
, BlockDriverState
*bs
)
159 switch (drain_type
) {
160 case BDRV_DRAIN_ALL
: bdrv_drain_all_begin(); break;
161 case BDRV_DRAIN
: bdrv_drained_begin(bs
); break;
162 case BDRV_SUBTREE_DRAIN
: bdrv_subtree_drained_begin(bs
); break;
163 default: g_assert_not_reached();
167 static void do_drain_end(enum drain_type drain_type
, BlockDriverState
*bs
)
169 switch (drain_type
) {
170 case BDRV_DRAIN_ALL
: bdrv_drain_all_end(); break;
171 case BDRV_DRAIN
: bdrv_drained_end(bs
); break;
172 case BDRV_SUBTREE_DRAIN
: bdrv_subtree_drained_end(bs
); break;
173 default: g_assert_not_reached();
177 static void do_drain_begin_unlocked(enum drain_type drain_type
, BlockDriverState
*bs
)
179 if (drain_type
!= BDRV_DRAIN_ALL
) {
180 aio_context_acquire(bdrv_get_aio_context(bs
));
182 do_drain_begin(drain_type
, bs
);
183 if (drain_type
!= BDRV_DRAIN_ALL
) {
184 aio_context_release(bdrv_get_aio_context(bs
));
188 static void do_drain_end_unlocked(enum drain_type drain_type
, BlockDriverState
*bs
)
190 if (drain_type
!= BDRV_DRAIN_ALL
) {
191 aio_context_acquire(bdrv_get_aio_context(bs
));
193 do_drain_end(drain_type
, bs
);
194 if (drain_type
!= BDRV_DRAIN_ALL
) {
195 aio_context_release(bdrv_get_aio_context(bs
));
199 static void test_drv_cb_common(enum drain_type drain_type
, bool recursive
)
202 BlockDriverState
*bs
, *backing
;
203 BDRVTestState
*s
, *backing_s
;
212 qemu_iovec_init_external(&qiov
, &iov
, 1);
214 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
215 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
218 blk_insert_bs(blk
, bs
, &error_abort
);
220 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
221 backing_s
= backing
->opaque
;
222 bdrv_set_backing_hd(bs
, backing
, &error_abort
);
224 /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
225 g_assert_cmpint(s
->drain_count
, ==, 0);
226 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
228 do_drain_begin(drain_type
, bs
);
230 g_assert_cmpint(s
->drain_count
, ==, 1);
231 g_assert_cmpint(backing_s
->drain_count
, ==, !!recursive
);
233 do_drain_end(drain_type
, bs
);
235 g_assert_cmpint(s
->drain_count
, ==, 0);
236 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
238 /* Now do the same while a request is pending */
239 aio_ret
= -EINPROGRESS
;
240 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, aio_ret_cb
, &aio_ret
);
241 g_assert(acb
!= NULL
);
242 g_assert_cmpint(aio_ret
, ==, -EINPROGRESS
);
244 g_assert_cmpint(s
->drain_count
, ==, 0);
245 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
247 do_drain_begin(drain_type
, bs
);
249 g_assert_cmpint(aio_ret
, ==, 0);
250 g_assert_cmpint(s
->drain_count
, ==, 1);
251 g_assert_cmpint(backing_s
->drain_count
, ==, !!recursive
);
253 do_drain_end(drain_type
, bs
);
255 g_assert_cmpint(s
->drain_count
, ==, 0);
256 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
263 static void test_drv_cb_drain_all(void)
265 test_drv_cb_common(BDRV_DRAIN_ALL
, true);
268 static void test_drv_cb_drain(void)
270 test_drv_cb_common(BDRV_DRAIN
, false);
273 static void test_drv_cb_drain_subtree(void)
275 test_drv_cb_common(BDRV_SUBTREE_DRAIN
, true);
278 static void test_drv_cb_co_drain_all(void)
280 call_in_coroutine(test_drv_cb_drain_all
);
283 static void test_drv_cb_co_drain(void)
285 call_in_coroutine(test_drv_cb_drain
);
288 static void test_drv_cb_co_drain_subtree(void)
290 call_in_coroutine(test_drv_cb_drain_subtree
);
293 static void test_quiesce_common(enum drain_type drain_type
, bool recursive
)
296 BlockDriverState
*bs
, *backing
;
298 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
299 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
301 blk_insert_bs(blk
, bs
, &error_abort
);
303 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
304 bdrv_set_backing_hd(bs
, backing
, &error_abort
);
306 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
307 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
309 do_drain_begin(drain_type
, bs
);
311 g_assert_cmpint(bs
->quiesce_counter
, ==, 1);
312 g_assert_cmpint(backing
->quiesce_counter
, ==, !!recursive
);
314 do_drain_end(drain_type
, bs
);
316 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
317 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
324 static void test_quiesce_drain_all(void)
326 test_quiesce_common(BDRV_DRAIN_ALL
, true);
329 static void test_quiesce_drain(void)
331 test_quiesce_common(BDRV_DRAIN
, false);
334 static void test_quiesce_drain_subtree(void)
336 test_quiesce_common(BDRV_SUBTREE_DRAIN
, true);
339 static void test_quiesce_co_drain_all(void)
341 call_in_coroutine(test_quiesce_drain_all
);
344 static void test_quiesce_co_drain(void)
346 call_in_coroutine(test_quiesce_drain
);
349 static void test_quiesce_co_drain_subtree(void)
351 call_in_coroutine(test_quiesce_drain_subtree
);
354 static void test_nested(void)
357 BlockDriverState
*bs
, *backing
;
358 BDRVTestState
*s
, *backing_s
;
359 enum drain_type outer
, inner
;
361 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
362 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
365 blk_insert_bs(blk
, bs
, &error_abort
);
367 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
368 backing_s
= backing
->opaque
;
369 bdrv_set_backing_hd(bs
, backing
, &error_abort
);
371 for (outer
= 0; outer
< DRAIN_TYPE_MAX
; outer
++) {
372 for (inner
= 0; inner
< DRAIN_TYPE_MAX
; inner
++) {
373 int backing_quiesce
= (outer
!= BDRV_DRAIN
) +
374 (inner
!= BDRV_DRAIN
);
376 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
377 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
378 g_assert_cmpint(s
->drain_count
, ==, 0);
379 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
381 do_drain_begin(outer
, bs
);
382 do_drain_begin(inner
, bs
);
384 g_assert_cmpint(bs
->quiesce_counter
, ==, 2);
385 g_assert_cmpint(backing
->quiesce_counter
, ==, backing_quiesce
);
386 g_assert_cmpint(s
->drain_count
, ==, 2);
387 g_assert_cmpint(backing_s
->drain_count
, ==, backing_quiesce
);
389 do_drain_end(inner
, bs
);
390 do_drain_end(outer
, bs
);
392 g_assert_cmpint(bs
->quiesce_counter
, ==, 0);
393 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
394 g_assert_cmpint(s
->drain_count
, ==, 0);
395 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
404 static void test_multiparent(void)
406 BlockBackend
*blk_a
, *blk_b
;
407 BlockDriverState
*bs_a
, *bs_b
, *backing
;
408 BDRVTestState
*a_s
, *b_s
, *backing_s
;
410 blk_a
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
411 bs_a
= bdrv_new_open_driver(&bdrv_test
, "test-node-a", BDRV_O_RDWR
,
414 blk_insert_bs(blk_a
, bs_a
, &error_abort
);
416 blk_b
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
417 bs_b
= bdrv_new_open_driver(&bdrv_test
, "test-node-b", BDRV_O_RDWR
,
420 blk_insert_bs(blk_b
, bs_b
, &error_abort
);
422 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
423 backing_s
= backing
->opaque
;
424 bdrv_set_backing_hd(bs_a
, backing
, &error_abort
);
425 bdrv_set_backing_hd(bs_b
, backing
, &error_abort
);
427 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 0);
428 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 0);
429 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
430 g_assert_cmpint(a_s
->drain_count
, ==, 0);
431 g_assert_cmpint(b_s
->drain_count
, ==, 0);
432 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
434 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_a
);
436 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
437 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
438 g_assert_cmpint(backing
->quiesce_counter
, ==, 1);
439 g_assert_cmpint(a_s
->drain_count
, ==, 1);
440 g_assert_cmpint(b_s
->drain_count
, ==, 1);
441 g_assert_cmpint(backing_s
->drain_count
, ==, 1);
443 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_b
);
445 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 2);
446 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 2);
447 g_assert_cmpint(backing
->quiesce_counter
, ==, 2);
448 g_assert_cmpint(a_s
->drain_count
, ==, 2);
449 g_assert_cmpint(b_s
->drain_count
, ==, 2);
450 g_assert_cmpint(backing_s
->drain_count
, ==, 2);
452 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_b
);
454 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
455 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
456 g_assert_cmpint(backing
->quiesce_counter
, ==, 1);
457 g_assert_cmpint(a_s
->drain_count
, ==, 1);
458 g_assert_cmpint(b_s
->drain_count
, ==, 1);
459 g_assert_cmpint(backing_s
->drain_count
, ==, 1);
461 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_a
);
463 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 0);
464 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 0);
465 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
466 g_assert_cmpint(a_s
->drain_count
, ==, 0);
467 g_assert_cmpint(b_s
->drain_count
, ==, 0);
468 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
477 static void test_graph_change_drain_subtree(void)
479 BlockBackend
*blk_a
, *blk_b
;
480 BlockDriverState
*bs_a
, *bs_b
, *backing
;
481 BDRVTestState
*a_s
, *b_s
, *backing_s
;
483 blk_a
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
484 bs_a
= bdrv_new_open_driver(&bdrv_test
, "test-node-a", BDRV_O_RDWR
,
487 blk_insert_bs(blk_a
, bs_a
, &error_abort
);
489 blk_b
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
490 bs_b
= bdrv_new_open_driver(&bdrv_test
, "test-node-b", BDRV_O_RDWR
,
493 blk_insert_bs(blk_b
, bs_b
, &error_abort
);
495 backing
= bdrv_new_open_driver(&bdrv_test
, "backing", 0, &error_abort
);
496 backing_s
= backing
->opaque
;
497 bdrv_set_backing_hd(bs_a
, backing
, &error_abort
);
499 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 0);
500 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 0);
501 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
502 g_assert_cmpint(a_s
->drain_count
, ==, 0);
503 g_assert_cmpint(b_s
->drain_count
, ==, 0);
504 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
506 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_a
);
507 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_a
);
508 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_a
);
509 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_b
);
510 do_drain_begin(BDRV_SUBTREE_DRAIN
, bs_b
);
512 bdrv_set_backing_hd(bs_b
, backing
, &error_abort
);
513 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 5);
514 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 5);
515 g_assert_cmpint(backing
->quiesce_counter
, ==, 5);
516 g_assert_cmpint(a_s
->drain_count
, ==, 5);
517 g_assert_cmpint(b_s
->drain_count
, ==, 5);
518 g_assert_cmpint(backing_s
->drain_count
, ==, 5);
520 bdrv_set_backing_hd(bs_b
, NULL
, &error_abort
);
521 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 3);
522 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 2);
523 g_assert_cmpint(backing
->quiesce_counter
, ==, 3);
524 g_assert_cmpint(a_s
->drain_count
, ==, 3);
525 g_assert_cmpint(b_s
->drain_count
, ==, 2);
526 g_assert_cmpint(backing_s
->drain_count
, ==, 3);
528 bdrv_set_backing_hd(bs_b
, backing
, &error_abort
);
529 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 5);
530 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 5);
531 g_assert_cmpint(backing
->quiesce_counter
, ==, 5);
532 g_assert_cmpint(a_s
->drain_count
, ==, 5);
533 g_assert_cmpint(b_s
->drain_count
, ==, 5);
534 g_assert_cmpint(backing_s
->drain_count
, ==, 5);
536 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_b
);
537 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_b
);
538 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_a
);
539 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_a
);
540 do_drain_end(BDRV_SUBTREE_DRAIN
, bs_a
);
542 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 0);
543 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 0);
544 g_assert_cmpint(backing
->quiesce_counter
, ==, 0);
545 g_assert_cmpint(a_s
->drain_count
, ==, 0);
546 g_assert_cmpint(b_s
->drain_count
, ==, 0);
547 g_assert_cmpint(backing_s
->drain_count
, ==, 0);
556 static void test_graph_change_drain_all(void)
558 BlockBackend
*blk_a
, *blk_b
;
559 BlockDriverState
*bs_a
, *bs_b
;
560 BDRVTestState
*a_s
, *b_s
;
562 /* Create node A with a BlockBackend */
563 blk_a
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
564 bs_a
= bdrv_new_open_driver(&bdrv_test
, "test-node-a", BDRV_O_RDWR
,
567 blk_insert_bs(blk_a
, bs_a
, &error_abort
);
569 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 0);
570 g_assert_cmpint(a_s
->drain_count
, ==, 0);
572 /* Call bdrv_drain_all_begin() */
573 bdrv_drain_all_begin();
575 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
576 g_assert_cmpint(a_s
->drain_count
, ==, 1);
578 /* Create node B with a BlockBackend */
579 blk_b
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
580 bs_b
= bdrv_new_open_driver(&bdrv_test
, "test-node-b", BDRV_O_RDWR
,
583 blk_insert_bs(blk_b
, bs_b
, &error_abort
);
585 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
586 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
587 g_assert_cmpint(a_s
->drain_count
, ==, 1);
588 g_assert_cmpint(b_s
->drain_count
, ==, 1);
590 /* Unref and finally delete node A */
593 g_assert_cmpint(bs_a
->quiesce_counter
, ==, 1);
594 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
595 g_assert_cmpint(a_s
->drain_count
, ==, 1);
596 g_assert_cmpint(b_s
->drain_count
, ==, 1);
600 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 1);
601 g_assert_cmpint(b_s
->drain_count
, ==, 1);
603 /* End the drained section */
604 bdrv_drain_all_end();
606 g_assert_cmpint(bs_b
->quiesce_counter
, ==, 0);
607 g_assert_cmpint(b_s
->drain_count
, ==, 0);
613 struct test_iothread_data
{
614 BlockDriverState
*bs
;
615 enum drain_type drain_type
;
619 static void test_iothread_drain_entry(void *opaque
)
621 struct test_iothread_data
*data
= opaque
;
623 aio_context_acquire(bdrv_get_aio_context(data
->bs
));
624 do_drain_begin(data
->drain_type
, data
->bs
);
625 g_assert_cmpint(*data
->aio_ret
, ==, 0);
626 do_drain_end(data
->drain_type
, data
->bs
);
627 aio_context_release(bdrv_get_aio_context(data
->bs
));
629 qemu_event_set(&done_event
);
632 static void test_iothread_aio_cb(void *opaque
, int ret
)
634 int *aio_ret
= opaque
;
636 qemu_event_set(&done_event
);
639 static void test_iothread_main_thread_bh(void *opaque
)
641 struct test_iothread_data
*data
= opaque
;
643 /* Test that the AioContext is not yet locked in a random BH that is
644 * executed during drain, otherwise this would deadlock. */
645 aio_context_acquire(bdrv_get_aio_context(data
->bs
));
646 bdrv_flush(data
->bs
);
647 aio_context_release(bdrv_get_aio_context(data
->bs
));
651 * Starts an AIO request on a BDS that runs in the AioContext of iothread 1.
652 * The request involves a BH on iothread 2 before it can complete.
654 * @drain_thread = 0 means that do_drain_begin/end are called from the main
655 * thread, @drain_thread = 1 means that they are called from iothread 1. Drain
656 * for this BDS cannot be called from iothread 2 because only the main thread
657 * may do cross-AioContext polling.
659 static void test_iothread_common(enum drain_type drain_type
, int drain_thread
)
662 BlockDriverState
*bs
;
666 struct test_iothread_data data
;
668 IOThread
*a
= iothread_new();
669 IOThread
*b
= iothread_new();
670 AioContext
*ctx_a
= iothread_get_aio_context(a
);
671 AioContext
*ctx_b
= iothread_get_aio_context(b
);
678 qemu_iovec_init_external(&qiov
, &iov
, 1);
680 /* bdrv_drain_all() may only be called from the main loop thread */
681 if (drain_type
== BDRV_DRAIN_ALL
&& drain_thread
!= 0) {
685 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
686 bs
= bdrv_new_open_driver(&bdrv_test
, "test-node", BDRV_O_RDWR
,
689 blk_insert_bs(blk
, bs
, &error_abort
);
691 blk_set_aio_context(blk
, ctx_a
);
692 aio_context_acquire(ctx_a
);
694 s
->bh_indirection_ctx
= ctx_b
;
696 aio_ret
= -EINPROGRESS
;
697 if (drain_thread
== 0) {
698 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, test_iothread_aio_cb
, &aio_ret
);
700 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, aio_ret_cb
, &aio_ret
);
702 g_assert(acb
!= NULL
);
703 g_assert_cmpint(aio_ret
, ==, -EINPROGRESS
);
705 aio_context_release(ctx_a
);
707 data
= (struct test_iothread_data
) {
709 .drain_type
= drain_type
,
713 switch (drain_thread
) {
715 if (drain_type
!= BDRV_DRAIN_ALL
) {
716 aio_context_acquire(ctx_a
);
719 aio_bh_schedule_oneshot(ctx_a
, test_iothread_main_thread_bh
, &data
);
721 /* The request is running on the IOThread a. Draining its block device
722 * will make sure that it has completed as far as the BDS is concerned,
723 * but the drain in this thread can continue immediately after
724 * bdrv_dec_in_flight() and aio_ret might be assigned only slightly
726 qemu_event_reset(&done_event
);
727 do_drain_begin(drain_type
, bs
);
728 g_assert_cmpint(bs
->in_flight
, ==, 0);
730 if (drain_type
!= BDRV_DRAIN_ALL
) {
731 aio_context_release(ctx_a
);
733 qemu_event_wait(&done_event
);
734 if (drain_type
!= BDRV_DRAIN_ALL
) {
735 aio_context_acquire(ctx_a
);
738 g_assert_cmpint(aio_ret
, ==, 0);
739 do_drain_end(drain_type
, bs
);
741 if (drain_type
!= BDRV_DRAIN_ALL
) {
742 aio_context_release(ctx_a
);
746 qemu_event_reset(&done_event
);
747 aio_bh_schedule_oneshot(ctx_a
, test_iothread_drain_entry
, &data
);
748 qemu_event_wait(&done_event
);
751 g_assert_not_reached();
754 aio_context_acquire(ctx_a
);
755 blk_set_aio_context(blk
, qemu_get_aio_context());
756 aio_context_release(ctx_a
);
766 static void test_iothread_drain_all(void)
768 test_iothread_common(BDRV_DRAIN_ALL
, 0);
769 test_iothread_common(BDRV_DRAIN_ALL
, 1);
772 static void test_iothread_drain(void)
774 test_iothread_common(BDRV_DRAIN
, 0);
775 test_iothread_common(BDRV_DRAIN
, 1);
778 static void test_iothread_drain_subtree(void)
780 test_iothread_common(BDRV_SUBTREE_DRAIN
, 0);
781 test_iothread_common(BDRV_SUBTREE_DRAIN
, 1);
785 typedef struct TestBlockJob
{
789 bool should_complete
;
792 static int test_job_prepare(Job
*job
)
794 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
796 /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
797 blk_flush(s
->common
.blk
);
798 return s
->prepare_ret
;
801 static void test_job_commit(Job
*job
)
803 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
805 /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
806 blk_flush(s
->common
.blk
);
809 static void test_job_abort(Job
*job
)
811 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
813 /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */
814 blk_flush(s
->common
.blk
);
817 static int coroutine_fn
test_job_run(Job
*job
, Error
**errp
)
819 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
821 job_transition_to_ready(&s
->common
.job
);
822 while (!s
->should_complete
) {
823 /* Avoid block_job_sleep_ns() because it marks the job as !busy. We
824 * want to emulate some actual activity (probably some I/O) here so
825 * that drain has to wait for this acitivity to stop. */
826 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME
, 100000);
827 job_pause_point(&s
->common
.job
);
833 static void test_job_complete(Job
*job
, Error
**errp
)
835 TestBlockJob
*s
= container_of(job
, TestBlockJob
, common
.job
);
836 s
->should_complete
= true;
839 BlockJobDriver test_job_driver
= {
841 .instance_size
= sizeof(TestBlockJob
),
842 .free
= block_job_free
,
843 .user_resume
= block_job_user_resume
,
844 .drain
= block_job_drain
,
846 .complete
= test_job_complete
,
847 .prepare
= test_job_prepare
,
848 .commit
= test_job_commit
,
849 .abort
= test_job_abort
,
853 enum test_job_result
{
856 TEST_JOB_FAIL_PREPARE
,
859 static void test_blockjob_common(enum drain_type drain_type
, bool use_iothread
,
860 enum test_job_result result
)
862 BlockBackend
*blk_src
, *blk_target
;
863 BlockDriverState
*src
, *target
;
866 IOThread
*iothread
= NULL
;
870 src
= bdrv_new_open_driver(&bdrv_test
, "source", BDRV_O_RDWR
,
872 blk_src
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
873 blk_insert_bs(blk_src
, src
, &error_abort
);
876 iothread
= iothread_new();
877 ctx
= iothread_get_aio_context(iothread
);
878 blk_set_aio_context(blk_src
, ctx
);
880 ctx
= qemu_get_aio_context();
883 target
= bdrv_new_open_driver(&bdrv_test
, "target", BDRV_O_RDWR
,
885 blk_target
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
886 blk_insert_bs(blk_target
, target
, &error_abort
);
888 aio_context_acquire(ctx
);
889 tjob
= block_job_create("job0", &test_job_driver
, NULL
, src
,
891 0, 0, NULL
, NULL
, &error_abort
);
893 block_job_add_bdrv(job
, "target", target
, 0, BLK_PERM_ALL
, &error_abort
);
896 case TEST_JOB_SUCCESS
:
898 case TEST_JOB_FAIL_RUN
:
899 tjob
->run_ret
= -EIO
;
901 case TEST_JOB_FAIL_PREPARE
:
902 tjob
->prepare_ret
= -EIO
;
906 job_start(&job
->job
);
907 aio_context_release(ctx
);
909 g_assert_cmpint(job
->job
.pause_count
, ==, 0);
910 g_assert_false(job
->job
.paused
);
911 g_assert_true(job
->job
.busy
); /* We're in job_sleep_ns() */
913 do_drain_begin_unlocked(drain_type
, src
);
915 if (drain_type
== BDRV_DRAIN_ALL
) {
916 /* bdrv_drain_all() drains both src and target */
917 g_assert_cmpint(job
->job
.pause_count
, ==, 2);
919 g_assert_cmpint(job
->job
.pause_count
, ==, 1);
921 g_assert_true(job
->job
.paused
);
922 g_assert_false(job
->job
.busy
); /* The job is paused */
924 do_drain_end_unlocked(drain_type
, src
);
927 /* paused is reset in the I/O thread, wait for it */
928 while (job
->job
.paused
) {
929 aio_poll(qemu_get_aio_context(), false);
933 g_assert_cmpint(job
->job
.pause_count
, ==, 0);
934 g_assert_false(job
->job
.paused
);
935 g_assert_true(job
->job
.busy
); /* We're in qemu_co_sleep_ns() */
937 do_drain_begin(drain_type
, target
);
939 if (drain_type
== BDRV_DRAIN_ALL
) {
940 /* bdrv_drain_all() drains both src and target */
941 g_assert_cmpint(job
->job
.pause_count
, ==, 2);
943 g_assert_cmpint(job
->job
.pause_count
, ==, 1);
945 g_assert_true(job
->job
.paused
);
946 g_assert_false(job
->job
.busy
); /* The job is paused */
948 do_drain_end(drain_type
, target
);
951 /* paused is reset in the I/O thread, wait for it */
952 while (job
->job
.paused
) {
953 aio_poll(qemu_get_aio_context(), false);
957 g_assert_cmpint(job
->job
.pause_count
, ==, 0);
958 g_assert_false(job
->job
.paused
);
959 g_assert_true(job
->job
.busy
); /* We're in job_sleep_ns() */
961 aio_context_acquire(ctx
);
962 ret
= job_complete_sync(&job
->job
, &error_abort
);
963 g_assert_cmpint(ret
, ==, (result
== TEST_JOB_SUCCESS
? 0 : -EIO
));
966 blk_set_aio_context(blk_src
, qemu_get_aio_context());
968 aio_context_release(ctx
);
971 blk_unref(blk_target
);
976 iothread_join(iothread
);
980 static void test_blockjob_drain_all(void)
982 test_blockjob_common(BDRV_DRAIN_ALL
, false, TEST_JOB_SUCCESS
);
985 static void test_blockjob_drain(void)
987 test_blockjob_common(BDRV_DRAIN
, false, TEST_JOB_SUCCESS
);
990 static void test_blockjob_drain_subtree(void)
992 test_blockjob_common(BDRV_SUBTREE_DRAIN
, false, TEST_JOB_SUCCESS
);
995 static void test_blockjob_error_drain_all(void)
997 test_blockjob_common(BDRV_DRAIN_ALL
, false, TEST_JOB_FAIL_RUN
);
998 test_blockjob_common(BDRV_DRAIN_ALL
, false, TEST_JOB_FAIL_PREPARE
);
1001 static void test_blockjob_error_drain(void)
1003 test_blockjob_common(BDRV_DRAIN
, false, TEST_JOB_FAIL_RUN
);
1004 test_blockjob_common(BDRV_DRAIN
, false, TEST_JOB_FAIL_PREPARE
);
1007 static void test_blockjob_error_drain_subtree(void)
1009 test_blockjob_common(BDRV_SUBTREE_DRAIN
, false, TEST_JOB_FAIL_RUN
);
1010 test_blockjob_common(BDRV_SUBTREE_DRAIN
, false, TEST_JOB_FAIL_PREPARE
);
1013 static void test_blockjob_iothread_drain_all(void)
1015 test_blockjob_common(BDRV_DRAIN_ALL
, true, TEST_JOB_SUCCESS
);
1018 static void test_blockjob_iothread_drain(void)
1020 test_blockjob_common(BDRV_DRAIN
, true, TEST_JOB_SUCCESS
);
1023 static void test_blockjob_iothread_drain_subtree(void)
1025 test_blockjob_common(BDRV_SUBTREE_DRAIN
, true, TEST_JOB_SUCCESS
);
1028 static void test_blockjob_iothread_error_drain_all(void)
1030 test_blockjob_common(BDRV_DRAIN_ALL
, true, TEST_JOB_FAIL_RUN
);
1031 test_blockjob_common(BDRV_DRAIN_ALL
, true, TEST_JOB_FAIL_PREPARE
);
1034 static void test_blockjob_iothread_error_drain(void)
1036 test_blockjob_common(BDRV_DRAIN
, true, TEST_JOB_FAIL_RUN
);
1037 test_blockjob_common(BDRV_DRAIN
, true, TEST_JOB_FAIL_PREPARE
);
1040 static void test_blockjob_iothread_error_drain_subtree(void)
1042 test_blockjob_common(BDRV_SUBTREE_DRAIN
, true, TEST_JOB_FAIL_RUN
);
1043 test_blockjob_common(BDRV_SUBTREE_DRAIN
, true, TEST_JOB_FAIL_PREPARE
);
1047 typedef struct BDRVTestTopState
{
1048 BdrvChild
*wait_child
;
1051 static void bdrv_test_top_close(BlockDriverState
*bs
)
1053 BdrvChild
*c
, *next_c
;
1054 QLIST_FOREACH_SAFE(c
, &bs
->children
, next
, next_c
) {
1055 bdrv_unref_child(bs
, c
);
1059 static int coroutine_fn
bdrv_test_top_co_preadv(BlockDriverState
*bs
,
1060 uint64_t offset
, uint64_t bytes
,
1061 QEMUIOVector
*qiov
, int flags
)
1063 BDRVTestTopState
*tts
= bs
->opaque
;
1064 return bdrv_co_preadv(tts
->wait_child
, offset
, bytes
, qiov
, flags
);
1067 static BlockDriver bdrv_test_top_driver
= {
1068 .format_name
= "test_top_driver",
1069 .instance_size
= sizeof(BDRVTestTopState
),
1071 .bdrv_close
= bdrv_test_top_close
,
1072 .bdrv_co_preadv
= bdrv_test_top_co_preadv
,
1074 .bdrv_child_perm
= bdrv_format_default_perms
,
1077 typedef struct TestCoDeleteByDrainData
{
1079 bool detach_instead_of_delete
;
1081 } TestCoDeleteByDrainData
;
1083 static void coroutine_fn
test_co_delete_by_drain(void *opaque
)
1085 TestCoDeleteByDrainData
*dbdd
= opaque
;
1086 BlockBackend
*blk
= dbdd
->blk
;
1087 BlockDriverState
*bs
= blk_bs(blk
);
1088 BDRVTestTopState
*tts
= bs
->opaque
;
1089 void *buffer
= g_malloc(65536);
1091 struct iovec iov
= {
1096 qemu_iovec_init_external(&qiov
, &iov
, 1);
1098 /* Pretend some internal write operation from parent to child.
1099 * Important: We have to read from the child, not from the parent!
1100 * Draining works by first propagating it all up the tree to the
1101 * root and then waiting for drainage from root to the leaves
1102 * (protocol nodes). If we have a request waiting on the root,
1103 * everything will be drained before we go back down the tree, but
1104 * we do not want that. We want to be in the middle of draining
1105 * when this following requests returns. */
1106 bdrv_co_preadv(tts
->wait_child
, 0, 65536, &qiov
, 0);
1108 g_assert_cmpint(bs
->refcnt
, ==, 1);
1110 if (!dbdd
->detach_instead_of_delete
) {
1113 BdrvChild
*c
, *next_c
;
1114 QLIST_FOREACH_SAFE(c
, &bs
->children
, next
, next_c
) {
1115 bdrv_unref_child(bs
, c
);
1124 * Test what happens when some BDS has some children, you drain one of
1125 * them and this results in the BDS being deleted.
1127 * If @detach_instead_of_delete is set, the BDS is not going to be
1128 * deleted but will only detach all of its children.
1130 static void do_test_delete_by_drain(bool detach_instead_of_delete
,
1131 enum drain_type drain_type
)
1134 BlockDriverState
*bs
, *child_bs
, *null_bs
;
1135 BDRVTestTopState
*tts
;
1136 TestCoDeleteByDrainData dbdd
;
1139 bs
= bdrv_new_open_driver(&bdrv_test_top_driver
, "top", BDRV_O_RDWR
,
1141 bs
->total_sectors
= 65536 >> BDRV_SECTOR_BITS
;
1144 null_bs
= bdrv_open("null-co://", NULL
, NULL
, BDRV_O_RDWR
| BDRV_O_PROTOCOL
,
1146 bdrv_attach_child(bs
, null_bs
, "null-child", &child_file
, &error_abort
);
1148 /* This child will be the one to pass to requests through to, and
1149 * it will stall until a drain occurs */
1150 child_bs
= bdrv_new_open_driver(&bdrv_test
, "child", BDRV_O_RDWR
,
1152 child_bs
->total_sectors
= 65536 >> BDRV_SECTOR_BITS
;
1153 /* Takes our reference to child_bs */
1154 tts
->wait_child
= bdrv_attach_child(bs
, child_bs
, "wait-child", &child_file
,
1157 /* This child is just there to be deleted
1158 * (for detach_instead_of_delete == true) */
1159 null_bs
= bdrv_open("null-co://", NULL
, NULL
, BDRV_O_RDWR
| BDRV_O_PROTOCOL
,
1161 bdrv_attach_child(bs
, null_bs
, "null-child", &child_file
, &error_abort
);
1163 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
1164 blk_insert_bs(blk
, bs
, &error_abort
);
1166 /* Referenced by blk now */
1169 g_assert_cmpint(bs
->refcnt
, ==, 1);
1170 g_assert_cmpint(child_bs
->refcnt
, ==, 1);
1171 g_assert_cmpint(null_bs
->refcnt
, ==, 1);
1174 dbdd
= (TestCoDeleteByDrainData
){
1176 .detach_instead_of_delete
= detach_instead_of_delete
,
1179 co
= qemu_coroutine_create(test_co_delete_by_drain
, &dbdd
);
1180 qemu_coroutine_enter(co
);
1182 /* Drain the child while the read operation is still pending.
1183 * This should result in the operation finishing and
1184 * test_co_delete_by_drain() resuming. Thus, @bs will be deleted
1185 * and the coroutine will exit while this drain operation is still
1187 switch (drain_type
) {
1190 bdrv_drain(child_bs
);
1191 bdrv_unref(child_bs
);
1193 case BDRV_SUBTREE_DRAIN
:
1194 /* Would have to ref/unref bs here for !detach_instead_of_delete, but
1195 * then the whole test becomes pointless because the graph changes
1196 * don't occur during the drain any more. */
1197 assert(detach_instead_of_delete
);
1198 bdrv_subtree_drained_begin(bs
);
1199 bdrv_subtree_drained_end(bs
);
1201 case BDRV_DRAIN_ALL
:
1202 bdrv_drain_all_begin();
1203 bdrv_drain_all_end();
1206 g_assert_not_reached();
1209 while (!dbdd
.done
) {
1210 aio_poll(qemu_get_aio_context(), true);
1213 if (detach_instead_of_delete
) {
1214 /* Here, the reference has not passed over to the coroutine,
1215 * so we have to delete the BB ourselves */
1220 static void test_delete_by_drain(void)
1222 do_test_delete_by_drain(false, BDRV_DRAIN
);
1225 static void test_detach_by_drain_all(void)
1227 do_test_delete_by_drain(true, BDRV_DRAIN_ALL
);
1230 static void test_detach_by_drain(void)
1232 do_test_delete_by_drain(true, BDRV_DRAIN
);
1235 static void test_detach_by_drain_subtree(void)
1237 do_test_delete_by_drain(true, BDRV_SUBTREE_DRAIN
);
1241 struct detach_by_parent_data
{
1242 BlockDriverState
*parent_b
;
1244 BlockDriverState
*c
;
1248 static struct detach_by_parent_data detach_by_parent_data
;
1250 static void detach_indirect_bh(void *opaque
)
1252 struct detach_by_parent_data
*data
= opaque
;
1254 bdrv_unref_child(data
->parent_b
, data
->child_b
);
1257 data
->child_c
= bdrv_attach_child(data
->parent_b
, data
->c
, "PB-C",
1258 &child_file
, &error_abort
);
1261 static void detach_by_parent_aio_cb(void *opaque
, int ret
)
1263 struct detach_by_parent_data
*data
= &detach_by_parent_data
;
1265 g_assert_cmpint(ret
, ==, 0);
1266 if (data
->by_parent_cb
) {
1267 detach_indirect_bh(data
);
1271 static void detach_by_driver_cb_drained_begin(BdrvChild
*child
)
1273 aio_bh_schedule_oneshot(qemu_get_current_aio_context(),
1274 detach_indirect_bh
, &detach_by_parent_data
);
1275 child_file
.drained_begin(child
);
1278 static BdrvChildRole detach_by_driver_cb_role
;
1287 * by_parent_cb == true: Test that parent callbacks don't poll
1289 * PA has a pending write request whose callback changes the child nodes of
1290 * PB: It removes B and adds C instead. The subtree of PB is drained, which
1291 * will indirectly drain the write request, too.
1293 * by_parent_cb == false: Test that bdrv_drain_invoke() doesn't poll
1295 * PA's BdrvChildRole has a .drained_begin callback that schedules a BH
1296 * that does the same graph change. If bdrv_drain_invoke() calls it, the
1297 * state is messed up, but if it is only polled in the single
1298 * BDRV_POLL_WHILE() at the end of the drain, this should work fine.
1300 static void test_detach_indirect(bool by_parent_cb
)
1303 BlockDriverState
*parent_a
, *parent_b
, *a
, *b
, *c
;
1304 BdrvChild
*child_a
, *child_b
;
1308 struct iovec iov
= {
1312 qemu_iovec_init_external(&qiov
, &iov
, 1);
1314 if (!by_parent_cb
) {
1315 detach_by_driver_cb_role
= child_file
;
1316 detach_by_driver_cb_role
.drained_begin
=
1317 detach_by_driver_cb_drained_begin
;
1320 /* Create all involved nodes */
1321 parent_a
= bdrv_new_open_driver(&bdrv_test
, "parent-a", BDRV_O_RDWR
,
1323 parent_b
= bdrv_new_open_driver(&bdrv_test
, "parent-b", 0,
1326 a
= bdrv_new_open_driver(&bdrv_test
, "a", BDRV_O_RDWR
, &error_abort
);
1327 b
= bdrv_new_open_driver(&bdrv_test
, "b", BDRV_O_RDWR
, &error_abort
);
1328 c
= bdrv_new_open_driver(&bdrv_test
, "c", BDRV_O_RDWR
, &error_abort
);
1330 /* blk is a BB for parent-a */
1331 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
1332 blk_insert_bs(blk
, parent_a
, &error_abort
);
1333 bdrv_unref(parent_a
);
1335 /* If we want to get bdrv_drain_invoke() to call aio_poll(), the driver
1336 * callback must not return immediately. */
1337 if (!by_parent_cb
) {
1338 BDRVTestState
*s
= parent_a
->opaque
;
1339 s
->sleep_in_drain_begin
= true;
1342 /* Set child relationships */
1345 child_b
= bdrv_attach_child(parent_b
, b
, "PB-B", &child_file
, &error_abort
);
1346 child_a
= bdrv_attach_child(parent_b
, a
, "PB-A", &child_backing
, &error_abort
);
1349 bdrv_attach_child(parent_a
, a
, "PA-A",
1350 by_parent_cb
? &child_file
: &detach_by_driver_cb_role
,
1353 g_assert_cmpint(parent_a
->refcnt
, ==, 1);
1354 g_assert_cmpint(parent_b
->refcnt
, ==, 1);
1355 g_assert_cmpint(a
->refcnt
, ==, 3);
1356 g_assert_cmpint(b
->refcnt
, ==, 2);
1357 g_assert_cmpint(c
->refcnt
, ==, 1);
1359 g_assert(QLIST_FIRST(&parent_b
->children
) == child_a
);
1360 g_assert(QLIST_NEXT(child_a
, next
) == child_b
);
1361 g_assert(QLIST_NEXT(child_b
, next
) == NULL
);
1363 /* Start the evil write request */
1364 detach_by_parent_data
= (struct detach_by_parent_data
) {
1365 .parent_b
= parent_b
,
1368 .by_parent_cb
= by_parent_cb
,
1370 acb
= blk_aio_preadv(blk
, 0, &qiov
, 0, detach_by_parent_aio_cb
, NULL
);
1371 g_assert(acb
!= NULL
);
1373 /* Drain and check the expected result */
1374 bdrv_subtree_drained_begin(parent_b
);
1376 g_assert(detach_by_parent_data
.child_c
!= NULL
);
1378 g_assert_cmpint(parent_a
->refcnt
, ==, 1);
1379 g_assert_cmpint(parent_b
->refcnt
, ==, 1);
1380 g_assert_cmpint(a
->refcnt
, ==, 3);
1381 g_assert_cmpint(b
->refcnt
, ==, 1);
1382 g_assert_cmpint(c
->refcnt
, ==, 2);
1384 g_assert(QLIST_FIRST(&parent_b
->children
) == detach_by_parent_data
.child_c
);
1385 g_assert(QLIST_NEXT(detach_by_parent_data
.child_c
, next
) == child_a
);
1386 g_assert(QLIST_NEXT(child_a
, next
) == NULL
);
1388 g_assert_cmpint(parent_a
->quiesce_counter
, ==, 1);
1389 g_assert_cmpint(parent_b
->quiesce_counter
, ==, 1);
1390 g_assert_cmpint(a
->quiesce_counter
, ==, 1);
1391 g_assert_cmpint(b
->quiesce_counter
, ==, 0);
1392 g_assert_cmpint(c
->quiesce_counter
, ==, 1);
1394 bdrv_subtree_drained_end(parent_b
);
1396 bdrv_unref(parent_b
);
1399 /* XXX Once bdrv_close() unref's children instead of just detaching them,
1400 * this won't be necessary any more. */
1405 g_assert_cmpint(a
->refcnt
, ==, 1);
1406 g_assert_cmpint(b
->refcnt
, ==, 1);
1407 g_assert_cmpint(c
->refcnt
, ==, 1);
1413 static void test_detach_by_parent_cb(void)
1415 test_detach_indirect(true);
1418 static void test_detach_by_driver_cb(void)
1420 test_detach_indirect(false);
1423 static void test_append_to_drained(void)
1426 BlockDriverState
*base
, *overlay
;
1427 BDRVTestState
*base_s
, *overlay_s
;
1429 blk
= blk_new(BLK_PERM_ALL
, BLK_PERM_ALL
);
1430 base
= bdrv_new_open_driver(&bdrv_test
, "base", BDRV_O_RDWR
, &error_abort
);
1431 base_s
= base
->opaque
;
1432 blk_insert_bs(blk
, base
, &error_abort
);
1434 overlay
= bdrv_new_open_driver(&bdrv_test
, "overlay", BDRV_O_RDWR
,
1436 overlay_s
= overlay
->opaque
;
1438 do_drain_begin(BDRV_DRAIN
, base
);
1439 g_assert_cmpint(base
->quiesce_counter
, ==, 1);
1440 g_assert_cmpint(base_s
->drain_count
, ==, 1);
1441 g_assert_cmpint(base
->in_flight
, ==, 0);
1443 /* Takes ownership of overlay, so we don't have to unref it later */
1444 bdrv_append(overlay
, base
, &error_abort
);
1445 g_assert_cmpint(base
->in_flight
, ==, 0);
1446 g_assert_cmpint(overlay
->in_flight
, ==, 0);
1448 g_assert_cmpint(base
->quiesce_counter
, ==, 1);
1449 g_assert_cmpint(base_s
->drain_count
, ==, 1);
1450 g_assert_cmpint(overlay
->quiesce_counter
, ==, 1);
1451 g_assert_cmpint(overlay_s
->drain_count
, ==, 1);
1453 do_drain_end(BDRV_DRAIN
, base
);
1455 g_assert_cmpint(base
->quiesce_counter
, ==, 0);
1456 g_assert_cmpint(base_s
->drain_count
, ==, 0);
1457 g_assert_cmpint(overlay
->quiesce_counter
, ==, 0);
1458 g_assert_cmpint(overlay_s
->drain_count
, ==, 0);
1464 int main(int argc
, char **argv
)
1469 qemu_init_main_loop(&error_abort
);
1471 g_test_init(&argc
, &argv
, NULL
);
1472 qemu_event_init(&done_event
, false);
1474 g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all
);
1475 g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain
);
1476 g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
1477 test_drv_cb_drain_subtree
);
1479 g_test_add_func("/bdrv-drain/driver-cb/co/drain_all",
1480 test_drv_cb_co_drain_all
);
1481 g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain
);
1482 g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
1483 test_drv_cb_co_drain_subtree
);
1486 g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all
);
1487 g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain
);
1488 g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
1489 test_quiesce_drain_subtree
);
1491 g_test_add_func("/bdrv-drain/quiesce/co/drain_all",
1492 test_quiesce_co_drain_all
);
1493 g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain
);
1494 g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
1495 test_quiesce_co_drain_subtree
);
1497 g_test_add_func("/bdrv-drain/nested", test_nested
);
1498 g_test_add_func("/bdrv-drain/multiparent", test_multiparent
);
1500 g_test_add_func("/bdrv-drain/graph-change/drain_subtree",
1501 test_graph_change_drain_subtree
);
1502 g_test_add_func("/bdrv-drain/graph-change/drain_all",
1503 test_graph_change_drain_all
);
1505 g_test_add_func("/bdrv-drain/iothread/drain_all", test_iothread_drain_all
);
1506 g_test_add_func("/bdrv-drain/iothread/drain", test_iothread_drain
);
1507 g_test_add_func("/bdrv-drain/iothread/drain_subtree",
1508 test_iothread_drain_subtree
);
1510 g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all
);
1511 g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain
);
1512 g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
1513 test_blockjob_drain_subtree
);
1515 g_test_add_func("/bdrv-drain/blockjob/error/drain_all",
1516 test_blockjob_error_drain_all
);
1517 g_test_add_func("/bdrv-drain/blockjob/error/drain",
1518 test_blockjob_error_drain
);
1519 g_test_add_func("/bdrv-drain/blockjob/error/drain_subtree",
1520 test_blockjob_error_drain_subtree
);
1522 g_test_add_func("/bdrv-drain/blockjob/iothread/drain_all",
1523 test_blockjob_iothread_drain_all
);
1524 g_test_add_func("/bdrv-drain/blockjob/iothread/drain",
1525 test_blockjob_iothread_drain
);
1526 g_test_add_func("/bdrv-drain/blockjob/iothread/drain_subtree",
1527 test_blockjob_iothread_drain_subtree
);
1529 g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_all",
1530 test_blockjob_iothread_error_drain_all
);
1531 g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain",
1532 test_blockjob_iothread_error_drain
);
1533 g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_subtree",
1534 test_blockjob_iothread_error_drain_subtree
);
1536 g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain
);
1537 g_test_add_func("/bdrv-drain/detach/drain_all", test_detach_by_drain_all
);
1538 g_test_add_func("/bdrv-drain/detach/drain", test_detach_by_drain
);
1539 g_test_add_func("/bdrv-drain/detach/drain_subtree", test_detach_by_drain_subtree
);
1540 g_test_add_func("/bdrv-drain/detach/parent_cb", test_detach_by_parent_cb
);
1541 g_test_add_func("/bdrv-drain/detach/driver_cb", test_detach_by_driver_cb
);
1543 g_test_add_func("/bdrv-drain/attach/drain", test_append_to_drained
);
1546 qemu_event_destroy(&done_event
);