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