X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=tests%2Ftest-bdrv-drain.c;h=12e2ecf517d7ad326c8a25d41a49909758b19d4f;hb=HEAD;hp=fa0e6a648b476da0fb7e9481039a893d73405395;hpb=138985c1ef8b66e4e5b383354e133e05d01d0b5f;p=mirror_qemu.git diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c deleted file mode 100644 index fa0e6a648b..0000000000 --- a/tests/test-bdrv-drain.c +++ /dev/null @@ -1,2237 +0,0 @@ -/* - * Block node draining tests - * - * Copyright (c) 2017 Kevin Wolf - * - * 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 "qemu/main-loop.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 int bdrv_test_change_backing_file(BlockDriverState *bs, - const char *backing_file, - const char *backing_fmt) -{ - return 0; -} - -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, - - .bdrv_change_backing_file = bdrv_test_change_backing_file, -}; - -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_disable_request_queuing(blk, true); - - 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, - .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); -} - - -typedef struct TestDropBackingBlockJob { - BlockJob common; - bool should_complete; - bool *did_complete; - BlockDriverState *detach_also; -} TestDropBackingBlockJob; - -static int coroutine_fn test_drop_backing_job_run(Job *job, Error **errp) -{ - TestDropBackingBlockJob *s = - container_of(job, TestDropBackingBlockJob, common.job); - - while (!s->should_complete) { - job_sleep_ns(job, 0); - } - - return 0; -} - -static void test_drop_backing_job_commit(Job *job) -{ - TestDropBackingBlockJob *s = - container_of(job, TestDropBackingBlockJob, common.job); - - bdrv_set_backing_hd(blk_bs(s->common.blk), NULL, &error_abort); - bdrv_set_backing_hd(s->detach_also, NULL, &error_abort); - - *s->did_complete = true; -} - -static const BlockJobDriver test_drop_backing_job_driver = { - .job_driver = { - .instance_size = sizeof(TestDropBackingBlockJob), - .free = block_job_free, - .user_resume = block_job_user_resume, - .run = test_drop_backing_job_run, - .commit = test_drop_backing_job_commit, - } -}; - -/** - * Creates a child node with three parent nodes on it, and then runs a - * block job on the final one, parent-node-2. - * - * The job is then asked to complete before a section where the child - * is drained. - * - * Ending this section will undrain the child's parents, first - * parent-node-2, then parent-node-1, then parent-node-0 -- the parent - * list is in reverse order of how they were added. Ending the drain - * on parent-node-2 will resume the job, thus completing it and - * scheduling job_exit(). - * - * Ending the drain on parent-node-1 will poll the AioContext, which - * lets job_exit() and thus test_drop_backing_job_commit() run. That - * function first removes the child as parent-node-2's backing file. - * - * In old (and buggy) implementations, there are two problems with - * that: - * (A) bdrv_drain_invoke() polls for every node that leaves the - * drained section. This means that job_exit() is scheduled - * before the child has left the drained section. Its - * quiesce_counter is therefore still 1 when it is removed from - * parent-node-2. - * - * (B) bdrv_replace_child_noperm() calls drained_end() on the old - * child's parents as many times as the child is quiesced. This - * means it will call drained_end() on parent-node-2 once. - * Because parent-node-2 is no longer quiesced at this point, this - * will fail. - * - * bdrv_replace_child_noperm() therefore must call drained_end() on - * the parent only if it really is still drained because the child is - * drained. - * - * If removing child from parent-node-2 was successful (as it should - * be), test_drop_backing_job_commit() will then also remove the child - * from parent-node-0. - * - * With an old version of our drain infrastructure ((A) above), that - * resulted in the following flow: - * - * 1. child attempts to leave its drained section. The call recurses - * to its parents. - * - * 2. parent-node-2 leaves the drained section. Polling in - * bdrv_drain_invoke() will schedule job_exit(). - * - * 3. parent-node-1 leaves the drained section. Polling in - * bdrv_drain_invoke() will run job_exit(), thus disconnecting - * parent-node-0 from the child node. - * - * 4. bdrv_parent_drained_end() uses a QLIST_FOREACH_SAFE() loop to - * iterate over the parents. Thus, it now accesses the BdrvChild - * object that used to connect parent-node-0 and the child node. - * However, that object no longer exists, so it accesses a dangling - * pointer. - * - * The solution is to only poll once when running a bdrv_drained_end() - * operation, specifically at the end when all drained_end() - * operations for all involved nodes have been scheduled. - * Note that this also solves (A) above, thus hiding (B). - */ -static void test_blockjob_commit_by_drained_end(void) -{ - BlockDriverState *bs_child, *bs_parents[3]; - TestDropBackingBlockJob *job; - bool job_has_completed = false; - int i; - - bs_child = bdrv_new_open_driver(&bdrv_test, "child-node", BDRV_O_RDWR, - &error_abort); - - for (i = 0; i < 3; i++) { - char name[32]; - snprintf(name, sizeof(name), "parent-node-%i", i); - bs_parents[i] = bdrv_new_open_driver(&bdrv_test, name, BDRV_O_RDWR, - &error_abort); - bdrv_set_backing_hd(bs_parents[i], bs_child, &error_abort); - } - - job = block_job_create("job", &test_drop_backing_job_driver, NULL, - bs_parents[2], 0, BLK_PERM_ALL, 0, 0, NULL, NULL, - &error_abort); - - job->detach_also = bs_parents[0]; - job->did_complete = &job_has_completed; - - job_start(&job->common.job); - - job->should_complete = true; - bdrv_drained_begin(bs_child); - g_assert(!job_has_completed); - bdrv_drained_end(bs_child); - g_assert(job_has_completed); - - bdrv_unref(bs_parents[0]); - bdrv_unref(bs_parents[1]); - bdrv_unref(bs_parents[2]); - bdrv_unref(bs_child); -} - - -typedef struct TestSimpleBlockJob { - BlockJob common; - bool should_complete; - bool *did_complete; -} TestSimpleBlockJob; - -static int coroutine_fn test_simple_job_run(Job *job, Error **errp) -{ - TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job); - - while (!s->should_complete) { - job_sleep_ns(job, 0); - } - - return 0; -} - -static void test_simple_job_clean(Job *job) -{ - TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job); - *s->did_complete = true; -} - -static const BlockJobDriver test_simple_job_driver = { - .job_driver = { - .instance_size = sizeof(TestSimpleBlockJob), - .free = block_job_free, - .user_resume = block_job_user_resume, - .run = test_simple_job_run, - .clean = test_simple_job_clean, - }, -}; - -static int drop_intermediate_poll_update_filename(BdrvChild *child, - BlockDriverState *new_base, - const char *filename, - Error **errp) -{ - /* - * We are free to poll here, which may change the block graph, if - * it is not drained. - */ - - /* If the job is not drained: Complete it, schedule job_exit() */ - aio_poll(qemu_get_current_aio_context(), false); - /* If the job is not drained: Run job_exit(), finish the job */ - aio_poll(qemu_get_current_aio_context(), false); - - return 0; -} - -/** - * Test a poll in the midst of bdrv_drop_intermediate(). - * - * bdrv_drop_intermediate() calls BdrvChildRole.update_filename(), - * which can yield or poll. This may lead to graph changes, unless - * the whole subtree in question is drained. - * - * We test this on the following graph: - * - * Job - * - * | - * job-node - * | - * v - * - * job-node - * - * | - * backing - * | - * v - * - * node-2 --chain--> node-1 --chain--> node-0 - * - * We drop node-1 with bdrv_drop_intermediate(top=node-1, base=node-0). - * - * This first updates node-2's backing filename by invoking - * drop_intermediate_poll_update_filename(), which polls twice. This - * causes the job to finish, which in turns causes the job-node to be - * deleted. - * - * bdrv_drop_intermediate() uses a QLIST_FOREACH_SAFE() loop, so it - * already has a pointer to the BdrvChild edge between job-node and - * node-1. When it tries to handle that edge, we probably get a - * segmentation fault because the object no longer exists. - * - * - * The solution is for bdrv_drop_intermediate() to drain top's - * subtree. This prevents graph changes from happening just because - * BdrvChildRole.update_filename() yields or polls. Thus, the block - * job is paused during that drained section and must finish before or - * after. - * - * (In addition, bdrv_replace_child() must keep the job paused.) - */ -static void test_drop_intermediate_poll(void) -{ - static BdrvChildRole chain_child_role; - BlockDriverState *chain[3]; - TestSimpleBlockJob *job; - BlockDriverState *job_node; - bool job_has_completed = false; - int i; - int ret; - - chain_child_role = child_backing; - chain_child_role.update_filename = drop_intermediate_poll_update_filename; - - for (i = 0; i < 3; i++) { - char name[32]; - snprintf(name, 32, "node-%i", i); - - chain[i] = bdrv_new_open_driver(&bdrv_test, name, 0, &error_abort); - } - - job_node = bdrv_new_open_driver(&bdrv_test, "job-node", BDRV_O_RDWR, - &error_abort); - bdrv_set_backing_hd(job_node, chain[1], &error_abort); - - /* - * Establish the chain last, so the chain links are the first - * elements in the BDS.parents lists - */ - for (i = 0; i < 3; i++) { - if (i) { - /* Takes the reference to chain[i - 1] */ - chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1], - "chain", &chain_child_role, - &error_abort); - } - } - - job = block_job_create("job", &test_simple_job_driver, NULL, job_node, - 0, BLK_PERM_ALL, 0, 0, NULL, NULL, &error_abort); - - /* The job has a reference now */ - bdrv_unref(job_node); - - job->did_complete = &job_has_completed; - - job_start(&job->common.job); - job->should_complete = true; - - g_assert(!job_has_completed); - ret = bdrv_drop_intermediate(chain[1], chain[0], NULL); - g_assert(ret == 0); - g_assert(job_has_completed); - - bdrv_unref(chain[2]); -} - - -typedef struct BDRVReplaceTestState { - bool was_drained; - bool was_undrained; - bool has_read; - - int drain_count; - - bool yield_before_read; - Coroutine *io_co; - Coroutine *drain_co; -} BDRVReplaceTestState; - -static void bdrv_replace_test_close(BlockDriverState *bs) -{ -} - -/** - * If @bs has a backing file: - * Yield if .yield_before_read is true (and wait for drain_begin to - * wake us up). - * Forward the read to bs->backing. Set .has_read to true. - * If drain_begin has woken us, wake it in turn. - * - * Otherwise: - * Set .has_read to true and return success. - */ -static int coroutine_fn bdrv_replace_test_co_preadv(BlockDriverState *bs, - uint64_t offset, - uint64_t bytes, - QEMUIOVector *qiov, - int flags) -{ - BDRVReplaceTestState *s = bs->opaque; - - if (bs->backing) { - int ret; - - g_assert(!s->drain_count); - - s->io_co = qemu_coroutine_self(); - if (s->yield_before_read) { - s->yield_before_read = false; - qemu_coroutine_yield(); - } - s->io_co = NULL; - - ret = bdrv_preadv(bs->backing, offset, qiov); - s->has_read = true; - - /* Wake up drain_co if it runs */ - if (s->drain_co) { - aio_co_wake(s->drain_co); - } - - return ret; - } - - s->has_read = true; - return 0; -} - -/** - * If .drain_count is 0, wake up .io_co if there is one; and set - * .was_drained. - * Increment .drain_count. - */ -static void coroutine_fn bdrv_replace_test_co_drain_begin(BlockDriverState *bs) -{ - BDRVReplaceTestState *s = bs->opaque; - - if (!s->drain_count) { - /* Keep waking io_co up until it is done */ - s->drain_co = qemu_coroutine_self(); - while (s->io_co) { - aio_co_wake(s->io_co); - s->io_co = NULL; - qemu_coroutine_yield(); - } - s->drain_co = NULL; - - s->was_drained = true; - } - s->drain_count++; -} - -/** - * Reduce .drain_count, set .was_undrained once it reaches 0. - * If .drain_count reaches 0 and the node has a backing file, issue a - * read request. - */ -static void coroutine_fn bdrv_replace_test_co_drain_end(BlockDriverState *bs) -{ - BDRVReplaceTestState *s = bs->opaque; - - g_assert(s->drain_count > 0); - if (!--s->drain_count) { - int ret; - - s->was_undrained = true; - - if (bs->backing) { - char data; - QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, &data, 1); - - /* Queue a read request post-drain */ - ret = bdrv_replace_test_co_preadv(bs, 0, 1, &qiov, 0); - g_assert(ret >= 0); - } - } -} - -static BlockDriver bdrv_replace_test = { - .format_name = "replace_test", - .instance_size = sizeof(BDRVReplaceTestState), - - .bdrv_close = bdrv_replace_test_close, - .bdrv_co_preadv = bdrv_replace_test_co_preadv, - - .bdrv_co_drain_begin = bdrv_replace_test_co_drain_begin, - .bdrv_co_drain_end = bdrv_replace_test_co_drain_end, - - .bdrv_child_perm = bdrv_format_default_perms, -}; - -static void coroutine_fn test_replace_child_mid_drain_read_co(void *opaque) -{ - int ret; - char data; - - ret = blk_co_pread(opaque, 0, 1, &data, 0); - g_assert(ret >= 0); -} - -/** - * We test two things: - * (1) bdrv_replace_child_noperm() must not undrain the parent if both - * children are drained. - * (2) bdrv_replace_child_noperm() must never flush I/O requests to a - * drained child. If the old child is drained, it must flush I/O - * requests after the new one has been attached. If the new child - * is drained, it must flush I/O requests before the old one is - * detached. - * - * To do so, we create one parent node and two child nodes; then - * attach one of the children (old_child_bs) to the parent, then - * drain both old_child_bs and new_child_bs according to - * old_drain_count and new_drain_count, respectively, and finally - * we invoke bdrv_replace_node() to replace old_child_bs by - * new_child_bs. - * - * The test block driver we use here (bdrv_replace_test) has a read - * function that: - * - For the parent node, can optionally yield, and then forwards the - * read to bdrv_preadv(), - * - For the child node, just returns immediately. - * - * If the read yields, the drain_begin function will wake it up. - * - * The drain_end function issues a read on the parent once it is fully - * undrained (which simulates requests starting to come in again). - */ -static void do_test_replace_child_mid_drain(int old_drain_count, - int new_drain_count) -{ - BlockBackend *parent_blk; - BlockDriverState *parent_bs; - BlockDriverState *old_child_bs, *new_child_bs; - BDRVReplaceTestState *parent_s; - BDRVReplaceTestState *old_child_s, *new_child_s; - Coroutine *io_co; - int i; - - parent_bs = bdrv_new_open_driver(&bdrv_replace_test, "parent", 0, - &error_abort); - parent_s = parent_bs->opaque; - - parent_blk = blk_new(qemu_get_aio_context(), - BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL); - blk_insert_bs(parent_blk, parent_bs, &error_abort); - - old_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "old-child", 0, - &error_abort); - new_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "new-child", 0, - &error_abort); - old_child_s = old_child_bs->opaque; - new_child_s = new_child_bs->opaque; - - /* So that we can read something */ - parent_bs->total_sectors = 1; - old_child_bs->total_sectors = 1; - new_child_bs->total_sectors = 1; - - bdrv_ref(old_child_bs); - parent_bs->backing = bdrv_attach_child(parent_bs, old_child_bs, "child", - &child_backing, &error_abort); - - for (i = 0; i < old_drain_count; i++) { - bdrv_drained_begin(old_child_bs); - } - for (i = 0; i < new_drain_count; i++) { - bdrv_drained_begin(new_child_bs); - } - - if (!old_drain_count) { - /* - * Start a read operation that will yield, so it will not - * complete before the node is drained. - */ - parent_s->yield_before_read = true; - io_co = qemu_coroutine_create(test_replace_child_mid_drain_read_co, - parent_blk); - qemu_coroutine_enter(io_co); - } - - /* If we have started a read operation, it should have yielded */ - g_assert(!parent_s->has_read); - - /* Reset drained status so we can see what bdrv_replace_node() does */ - parent_s->was_drained = false; - parent_s->was_undrained = false; - - g_assert(parent_bs->quiesce_counter == old_drain_count); - bdrv_replace_node(old_child_bs, new_child_bs, &error_abort); - g_assert(parent_bs->quiesce_counter == new_drain_count); - - if (!old_drain_count && !new_drain_count) { - /* - * From undrained to undrained drains and undrains the parent, - * because bdrv_replace_node() contains a drained section for - * @old_child_bs. - */ - g_assert(parent_s->was_drained && parent_s->was_undrained); - } else if (!old_drain_count && new_drain_count) { - /* - * From undrained to drained should drain the parent and keep - * it that way. - */ - g_assert(parent_s->was_drained && !parent_s->was_undrained); - } else if (old_drain_count && !new_drain_count) { - /* - * From drained to undrained should undrain the parent and - * keep it that way. - */ - g_assert(!parent_s->was_drained && parent_s->was_undrained); - } else /* if (old_drain_count && new_drain_count) */ { - /* - * From drained to drained must not undrain the parent at any - * point - */ - g_assert(!parent_s->was_drained && !parent_s->was_undrained); - } - - if (!old_drain_count || !new_drain_count) { - /* - * If !old_drain_count, we have started a read request before - * bdrv_replace_node(). If !new_drain_count, the parent must - * have been undrained at some point, and - * bdrv_replace_test_co_drain_end() starts a read request - * then. - */ - g_assert(parent_s->has_read); - } else { - /* - * If the parent was never undrained, there is no way to start - * a read request. - */ - g_assert(!parent_s->has_read); - } - - /* A drained child must have not received any request */ - g_assert(!(old_drain_count && old_child_s->has_read)); - g_assert(!(new_drain_count && new_child_s->has_read)); - - for (i = 0; i < new_drain_count; i++) { - bdrv_drained_end(new_child_bs); - } - for (i = 0; i < old_drain_count; i++) { - bdrv_drained_end(old_child_bs); - } - - /* - * By now, bdrv_replace_test_co_drain_end() must have been called - * at some point while the new child was attached to the parent. - */ - g_assert(parent_s->has_read); - g_assert(new_child_s->has_read); - - blk_unref(parent_blk); - bdrv_unref(parent_bs); - bdrv_unref(old_child_bs); - bdrv_unref(new_child_bs); -} - -static void test_replace_child_mid_drain(void) -{ - int old_drain_count, new_drain_count; - - for (old_drain_count = 0; old_drain_count < 2; old_drain_count++) { - for (new_drain_count = 0; new_drain_count < 2; new_drain_count++) { - do_test_replace_child_mid_drain(old_drain_count, new_drain_count); - } - } -} - -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); - - g_test_add_func("/bdrv-drain/blockjob/commit_by_drained_end", - test_blockjob_commit_by_drained_end); - - g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll", - test_drop_intermediate_poll); - - g_test_add_func("/bdrv-drain/replace_child/mid-drain", - test_replace_child_mid_drain); - - ret = g_test_run(); - qemu_event_destroy(&done_event); - return ret; -}