test-bdrv-drain: Graph change through parent callback

}

struct detach_by_parent_data {

    BlockDriverState *parent_b;

    BdrvChild *child_b;

    BlockDriverState *c;

    BdrvChild *child_c;

};

static void detach_by_parent_aio_cb(void *opaque, int ret)

{

    struct detach_by_parent_data *data = opaque;

    g_assert_cmpint(ret, ==, 0);

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

}

/*

 * Initial graph:

 *

 * PA     PB

 *    \ /   \

 *     A     B     C

 *

 * 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.

 */

static void test_detach_by_parent_cb(void)

{

    BlockBackend *blk;

    BlockDriverState *parent_a, *parent_b, *a, *b, *c;

    BdrvChild *child_a, *child_b;

    BlockAIOCB *acb;

    struct detach_by_parent_data data;

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base = NULL,

        .iov_len = 0,

    };

    qemu_iovec_init_external(&qiov, &iov, 1);

    /* 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(BLK_PERM_ALL, BLK_PERM_ALL);

    blk_insert_bs(blk, parent_a, &error_abort);

    bdrv_unref(parent_a);

    /* 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", &child_file, &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 */

    data = (struct detach_by_parent_data) {

        .parent_b = parent_b,

        .child_b = child_b,

        .c = c,

    };

    acb = blk_aio_preadv(blk, 0, &qiov, 0, detach_by_parent_aio_cb, &data);

    g_assert(acb != NULL);

    /* Drain and check the expected result */

    bdrv_subtree_drained_begin(parent_b);

    g_assert(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) == data.child_c);

    g_assert(QLIST_NEXT(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);

    /* XXX Once bdrv_close() unref's children instead of just detaching them,

     * this won't be necessary any more. */

    bdrv_unref(a);

    bdrv_unref(a);

    bdrv_unref(c);

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

}

int main(int argc, char **argv)

{

    int ret;

    g_test_add_func("/bdrv-drain/deletion/drain", test_delete_by_drain);

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

    ret = g_test_run();

    qemu_event_destroy(&done_event);