Fixes to test-bdrv-drain unit test
cover Fixes to test-bdrv-drain unit test
This test performs graph modification while being in IO_CODE. This is not allowed anymore.
This serie is taken from the forgotten (and partially invalid anymore) serie:
"[PATCH v2 00/10] block: bug fixes in preparation of AioContext removal" (actually one could also use patch 9 and 10 from that serie, so if you're interested take a look).
https://patchew.org/QEMU/[email protected]/[email protected]/
This serie substitutes Paolo's recent patch:
"[RFC PATCH] test-bdrv-drain: keep graph manipulations out of coroutines"
Thank you,
Emanuele
Emanuele Giuseppe Esposito (2):
test-bdrv-drain.c: remove test_detach_by_parent_cb() tests/unit/test-bdrv-drain.c: graph setup functions can't run in
coroutines
tests/unit/test-bdrv-drain.c | 159 ++++++++++++++++++----------------- 1 file changed, 82 insertions(+), 77 deletions(-)
Signature · 1 line
2.31.1
PATCH 1/2 test-bdrv-drain.c: remove test_detach_by_parent_cb()
This test uses a callback of an I/O function (blk_aio_preadv) to modify the graph, using bdrv_attach_child.
This is simply not allowed anymore. I/O cannot change the graph.
The problem in this test is in:
acb = blk_aio_preadv(blk, 0, &qiov, 0, detach_by_parent_aio_cb, NULL); /* Drain and check the expected result */ bdrv_subtree_drained_begin(parent_b);
because the detach_by_parent_aio_cb calls detach_indirect_bh(), that modifies the graph and is invoked during bdrv_subtree_drained_begin(). The call stack is the following:
1. blk_aio_preadv() creates a coroutine, increments in_flight counter and enters the coroutine running blk_aio_read_entry()
2. blk_aio_read_entry() performs the read and then schedules a bh to complete (blk_aio_complete)
3. at this point, subtree_drained_begin() kicks in and waits for all in_flight requests, polling
4. polling allows the bh to be scheduled, so blk_aio_complete runs
5. blk_aio_complete *first* invokes the callback (detach_by_parent_aio_cb) and then decrements the in_flight counter
6. Here is the problem: detach_by_parent_aio_cb modifies the graph, so both bdrv_unref_child() and bdrv_attach_child() will have subtree_drains inside. And this causes a deadlock, because the nested drain will wait for in_flight counter to go to zero, which is only happening once the drain itself finishes.
Different story is test_detach_by_driver_cb(): in this case, detach_by_parent_aio_cb() does not call detach_indirect_bh(), but it is instead called as a bh running in the main loop by detach_by_driver_cb_drained_begin(), the callback for .drained_begin().
This test was added in 231281ab42 and part of the series "Drain fixes and cleanups, part 3"
https://lists.nongnu.org/archive/html/qemu-block/2018-05/msg01132.html
but as explained above I believe that it is not valid anymore, and can be discarded.
--- tests/unit/test-bdrv-drain.c | 41 ++++++++---------------------------- 1 file changed, 9 insertions(+), 32 deletions(-)
tests/unit/test-bdrv-drain.c +9 -32
@@ -1316,7 +1316,6 @@ struct detach_by_parent_data {BdrvChild *child_b;BlockDriverState *c;BdrvChild *child_c; -bool by_parent_cb; };static struct detach_by_parent_data detach_by_parent_data;
@@ -1334,12 +1333,7 @@ static void detach_indirect_bh(void *opaque)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)
@@ -1358,33 +1352,25 @@ static BdrvChildClass detach_by_driver_cb_class;* \ / \ * 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 +* Test that bdrv_drain_invoke() doesn't poll * * PA's BdrvChildClass 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) +static void test_detach_indirect (void ) {BlockBackend *blk;BlockDriverState *parent_a, *parent_b, *a, *b, *c;BdrvChild *child_a, *child_b;BlockAIOCB *acb; +BDRVTestState *s;QEMUIOVector qiov =QEMU_IOVEC_INIT_BUF (qiov,NULL ,0 ); -if (!by_parent_cb) { - detach_by_driver_cb_class = child_of_bds; - detach_by_driver_cb_class.drained_begin = - detach_by_driver_cb_drained_begin; - } + detach_by_driver_cb_class = child_of_bds; + detach_by_driver_cb_class.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,
@@ -1403,10 +1389,8 @@ static void test_detach_indirect(bool by_parent_cb)/* 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; - } + s = parent_a->opaque; + s->sleep_in_drain_begin = true;/* Set child relationships */ bdrv_ref (b);
@@ -1418,7 +1402,7 @@ static void test_detach_indirect(bool by_parent_cb)bdrv_ref (a);bdrv_attach_child (parent_a, a,"PA-A" , - by_parent_cb ? &child_of_bds : &detach_by_driver_cb_class, + &detach_by_driver_cb_class,BDRV_CHILD_DATA , &error_abort); g_assert_cmpint(parent_a->refcnt, ==, 1);
@@ -1436,7 +1420,6 @@ static void test_detach_indirect(bool by_parent_cb) .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 );
@@ -1475,14 +1458,9 @@ static void test_detach_indirect(bool by_parent_cb)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); +test_detach_indirect (); }static void test_append_to_drained (void )
@@ -2236,7 +2214,6 @@ int main(int argc, char **argv)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);
Signature · 1 line
2.31.1
PATCH 2/2 tests/unit/test-bdrv-drain.c: graph setup functions can't run in coroutines
In reply to Emanuele Giuseppe EspositoGraph initialization functions like blk_new(), bdrv_new() and so on should not run in a coroutine. In fact, they might invoke a drain (for example blk_insert_bs eventually calls bdrv_replace_child_noperm) that in turn can invoke callbacks like bdrv_do_drained_begin_quiesce(), that asserts exactly that we are not in a coroutine.
Move the initialization phase of test_drv_cb and test_quiesce_common outside the coroutine logic.
--- tests/unit/test-bdrv-drain.c | 118 ++++++++++++++++++++++------------- 1 file changed, 73 insertions(+), 45 deletions(-)
tests/unit/test-bdrv-drain.c +73 -45
@@ -116,7 +116,8 @@ static void aio_ret_cb(void *opaque, int ret) }typedef struct CallInCoroutineData { -void (*entry)(void ); +void (*entry)(void *); +void *arg;bool done; }CallInCoroutineData ;
@@ -124,15 +125,16 @@ static coroutine_fn void call_in_coroutine_entry(void *opaque) {CallInCoroutineData *data = opaque; - data->entry (); + data->entry (data->arg); data->done = true; } -static void call_in_coroutine (void (*entry)(void )) +static void call_in_coroutine (void (*entry)(void *),void *arg) {Coroutine *co;CallInCoroutineData data = { .entry = entry, + .arg = arg, .done = false, };
@@ -192,26 +194,28 @@ static void do_drain_end_unlocked(enum drain_type drain_type, BlockDriverState * } } -static void test_drv_cb_common (enum drain_type drain_type,bool recursive) -{ +typedef struct TestDriverCBData { +enum drain_type drain_type; +bool recursive;BlockBackend *blk;BlockDriverState *bs, *backing; -BDRVTestState *s, *backing_s; +}TestDriverCBData ; + +static void test_drv_cb_common (void *arg) +{ +TestDriverCBData *data = arg; +BlockBackend *blk = data->blk; +BlockDriverState *bs = data->bs; +BlockDriverState *backing = data->backing; +enum drain_type drain_type = data->drain_type; +bool recursive = data->recursive; +BDRVTestState *s = bs->opaque; +BDRVTestState *backing_s = backing->opaque;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);
@@ -245,54 +249,77 @@ static void test_drv_cb_common(enum drain_type drain_type, bool recursive) 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_common_cb (enum drain_type drain_type,bool in_coroutine, +void (*cb)(void *)) +{ +TestDriverCBData data; + + data.drain_type = drain_type; + data.recursive = (drain_type !=BDRV_DRAIN ); + + data.blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); + data.bs =bdrv_new_open_driver (&bdrv_test,"test-node" ,BDRV_O_RDWR , + &error_abort); +blk_insert_bs (data.blk, data.bs, &error_abort); + + data.backing =bdrv_new_open_driver (&bdrv_test,"backing" ,0 , &error_abort); +bdrv_set_backing_hd (data.bs, data.backing, &error_abort); + +if (in_coroutine) { +call_in_coroutine (cb, &data); + }else { +cb (&data); + } + +bdrv_unref (data.backing); +bdrv_unref (data.bs); +blk_unref (data.blk); +} + +static void test_drv_cb (enum drain_type drain_type,bool in_coroutine) +{ +test_common_cb (drain_type, in_coroutine, test_drv_cb_common); }static void test_drv_cb_drain_all (void ) { -test_drv_cb_common (BDRV_DRAIN_ALL , true); +test_drv_cb (BDRV_DRAIN_ALL , false); }static void test_drv_cb_drain (void ) { -test_drv_cb_common (BDRV_DRAIN , false); +test_drv_cb (BDRV_DRAIN , false); }static void test_drv_cb_drain_subtree (void ) { -test_drv_cb_common (BDRV_SUBTREE_DRAIN , true); +test_drv_cb (BDRV_SUBTREE_DRAIN , false); }static void test_drv_cb_co_drain_all (void ) { -call_in_coroutine (test_drv_cb_drain_all); +test_drv_cb (BDRV_DRAIN_ALL , true); }static void test_drv_cb_co_drain (void ) { -call_in_coroutine (test_drv_cb_drain); +test_drv_cb (BDRV_DRAIN , true); }static void test_drv_cb_co_drain_subtree (void ) { -call_in_coroutine (test_drv_cb_drain_subtree); +test_drv_cb (BDRV_SUBTREE_DRAIN , true); } -static void test_quiesce_common (enum drain_type drain_type,bool recursive) +static void test_quiesce_common (void *arg) { -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); +TestDriverCBData *data = arg; +BlockDriverState *bs = data->bs; +BlockDriverState *backing = data->backing; +enum drain_type drain_type = data->drain_type; +bool recursive = data->recursive; g_assert_cmpint(bs->quiesce_counter, ==, 0); g_assert_cmpint(backing->quiesce_counter, ==, 0);
@@ -306,40 +333,41 @@ static void test_quiesce_common(enum drain_type drain_type, bool recursive) 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 (enum drain_type drain_type,bool in_coroutine) +{ +test_common_cb (drain_type, in_coroutine, test_quiesce_common); }static void test_quiesce_drain_all (void ) { -test_quiesce_common (BDRV_DRAIN_ALL , true); +test_quiesce (BDRV_DRAIN_ALL , false); }static void test_quiesce_drain (void ) { -test_quiesce_common (BDRV_DRAIN , false); +test_quiesce (BDRV_DRAIN , false); }static void test_quiesce_drain_subtree (void ) { -test_quiesce_common (BDRV_SUBTREE_DRAIN , true); +test_quiesce (BDRV_SUBTREE_DRAIN , false); }static void test_quiesce_co_drain_all (void ) { -call_in_coroutine (test_quiesce_drain_all); +test_quiesce (BDRV_DRAIN_ALL , true); }static void test_quiesce_co_drain (void ) { -call_in_coroutine (test_quiesce_drain); +test_quiesce (BDRV_DRAIN , true); }static void test_quiesce_co_drain_subtree (void ) { -call_in_coroutine (test_quiesce_drain_subtree); +test_quiesce (BDRV_SUBTREE_DRAIN , true); }static void test_nested (void )
Signature · 1 line
2.31.1