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