]> Git Repo - qemu.git/blame - tests/test-bdrv-drain.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
blockjob: Improve BlockJobInfo.offset/len documentation
[qemu.git] / tests / test-bdrv-drain.c
CommitLineData
881cfd17
KW		 1/*
2 * Block node draining tests
3 *
4 * Copyright (c) 2017 Kevin Wolf <[email protected]>
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
499static void test_job_completed(BlockJob *job, void *opaque)
500{
501 block_job_completed(job, 0);
502}
503
504static void coroutine_fn test_job_start(void *opaque)
505{
506 TestBlockJob *s = opaque;
507
0ec4dfb8 508 block_job_event_ready(&s->common);
7253220d
KW		 509 while (!s->should_complete) {
510 block_job_sleep_ns(&s->common, 100000);
511 }
512
513 block_job_defer_to_main_loop(&s->common, test_job_completed, NULL);
514}
515
516static void test_job_complete(BlockJob *job, Error **errp)
517{
518 TestBlockJob *s = container_of(job, TestBlockJob, common);
519 s->should_complete = true;
520}
521
522BlockJobDriver test_job_driver = {
523 .instance_size = sizeof(TestBlockJob),
524 .start = test_job_start,
525 .complete = test_job_complete,
526};
527
528static void test_blockjob_common(enum drain_type drain_type)
529{
530 BlockBackend *blk_src, *blk_target;
531 BlockDriverState *src, *target;
532 BlockJob *job;
533 int ret;
534
535 src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
536 &error_abort);
537 blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
538 blk_insert_bs(blk_src, src, &error_abort);
539
540 target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
541 &error_abort);
542 blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
543 blk_insert_bs(blk_target, target, &error_abort);
544
75859b94
JS		 545 job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
546 0, 0, NULL, NULL, &error_abort);
7253220d
KW		 547 block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
548 block_job_start(job);
549
550 g_assert_cmpint(job->pause_count, ==, 0);
551 g_assert_false(job->paused);
552 g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
553
554 do_drain_begin(drain_type, src);
555
556 if (drain_type == BDRV_DRAIN_ALL) {
81193349
KW		 557 /* bdrv_drain_all() drains both src and target */
558 g_assert_cmpint(job->pause_count, ==, 2);
7253220d
KW		 559 } else {
560 g_assert_cmpint(job->pause_count, ==, 1);
561 }
562 /* XXX We don't wait until the job is actually paused. Is this okay? */
563 /* g_assert_true(job->paused); */
564 g_assert_false(job->busy); /* The job is paused */
565
566 do_drain_end(drain_type, src);
567
568 g_assert_cmpint(job->pause_count, ==, 0);
569 g_assert_false(job->paused);
570 g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
571
572 do_drain_begin(drain_type, target);
573
574 if (drain_type == BDRV_DRAIN_ALL) {
81193349
KW		 575 /* bdrv_drain_all() drains both src and target */
576 g_assert_cmpint(job->pause_count, ==, 2);
7253220d
KW		 577 } else {
578 g_assert_cmpint(job->pause_count, ==, 1);
579 }
580 /* XXX We don't wait until the job is actually paused. Is this okay? */
581 /* g_assert_true(job->paused); */
582 g_assert_false(job->busy); /* The job is paused */
583
584 do_drain_end(drain_type, target);
585
586 g_assert_cmpint(job->pause_count, ==, 0);
587 g_assert_false(job->paused);
588 g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
589
590 ret = block_job_complete_sync(job, &error_abort);
591 g_assert_cmpint(ret, ==, 0);
592
593 blk_unref(blk_src);
594 blk_unref(blk_target);
595 bdrv_unref(src);
596 bdrv_unref(target);
597}
598
599static void test_blockjob_drain_all(void)
600{
601 test_blockjob_common(BDRV_DRAIN_ALL);
602}
603
604static void test_blockjob_drain(void)
605{
606 test_blockjob_common(BDRV_DRAIN);
607}
608
d2a85d0f
KW		 609static void test_blockjob_drain_subtree(void)
610{
611 test_blockjob_common(BDRV_SUBTREE_DRAIN);
612}
613
881cfd17
KW		 614int main(int argc, char **argv)
615{
616 bdrv_init();
617 qemu_init_main_loop(&error_abort);
618
619 g_test_init(&argc, &argv, NULL);
620
621 g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
86e1c840 622 g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
d2a85d0f
KW		 623 g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
624 test_drv_cb_drain_subtree);
881cfd17 625
0582eb10
KW		 626 // XXX bdrv_drain_all() doesn't work in coroutine context
627 g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
628 g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
629 test_drv_cb_co_drain_subtree);
630
631
89a6ceab
KW		 632 g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
633 g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
d2a85d0f
KW		 634 g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
635 test_quiesce_drain_subtree);
89a6ceab 636
0582eb10
KW		 637 // XXX bdrv_drain_all() doesn't work in coroutine context
638 g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
639 g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
640 test_quiesce_co_drain_subtree);
641
6c429a6a 642 g_test_add_func("/bdrv-drain/nested", test_nested);
27e64474 643 g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
acebcf8d 644 g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
6c429a6a 645
7253220d
KW		 646 g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
647 g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
d2a85d0f
KW		 648 g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
649 test_blockjob_drain_subtree);
7253220d 650
881cfd17
KW		 651 return g_test_run();
652}
Empty description
This page took 0.130406 seconds and 4 git commands to generate.