| /* |
| * Block node draining tests |
| * |
| * Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com> |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "block/block.h" |
| #include "block/blockjob_int.h" |
| #include "sysemu/block-backend.h" |
| #include "qapi/error.h" |
| #include "iothread.h" |
| |
| static QemuEvent done_event; |
| |
| typedef struct BDRVTestState { |
| int drain_count; |
| AioContext *bh_indirection_ctx; |
| bool sleep_in_drain_begin; |
| } BDRVTestState; |
| |
| static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs) |
| { |
| BDRVTestState *s = bs->opaque; |
| s->drain_count++; |
| if (s->sleep_in_drain_begin) { |
| qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000); |
| } |
| } |
| |
| static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs) |
| { |
| BDRVTestState *s = bs->opaque; |
| s->drain_count--; |
| } |
| |
| static void bdrv_test_close(BlockDriverState *bs) |
| { |
| BDRVTestState *s = bs->opaque; |
| g_assert_cmpint(s->drain_count, >, 0); |
| } |
| |
| static void co_reenter_bh(void *opaque) |
| { |
| aio_co_wake(opaque); |
| } |
| |
| static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs, |
| uint64_t offset, uint64_t bytes, |
| QEMUIOVector *qiov, int flags) |
| { |
| BDRVTestState *s = bs->opaque; |
| |
| /* We want this request to stay until the polling loop in drain waits for |
| * it to complete. We need to sleep a while as bdrv_drain_invoke() comes |
| * first and polls its result, too, but it shouldn't accidentally complete |
| * this request yet. */ |
| qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000); |
| |
| if (s->bh_indirection_ctx) { |
| aio_bh_schedule_oneshot(s->bh_indirection_ctx, co_reenter_bh, |
| qemu_coroutine_self()); |
| qemu_coroutine_yield(); |
| } |
| |
| return 0; |
| } |
| |
| static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c, |
| const BdrvChildRole *role, |
| BlockReopenQueue *reopen_queue, |
| uint64_t perm, uint64_t shared, |
| uint64_t *nperm, uint64_t *nshared) |
| { |
| /* bdrv_format_default_perms() accepts only these two, so disguise |
| * detach_by_driver_cb_role as one of them. */ |
| if (role != &child_file && role != &child_backing) { |
| role = &child_file; |
| } |
| |
| bdrv_format_default_perms(bs, c, role, reopen_queue, perm, shared, |
| nperm, nshared); |
| } |
| |
| static BlockDriver bdrv_test = { |
| .format_name = "test", |
| .instance_size = sizeof(BDRVTestState), |
| |
| .bdrv_close = bdrv_test_close, |
| .bdrv_co_preadv = bdrv_test_co_preadv, |
| |
| .bdrv_co_drain_begin = bdrv_test_co_drain_begin, |
| .bdrv_co_drain_end = bdrv_test_co_drain_end, |
| |
| .bdrv_child_perm = bdrv_test_child_perm, |
| }; |
| |
| static void aio_ret_cb(void *opaque, int ret) |
| { |
| int *aio_ret = opaque; |
| *aio_ret = ret; |
| } |
| |
| typedef struct CallInCoroutineData { |
| void (*entry)(void); |
| bool done; |
| } CallInCoroutineData; |
| |
| static coroutine_fn void call_in_coroutine_entry(void *opaque) |
| { |
| CallInCoroutineData *data = opaque; |
| |
| data->entry(); |
| data->done = true; |
| } |
| |
| static void call_in_coroutine(void (*entry)(void)) |
| { |
| Coroutine *co; |
| CallInCoroutineData data = { |
| .entry = entry, |
| .done = false, |
| }; |
| |
| co = qemu_coroutine_create(call_in_coroutine_entry, &data); |
| qemu_coroutine_enter(co); |
| while (!data.done) { |
| aio_poll(qemu_get_aio_context(), true); |
| } |
| } |
| |
| enum drain_type { |
| BDRV_DRAIN_ALL, |
| BDRV_DRAIN, |
| BDRV_SUBTREE_DRAIN, |
| DRAIN_TYPE_MAX, |
| }; |
| |
| static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs) |
| { |
| switch (drain_type) { |
| case BDRV_DRAIN_ALL: bdrv_drain_all_begin(); break; |
| case BDRV_DRAIN: bdrv_drained_begin(bs); break; |
| case BDRV_SUBTREE_DRAIN: bdrv_subtree_drained_begin(bs); break; |
| default: g_assert_not_reached(); |
| } |
| } |
| |
| static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs) |
| { |
| switch (drain_type) { |
| case BDRV_DRAIN_ALL: bdrv_drain_all_end(); break; |
| case BDRV_DRAIN: bdrv_drained_end(bs); break; |
| case BDRV_SUBTREE_DRAIN: bdrv_subtree_drained_end(bs); break; |
| default: g_assert_not_reached(); |
| } |
| } |
| |
| static void do_drain_begin_unlocked(enum drain_type drain_type, BlockDriverState *bs) |
| { |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_acquire(bdrv_get_aio_context(bs)); |
| } |
| do_drain_begin(drain_type, bs); |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_release(bdrv_get_aio_context(bs)); |
| } |
| } |
| |
| static void do_drain_end_unlocked(enum drain_type drain_type, BlockDriverState *bs) |
| { |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_acquire(bdrv_get_aio_context(bs)); |
| } |
| do_drain_end(drain_type, bs); |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_release(bdrv_get_aio_context(bs)); |
| } |
| } |
| |
| static void test_drv_cb_common(enum drain_type drain_type, bool recursive) |
| { |
| BlockBackend *blk; |
| BlockDriverState *bs, *backing; |
| BDRVTestState *s, *backing_s; |
| BlockAIOCB *acb; |
| int aio_ret; |
| |
| QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0); |
| |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR, |
| &error_abort); |
| s = bs->opaque; |
| blk_insert_bs(blk, bs, &error_abort); |
| |
| backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort); |
| backing_s = backing->opaque; |
| bdrv_set_backing_hd(bs, backing, &error_abort); |
| |
| /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */ |
| g_assert_cmpint(s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| do_drain_begin(drain_type, bs); |
| |
| g_assert_cmpint(s->drain_count, ==, 1); |
| g_assert_cmpint(backing_s->drain_count, ==, !!recursive); |
| |
| do_drain_end(drain_type, bs); |
| |
| g_assert_cmpint(s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| /* Now do the same while a request is pending */ |
| aio_ret = -EINPROGRESS; |
| acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret); |
| g_assert(acb != NULL); |
| g_assert_cmpint(aio_ret, ==, -EINPROGRESS); |
| |
| g_assert_cmpint(s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| do_drain_begin(drain_type, bs); |
| |
| g_assert_cmpint(aio_ret, ==, 0); |
| g_assert_cmpint(s->drain_count, ==, 1); |
| g_assert_cmpint(backing_s->drain_count, ==, !!recursive); |
| |
| do_drain_end(drain_type, bs); |
| |
| g_assert_cmpint(s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| bdrv_unref(backing); |
| bdrv_unref(bs); |
| blk_unref(blk); |
| } |
| |
| static void test_drv_cb_drain_all(void) |
| { |
| test_drv_cb_common(BDRV_DRAIN_ALL, true); |
| } |
| |
| static void test_drv_cb_drain(void) |
| { |
| test_drv_cb_common(BDRV_DRAIN, false); |
| } |
| |
| static void test_drv_cb_drain_subtree(void) |
| { |
| test_drv_cb_common(BDRV_SUBTREE_DRAIN, true); |
| } |
| |
| static void test_drv_cb_co_drain_all(void) |
| { |
| call_in_coroutine(test_drv_cb_drain_all); |
| } |
| |
| static void test_drv_cb_co_drain(void) |
| { |
| call_in_coroutine(test_drv_cb_drain); |
| } |
| |
| static void test_drv_cb_co_drain_subtree(void) |
| { |
| call_in_coroutine(test_drv_cb_drain_subtree); |
| } |
| |
| static void test_quiesce_common(enum drain_type drain_type, bool recursive) |
| { |
| BlockBackend *blk; |
| BlockDriverState *bs, *backing; |
| |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR, |
| &error_abort); |
| blk_insert_bs(blk, bs, &error_abort); |
| |
| backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort); |
| bdrv_set_backing_hd(bs, backing, &error_abort); |
| |
| g_assert_cmpint(bs->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| |
| do_drain_begin(drain_type, bs); |
| |
| g_assert_cmpint(bs->quiesce_counter, ==, 1); |
| g_assert_cmpint(backing->quiesce_counter, ==, !!recursive); |
| |
| do_drain_end(drain_type, bs); |
| |
| g_assert_cmpint(bs->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| |
| bdrv_unref(backing); |
| bdrv_unref(bs); |
| blk_unref(blk); |
| } |
| |
| static void test_quiesce_drain_all(void) |
| { |
| test_quiesce_common(BDRV_DRAIN_ALL, true); |
| } |
| |
| static void test_quiesce_drain(void) |
| { |
| test_quiesce_common(BDRV_DRAIN, false); |
| } |
| |
| static void test_quiesce_drain_subtree(void) |
| { |
| test_quiesce_common(BDRV_SUBTREE_DRAIN, true); |
| } |
| |
| static void test_quiesce_co_drain_all(void) |
| { |
| call_in_coroutine(test_quiesce_drain_all); |
| } |
| |
| static void test_quiesce_co_drain(void) |
| { |
| call_in_coroutine(test_quiesce_drain); |
| } |
| |
| static void test_quiesce_co_drain_subtree(void) |
| { |
| call_in_coroutine(test_quiesce_drain_subtree); |
| } |
| |
| static void test_nested(void) |
| { |
| BlockBackend *blk; |
| BlockDriverState *bs, *backing; |
| BDRVTestState *s, *backing_s; |
| enum drain_type outer, inner; |
| |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR, |
| &error_abort); |
| s = bs->opaque; |
| blk_insert_bs(blk, bs, &error_abort); |
| |
| backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort); |
| backing_s = backing->opaque; |
| bdrv_set_backing_hd(bs, backing, &error_abort); |
| |
| for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) { |
| for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) { |
| int backing_quiesce = (outer != BDRV_DRAIN) + |
| (inner != BDRV_DRAIN); |
| |
| g_assert_cmpint(bs->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| g_assert_cmpint(s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| do_drain_begin(outer, bs); |
| do_drain_begin(inner, bs); |
| |
| g_assert_cmpint(bs->quiesce_counter, ==, 2); |
| g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce); |
| g_assert_cmpint(s->drain_count, ==, 2); |
| g_assert_cmpint(backing_s->drain_count, ==, backing_quiesce); |
| |
| do_drain_end(inner, bs); |
| do_drain_end(outer, bs); |
| |
| g_assert_cmpint(bs->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| g_assert_cmpint(s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| } |
| } |
| |
| bdrv_unref(backing); |
| bdrv_unref(bs); |
| blk_unref(blk); |
| } |
| |
| static void test_multiparent(void) |
| { |
| BlockBackend *blk_a, *blk_b; |
| BlockDriverState *bs_a, *bs_b, *backing; |
| BDRVTestState *a_s, *b_s, *backing_s; |
| |
| blk_a = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR, |
| &error_abort); |
| a_s = bs_a->opaque; |
| blk_insert_bs(blk_a, bs_a, &error_abort); |
| |
| blk_b = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR, |
| &error_abort); |
| b_s = bs_b->opaque; |
| blk_insert_bs(blk_b, bs_b, &error_abort); |
| |
| backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort); |
| backing_s = backing->opaque; |
| bdrv_set_backing_hd(bs_a, backing, &error_abort); |
| bdrv_set_backing_hd(bs_b, backing, &error_abort); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 0); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| g_assert_cmpint(a_s->drain_count, ==, 0); |
| g_assert_cmpint(b_s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 1); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 1); |
| g_assert_cmpint(backing->quiesce_counter, ==, 1); |
| g_assert_cmpint(a_s->drain_count, ==, 1); |
| g_assert_cmpint(b_s->drain_count, ==, 1); |
| g_assert_cmpint(backing_s->drain_count, ==, 1); |
| |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 2); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 2); |
| g_assert_cmpint(backing->quiesce_counter, ==, 2); |
| g_assert_cmpint(a_s->drain_count, ==, 2); |
| g_assert_cmpint(b_s->drain_count, ==, 2); |
| g_assert_cmpint(backing_s->drain_count, ==, 2); |
| |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_b); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 1); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 1); |
| g_assert_cmpint(backing->quiesce_counter, ==, 1); |
| g_assert_cmpint(a_s->drain_count, ==, 1); |
| g_assert_cmpint(b_s->drain_count, ==, 1); |
| g_assert_cmpint(backing_s->drain_count, ==, 1); |
| |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_a); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 0); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| g_assert_cmpint(a_s->drain_count, ==, 0); |
| g_assert_cmpint(b_s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| bdrv_unref(backing); |
| bdrv_unref(bs_a); |
| bdrv_unref(bs_b); |
| blk_unref(blk_a); |
| blk_unref(blk_b); |
| } |
| |
| static void test_graph_change_drain_subtree(void) |
| { |
| BlockBackend *blk_a, *blk_b; |
| BlockDriverState *bs_a, *bs_b, *backing; |
| BDRVTestState *a_s, *b_s, *backing_s; |
| |
| blk_a = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR, |
| &error_abort); |
| a_s = bs_a->opaque; |
| blk_insert_bs(blk_a, bs_a, &error_abort); |
| |
| blk_b = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR, |
| &error_abort); |
| b_s = bs_b->opaque; |
| blk_insert_bs(blk_b, bs_b, &error_abort); |
| |
| backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort); |
| backing_s = backing->opaque; |
| bdrv_set_backing_hd(bs_a, backing, &error_abort); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 0); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| g_assert_cmpint(a_s->drain_count, ==, 0); |
| g_assert_cmpint(b_s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a); |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a); |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a); |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b); |
| do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b); |
| |
| bdrv_set_backing_hd(bs_b, backing, &error_abort); |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 5); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 5); |
| g_assert_cmpint(backing->quiesce_counter, ==, 5); |
| g_assert_cmpint(a_s->drain_count, ==, 5); |
| g_assert_cmpint(b_s->drain_count, ==, 5); |
| g_assert_cmpint(backing_s->drain_count, ==, 5); |
| |
| bdrv_set_backing_hd(bs_b, NULL, &error_abort); |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 3); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 2); |
| g_assert_cmpint(backing->quiesce_counter, ==, 3); |
| g_assert_cmpint(a_s->drain_count, ==, 3); |
| g_assert_cmpint(b_s->drain_count, ==, 2); |
| g_assert_cmpint(backing_s->drain_count, ==, 3); |
| |
| bdrv_set_backing_hd(bs_b, backing, &error_abort); |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 5); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 5); |
| g_assert_cmpint(backing->quiesce_counter, ==, 5); |
| g_assert_cmpint(a_s->drain_count, ==, 5); |
| g_assert_cmpint(b_s->drain_count, ==, 5); |
| g_assert_cmpint(backing_s->drain_count, ==, 5); |
| |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_b); |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_b); |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_a); |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_a); |
| do_drain_end(BDRV_SUBTREE_DRAIN, bs_a); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 0); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 0); |
| g_assert_cmpint(backing->quiesce_counter, ==, 0); |
| g_assert_cmpint(a_s->drain_count, ==, 0); |
| g_assert_cmpint(b_s->drain_count, ==, 0); |
| g_assert_cmpint(backing_s->drain_count, ==, 0); |
| |
| bdrv_unref(backing); |
| bdrv_unref(bs_a); |
| bdrv_unref(bs_b); |
| blk_unref(blk_a); |
| blk_unref(blk_b); |
| } |
| |
| static void test_graph_change_drain_all(void) |
| { |
| BlockBackend *blk_a, *blk_b; |
| BlockDriverState *bs_a, *bs_b; |
| BDRVTestState *a_s, *b_s; |
| |
| /* Create node A with a BlockBackend */ |
| blk_a = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR, |
| &error_abort); |
| a_s = bs_a->opaque; |
| blk_insert_bs(blk_a, bs_a, &error_abort); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 0); |
| g_assert_cmpint(a_s->drain_count, ==, 0); |
| |
| /* Call bdrv_drain_all_begin() */ |
| bdrv_drain_all_begin(); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 1); |
| g_assert_cmpint(a_s->drain_count, ==, 1); |
| |
| /* Create node B with a BlockBackend */ |
| blk_b = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR, |
| &error_abort); |
| b_s = bs_b->opaque; |
| blk_insert_bs(blk_b, bs_b, &error_abort); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 1); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 1); |
| g_assert_cmpint(a_s->drain_count, ==, 1); |
| g_assert_cmpint(b_s->drain_count, ==, 1); |
| |
| /* Unref and finally delete node A */ |
| blk_unref(blk_a); |
| |
| g_assert_cmpint(bs_a->quiesce_counter, ==, 1); |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 1); |
| g_assert_cmpint(a_s->drain_count, ==, 1); |
| g_assert_cmpint(b_s->drain_count, ==, 1); |
| |
| bdrv_unref(bs_a); |
| |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 1); |
| g_assert_cmpint(b_s->drain_count, ==, 1); |
| |
| /* End the drained section */ |
| bdrv_drain_all_end(); |
| |
| g_assert_cmpint(bs_b->quiesce_counter, ==, 0); |
| g_assert_cmpint(b_s->drain_count, ==, 0); |
| |
| bdrv_unref(bs_b); |
| blk_unref(blk_b); |
| } |
| |
| struct test_iothread_data { |
| BlockDriverState *bs; |
| enum drain_type drain_type; |
| int *aio_ret; |
| }; |
| |
| static void test_iothread_drain_entry(void *opaque) |
| { |
| struct test_iothread_data *data = opaque; |
| |
| aio_context_acquire(bdrv_get_aio_context(data->bs)); |
| do_drain_begin(data->drain_type, data->bs); |
| g_assert_cmpint(*data->aio_ret, ==, 0); |
| do_drain_end(data->drain_type, data->bs); |
| aio_context_release(bdrv_get_aio_context(data->bs)); |
| |
| qemu_event_set(&done_event); |
| } |
| |
| static void test_iothread_aio_cb(void *opaque, int ret) |
| { |
| int *aio_ret = opaque; |
| *aio_ret = ret; |
| qemu_event_set(&done_event); |
| } |
| |
| static void test_iothread_main_thread_bh(void *opaque) |
| { |
| struct test_iothread_data *data = opaque; |
| |
| /* Test that the AioContext is not yet locked in a random BH that is |
| * executed during drain, otherwise this would deadlock. */ |
| aio_context_acquire(bdrv_get_aio_context(data->bs)); |
| bdrv_flush(data->bs); |
| aio_context_release(bdrv_get_aio_context(data->bs)); |
| } |
| |
| /* |
| * Starts an AIO request on a BDS that runs in the AioContext of iothread 1. |
| * The request involves a BH on iothread 2 before it can complete. |
| * |
| * @drain_thread = 0 means that do_drain_begin/end are called from the main |
| * thread, @drain_thread = 1 means that they are called from iothread 1. Drain |
| * for this BDS cannot be called from iothread 2 because only the main thread |
| * may do cross-AioContext polling. |
| */ |
| static void test_iothread_common(enum drain_type drain_type, int drain_thread) |
| { |
| BlockBackend *blk; |
| BlockDriverState *bs; |
| BDRVTestState *s; |
| BlockAIOCB *acb; |
| int aio_ret; |
| struct test_iothread_data data; |
| |
| IOThread *a = iothread_new(); |
| IOThread *b = iothread_new(); |
| AioContext *ctx_a = iothread_get_aio_context(a); |
| AioContext *ctx_b = iothread_get_aio_context(b); |
| |
| QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0); |
| |
| /* bdrv_drain_all() may only be called from the main loop thread */ |
| if (drain_type == BDRV_DRAIN_ALL && drain_thread != 0) { |
| goto out; |
| } |
| |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR, |
| &error_abort); |
| s = bs->opaque; |
| blk_insert_bs(blk, bs, &error_abort); |
| |
| blk_set_aio_context(blk, ctx_a, &error_abort); |
| aio_context_acquire(ctx_a); |
| |
| s->bh_indirection_ctx = ctx_b; |
| |
| aio_ret = -EINPROGRESS; |
| qemu_event_reset(&done_event); |
| |
| if (drain_thread == 0) { |
| acb = blk_aio_preadv(blk, 0, &qiov, 0, test_iothread_aio_cb, &aio_ret); |
| } else { |
| acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret); |
| } |
| g_assert(acb != NULL); |
| g_assert_cmpint(aio_ret, ==, -EINPROGRESS); |
| |
| aio_context_release(ctx_a); |
| |
| data = (struct test_iothread_data) { |
| .bs = bs, |
| .drain_type = drain_type, |
| .aio_ret = &aio_ret, |
| }; |
| |
| switch (drain_thread) { |
| case 0: |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_acquire(ctx_a); |
| } |
| |
| aio_bh_schedule_oneshot(ctx_a, test_iothread_main_thread_bh, &data); |
| |
| /* The request is running on the IOThread a. Draining its block device |
| * will make sure that it has completed as far as the BDS is concerned, |
| * but the drain in this thread can continue immediately after |
| * bdrv_dec_in_flight() and aio_ret might be assigned only slightly |
| * later. */ |
| do_drain_begin(drain_type, bs); |
| g_assert_cmpint(bs->in_flight, ==, 0); |
| |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_release(ctx_a); |
| } |
| qemu_event_wait(&done_event); |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_acquire(ctx_a); |
| } |
| |
| g_assert_cmpint(aio_ret, ==, 0); |
| do_drain_end(drain_type, bs); |
| |
| if (drain_type != BDRV_DRAIN_ALL) { |
| aio_context_release(ctx_a); |
| } |
| break; |
| case 1: |
| aio_bh_schedule_oneshot(ctx_a, test_iothread_drain_entry, &data); |
| qemu_event_wait(&done_event); |
| break; |
| default: |
| g_assert_not_reached(); |
| } |
| |
| aio_context_acquire(ctx_a); |
| blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort); |
| aio_context_release(ctx_a); |
| |
| bdrv_unref(bs); |
| blk_unref(blk); |
| |
| out: |
| iothread_join(a); |
| iothread_join(b); |
| } |
| |
| static void test_iothread_drain_all(void) |
| { |
| test_iothread_common(BDRV_DRAIN_ALL, 0); |
| test_iothread_common(BDRV_DRAIN_ALL, 1); |
| } |
| |
| static void test_iothread_drain(void) |
| { |
| test_iothread_common(BDRV_DRAIN, 0); |
| test_iothread_common(BDRV_DRAIN, 1); |
| } |
| |
| static void test_iothread_drain_subtree(void) |
| { |
| test_iothread_common(BDRV_SUBTREE_DRAIN, 0); |
| test_iothread_common(BDRV_SUBTREE_DRAIN, 1); |
| } |
| |
| |
| typedef struct TestBlockJob { |
| BlockJob common; |
| int run_ret; |
| int prepare_ret; |
| bool running; |
| bool should_complete; |
| } TestBlockJob; |
| |
| static int test_job_prepare(Job *job) |
| { |
| TestBlockJob *s = container_of(job, TestBlockJob, common.job); |
| |
| /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */ |
| blk_flush(s->common.blk); |
| return s->prepare_ret; |
| } |
| |
| static void test_job_commit(Job *job) |
| { |
| TestBlockJob *s = container_of(job, TestBlockJob, common.job); |
| |
| /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */ |
| blk_flush(s->common.blk); |
| } |
| |
| static void test_job_abort(Job *job) |
| { |
| TestBlockJob *s = container_of(job, TestBlockJob, common.job); |
| |
| /* Provoke an AIO_WAIT_WHILE() call to verify there is no deadlock */ |
| blk_flush(s->common.blk); |
| } |
| |
| static int coroutine_fn test_job_run(Job *job, Error **errp) |
| { |
| TestBlockJob *s = container_of(job, TestBlockJob, common.job); |
| |
| /* We are running the actual job code past the pause point in |
| * job_co_entry(). */ |
| s->running = true; |
| |
| job_transition_to_ready(&s->common.job); |
| while (!s->should_complete) { |
| /* Avoid job_sleep_ns() because it marks the job as !busy. We want to |
| * emulate some actual activity (probably some I/O) here so that drain |
| * has to wait for this activity to stop. */ |
| qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000); |
| |
| job_pause_point(&s->common.job); |
| } |
| |
| return s->run_ret; |
| } |
| |
| static void test_job_complete(Job *job, Error **errp) |
| { |
| TestBlockJob *s = container_of(job, TestBlockJob, common.job); |
| s->should_complete = true; |
| } |
| |
| BlockJobDriver test_job_driver = { |
| .job_driver = { |
| .instance_size = sizeof(TestBlockJob), |
| .free = block_job_free, |
| .user_resume = block_job_user_resume, |
| .drain = block_job_drain, |
| .run = test_job_run, |
| .complete = test_job_complete, |
| .prepare = test_job_prepare, |
| .commit = test_job_commit, |
| .abort = test_job_abort, |
| }, |
| }; |
| |
| enum test_job_result { |
| TEST_JOB_SUCCESS, |
| TEST_JOB_FAIL_RUN, |
| TEST_JOB_FAIL_PREPARE, |
| }; |
| |
| enum test_job_drain_node { |
| TEST_JOB_DRAIN_SRC, |
| TEST_JOB_DRAIN_SRC_CHILD, |
| TEST_JOB_DRAIN_SRC_PARENT, |
| }; |
| |
| static void test_blockjob_common_drain_node(enum drain_type drain_type, |
| bool use_iothread, |
| enum test_job_result result, |
| enum test_job_drain_node drain_node) |
| { |
| BlockBackend *blk_src, *blk_target; |
| BlockDriverState *src, *src_backing, *src_overlay, *target, *drain_bs; |
| BlockJob *job; |
| TestBlockJob *tjob; |
| IOThread *iothread = NULL; |
| AioContext *ctx; |
| int ret; |
| |
| src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR, |
| &error_abort); |
| src_backing = bdrv_new_open_driver(&bdrv_test, "source-backing", |
| BDRV_O_RDWR, &error_abort); |
| src_overlay = bdrv_new_open_driver(&bdrv_test, "source-overlay", |
| BDRV_O_RDWR, &error_abort); |
| |
| bdrv_set_backing_hd(src_overlay, src, &error_abort); |
| bdrv_unref(src); |
| bdrv_set_backing_hd(src, src_backing, &error_abort); |
| bdrv_unref(src_backing); |
| |
| blk_src = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| blk_insert_bs(blk_src, src_overlay, &error_abort); |
| |
| switch (drain_node) { |
| case TEST_JOB_DRAIN_SRC: |
| drain_bs = src; |
| break; |
| case TEST_JOB_DRAIN_SRC_CHILD: |
| drain_bs = src_backing; |
| break; |
| case TEST_JOB_DRAIN_SRC_PARENT: |
| drain_bs = src_overlay; |
| break; |
| default: |
| g_assert_not_reached(); |
| } |
| |
| if (use_iothread) { |
| iothread = iothread_new(); |
| ctx = iothread_get_aio_context(iothread); |
| blk_set_aio_context(blk_src, ctx, &error_abort); |
| } else { |
| ctx = qemu_get_aio_context(); |
| } |
| |
| target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR, |
| &error_abort); |
| blk_target = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| blk_insert_bs(blk_target, target, &error_abort); |
| blk_set_allow_aio_context_change(blk_target, true); |
| |
| aio_context_acquire(ctx); |
| tjob = block_job_create("job0", &test_job_driver, NULL, src, |
| 0, BLK_PERM_ALL, |
| 0, 0, NULL, NULL, &error_abort); |
| job = &tjob->common; |
| block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort); |
| |
| switch (result) { |
| case TEST_JOB_SUCCESS: |
| break; |
| case TEST_JOB_FAIL_RUN: |
| tjob->run_ret = -EIO; |
| break; |
| case TEST_JOB_FAIL_PREPARE: |
| tjob->prepare_ret = -EIO; |
| break; |
| } |
| |
| job_start(&job->job); |
| aio_context_release(ctx); |
| |
| if (use_iothread) { |
| /* job_co_entry() is run in the I/O thread, wait for the actual job |
| * code to start (we don't want to catch the job in the pause point in |
| * job_co_entry(). */ |
| while (!tjob->running) { |
| aio_poll(qemu_get_aio_context(), false); |
| } |
| } |
| |
| g_assert_cmpint(job->job.pause_count, ==, 0); |
| g_assert_false(job->job.paused); |
| g_assert_true(tjob->running); |
| g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */ |
| |
| do_drain_begin_unlocked(drain_type, drain_bs); |
| |
| if (drain_type == BDRV_DRAIN_ALL) { |
| /* bdrv_drain_all() drains both src and target */ |
| g_assert_cmpint(job->job.pause_count, ==, 2); |
| } else { |
| g_assert_cmpint(job->job.pause_count, ==, 1); |
| } |
| g_assert_true(job->job.paused); |
| g_assert_false(job->job.busy); /* The job is paused */ |
| |
| do_drain_end_unlocked(drain_type, drain_bs); |
| |
| if (use_iothread) { |
| /* paused is reset in the I/O thread, wait for it */ |
| while (job->job.paused) { |
| aio_poll(qemu_get_aio_context(), false); |
| } |
| } |
| |
| g_assert_cmpint(job->job.pause_count, ==, 0); |
| g_assert_false(job->job.paused); |
| g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */ |
| |
| do_drain_begin_unlocked(drain_type, target); |
| |
| if (drain_type == BDRV_DRAIN_ALL) { |
| /* bdrv_drain_all() drains both src and target */ |
| g_assert_cmpint(job->job.pause_count, ==, 2); |
| } else { |
| g_assert_cmpint(job->job.pause_count, ==, 1); |
| } |
| g_assert_true(job->job.paused); |
| g_assert_false(job->job.busy); /* The job is paused */ |
| |
| do_drain_end_unlocked(drain_type, target); |
| |
| if (use_iothread) { |
| /* paused is reset in the I/O thread, wait for it */ |
| while (job->job.paused) { |
| aio_poll(qemu_get_aio_context(), false); |
| } |
| } |
| |
| g_assert_cmpint(job->job.pause_count, ==, 0); |
| g_assert_false(job->job.paused); |
| g_assert_true(job->job.busy); /* We're in qemu_co_sleep_ns() */ |
| |
| aio_context_acquire(ctx); |
| ret = job_complete_sync(&job->job, &error_abort); |
| g_assert_cmpint(ret, ==, (result == TEST_JOB_SUCCESS ? 0 : -EIO)); |
| |
| if (use_iothread) { |
| blk_set_aio_context(blk_src, qemu_get_aio_context(), &error_abort); |
| assert(blk_get_aio_context(blk_target) == qemu_get_aio_context()); |
| } |
| aio_context_release(ctx); |
| |
| blk_unref(blk_src); |
| blk_unref(blk_target); |
| bdrv_unref(src_overlay); |
| bdrv_unref(target); |
| |
| if (iothread) { |
| iothread_join(iothread); |
| } |
| } |
| |
| static void test_blockjob_common(enum drain_type drain_type, bool use_iothread, |
| enum test_job_result result) |
| { |
| test_blockjob_common_drain_node(drain_type, use_iothread, result, |
| TEST_JOB_DRAIN_SRC); |
| test_blockjob_common_drain_node(drain_type, use_iothread, result, |
| TEST_JOB_DRAIN_SRC_CHILD); |
| if (drain_type == BDRV_SUBTREE_DRAIN) { |
| test_blockjob_common_drain_node(drain_type, use_iothread, result, |
| TEST_JOB_DRAIN_SRC_PARENT); |
| } |
| } |
| |
| static void test_blockjob_drain_all(void) |
| { |
| test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_SUCCESS); |
| } |
| |
| static void test_blockjob_drain(void) |
| { |
| test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_SUCCESS); |
| } |
| |
| static void test_blockjob_drain_subtree(void) |
| { |
| test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_SUCCESS); |
| } |
| |
| static void test_blockjob_error_drain_all(void) |
| { |
| test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_FAIL_RUN); |
| test_blockjob_common(BDRV_DRAIN_ALL, false, TEST_JOB_FAIL_PREPARE); |
| } |
| |
| static void test_blockjob_error_drain(void) |
| { |
| test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_FAIL_RUN); |
| test_blockjob_common(BDRV_DRAIN, false, TEST_JOB_FAIL_PREPARE); |
| } |
| |
| static void test_blockjob_error_drain_subtree(void) |
| { |
| test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_FAIL_RUN); |
| test_blockjob_common(BDRV_SUBTREE_DRAIN, false, TEST_JOB_FAIL_PREPARE); |
| } |
| |
| static void test_blockjob_iothread_drain_all(void) |
| { |
| test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_SUCCESS); |
| } |
| |
| static void test_blockjob_iothread_drain(void) |
| { |
| test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_SUCCESS); |
| } |
| |
| static void test_blockjob_iothread_drain_subtree(void) |
| { |
| test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_SUCCESS); |
| } |
| |
| static void test_blockjob_iothread_error_drain_all(void) |
| { |
| test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_FAIL_RUN); |
| test_blockjob_common(BDRV_DRAIN_ALL, true, TEST_JOB_FAIL_PREPARE); |
| } |
| |
| static void test_blockjob_iothread_error_drain(void) |
| { |
| test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_FAIL_RUN); |
| test_blockjob_common(BDRV_DRAIN, true, TEST_JOB_FAIL_PREPARE); |
| } |
| |
| static void test_blockjob_iothread_error_drain_subtree(void) |
| { |
| test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_FAIL_RUN); |
| test_blockjob_common(BDRV_SUBTREE_DRAIN, true, TEST_JOB_FAIL_PREPARE); |
| } |
| |
| |
| typedef struct BDRVTestTopState { |
| BdrvChild *wait_child; |
| } BDRVTestTopState; |
| |
| static void bdrv_test_top_close(BlockDriverState *bs) |
| { |
| BdrvChild *c, *next_c; |
| QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) { |
| bdrv_unref_child(bs, c); |
| } |
| } |
| |
| static int coroutine_fn bdrv_test_top_co_preadv(BlockDriverState *bs, |
| uint64_t offset, uint64_t bytes, |
| QEMUIOVector *qiov, int flags) |
| { |
| BDRVTestTopState *tts = bs->opaque; |
| return bdrv_co_preadv(tts->wait_child, offset, bytes, qiov, flags); |
| } |
| |
| static BlockDriver bdrv_test_top_driver = { |
| .format_name = "test_top_driver", |
| .instance_size = sizeof(BDRVTestTopState), |
| |
| .bdrv_close = bdrv_test_top_close, |
| .bdrv_co_preadv = bdrv_test_top_co_preadv, |
| |
| .bdrv_child_perm = bdrv_format_default_perms, |
| }; |
| |
| typedef struct TestCoDeleteByDrainData { |
| BlockBackend *blk; |
| bool detach_instead_of_delete; |
| bool done; |
| } TestCoDeleteByDrainData; |
| |
| static void coroutine_fn test_co_delete_by_drain(void *opaque) |
| { |
| TestCoDeleteByDrainData *dbdd = opaque; |
| BlockBackend *blk = dbdd->blk; |
| BlockDriverState *bs = blk_bs(blk); |
| BDRVTestTopState *tts = bs->opaque; |
| void *buffer = g_malloc(65536); |
| QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buffer, 65536); |
| |
| /* Pretend some internal write operation from parent to child. |
| * Important: We have to read from the child, not from the parent! |
| * Draining works by first propagating it all up the tree to the |
| * root and then waiting for drainage from root to the leaves |
| * (protocol nodes). If we have a request waiting on the root, |
| * everything will be drained before we go back down the tree, but |
| * we do not want that. We want to be in the middle of draining |
| * when this following requests returns. */ |
| bdrv_co_preadv(tts->wait_child, 0, 65536, &qiov, 0); |
| |
| g_assert_cmpint(bs->refcnt, ==, 1); |
| |
| if (!dbdd->detach_instead_of_delete) { |
| blk_unref(blk); |
| } else { |
| BdrvChild *c, *next_c; |
| QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) { |
| bdrv_unref_child(bs, c); |
| } |
| } |
| |
| dbdd->done = true; |
| g_free(buffer); |
| } |
| |
| /** |
| * Test what happens when some BDS has some children, you drain one of |
| * them and this results in the BDS being deleted. |
| * |
| * If @detach_instead_of_delete is set, the BDS is not going to be |
| * deleted but will only detach all of its children. |
| */ |
| static void do_test_delete_by_drain(bool detach_instead_of_delete, |
| enum drain_type drain_type) |
| { |
| BlockBackend *blk; |
| BlockDriverState *bs, *child_bs, *null_bs; |
| BDRVTestTopState *tts; |
| TestCoDeleteByDrainData dbdd; |
| Coroutine *co; |
| |
| bs = bdrv_new_open_driver(&bdrv_test_top_driver, "top", BDRV_O_RDWR, |
| &error_abort); |
| bs->total_sectors = 65536 >> BDRV_SECTOR_BITS; |
| tts = bs->opaque; |
| |
| null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL, |
| &error_abort); |
| bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort); |
| |
| /* This child will be the one to pass to requests through to, and |
| * it will stall until a drain occurs */ |
| child_bs = bdrv_new_open_driver(&bdrv_test, "child", BDRV_O_RDWR, |
| &error_abort); |
| child_bs->total_sectors = 65536 >> BDRV_SECTOR_BITS; |
| /* Takes our reference to child_bs */ |
| tts->wait_child = bdrv_attach_child(bs, child_bs, "wait-child", &child_file, |
| &error_abort); |
| |
| /* This child is just there to be deleted |
| * (for detach_instead_of_delete == true) */ |
| null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL, |
| &error_abort); |
| bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort); |
| |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| blk_insert_bs(blk, bs, &error_abort); |
| |
| /* Referenced by blk now */ |
| bdrv_unref(bs); |
| |
| g_assert_cmpint(bs->refcnt, ==, 1); |
| g_assert_cmpint(child_bs->refcnt, ==, 1); |
| g_assert_cmpint(null_bs->refcnt, ==, 1); |
| |
| |
| dbdd = (TestCoDeleteByDrainData){ |
| .blk = blk, |
| .detach_instead_of_delete = detach_instead_of_delete, |
| .done = false, |
| }; |
| co = qemu_coroutine_create(test_co_delete_by_drain, &dbdd); |
| qemu_coroutine_enter(co); |
| |
| /* Drain the child while the read operation is still pending. |
| * This should result in the operation finishing and |
| * test_co_delete_by_drain() resuming. Thus, @bs will be deleted |
| * and the coroutine will exit while this drain operation is still |
| * in progress. */ |
| switch (drain_type) { |
| case BDRV_DRAIN: |
| bdrv_ref(child_bs); |
| bdrv_drain(child_bs); |
| bdrv_unref(child_bs); |
| break; |
| case BDRV_SUBTREE_DRAIN: |
| /* Would have to ref/unref bs here for !detach_instead_of_delete, but |
| * then the whole test becomes pointless because the graph changes |
| * don't occur during the drain any more. */ |
| assert(detach_instead_of_delete); |
| bdrv_subtree_drained_begin(bs); |
| bdrv_subtree_drained_end(bs); |
| break; |
| case BDRV_DRAIN_ALL: |
| bdrv_drain_all_begin(); |
| bdrv_drain_all_end(); |
| break; |
| default: |
| g_assert_not_reached(); |
| } |
| |
| while (!dbdd.done) { |
| aio_poll(qemu_get_aio_context(), true); |
| } |
| |
| if (detach_instead_of_delete) { |
| /* Here, the reference has not passed over to the coroutine, |
| * so we have to delete the BB ourselves */ |
| blk_unref(blk); |
| } |
| } |
| |
| static void test_delete_by_drain(void) |
| { |
| do_test_delete_by_drain(false, BDRV_DRAIN); |
| } |
| |
| static void test_detach_by_drain_all(void) |
| { |
| do_test_delete_by_drain(true, BDRV_DRAIN_ALL); |
| } |
| |
| static void test_detach_by_drain(void) |
| { |
| do_test_delete_by_drain(true, BDRV_DRAIN); |
| } |
| |
| static void test_detach_by_drain_subtree(void) |
| { |
| do_test_delete_by_drain(true, BDRV_SUBTREE_DRAIN); |
| } |
| |
| |
| struct detach_by_parent_data { |
| BlockDriverState *parent_b; |
| BdrvChild *child_b; |
| BlockDriverState *c; |
| BdrvChild *child_c; |
| bool by_parent_cb; |
| }; |
| static struct detach_by_parent_data detach_by_parent_data; |
| |
| static void detach_indirect_bh(void *opaque) |
| { |
| struct detach_by_parent_data *data = opaque; |
| |
| bdrv_unref_child(data->parent_b, data->child_b); |
| |
| bdrv_ref(data->c); |
| data->child_c = bdrv_attach_child(data->parent_b, data->c, "PB-C", |
| &child_file, &error_abort); |
| } |
| |
| static void detach_by_parent_aio_cb(void *opaque, int ret) |
| { |
| struct detach_by_parent_data *data = &detach_by_parent_data; |
| |
| g_assert_cmpint(ret, ==, 0); |
| if (data->by_parent_cb) { |
| detach_indirect_bh(data); |
| } |
| } |
| |
| static void detach_by_driver_cb_drained_begin(BdrvChild *child) |
| { |
| aio_bh_schedule_oneshot(qemu_get_current_aio_context(), |
| detach_indirect_bh, &detach_by_parent_data); |
| child_file.drained_begin(child); |
| } |
| |
| static BdrvChildRole detach_by_driver_cb_role; |
| |
| /* |
| * Initial graph: |
| * |
| * PA PB |
| * \ / \ |
| * A B C |
| * |
| * by_parent_cb == true: Test that parent callbacks don't poll |
| * |
| * PA has a pending write request whose callback changes the child nodes of |
| * PB: It removes B and adds C instead. The subtree of PB is drained, which |
| * will indirectly drain the write request, too. |
| * |
| * by_parent_cb == false: Test that bdrv_drain_invoke() doesn't poll |
| * |
| * PA's BdrvChildRole has a .drained_begin callback that schedules a BH |
| * that does the same graph change. If bdrv_drain_invoke() calls it, the |
| * state is messed up, but if it is only polled in the single |
| * BDRV_POLL_WHILE() at the end of the drain, this should work fine. |
| */ |
| static void test_detach_indirect(bool by_parent_cb) |
| { |
| BlockBackend *blk; |
| BlockDriverState *parent_a, *parent_b, *a, *b, *c; |
| BdrvChild *child_a, *child_b; |
| BlockAIOCB *acb; |
| |
| QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0); |
| |
| if (!by_parent_cb) { |
| detach_by_driver_cb_role = child_file; |
| detach_by_driver_cb_role.drained_begin = |
| detach_by_driver_cb_drained_begin; |
| } |
| |
| /* Create all involved nodes */ |
| parent_a = bdrv_new_open_driver(&bdrv_test, "parent-a", BDRV_O_RDWR, |
| &error_abort); |
| parent_b = bdrv_new_open_driver(&bdrv_test, "parent-b", 0, |
| &error_abort); |
| |
| a = bdrv_new_open_driver(&bdrv_test, "a", BDRV_O_RDWR, &error_abort); |
| b = bdrv_new_open_driver(&bdrv_test, "b", BDRV_O_RDWR, &error_abort); |
| c = bdrv_new_open_driver(&bdrv_test, "c", BDRV_O_RDWR, &error_abort); |
| |
| /* blk is a BB for parent-a */ |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| blk_insert_bs(blk, parent_a, &error_abort); |
| bdrv_unref(parent_a); |
| |
| /* If we want to get bdrv_drain_invoke() to call aio_poll(), the driver |
| * callback must not return immediately. */ |
| if (!by_parent_cb) { |
| BDRVTestState *s = parent_a->opaque; |
| s->sleep_in_drain_begin = true; |
| } |
| |
| /* Set child relationships */ |
| bdrv_ref(b); |
| bdrv_ref(a); |
| child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, &error_abort); |
| child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_backing, &error_abort); |
| |
| bdrv_ref(a); |
| bdrv_attach_child(parent_a, a, "PA-A", |
| by_parent_cb ? &child_file : &detach_by_driver_cb_role, |
| &error_abort); |
| |
| g_assert_cmpint(parent_a->refcnt, ==, 1); |
| g_assert_cmpint(parent_b->refcnt, ==, 1); |
| g_assert_cmpint(a->refcnt, ==, 3); |
| g_assert_cmpint(b->refcnt, ==, 2); |
| g_assert_cmpint(c->refcnt, ==, 1); |
| |
| g_assert(QLIST_FIRST(&parent_b->children) == child_a); |
| g_assert(QLIST_NEXT(child_a, next) == child_b); |
| g_assert(QLIST_NEXT(child_b, next) == NULL); |
| |
| /* Start the evil write request */ |
| detach_by_parent_data = (struct detach_by_parent_data) { |
| .parent_b = parent_b, |
| .child_b = child_b, |
| .c = c, |
| .by_parent_cb = by_parent_cb, |
| }; |
| acb = blk_aio_preadv(blk, 0, &qiov, 0, detach_by_parent_aio_cb, NULL); |
| g_assert(acb != NULL); |
| |
| /* Drain and check the expected result */ |
| bdrv_subtree_drained_begin(parent_b); |
| |
| g_assert(detach_by_parent_data.child_c != NULL); |
| |
| g_assert_cmpint(parent_a->refcnt, ==, 1); |
| g_assert_cmpint(parent_b->refcnt, ==, 1); |
| g_assert_cmpint(a->refcnt, ==, 3); |
| g_assert_cmpint(b->refcnt, ==, 1); |
| g_assert_cmpint(c->refcnt, ==, 2); |
| |
| g_assert(QLIST_FIRST(&parent_b->children) == detach_by_parent_data.child_c); |
| g_assert(QLIST_NEXT(detach_by_parent_data.child_c, next) == child_a); |
| g_assert(QLIST_NEXT(child_a, next) == NULL); |
| |
| g_assert_cmpint(parent_a->quiesce_counter, ==, 1); |
| g_assert_cmpint(parent_b->quiesce_counter, ==, 1); |
| g_assert_cmpint(a->quiesce_counter, ==, 1); |
| g_assert_cmpint(b->quiesce_counter, ==, 0); |
| g_assert_cmpint(c->quiesce_counter, ==, 1); |
| |
| bdrv_subtree_drained_end(parent_b); |
| |
| bdrv_unref(parent_b); |
| blk_unref(blk); |
| |
| g_assert_cmpint(a->refcnt, ==, 1); |
| g_assert_cmpint(b->refcnt, ==, 1); |
| g_assert_cmpint(c->refcnt, ==, 1); |
| bdrv_unref(a); |
| bdrv_unref(b); |
| bdrv_unref(c); |
| } |
| |
| static void test_detach_by_parent_cb(void) |
| { |
| test_detach_indirect(true); |
| } |
| |
| static void test_detach_by_driver_cb(void) |
| { |
| test_detach_indirect(false); |
| } |
| |
| static void test_append_to_drained(void) |
| { |
| BlockBackend *blk; |
| BlockDriverState *base, *overlay; |
| BDRVTestState *base_s, *overlay_s; |
| |
| blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL); |
| base = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort); |
| base_s = base->opaque; |
| blk_insert_bs(blk, base, &error_abort); |
| |
| overlay = bdrv_new_open_driver(&bdrv_test, "overlay", BDRV_O_RDWR, |
| &error_abort); |
| overlay_s = overlay->opaque; |
| |
| do_drain_begin(BDRV_DRAIN, base); |
| g_assert_cmpint(base->quiesce_counter, ==, 1); |
| g_assert_cmpint(base_s->drain_count, ==, 1); |
| g_assert_cmpint(base->in_flight, ==, 0); |
| |
| /* Takes ownership of overlay, so we don't have to unref it later */ |
| bdrv_append(overlay, base, &error_abort); |
| g_assert_cmpint(base->in_flight, ==, 0); |
| g_assert_cmpint(overlay->in_flight, ==, 0); |
| |
| g_assert_cmpint(base->quiesce_counter, ==, 1); |
| g_assert_cmpint(base_s->drain_count, ==, 1); |
| g_assert_cmpint(overlay->quiesce_counter, ==, 1); |
| g_assert_cmpint(overlay_s->drain_count, ==, 1); |
| |
| do_drain_end(BDRV_DRAIN, base); |
| |
| g_assert_cmpint(base->quiesce_counter, ==, 0); |
| g_assert_cmpint(base_s->drain_count, ==, 0); |
| g_assert_cmpint(overlay->quiesce_counter, ==, 0); |
| g_assert_cmpint(overlay_s->drain_count, ==, 0); |
| |
| bdrv_unref(base); |
| blk_unref(blk); |
| } |
| |
| static void test_set_aio_context(void) |
| { |
| BlockDriverState *bs; |
| IOThread *a = iothread_new(); |
| IOThread *b = iothread_new(); |
| AioContext *ctx_a = iothread_get_aio_context(a); |
| AioContext *ctx_b = iothread_get_aio_context(b); |
| |
| bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR, |
| &error_abort); |
| |
| bdrv_drained_begin(bs); |
| bdrv_try_set_aio_context(bs, ctx_a, &error_abort); |
| |
| aio_context_acquire(ctx_a); |
| bdrv_drained_end(bs); |
| |
| bdrv_drained_begin(bs); |
| bdrv_try_set_aio_context(bs, ctx_b, &error_abort); |
| aio_context_release(ctx_a); |
| aio_context_acquire(ctx_b); |
| bdrv_try_set_aio_context(bs, qemu_get_aio_context(), &error_abort); |
| aio_context_release(ctx_b); |
| bdrv_drained_end(bs); |
| |
| bdrv_unref(bs); |
| iothread_join(a); |
| iothread_join(b); |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int ret; |
| |
| bdrv_init(); |
| qemu_init_main_loop(&error_abort); |
| |
| g_test_init(&argc, &argv, NULL); |
| qemu_event_init(&done_event, false); |
| |
| g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all); |
| g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain); |
| g_test_add_func("/bdrv-drain/driver-cb/drain_subtree", |
| test_drv_cb_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/driver-cb/co/drain_all", |
| test_drv_cb_co_drain_all); |
| g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain); |
| g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree", |
| test_drv_cb_co_drain_subtree); |
| |
| |
| g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all); |
| g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain); |
| g_test_add_func("/bdrv-drain/quiesce/drain_subtree", |
| test_quiesce_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/quiesce/co/drain_all", |
| test_quiesce_co_drain_all); |
| g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain); |
| g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree", |
| test_quiesce_co_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/nested", test_nested); |
| g_test_add_func("/bdrv-drain/multiparent", test_multiparent); |
| |
| g_test_add_func("/bdrv-drain/graph-change/drain_subtree", |
| test_graph_change_drain_subtree); |
| g_test_add_func("/bdrv-drain/graph-change/drain_all", |
| test_graph_change_drain_all); |
| |
| g_test_add_func("/bdrv-drain/iothread/drain_all", test_iothread_drain_all); |
| g_test_add_func("/bdrv-drain/iothread/drain", test_iothread_drain); |
| g_test_add_func("/bdrv-drain/iothread/drain_subtree", |
| test_iothread_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all); |
| g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain); |
| g_test_add_func("/bdrv-drain/blockjob/drain_subtree", |
| test_blockjob_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/blockjob/error/drain_all", |
| test_blockjob_error_drain_all); |
| g_test_add_func("/bdrv-drain/blockjob/error/drain", |
| test_blockjob_error_drain); |
| g_test_add_func("/bdrv-drain/blockjob/error/drain_subtree", |
| test_blockjob_error_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/blockjob/iothread/drain_all", |
| test_blockjob_iothread_drain_all); |
| g_test_add_func("/bdrv-drain/blockjob/iothread/drain", |
| test_blockjob_iothread_drain); |
| g_test_add_func("/bdrv-drain/blockjob/iothread/drain_subtree", |
| test_blockjob_iothread_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_all", |
| test_blockjob_iothread_error_drain_all); |
| g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain", |
| test_blockjob_iothread_error_drain); |
| g_test_add_func("/bdrv-drain/blockjob/iothread/error/drain_subtree", |
| test_blockjob_iothread_error_drain_subtree); |
| |
| g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain); |
| g_test_add_func("/bdrv-drain/detach/drain_all", test_detach_by_drain_all); |
| g_test_add_func("/bdrv-drain/detach/drain", test_detach_by_drain); |
| g_test_add_func("/bdrv-drain/detach/drain_subtree", test_detach_by_drain_subtree); |
| g_test_add_func("/bdrv-drain/detach/parent_cb", test_detach_by_parent_cb); |
| g_test_add_func("/bdrv-drain/detach/driver_cb", test_detach_by_driver_cb); |
| |
| g_test_add_func("/bdrv-drain/attach/drain", test_append_to_drained); |
| |
| g_test_add_func("/bdrv-drain/set_aio_context", test_set_aio_context); |
| |
| ret = g_test_run(); |
| qemu_event_destroy(&done_event); |
| return ret; |
| } |
