]> git.proxmox.com Git - mirror_qemu.git/blame - tests/test-bdrv-drain.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'remotes/dgilbert/tags/pull-migration-20180615a' into...
[mirror_qemu.git] / tests / test-bdrv-drain.c
CommitLineData
881cfd17
KW		 1/*
2 * Block node draining tests
3 *
4 * Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25#include "qemu/osdep.h"
26#include "block/block.h"
7253220d 27#include "block/blockjob_int.h"
881cfd17
KW		 28#include "sysemu/block-backend.h"
29#include "qapi/error.h"
30
31typedef struct BDRVTestState {
32 int drain_count;
33} BDRVTestState;
34
35static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
36{
37 BDRVTestState *s = bs->opaque;
38 s->drain_count++;
39}
40
41static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
42{
43 BDRVTestState *s = bs->opaque;
44 s->drain_count--;
45}
46
47static void bdrv_test_close(BlockDriverState *bs)
48{
49 BDRVTestState *s = bs->opaque;
50 g_assert_cmpint(s->drain_count, >, 0);
51}
52
53static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
54 uint64_t offset, uint64_t bytes,
55 QEMUIOVector *qiov, int flags)
56{
57 /* We want this request to stay until the polling loop in drain waits for
58 * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
59 * first and polls its result, too, but it shouldn't accidentally complete
60 * this request yet. */
61 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
62
63 return 0;
64}
65
66static BlockDriver bdrv_test = {
67 .format_name = "test",
68 .instance_size = sizeof(BDRVTestState),
69
70 .bdrv_close = bdrv_test_close,
71 .bdrv_co_preadv = bdrv_test_co_preadv,
72
73 .bdrv_co_drain_begin = bdrv_test_co_drain_begin,
74 .bdrv_co_drain_end = bdrv_test_co_drain_end,
86e1c840
KW		 75
76 .bdrv_child_perm = bdrv_format_default_perms,
881cfd17
KW		 77};
78
79static void aio_ret_cb(void *opaque, int ret)
80{
81 int *aio_ret = opaque;
82 *aio_ret = ret;
83}
84
0582eb10
KW		 85typedef struct CallInCoroutineData {
86 void (*entry)(void);
87 bool done;
88} CallInCoroutineData;
89
90static coroutine_fn void call_in_coroutine_entry(void *opaque)
91{
92 CallInCoroutineData *data = opaque;
93
94 data->entry();
95 data->done = true;
96}
97
98static void call_in_coroutine(void (*entry)(void))
99{
100 Coroutine *co;
101 CallInCoroutineData data = {
102 .entry = entry,
103 .done = false,
104 };
105
106 co = qemu_coroutine_create(call_in_coroutine_entry, &data);
107 qemu_coroutine_enter(co);
108 while (!data.done) {
109 aio_poll(qemu_get_aio_context(), true);
110 }
111}
112
86e1c840
KW		 113enum drain_type {
114 BDRV_DRAIN_ALL,
115 BDRV_DRAIN,
d2a85d0f 116 BDRV_SUBTREE_DRAIN,
6c429a6a 117 DRAIN_TYPE_MAX,
86e1c840
KW		 118};
119
120static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
121{
122 switch (drain_type) {
123 case BDRV_DRAIN_ALL: bdrv_drain_all_begin(); break;
124 case BDRV_DRAIN: bdrv_drained_begin(bs); break;
d2a85d0f 125 case BDRV_SUBTREE_DRAIN: bdrv_subtree_drained_begin(bs); break;
86e1c840
KW		 126 default: g_assert_not_reached();
127 }
128}
129
130static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
131{
132 switch (drain_type) {
133 case BDRV_DRAIN_ALL: bdrv_drain_all_end(); break;
134 case BDRV_DRAIN: bdrv_drained_end(bs); break;
d2a85d0f 135 case BDRV_SUBTREE_DRAIN: bdrv_subtree_drained_end(bs); break;
86e1c840
KW		 136 default: g_assert_not_reached();
137 }
138}
139
140static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
881cfd17
KW		 141{
142 BlockBackend *blk;
86e1c840
KW		 143 BlockDriverState *bs, *backing;
144 BDRVTestState *s, *backing_s;
881cfd17
KW		 145 BlockAIOCB *acb;
146 int aio_ret;
147
148 QEMUIOVector qiov;
149 struct iovec iov = {
150 .iov_base = NULL,
151 .iov_len = 0,
152 };
153 qemu_iovec_init_external(&qiov, &iov, 1);
154
155 blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
156 bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
157 &error_abort);
158 s = bs->opaque;
159 blk_insert_bs(blk, bs, &error_abort);
160
86e1c840
KW		 161 backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
162 backing_s = backing->opaque;
163 bdrv_set_backing_hd(bs, backing, &error_abort);
164
881cfd17
KW		 165 /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
166 g_assert_cmpint(s->drain_count, ==, 0);
86e1c840
KW		 167 g_assert_cmpint(backing_s->drain_count, ==, 0);
168
169 do_drain_begin(drain_type, bs);
170
881cfd17 171 g_assert_cmpint(s->drain_count, ==, 1);
86e1c840
KW		 172 g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
173
174 do_drain_end(drain_type, bs);
175
881cfd17 176 g_assert_cmpint(s->drain_count, ==, 0);
86e1c840 177 g_assert_cmpint(backing_s->drain_count, ==, 0);
881cfd17
KW		 178
179 /* Now do the same while a request is pending */
180 aio_ret = -EINPROGRESS;
181 acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
182 g_assert(acb != NULL);
183 g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
184
185 g_assert_cmpint(s->drain_count, ==, 0);
86e1c840
KW		 186 g_assert_cmpint(backing_s->drain_count, ==, 0);
187
188 do_drain_begin(drain_type, bs);
189
881cfd17
KW		 190 g_assert_cmpint(aio_ret, ==, 0);
191 g_assert_cmpint(s->drain_count, ==, 1);
86e1c840
KW		 192 g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
193
194 do_drain_end(drain_type, bs);
195
881cfd17 196 g_assert_cmpint(s->drain_count, ==, 0);
86e1c840 197 g_assert_cmpint(backing_s->drain_count, ==, 0);
881cfd17 198
86e1c840 199 bdrv_unref(backing);
881cfd17
KW		 200 bdrv_unref(bs);
201 blk_unref(blk);
202}
203
86e1c840
KW		 204static void test_drv_cb_drain_all(void)
205{
206 test_drv_cb_common(BDRV_DRAIN_ALL, true);
207}
208
209static void test_drv_cb_drain(void)
210{
211 test_drv_cb_common(BDRV_DRAIN, false);
212}
213
d2a85d0f
KW		 214static void test_drv_cb_drain_subtree(void)
215{
216 test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
217}
218
0582eb10
KW		 219static void test_drv_cb_co_drain(void)
220{
221 call_in_coroutine(test_drv_cb_drain);
222}
223
224static void test_drv_cb_co_drain_subtree(void)
225{
226 call_in_coroutine(test_drv_cb_drain_subtree);
227}
228
89a6ceab
KW		 229static void test_quiesce_common(enum drain_type drain_type, bool recursive)
230{
231 BlockBackend *blk;
232 BlockDriverState *bs, *backing;
233
234 blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
235 bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
236 &error_abort);
237 blk_insert_bs(blk, bs, &error_abort);
238
239 backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
240 bdrv_set_backing_hd(bs, backing, &error_abort);
241
242 g_assert_cmpint(bs->quiesce_counter, ==, 0);
243 g_assert_cmpint(backing->quiesce_counter, ==, 0);
244
245 do_drain_begin(drain_type, bs);
246
247 g_assert_cmpint(bs->quiesce_counter, ==, 1);
248 g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
249
250 do_drain_end(drain_type, bs);
251
252 g_assert_cmpint(bs->quiesce_counter, ==, 0);
253 g_assert_cmpint(backing->quiesce_counter, ==, 0);
254
255 bdrv_unref(backing);
256 bdrv_unref(bs);
257 blk_unref(blk);
258}
259
260static void test_quiesce_drain_all(void)
261{
262 // XXX drain_all doesn't quiesce
263 //test_quiesce_common(BDRV_DRAIN_ALL, true);
264}
265
266static void test_quiesce_drain(void)
267{
268 test_quiesce_common(BDRV_DRAIN, false);
269}
270
d2a85d0f
KW		 271static void test_quiesce_drain_subtree(void)
272{
273 test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
274}
275
0582eb10
KW		 276static void test_quiesce_co_drain(void)
277{
278 call_in_coroutine(test_quiesce_drain);
279}
280
281static void test_quiesce_co_drain_subtree(void)
282{
283 call_in_coroutine(test_quiesce_drain_subtree);
284}
285
6c429a6a
KW		 286static void test_nested(void)
287{
288 BlockBackend *blk;
289 BlockDriverState *bs, *backing;
290 BDRVTestState *s, *backing_s;
291 enum drain_type outer, inner;
292
293 blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
294 bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
295 &error_abort);
296 s = bs->opaque;
297 blk_insert_bs(blk, bs, &error_abort);
298
299 backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
300 backing_s = backing->opaque;
301 bdrv_set_backing_hd(bs, backing, &error_abort);
302
303 for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
304 for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
305 /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
306 int bs_quiesce = (outer != BDRV_DRAIN_ALL) +
307 (inner != BDRV_DRAIN_ALL);
d2a85d0f
KW		 308 int backing_quiesce = (outer == BDRV_SUBTREE_DRAIN) +
309 (inner == BDRV_SUBTREE_DRAIN);
6c429a6a
KW		 310 int backing_cb_cnt = (outer != BDRV_DRAIN) +
311 (inner != BDRV_DRAIN);
312
313 g_assert_cmpint(bs->quiesce_counter, ==, 0);
314 g_assert_cmpint(backing->quiesce_counter, ==, 0);
315 g_assert_cmpint(s->drain_count, ==, 0);
316 g_assert_cmpint(backing_s->drain_count, ==, 0);
317
318 do_drain_begin(outer, bs);
319 do_drain_begin(inner, bs);
320
321 g_assert_cmpint(bs->quiesce_counter, ==, bs_quiesce);
322 g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
323 g_assert_cmpint(s->drain_count, ==, 2);
324 g_assert_cmpint(backing_s->drain_count, ==, backing_cb_cnt);
325
326 do_drain_end(inner, bs);
327 do_drain_end(outer, bs);
328
329 g_assert_cmpint(bs->quiesce_counter, ==, 0);
330 g_assert_cmpint(backing->quiesce_counter, ==, 0);
331 g_assert_cmpint(s->drain_count, ==, 0);
332 g_assert_cmpint(backing_s->drain_count, ==, 0);
333 }
334 }
335
336 bdrv_unref(backing);
337 bdrv_unref(bs);
338 blk_unref(blk);
339}
340
27e64474
KW		 341static void test_multiparent(void)
342{
343 BlockBackend *blk_a, *blk_b;
344 BlockDriverState *bs_a, *bs_b, *backing;
345 BDRVTestState *a_s, *b_s, *backing_s;
346
347 blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
348 bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
349 &error_abort);
350 a_s = bs_a->opaque;
351 blk_insert_bs(blk_a, bs_a, &error_abort);
352
353 blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
354 bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
355 &error_abort);
356 b_s = bs_b->opaque;
357 blk_insert_bs(blk_b, bs_b, &error_abort);
358
359 backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
360 backing_s = backing->opaque;
361 bdrv_set_backing_hd(bs_a, backing, &error_abort);
362 bdrv_set_backing_hd(bs_b, backing, &error_abort);
363
364 g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
365 g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
366 g_assert_cmpint(backing->quiesce_counter, ==, 0);
367 g_assert_cmpint(a_s->drain_count, ==, 0);
368 g_assert_cmpint(b_s->drain_count, ==, 0);
369 g_assert_cmpint(backing_s->drain_count, ==, 0);
370
371 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
372
373 g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
374 g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
375 g_assert_cmpint(backing->quiesce_counter, ==, 1);
376 g_assert_cmpint(a_s->drain_count, ==, 1);
377 g_assert_cmpint(b_s->drain_count, ==, 1);
378 g_assert_cmpint(backing_s->drain_count, ==, 1);
379
380 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
381
382 g_assert_cmpint(bs_a->quiesce_counter, ==, 2);
383 g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
384 g_assert_cmpint(backing->quiesce_counter, ==, 2);
385 g_assert_cmpint(a_s->drain_count, ==, 2);
386 g_assert_cmpint(b_s->drain_count, ==, 2);
387 g_assert_cmpint(backing_s->drain_count, ==, 2);
388
389 do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
390
391 g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
392 g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
393 g_assert_cmpint(backing->quiesce_counter, ==, 1);
394 g_assert_cmpint(a_s->drain_count, ==, 1);
395 g_assert_cmpint(b_s->drain_count, ==, 1);
396 g_assert_cmpint(backing_s->drain_count, ==, 1);
397
398 do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
399
400 g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
401 g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
402 g_assert_cmpint(backing->quiesce_counter, ==, 0);
403 g_assert_cmpint(a_s->drain_count, ==, 0);
404 g_assert_cmpint(b_s->drain_count, ==, 0);
405 g_assert_cmpint(backing_s->drain_count, ==, 0);
406
407 bdrv_unref(backing);
408 bdrv_unref(bs_a);
409 bdrv_unref(bs_b);
410 blk_unref(blk_a);
411 blk_unref(blk_b);
412}
413
acebcf8d
KW		 414static void test_graph_change(void)
415{
416 BlockBackend *blk_a, *blk_b;
417 BlockDriverState *bs_a, *bs_b, *backing;
418 BDRVTestState *a_s, *b_s, *backing_s;
419
420 blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
421 bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
422 &error_abort);
423 a_s = bs_a->opaque;
424 blk_insert_bs(blk_a, bs_a, &error_abort);
425
426 blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
427 bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
428 &error_abort);
429 b_s = bs_b->opaque;
430 blk_insert_bs(blk_b, bs_b, &error_abort);
431
432 backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
433 backing_s = backing->opaque;
434 bdrv_set_backing_hd(bs_a, backing, &error_abort);
435
436 g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
437 g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
438 g_assert_cmpint(backing->quiesce_counter, ==, 0);
439 g_assert_cmpint(a_s->drain_count, ==, 0);
440 g_assert_cmpint(b_s->drain_count, ==, 0);
441 g_assert_cmpint(backing_s->drain_count, ==, 0);
442
443 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
444 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
445 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
446 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
447 do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
448
449 bdrv_set_backing_hd(bs_b, backing, &error_abort);
450 g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
451 g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
452 g_assert_cmpint(backing->quiesce_counter, ==, 5);
453 g_assert_cmpint(a_s->drain_count, ==, 5);
454 g_assert_cmpint(b_s->drain_count, ==, 5);
455 g_assert_cmpint(backing_s->drain_count, ==, 5);
456
457 bdrv_set_backing_hd(bs_b, NULL, &error_abort);
458 g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
459 g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
460 g_assert_cmpint(backing->quiesce_counter, ==, 3);
461 g_assert_cmpint(a_s->drain_count, ==, 3);
462 g_assert_cmpint(b_s->drain_count, ==, 2);
463 g_assert_cmpint(backing_s->drain_count, ==, 3);
464
465 bdrv_set_backing_hd(bs_b, backing, &error_abort);
466 g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
467 g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
468 g_assert_cmpint(backing->quiesce_counter, ==, 5);
469 g_assert_cmpint(a_s->drain_count, ==, 5);
470 g_assert_cmpint(b_s->drain_count, ==, 5);
471 g_assert_cmpint(backing_s->drain_count, ==, 5);
472
473 do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
474 do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
475 do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
476 do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
477 do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
478
479 g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
480 g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
481 g_assert_cmpint(backing->quiesce_counter, ==, 0);
482 g_assert_cmpint(a_s->drain_count, ==, 0);
483 g_assert_cmpint(b_s->drain_count, ==, 0);
484 g_assert_cmpint(backing_s->drain_count, ==, 0);
485
486 bdrv_unref(backing);
487 bdrv_unref(bs_a);
488 bdrv_unref(bs_b);
489 blk_unref(blk_a);
490 blk_unref(blk_b);
491}
492
7253220d
KW		 493
494typedef struct TestBlockJob {
495 BlockJob common;
496 bool should_complete;
497} TestBlockJob;
498
1908a559 499static void test_job_completed(Job *job, void *opaque)
7253220d 500{
1266c9b9 501 job_completed(job, 0, NULL);
7253220d
KW		 502}
503
504static void coroutine_fn test_job_start(void *opaque)
505{
506 TestBlockJob *s = opaque;
507
2e1795b5 508 job_transition_to_ready(&s->common.job);
7253220d 509 while (!s->should_complete) {
5d43e86e 510 job_sleep_ns(&s->common.job, 100000);
7253220d
KW		 511 }
512
1908a559 513 job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
7253220d
KW		 514}
515
3453d972 516static void test_job_complete(Job *job, Error **errp)
7253220d 517{
3453d972 518 TestBlockJob *s = container_of(job, TestBlockJob, common.job);
7253220d
KW		 519 s->should_complete = true;
520}
521
522BlockJobDriver test_job_driver = {
33e9e9bd
KW		 523 .job_driver = {
524 .instance_size = sizeof(TestBlockJob),
80fa2c75 525 .free = block_job_free,
b15de828 526 .user_resume = block_job_user_resume,
b69f777d 527 .drain = block_job_drain,
da01ff7f 528 .start = test_job_start,
3453d972 529 .complete = test_job_complete,
33e9e9bd 530 },
7253220d
KW		 531};
532
533static void test_blockjob_common(enum drain_type drain_type)
534{
535 BlockBackend *blk_src, *blk_target;
536 BlockDriverState *src, *target;
537 BlockJob *job;
538 int ret;
539
540 src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
541 &error_abort);
542 blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
543 blk_insert_bs(blk_src, src, &error_abort);
544
545 target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
546 &error_abort);
547 blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
548 blk_insert_bs(blk_target, target, &error_abort);
549
75859b94
JS		 550 job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
551 0, 0, NULL, NULL, &error_abort);
7253220d 552 block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
da01ff7f 553 job_start(&job->job);
7253220d 554
da01ff7f
KW		 555 g_assert_cmpint(job->job.pause_count, ==, 0);
556 g_assert_false(job->job.paused);
5d43e86e 557 g_assert_false(job->job.busy); /* We're in job_sleep_ns() */
7253220d
KW		 558
559 do_drain_begin(drain_type, src);
560
561 if (drain_type == BDRV_DRAIN_ALL) {
81193349 562 /* bdrv_drain_all() drains both src and target */
da01ff7f 563 g_assert_cmpint(job->job.pause_count, ==, 2);
7253220d 564 } else {
da01ff7f 565 g_assert_cmpint(job->job.pause_count, ==, 1);
7253220d
KW		 566 }
567 /* XXX We don't wait until the job is actually paused. Is this okay? */
da01ff7f
KW		 568 /* g_assert_true(job->job.paused); */
569 g_assert_false(job->job.busy); /* The job is paused */
7253220d
KW		 570
571 do_drain_end(drain_type, src);
572
da01ff7f
KW		 573 g_assert_cmpint(job->job.pause_count, ==, 0);
574 g_assert_false(job->job.paused);
5d43e86e 575 g_assert_false(job->job.busy); /* We're in job_sleep_ns() */
7253220d
KW		 576
577 do_drain_begin(drain_type, target);
578
579 if (drain_type == BDRV_DRAIN_ALL) {
81193349 580 /* bdrv_drain_all() drains both src and target */
da01ff7f 581 g_assert_cmpint(job->job.pause_count, ==, 2);
7253220d 582 } else {
da01ff7f 583 g_assert_cmpint(job->job.pause_count, ==, 1);
7253220d
KW		 584 }
585 /* XXX We don't wait until the job is actually paused. Is this okay? */
da01ff7f
KW		 586 /* g_assert_true(job->job.paused); */
587 g_assert_false(job->job.busy); /* The job is paused */
7253220d
KW		 588
589 do_drain_end(drain_type, target);
590
da01ff7f
KW		 591 g_assert_cmpint(job->job.pause_count, ==, 0);
592 g_assert_false(job->job.paused);
5d43e86e 593 g_assert_false(job->job.busy); /* We're in job_sleep_ns() */
7253220d 594
3d70ff53 595 ret = job_complete_sync(&job->job, &error_abort);
7253220d
KW		 596 g_assert_cmpint(ret, ==, 0);
597
598 blk_unref(blk_src);
599 blk_unref(blk_target);
600 bdrv_unref(src);
601 bdrv_unref(target);
602}
603
604static void test_blockjob_drain_all(void)
605{
606 test_blockjob_common(BDRV_DRAIN_ALL);
607}
608
609static void test_blockjob_drain(void)
610{
611 test_blockjob_common(BDRV_DRAIN);
612}
613
d2a85d0f
KW		 614static void test_blockjob_drain_subtree(void)
615{
616 test_blockjob_common(BDRV_SUBTREE_DRAIN);
617}
618
881cfd17
KW		 619int main(int argc, char **argv)
620{
621 bdrv_init();
622 qemu_init_main_loop(&error_abort);
623
624 g_test_init(&argc, &argv, NULL);
625
626 g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
86e1c840 627 g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
d2a85d0f
KW		 628 g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
629 test_drv_cb_drain_subtree);
881cfd17 630
0582eb10
KW		 631 // XXX bdrv_drain_all() doesn't work in coroutine context
632 g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
633 g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
634 test_drv_cb_co_drain_subtree);
635
636
89a6ceab
KW		 637 g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
638 g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
d2a85d0f
KW		 639 g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
640 test_quiesce_drain_subtree);
89a6ceab 641
0582eb10
KW		 642 // XXX bdrv_drain_all() doesn't work in coroutine context
643 g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
644 g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
645 test_quiesce_co_drain_subtree);
646
6c429a6a 647 g_test_add_func("/bdrv-drain/nested", test_nested);
27e64474 648 g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
acebcf8d 649 g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
6c429a6a 650
7253220d
KW		 651 g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
652 g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
d2a85d0f
KW		 653 g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
654 test_blockjob_drain_subtree);
7253220d 655
881cfd17
KW		 656 return g_test_run();
657}
QEMU mirror