On 12.07.22 23:19, Emanuele Giuseppe Esposito wrote:
Replace all direct usage of ->can_set_aio_ctx and ->set_aio_ctx,
and call bdrv_child_try_change_aio_context() in
bdrv_try_set_aio_context(), the main function called through
the whole block layer.
From this point onwards, ->can_set_aio_ctx and ->set_aio_ctx
won't be used anymore.
Signed-off-by: Emanuele Giuseppe Esposito <eespo...@redhat.com>
---
block.c | 30 ++++++++++++++++--------------
block/block-backend.c | 8 ++++++--
2 files changed, 22 insertions(+), 16 deletions(-)
diff --git a/block.c b/block.c
index a7ba590dfa..101188a2d4 100644
--- a/block.c
+++ b/block.c
@@ -2966,17 +2966,18 @@ static void bdrv_attach_child_common_abort(void *opaque)
}
if (bdrv_child_get_parent_aio_context(child) != s->old_parent_ctx) {
+ Transaction *tran;
GSList *ignore;
+ bool ret;
- /* No need to ignore `child`, because it has been detached already */
- ignore = NULL;
- child->klass->can_set_aio_ctx(child, s->old_parent_ctx, &ignore,
- &error_abort);
- g_slist_free(ignore);
+ tran = tran_new();
+ /* No need to ignore `child`, because it has been detached already */
ignore = NULL;
- child->klass->set_aio_ctx(child, s->old_parent_ctx, &ignore);
+ ret = child->klass->change_aio_ctx(child, s->old_parent_ctx, &ignore,
+ tran, &error_abort);
g_slist_free(ignore);
+ tran_finalize(tran, ret ? ret : -1);
As far as I understand, the transaction is supposed to always succeed;
that’s why we pass `&error_abort`, I thought.
If so, `ret` should always be true. More importantly, though, I think
the `ret ? ret : -1` is wrong because it’ll always evaluate to either 1
or -1, but never to 0, which would indicate success. I think it should
be `ret == true ? 0 : -1`, or even better `assert(ret == true);
tran_finalize(tran, 0);`.
}
bdrv_unref(bs);
@@ -3037,17 +3038,18 @@ static int bdrv_attach_child_common(BlockDriverState
*child_bs,
Error *local_err = NULL;
int ret = bdrv_try_set_aio_context(child_bs, parent_ctx, &local_err);
- if (ret < 0 && child_class->can_set_aio_ctx) {
+ if (ret < 0 && child_class->change_aio_ctx) {
+ Transaction *tran = tran_new();
GSList *ignore = g_slist_prepend(NULL, new_child);
- if (child_class->can_set_aio_ctx(new_child, child_ctx, &ignore,
- NULL))
- {
+ bool ret_child;
+
+ ret_child = child_class->change_aio_ctx(new_child, child_ctx,
+ &ignore, tran, NULL);
+ if (ret_child) {
To be honest, due to the mix of return value styles we have, perhaps a
`ret_child == true` would help to signal that this is a success path.
error_free(local_err);
ret = 0;
- g_slist_free(ignore);
- ignore = g_slist_prepend(NULL, new_child);
- child_class->set_aio_ctx(new_child, child_ctx, &ignore);
}
+ tran_finalize(tran, ret_child ? ret_child : -1);
This too should probably be `ret_child == true ? 0 : -1`.
g_slist_free(ignore);
}
@@ -7708,7 +7710,7 @@ int bdrv_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
Error **errp)
{
GLOBAL_STATE_CODE();
- return bdrv_child_try_set_aio_context(bs, ctx, NULL, errp);
+ return bdrv_child_try_change_aio_context(bs, ctx, NULL, errp);
Why not remove this function and adjust all callers?
Hanna
}
void bdrv_add_aio_context_notifier(BlockDriverState *bs,