[mirror_qemu.git] / tests / test-bdrv-drain.c

/*
 * 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"

typedef struct BDRVTestState {
    int drain_count;
} BDRVTestState;

static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
{
    BDRVTestState *s = bs->opaque;
    s->drain_count++;
}

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 int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
                                            uint64_t offset, uint64_t bytes,
                                            QEMUIOVector *qiov, int flags)
{
    /* 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);

    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_format_default_perms,
};

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 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;
    struct iovec iov = {
        .iov_base = NULL,
        .iov_len = 0,
    };
    qemu_iovec_init_external(&qiov, &iov, 1);

    blk = blk_new(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(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(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)
{
    // XXX drain_all doesn't quiesce
    //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(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(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++) {
            /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
            int bs_quiesce      = (outer != BDRV_DRAIN_ALL) +
                                  (inner != BDRV_DRAIN_ALL);
            int backing_quiesce = (outer == BDRV_SUBTREE_DRAIN) +
                                  (inner == BDRV_SUBTREE_DRAIN);
            int backing_cb_cnt  = (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, ==, bs_quiesce);
            g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
            g_assert_cmpint(s->drain_count, ==, 2);
            g_assert_cmpint(backing_s->drain_count, ==, backing_cb_cnt);

            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);
}


typedef struct TestBlockJob {
    BlockJob common;
    bool should_complete;
} TestBlockJob;

static void test_job_completed(BlockJob *job, void *opaque)
{
    block_job_completed(job, 0);
}

static void coroutine_fn test_job_start(void *opaque)
{
    TestBlockJob *s = opaque;

    while (!s->should_complete) {
        block_job_sleep_ns(&s->common, 100000);
    }

    block_job_defer_to_main_loop(&s->common, test_job_completed, NULL);
}

static void test_job_complete(BlockJob *job, Error **errp)
{
    TestBlockJob *s = container_of(job, TestBlockJob, common);
    s->should_complete = true;
}

BlockJobDriver test_job_driver = {
    .instance_size  = sizeof(TestBlockJob),
    .start          = test_job_start,
    .complete       = test_job_complete,
};

static void test_blockjob_common(enum drain_type drain_type)
{
    BlockBackend *blk_src, *blk_target;
    BlockDriverState *src, *target;
    BlockJob *job;
    int ret;

    src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
                               &error_abort);
    blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
    blk_insert_bs(blk_src, src, &error_abort);

    target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
                                  &error_abort);
    blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
    blk_insert_bs(blk_target, target, &error_abort);

    job = block_job_create("job0", &test_job_driver, src, 0, BLK_PERM_ALL, 0,
                           0, NULL, NULL, &error_abort);
    block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
    block_job_start(job);

    g_assert_cmpint(job->pause_count, ==, 0);
    g_assert_false(job->paused);
    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */

    do_drain_begin(drain_type, src);

    if (drain_type == BDRV_DRAIN_ALL) {
        /* bdrv_drain_all() drains both src and target */
        g_assert_cmpint(job->pause_count, ==, 2);
    } else {
        g_assert_cmpint(job->pause_count, ==, 1);
    }
    /* XXX We don't wait until the job is actually paused. Is this okay? */
    /* g_assert_true(job->paused); */
    g_assert_false(job->busy); /* The job is paused */

    do_drain_end(drain_type, src);

    g_assert_cmpint(job->pause_count, ==, 0);
    g_assert_false(job->paused);
    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */

    do_drain_begin(drain_type, target);

    if (drain_type == BDRV_DRAIN_ALL) {
        /* bdrv_drain_all() drains both src and target */
        g_assert_cmpint(job->pause_count, ==, 2);
    } else {
        g_assert_cmpint(job->pause_count, ==, 1);
    }
    /* XXX We don't wait until the job is actually paused. Is this okay? */
    /* g_assert_true(job->paused); */
    g_assert_false(job->busy); /* The job is paused */

    do_drain_end(drain_type, target);

    g_assert_cmpint(job->pause_count, ==, 0);
    g_assert_false(job->paused);
    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */

    ret = block_job_complete_sync(job, &error_abort);
    g_assert_cmpint(ret, ==, 0);

    blk_unref(blk_src);
    blk_unref(blk_target);
    bdrv_unref(src);
    bdrv_unref(target);
}

static void test_blockjob_drain_all(void)
{
    test_blockjob_common(BDRV_DRAIN_ALL);
}

static void test_blockjob_drain(void)
{
    test_blockjob_common(BDRV_DRAIN);
}

static void test_blockjob_drain_subtree(void)
{
    test_blockjob_common(BDRV_SUBTREE_DRAIN);
}

int main(int argc, char **argv)
{
    bdrv_init();
    qemu_init_main_loop(&error_abort);

    g_test_init(&argc, &argv, NULL);

    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);

    // XXX bdrv_drain_all() doesn't work in coroutine context
    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);

    // XXX bdrv_drain_all() doesn't work in coroutine context
    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/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);

    return g_test_run();
}
Commit	Line	Data
881cfd17 KW	1	/*
	2	* Block node draining tests
	3	*
	4	* Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com>
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25	#include "qemu/osdep.h"
	26	#include "block/block.h"
7253220d	27	#include "block/blockjob_int.h"
881cfd17 KW	28	#include "sysemu/block-backend.h"
	29	#include "qapi/error.h"
	30
	31	typedef struct BDRVTestState {
	32	int drain_count;
	33	} BDRVTestState;
	34
	35	static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
	36	{
	37	BDRVTestState *s = bs->opaque;
	38	s->drain_count++;
	39	}
	40
	41	static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
	42	{
	43	BDRVTestState *s = bs->opaque;
	44	s->drain_count--;
	45	}
	46
	47	static void bdrv_test_close(BlockDriverState *bs)
	48	{
	49	BDRVTestState *s = bs->opaque;
	50	g_assert_cmpint(s->drain_count, >, 0);
	51	}
	52
	53	static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
	54	uint64_t offset, uint64_t bytes,
	55	QEMUIOVector *qiov, int flags)
	56	{
	57	/* We want this request to stay until the polling loop in drain waits for
	58	* it to complete. We need to sleep a while as bdrv_drain_invoke() comes
	59	* first and polls its result, too, but it shouldn't accidentally complete
	60	* this request yet. */
	61	qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
	62
	63	return 0;
	64	}
	65
	66	static BlockDriver bdrv_test = {
	67	.format_name = "test",
	68	.instance_size = sizeof(BDRVTestState),
	69
	70	.bdrv_close = bdrv_test_close,
	71	.bdrv_co_preadv = bdrv_test_co_preadv,
	72
	73	.bdrv_co_drain_begin = bdrv_test_co_drain_begin,
	74	.bdrv_co_drain_end = bdrv_test_co_drain_end,
86e1c840 KW	75
86e1c840 KW	76	.bdrv_child_perm = bdrv_format_default_perms,
881cfd17 KW	77	};
	78
	79	static void aio_ret_cb(void *opaque, int ret)
	80	{
	81	int *aio_ret = opaque;
	82	*aio_ret = ret;
	83	}
	84
0582eb10 KW	85	typedef struct CallInCoroutineData {
	86	void (*entry)(void);
	87	bool done;
	88	} CallInCoroutineData;
	89
	90	static coroutine_fn void call_in_coroutine_entry(void *opaque)
	91	{
	92	CallInCoroutineData *data = opaque;
	93
	94	data->entry();
	95	data->done = true;
	96	}
	97
	98	static void call_in_coroutine(void (*entry)(void))
	99	{
	100	Coroutine *co;
	101	CallInCoroutineData data = {
	102	.entry = entry,
	103	.done = false,
	104	};
	105
	106	co = qemu_coroutine_create(call_in_coroutine_entry, &data);
	107	qemu_coroutine_enter(co);
	108	while (!data.done) {
	109	aio_poll(qemu_get_aio_context(), true);
	110	}
	111	}
	112
86e1c840 KW	113	enum drain_type {
	114	BDRV_DRAIN_ALL,
	115	BDRV_DRAIN,
d2a85d0f	116	BDRV_SUBTREE_DRAIN,
6c429a6a	117	DRAIN_TYPE_MAX,
86e1c840 KW	118	};
	119
	120	static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
	121	{
	122	switch (drain_type) {
	123	case BDRV_DRAIN_ALL: bdrv_drain_all_begin(); break;
	124	case BDRV_DRAIN: bdrv_drained_begin(bs); break;
d2a85d0f	125	case BDRV_SUBTREE_DRAIN: bdrv_subtree_drained_begin(bs); break;
86e1c840 KW	126	default: g_assert_not_reached();
	127	}
	128	}
	129
	130	static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
	131	{
	132	switch (drain_type) {
	133	case BDRV_DRAIN_ALL: bdrv_drain_all_end(); break;
	134	case BDRV_DRAIN: bdrv_drained_end(bs); break;
d2a85d0f	135	case BDRV_SUBTREE_DRAIN: bdrv_subtree_drained_end(bs); break;
86e1c840 KW	136	default: g_assert_not_reached();
	137	}
	138	}
	139
	140	static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
881cfd17 KW	141	{
881cfd17 KW	142	BlockBackend *blk;
86e1c840 KW	143	BlockDriverState bs, backing;
86e1c840 KW	144	BDRVTestState s, backing_s;
881cfd17 KW	145	BlockAIOCB *acb;
	146	int aio_ret;
	147
	148	QEMUIOVector qiov;
	149	struct iovec iov = {
	150	.iov_base = NULL,
	151	.iov_len = 0,
	152	};
	153	qemu_iovec_init_external(&qiov, &iov, 1);
	154
	155	blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
	156	bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
	157	&error_abort);
	158	s = bs->opaque;
	159	blk_insert_bs(blk, bs, &error_abort);
	160
86e1c840 KW	161	backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
	162	backing_s = backing->opaque;
	163	bdrv_set_backing_hd(bs, backing, &error_abort);
	164
881cfd17 KW	165	/* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
881cfd17 KW	166	g_assert_cmpint(s->drain_count, ==, 0);
86e1c840 KW	167	g_assert_cmpint(backing_s->drain_count, ==, 0);
	168
	169	do_drain_begin(drain_type, bs);
	170
881cfd17	171	g_assert_cmpint(s->drain_count, ==, 1);
86e1c840 KW	172	g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
	173
	174	do_drain_end(drain_type, bs);
	175
881cfd17	176	g_assert_cmpint(s->drain_count, ==, 0);
86e1c840	177	g_assert_cmpint(backing_s->drain_count, ==, 0);
881cfd17 KW	178
	179	/* Now do the same while a request is pending */
	180	aio_ret = -EINPROGRESS;
	181	acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
	182	g_assert(acb != NULL);
	183	g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
	184
	185	g_assert_cmpint(s->drain_count, ==, 0);
86e1c840 KW	186	g_assert_cmpint(backing_s->drain_count, ==, 0);
	187
	188	do_drain_begin(drain_type, bs);
	189
881cfd17 KW	190	g_assert_cmpint(aio_ret, ==, 0);
881cfd17 KW	191	g_assert_cmpint(s->drain_count, ==, 1);
86e1c840 KW	192	g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
	193
	194	do_drain_end(drain_type, bs);
	195
881cfd17	196	g_assert_cmpint(s->drain_count, ==, 0);
86e1c840	197	g_assert_cmpint(backing_s->drain_count, ==, 0);
881cfd17	198
86e1c840	199	bdrv_unref(backing);
881cfd17 KW	200	bdrv_unref(bs);
	201	blk_unref(blk);
	202	}
	203
86e1c840 KW	204	static void test_drv_cb_drain_all(void)
	205	{
	206	test_drv_cb_common(BDRV_DRAIN_ALL, true);
	207	}
	208
	209	static void test_drv_cb_drain(void)
	210	{
	211	test_drv_cb_common(BDRV_DRAIN, false);
	212	}
	213
d2a85d0f KW	214	static void test_drv_cb_drain_subtree(void)
	215	{
	216	test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
	217	}
	218
0582eb10 KW	219	static void test_drv_cb_co_drain(void)
	220	{
	221	call_in_coroutine(test_drv_cb_drain);
	222	}
	223
	224	static void test_drv_cb_co_drain_subtree(void)
	225	{
	226	call_in_coroutine(test_drv_cb_drain_subtree);
	227	}
	228
89a6ceab KW	229	static void test_quiesce_common(enum drain_type drain_type, bool recursive)
	230	{
	231	BlockBackend *blk;
	232	BlockDriverState bs, backing;
	233
	234	blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
	235	bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
	236	&error_abort);
	237	blk_insert_bs(blk, bs, &error_abort);
	238
	239	backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
	240	bdrv_set_backing_hd(bs, backing, &error_abort);
	241
	242	g_assert_cmpint(bs->quiesce_counter, ==, 0);
	243	g_assert_cmpint(backing->quiesce_counter, ==, 0);
	244
	245	do_drain_begin(drain_type, bs);
	246
	247	g_assert_cmpint(bs->quiesce_counter, ==, 1);
	248	g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
	249
	250	do_drain_end(drain_type, bs);
	251
	252	g_assert_cmpint(bs->quiesce_counter, ==, 0);
	253	g_assert_cmpint(backing->quiesce_counter, ==, 0);
	254
	255	bdrv_unref(backing);
	256	bdrv_unref(bs);
	257	blk_unref(blk);
	258	}
	259
	260	static void test_quiesce_drain_all(void)
	261	{
	262	// XXX drain_all doesn't quiesce
	263	//test_quiesce_common(BDRV_DRAIN_ALL, true);
	264	}
	265
	266	static void test_quiesce_drain(void)
	267	{
	268	test_quiesce_common(BDRV_DRAIN, false);
	269	}
	270
d2a85d0f KW	271	static void test_quiesce_drain_subtree(void)
	272	{
	273	test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
	274	}
	275
0582eb10 KW	276	static void test_quiesce_co_drain(void)
	277	{
	278	call_in_coroutine(test_quiesce_drain);
	279	}
	280
	281	static void test_quiesce_co_drain_subtree(void)
	282	{
	283	call_in_coroutine(test_quiesce_drain_subtree);
	284	}
	285
6c429a6a KW	286	static void test_nested(void)
	287	{
	288	BlockBackend *blk;
	289	BlockDriverState bs, backing;
	290	BDRVTestState s, backing_s;
	291	enum drain_type outer, inner;
	292
	293	blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
	294	bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
	295	&error_abort);
	296	s = bs->opaque;
	297	blk_insert_bs(blk, bs, &error_abort);
	298
	299	backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
	300	backing_s = backing->opaque;
	301	bdrv_set_backing_hd(bs, backing, &error_abort);
	302
	303	for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
	304	for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
	305	/* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
	306	int bs_quiesce = (outer != BDRV_DRAIN_ALL) +
	307	(inner != BDRV_DRAIN_ALL);
d2a85d0f KW	308	int backing_quiesce = (outer == BDRV_SUBTREE_DRAIN) +
d2a85d0f KW	309	(inner == BDRV_SUBTREE_DRAIN);
6c429a6a KW	310	int backing_cb_cnt = (outer != BDRV_DRAIN) +
	311	(inner != BDRV_DRAIN);
	312
	313	g_assert_cmpint(bs->quiesce_counter, ==, 0);
	314	g_assert_cmpint(backing->quiesce_counter, ==, 0);
	315	g_assert_cmpint(s->drain_count, ==, 0);
	316	g_assert_cmpint(backing_s->drain_count, ==, 0);
	317
	318	do_drain_begin(outer, bs);
	319	do_drain_begin(inner, bs);
	320
	321	g_assert_cmpint(bs->quiesce_counter, ==, bs_quiesce);
	322	g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
	323	g_assert_cmpint(s->drain_count, ==, 2);
	324	g_assert_cmpint(backing_s->drain_count, ==, backing_cb_cnt);
	325
	326	do_drain_end(inner, bs);
	327	do_drain_end(outer, bs);
	328
	329	g_assert_cmpint(bs->quiesce_counter, ==, 0);
	330	g_assert_cmpint(backing->quiesce_counter, ==, 0);
	331	g_assert_cmpint(s->drain_count, ==, 0);
	332	g_assert_cmpint(backing_s->drain_count, ==, 0);
	333	}
	334	}
	335
	336	bdrv_unref(backing);
	337	bdrv_unref(bs);
	338	blk_unref(blk);
	339	}
	340
7253220d KW	341
	342	typedef struct TestBlockJob {
	343	BlockJob common;
	344	bool should_complete;
	345	} TestBlockJob;
	346
	347	static void test_job_completed(BlockJob job, void opaque)
	348	{
	349	block_job_completed(job, 0);
	350	}
	351
	352	static void coroutine_fn test_job_start(void *opaque)
	353	{
	354	TestBlockJob *s = opaque;
	355
	356	while (!s->should_complete) {
	357	block_job_sleep_ns(&s->common, 100000);
	358	}
	359
	360	block_job_defer_to_main_loop(&s->common, test_job_completed, NULL);
	361	}
	362
	363	static void test_job_complete(BlockJob job, Error *errp)
	364	{
	365	TestBlockJob *s = container_of(job, TestBlockJob, common);
	366	s->should_complete = true;
	367	}
	368
	369	BlockJobDriver test_job_driver = {
	370	.instance_size = sizeof(TestBlockJob),
	371	.start = test_job_start,
	372	.complete = test_job_complete,
	373	};
	374
	375	static void test_blockjob_common(enum drain_type drain_type)
	376	{
	377	BlockBackend blk_src, blk_target;
	378	BlockDriverState src, target;
	379	BlockJob *job;
	380	int ret;
	381
	382	src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
	383	&error_abort);
	384	blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
	385	blk_insert_bs(blk_src, src, &error_abort);
	386
	387	target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
	388	&error_abort);
	389	blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
	390	blk_insert_bs(blk_target, target, &error_abort);
	391
	392	job = block_job_create("job0", &test_job_driver, src, 0, BLK_PERM_ALL, 0,
	393	0, NULL, NULL, &error_abort);
	394	block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
	395	block_job_start(job);
	396
	397	g_assert_cmpint(job->pause_count, ==, 0);
	398	g_assert_false(job->paused);
	399	g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
	400
	401	do_drain_begin(drain_type, src);
	402
	403	if (drain_type == BDRV_DRAIN_ALL) {
81193349 KW	404	/* bdrv_drain_all() drains both src and target */
81193349 KW	405	g_assert_cmpint(job->pause_count, ==, 2);
7253220d KW	406	} else {
	407	g_assert_cmpint(job->pause_count, ==, 1);
	408	}
	409	/* XXX We don't wait until the job is actually paused. Is this okay? */
	410	/* g_assert_true(job->paused); */
	411	g_assert_false(job->busy); /* The job is paused */
	412
	413	do_drain_end(drain_type, src);
	414
	415	g_assert_cmpint(job->pause_count, ==, 0);
	416	g_assert_false(job->paused);
	417	g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
	418
	419	do_drain_begin(drain_type, target);
	420
	421	if (drain_type == BDRV_DRAIN_ALL) {
81193349 KW	422	/* bdrv_drain_all() drains both src and target */
81193349 KW	423	g_assert_cmpint(job->pause_count, ==, 2);
7253220d KW	424	} else {
	425	g_assert_cmpint(job->pause_count, ==, 1);
	426	}
	427	/* XXX We don't wait until the job is actually paused. Is this okay? */
	428	/* g_assert_true(job->paused); */
	429	g_assert_false(job->busy); /* The job is paused */
	430
	431	do_drain_end(drain_type, target);
	432
	433	g_assert_cmpint(job->pause_count, ==, 0);
	434	g_assert_false(job->paused);
	435	g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
	436
	437	ret = block_job_complete_sync(job, &error_abort);
	438	g_assert_cmpint(ret, ==, 0);
	439
	440	blk_unref(blk_src);
	441	blk_unref(blk_target);
	442	bdrv_unref(src);
	443	bdrv_unref(target);
	444	}
	445
	446	static void test_blockjob_drain_all(void)
	447	{
	448	test_blockjob_common(BDRV_DRAIN_ALL);
	449	}
	450
	451	static void test_blockjob_drain(void)
	452	{
	453	test_blockjob_common(BDRV_DRAIN);
	454	}
	455
d2a85d0f KW	456	static void test_blockjob_drain_subtree(void)
	457	{
	458	test_blockjob_common(BDRV_SUBTREE_DRAIN);
	459	}
	460
881cfd17 KW	461	int main(int argc, char **argv)
	462	{
	463	bdrv_init();
	464	qemu_init_main_loop(&error_abort);
	465
	466	g_test_init(&argc, &argv, NULL);
	467
	468	g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
86e1c840	469	g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
d2a85d0f KW	470	g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
d2a85d0f KW	471	test_drv_cb_drain_subtree);
881cfd17	472
0582eb10 KW	473	// XXX bdrv_drain_all() doesn't work in coroutine context
	474	g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
	475	g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
	476	test_drv_cb_co_drain_subtree);
	477
	478
89a6ceab KW	479	g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
89a6ceab KW	480	g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
d2a85d0f KW	481	g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
d2a85d0f KW	482	test_quiesce_drain_subtree);
89a6ceab	483
0582eb10 KW	484	// XXX bdrv_drain_all() doesn't work in coroutine context
	485	g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
	486	g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
	487	test_quiesce_co_drain_subtree);
	488
6c429a6a KW	489	g_test_add_func("/bdrv-drain/nested", test_nested);
6c429a6a KW	490
7253220d KW	491	g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
7253220d KW	492	g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
d2a85d0f KW	493	g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
d2a85d0f KW	494	test_blockjob_drain_subtree);
7253220d	495
881cfd17 KW	496	return g_test_run();
881cfd17 KW	497	}