g_free(gen_node_name);
}
-/*
- * The caller must always hold @bs AioContext lock, because this function calls
- * bdrv_refresh_total_sectors() which polls when called from non-coroutine
- * context.
- */
static int no_coroutine_fn GRAPH_UNLOCKED
bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, const char *node_name,
QDict *options, int open_flags, Error **errp)
{
- AioContext *ctx;
Error *local_err = NULL;
int i, ret;
GLOBAL_STATE_CODE();
bs->supported_read_flags |= BDRV_REQ_REGISTERED_BUF;
bs->supported_write_flags |= BDRV_REQ_REGISTERED_BUF;
- /* Get the context after .bdrv_open, it can change the context */
- ctx = bdrv_get_aio_context(bs);
- aio_context_acquire(ctx);
-
ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
if (ret < 0) {
error_setg_errno(errp, -ret, "Could not refresh total sector count");
- aio_context_release(ctx);
return ret;
}
bdrv_graph_rdlock_main_loop();
bdrv_refresh_limits(bs, NULL, &local_err);
bdrv_graph_rdunlock_main_loop();
- aio_context_release(ctx);
if (local_err) {
error_propagate(errp, local_err);
return 0;
open_failed:
bs->drv = NULL;
+
+ bdrv_graph_wrlock();
if (bs->file != NULL) {
- bdrv_graph_wrlock(NULL);
bdrv_unref_child(bs, bs->file);
- bdrv_graph_wrunlock();
assert(!bs->file);
}
+ bdrv_graph_wrunlock();
+
g_free(bs->opaque);
bs->opaque = NULL;
return ret;
Error *local_err = NULL;
bool ro;
+ GLOBAL_STATE_CODE();
+
+ bdrv_graph_rdlock_main_loop();
assert(bs->file == NULL);
assert(options != NULL && bs->options != options);
- GLOBAL_STATE_CODE();
+ bdrv_graph_rdunlock_main_loop();
opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
if (!qemu_opts_absorb_qdict(opts, options, errp)) {
* Replaces the node that a BdrvChild points to without updating permissions.
*
* If @new_bs is non-NULL, the parent of @child must already be drained through
- * @child and the caller must hold the AioContext lock for @new_bs.
+ * @child.
*/
static void GRAPH_WRLOCK
bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs)
*
* Returns new created child.
*
- * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
- * @child_bs can move to a different AioContext in this function. Callers must
- * make sure that their AioContext locking is still correct after this.
+ * Both @parent_bs and @child_bs can move to a different AioContext in this
+ * function.
*/
static BdrvChild * GRAPH_WRLOCK
bdrv_attach_child_common(BlockDriverState *child_bs,
Transaction *tran, Error **errp)
{
BdrvChild *new_child;
- AioContext *parent_ctx, *new_child_ctx;
+ AioContext *parent_ctx;
AioContext *child_ctx = bdrv_get_aio_context(child_bs);
assert(child_class->get_parent_desc);
}
}
- new_child_ctx = bdrv_get_aio_context(child_bs);
- if (new_child_ctx != child_ctx) {
- aio_context_release(child_ctx);
- aio_context_acquire(new_child_ctx);
- }
-
bdrv_ref(child_bs);
/*
* Let every new BdrvChild start with a drained parent. Inserting the child
};
tran_add(tran, &bdrv_attach_child_common_drv, s);
- if (new_child_ctx != child_ctx) {
- aio_context_release(new_child_ctx);
- aio_context_acquire(child_ctx);
- }
-
return new_child;
}
/*
* Function doesn't update permissions, caller is responsible for this.
*
- * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
- * @child_bs can move to a different AioContext in this function. Callers must
- * make sure that their AioContext locking is still correct after this.
+ * Both @parent_bs and @child_bs can move to a different AioContext in this
+ * function.
*
* After calling this function, the transaction @tran may only be completed
* while holding a writer lock for the graph.
*
* On failure NULL is returned, errp is set and the reference to
* child_bs is also dropped.
- *
- * The caller must hold the AioContext lock @child_bs, but not that of @ctx
- * (unless @child_bs is already in @ctx).
*/
BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
*
* On failure NULL is returned, errp is set and the reference to
* child_bs is also dropped.
- *
- * If @parent_bs and @child_bs are in different AioContexts, the caller must
- * hold the AioContext lock for @child_bs, but not for @parent_bs.
*/
BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
BlockDriverState *child_bs,
*
* Function doesn't update permissions, caller is responsible for this.
*
- * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
- * @child_bs can move to a different AioContext in this function. Callers must
- * make sure that their AioContext locking is still correct after this.
+ * Both @parent_bs and @child_bs can move to a different AioContext in this
+ * function.
*
* After calling this function, the transaction @tran may only be completed
* while holding a writer lock for the graph.
}
/*
- * The caller must hold the AioContext lock for @backing_hd. Both @bs and
- * @backing_hd can move to a different AioContext in this function. Callers must
- * make sure that their AioContext locking is still correct after this.
+ * Both @bs and @backing_hd can move to a different AioContext in this
+ * function.
*
* If a backing child is already present (i.e. we're detaching a node), that
* child node must be drained.
int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
Error **errp)
{
- BlockDriverState *drain_bs = bs->backing ? bs->backing->bs : bs;
+ BlockDriverState *drain_bs;
int ret;
GLOBAL_STATE_CODE();
+ bdrv_graph_rdlock_main_loop();
+ drain_bs = bs->backing ? bs->backing->bs : bs;
+ bdrv_graph_rdunlock_main_loop();
+
bdrv_ref(drain_bs);
bdrv_drained_begin(drain_bs);
- bdrv_graph_wrlock(backing_hd);
+ bdrv_graph_wrlock();
ret = bdrv_set_backing_hd_drained(bs, backing_hd, errp);
bdrv_graph_wrunlock();
bdrv_drained_end(drain_bs);
* itself, all options starting with "${bdref_key}." are considered part of the
* BlockdevRef.
*
- * The caller must hold the main AioContext lock.
- *
* TODO Can this be unified with bdrv_open_image()?
*/
int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
int ret = 0;
bool implicit_backing = false;
BlockDriverState *backing_hd;
- AioContext *backing_hd_ctx;
QDict *options;
QDict *tmp_parent_options = NULL;
Error *local_err = NULL;
GLOBAL_STATE_CODE();
+ GRAPH_RDLOCK_GUARD_MAINLOOP();
if (bs->backing != NULL) {
goto free_exit;
implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file);
}
- bdrv_graph_rdlock_main_loop();
backing_filename = bdrv_get_full_backing_filename(bs, &local_err);
- bdrv_graph_rdunlock_main_loop();
-
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
}
if (implicit_backing) {
- bdrv_graph_rdlock_main_loop();
bdrv_refresh_filename(backing_hd);
- bdrv_graph_rdunlock_main_loop();
pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
backing_hd->filename);
}
/* Hook up the backing file link; drop our reference, bs owns the
* backing_hd reference now */
- backing_hd_ctx = bdrv_get_aio_context(backing_hd);
- aio_context_acquire(backing_hd_ctx);
ret = bdrv_set_backing_hd(bs, backing_hd, errp);
bdrv_unref(backing_hd);
- aio_context_release(backing_hd_ctx);
if (ret < 0) {
goto free_exit;
*
* The BlockdevRef will be removed from the options QDict.
*
- * The caller must hold the lock of the main AioContext and no other AioContext.
- * @parent can move to a different AioContext in this function. Callers must
- * make sure that their AioContext locking is still correct after this.
+ * @parent can move to a different AioContext in this function.
*/
BdrvChild *bdrv_open_child(const char *filename,
QDict *options, const char *bdref_key,
{
BlockDriverState *bs;
BdrvChild *child;
- AioContext *ctx;
GLOBAL_STATE_CODE();
return NULL;
}
- bdrv_graph_wrlock(NULL);
- ctx = bdrv_get_aio_context(bs);
- aio_context_acquire(ctx);
+ bdrv_graph_wrlock();
child = bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
errp);
- aio_context_release(ctx);
bdrv_graph_wrunlock();
return child;
/*
* Wrapper on bdrv_open_child() for most popular case: open primary child of bs.
*
- * The caller must hold the lock of the main AioContext and no other AioContext.
- * @parent can move to a different AioContext in this function. Callers must
- * make sure that their AioContext locking is still correct after this.
+ * @parent can move to a different AioContext in this function.
*/
int bdrv_open_file_child(const char *filename,
QDict *options, const char *bdref_key,
int64_t total_size;
QemuOpts *opts = NULL;
BlockDriverState *bs_snapshot = NULL;
- AioContext *ctx = bdrv_get_aio_context(bs);
int ret;
GLOBAL_STATE_CODE();
instead of opening 'filename' directly */
/* Get the required size from the image */
- aio_context_acquire(ctx);
total_size = bdrv_getlength(bs);
- aio_context_release(ctx);
if (total_size < 0) {
error_setg_errno(errp, -total_size, "Could not get image size");
goto out;
}
- aio_context_acquire(ctx);
ret = bdrv_append(bs_snapshot, bs, errp);
- aio_context_release(ctx);
-
if (ret < 0) {
bs_snapshot = NULL;
goto out;
* The reference parameter may be used to specify an existing block device which
* should be opened. If specified, neither options nor a filename may be given,
* nor can an existing BDS be reused (that is, *pbs has to be NULL).
- *
- * The caller must always hold the main AioContext lock.
*/
static BlockDriverState * no_coroutine_fn
bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
Error *local_err = NULL;
QDict *snapshot_options = NULL;
int snapshot_flags = 0;
- AioContext *ctx = qemu_get_aio_context();
assert(!child_class || !flags);
assert(!child_class == !parent);
/* Not requesting BLK_PERM_CONSISTENT_READ because we're only
* looking at the header to guess the image format. This works even
* in cases where a guest would not see a consistent state. */
- ctx = bdrv_get_aio_context(file_bs);
- aio_context_acquire(ctx);
+ AioContext *ctx = bdrv_get_aio_context(file_bs);
file = blk_new(ctx, 0, BLK_PERM_ALL);
blk_insert_bs(file, file_bs, &local_err);
bdrv_unref(file_bs);
- aio_context_release(ctx);
if (local_err) {
goto fail;
goto fail;
}
- /* The AioContext could have changed during bdrv_open_common() */
- ctx = bdrv_get_aio_context(bs);
-
if (file) {
- aio_context_acquire(ctx);
blk_unref(file);
- aio_context_release(ctx);
file = NULL;
}
* (snapshot_bs); thus, we have to drop the strong reference to bs
* (which we obtained by calling bdrv_new()). bs will not be deleted,
* though, because the overlay still has a reference to it. */
- aio_context_acquire(ctx);
bdrv_unref(bs);
- aio_context_release(ctx);
bs = snapshot_bs;
}
return bs;
fail:
- aio_context_acquire(ctx);
blk_unref(file);
qobject_unref(snapshot_options);
qobject_unref(bs->explicit_options);
bs->options = NULL;
bs->explicit_options = NULL;
bdrv_unref(bs);
- aio_context_release(ctx);
error_propagate(errp, local_err);
return NULL;
close_and_fail:
- aio_context_acquire(ctx);
bdrv_unref(bs);
- aio_context_release(ctx);
qobject_unref(snapshot_options);
qobject_unref(options);
error_propagate(errp, local_err);
return NULL;
}
-/* The caller must always hold the main AioContext lock. */
BlockDriverState *bdrv_open(const char *filename, const char *reference,
QDict *options, int flags, Error **errp)
{
if (bs_queue) {
BlockReopenQueueEntry *bs_entry, *next;
QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
- AioContext *ctx = bdrv_get_aio_context(bs_entry->state.bs);
-
- aio_context_acquire(ctx);
bdrv_drained_end(bs_entry->state.bs);
- aio_context_release(ctx);
-
qobject_unref(bs_entry->state.explicit_options);
qobject_unref(bs_entry->state.options);
g_free(bs_entry);
{
int ret = -1;
BlockReopenQueueEntry *bs_entry, *next;
- AioContext *ctx;
Transaction *tran = tran_new();
g_autoptr(GSList) refresh_list = NULL;
GLOBAL_STATE_CODE();
QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
- ctx = bdrv_get_aio_context(bs_entry->state.bs);
- aio_context_acquire(ctx);
ret = bdrv_flush(bs_entry->state.bs);
- aio_context_release(ctx);
if (ret < 0) {
error_setg_errno(errp, -ret, "Error flushing drive");
goto abort;
QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
assert(bs_entry->state.bs->quiesce_counter > 0);
- ctx = bdrv_get_aio_context(bs_entry->state.bs);
- aio_context_acquire(ctx);
ret = bdrv_reopen_prepare(&bs_entry->state, bs_queue, tran, errp);
- aio_context_release(ctx);
if (ret < 0) {
goto abort;
}
* to first element.
*/
QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
- ctx = bdrv_get_aio_context(bs_entry->state.bs);
- aio_context_acquire(ctx);
bdrv_reopen_commit(&bs_entry->state);
- aio_context_release(ctx);
}
- bdrv_graph_wrlock(NULL);
+ bdrv_graph_wrlock();
tran_commit(tran);
bdrv_graph_wrunlock();
BlockDriverState *bs = bs_entry->state.bs;
if (bs->drv->bdrv_reopen_commit_post) {
- ctx = bdrv_get_aio_context(bs);
- aio_context_acquire(ctx);
bs->drv->bdrv_reopen_commit_post(&bs_entry->state);
- aio_context_release(ctx);
}
}
goto cleanup;
abort:
- bdrv_graph_wrlock(NULL);
+ bdrv_graph_wrlock();
tran_abort(tran);
bdrv_graph_wrunlock();
QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
if (bs_entry->prepared) {
- ctx = bdrv_get_aio_context(bs_entry->state.bs);
- aio_context_acquire(ctx);
bdrv_reopen_abort(&bs_entry->state);
- aio_context_release(ctx);
}
}
int bdrv_reopen(BlockDriverState *bs, QDict *opts, bool keep_old_opts,
Error **errp)
{
- AioContext *ctx = bdrv_get_aio_context(bs);
BlockReopenQueue *queue;
- int ret;
GLOBAL_STATE_CODE();
queue = bdrv_reopen_queue(NULL, bs, opts, keep_old_opts);
- if (ctx != qemu_get_aio_context()) {
- aio_context_release(ctx);
- }
- ret = bdrv_reopen_multiple(queue, errp);
-
- if (ctx != qemu_get_aio_context()) {
- aio_context_acquire(ctx);
- }
-
- return ret;
+ return bdrv_reopen_multiple(queue, errp);
}
int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
*
* Return 0 on success, otherwise return < 0 and set @errp.
*
- * The caller must hold the AioContext lock of @reopen_state->bs.
* @reopen_state->bs can move to a different AioContext in this function.
- * Callers must make sure that their AioContext locking is still correct after
- * this.
*/
static int GRAPH_UNLOCKED
bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
{
BlockDriverState *bs = reopen_state->bs;
BlockDriverState *new_child_bs;
- BlockDriverState *old_child_bs = is_backing ? child_bs(bs->backing) :
- child_bs(bs->file);
+ BlockDriverState *old_child_bs;
+
const char *child_name = is_backing ? "backing" : "file";
QObject *value;
const char *str;
- AioContext *ctx, *old_ctx;
bool has_child;
int ret;
g_assert_not_reached();
}
+ old_child_bs = is_backing ? child_bs(bs->backing) : child_bs(bs->file);
if (old_child_bs == new_child_bs) {
ret = 0;
goto out_rdlock;
bdrv_drained_begin(old_child_bs);
}
- old_ctx = bdrv_get_aio_context(bs);
- ctx = bdrv_get_aio_context(new_child_bs);
- if (old_ctx != ctx) {
- aio_context_release(old_ctx);
- aio_context_acquire(ctx);
- }
-
bdrv_graph_rdunlock_main_loop();
- bdrv_graph_wrlock(new_child_bs);
+ bdrv_graph_wrlock();
ret = bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
tran, errp);
bdrv_graph_wrunlock();
- if (old_ctx != ctx) {
- aio_context_release(ctx);
- aio_context_acquire(old_ctx);
- }
-
if (old_child_bs) {
bdrv_drained_end(old_child_bs);
bdrv_unref(old_child_bs);
* It is the responsibility of the caller to then call the abort() or
* commit() for any other BDS that have been left in a prepare() state
*
- * The caller must hold the AioContext lock of @reopen_state->bs.
- *
* After calling this function, the transaction @change_child_tran may only be
* completed while holding a writer lock for the graph.
*/
* file or if the image file has a backing file name as part of
* its metadata. Otherwise the 'backing' option can be omitted.
*/
+ bdrv_graph_rdlock_main_loop();
if (drv->supports_backing && reopen_state->backing_missing &&
(reopen_state->bs->backing || reopen_state->bs->backing_file[0])) {
error_setg(errp, "backing is missing for '%s'",
reopen_state->bs->node_name);
+ bdrv_graph_rdunlock_main_loop();
ret = -EINVAL;
goto error;
}
+ bdrv_graph_rdunlock_main_loop();
/*
* Allow changing the 'backing' option. The new value can be
bs->drv = NULL;
}
- bdrv_graph_wrlock(bs);
+ bdrv_graph_wrlock();
QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
bdrv_unref_child(bs, child);
}
- bdrv_graph_wrunlock();
assert(!bs->backing);
assert(!bs->file);
+ bdrv_graph_wrunlock();
+
g_free(bs->opaque);
bs->opaque = NULL;
qatomic_set(&bs->copy_on_read, 0);
bdrv_graph_rdunlock_main_loop();
bdrv_drained_begin(child_bs);
- bdrv_graph_wrlock(bs);
+ bdrv_graph_wrlock();
ret = bdrv_replace_node_common(bs, child_bs, true, true, errp);
bdrv_graph_wrunlock();
bdrv_drained_end(child_bs);
* child.
*
* This function does not create any image files.
- *
- * The caller must hold the AioContext lock for @bs_top.
*/
int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
Error **errp)
int ret;
BdrvChild *child;
Transaction *tran = tran_new();
- AioContext *old_context, *new_context = NULL;
GLOBAL_STATE_CODE();
+ bdrv_graph_rdlock_main_loop();
assert(!bs_new->backing);
+ bdrv_graph_rdunlock_main_loop();
- old_context = bdrv_get_aio_context(bs_top);
bdrv_drained_begin(bs_top);
-
- /*
- * bdrv_drained_begin() requires that only the AioContext of the drained
- * node is locked, and at this point it can still differ from the AioContext
- * of bs_top.
- */
- new_context = bdrv_get_aio_context(bs_new);
- aio_context_release(old_context);
- aio_context_acquire(new_context);
bdrv_drained_begin(bs_new);
- aio_context_release(new_context);
- aio_context_acquire(old_context);
- new_context = NULL;
- bdrv_graph_wrlock(bs_top);
+ bdrv_graph_wrlock();
child = bdrv_attach_child_noperm(bs_new, bs_top, "backing",
&child_of_bds, bdrv_backing_role(bs_new),
goto out;
}
- /*
- * bdrv_attach_child_noperm could change the AioContext of bs_top and
- * bs_new, but at least they are in the same AioContext now. This is the
- * AioContext that we need to lock for the rest of the function.
- */
- new_context = bdrv_get_aio_context(bs_top);
-
- if (old_context != new_context) {
- aio_context_release(old_context);
- aio_context_acquire(new_context);
- }
-
ret = bdrv_replace_node_noperm(bs_top, bs_new, true, tran, errp);
if (ret < 0) {
goto out;
bdrv_drained_end(bs_top);
bdrv_drained_end(bs_new);
- if (new_context && old_context != new_context) {
- aio_context_release(new_context);
- aio_context_acquire(old_context);
- }
-
return ret;
}
bdrv_ref(old_bs);
bdrv_drained_begin(old_bs);
bdrv_drained_begin(new_bs);
- bdrv_graph_wrlock(new_bs);
+ bdrv_graph_wrlock();
bdrv_replace_child_tran(child, new_bs, tran);
* after the call (even on failure), so if the caller intends to reuse the
* dictionary, it needs to use qobject_ref() before calling bdrv_open.
*
- * The caller holds the AioContext lock for @bs. It must make sure that @bs
- * stays in the same AioContext, i.e. @options must not refer to nodes in a
- * different AioContext.
+ * The caller must make sure that @bs stays in the same AioContext, i.e.
+ * @options must not refer to nodes in a different AioContext.
*/
BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *options,
int flags, Error **errp)
GLOBAL_STATE_CODE();
- aio_context_release(ctx);
- aio_context_acquire(qemu_get_aio_context());
new_node_bs = bdrv_new_open_driver_opts(drv, node_name, options, flags,
errp);
- aio_context_release(qemu_get_aio_context());
- aio_context_acquire(ctx);
assert(bdrv_get_aio_context(bs) == ctx);
options = NULL; /* bdrv_new_open_driver() eats options */
bdrv_ref(bs);
bdrv_drained_begin(bs);
bdrv_drained_begin(new_node_bs);
- bdrv_graph_wrlock(new_node_bs);
+ bdrv_graph_wrlock();
ret = bdrv_replace_node(bs, new_node_bs, errp);
bdrv_graph_wrunlock();
bdrv_drained_end(new_node_bs);
* image file header
* -ENOTSUP - format driver doesn't support changing the backing file
*/
-int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,
- const char *backing_fmt, bool require)
+int coroutine_fn
+bdrv_co_change_backing_file(BlockDriverState *bs, const char *backing_file,
+ const char *backing_fmt, bool require)
{
BlockDriver *drv = bs->drv;
int ret;
- GLOBAL_STATE_CODE();
+ IO_CODE();
if (!drv) {
return -ENOMEDIUM;
return -EINVAL;
}
- if (drv->bdrv_change_backing_file != NULL) {
- ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
+ if (drv->bdrv_co_change_backing_file != NULL) {
+ ret = drv->bdrv_co_change_backing_file(bs, backing_file, backing_fmt);
} else {
ret = -ENOTSUP;
}
bdrv_ref(top);
bdrv_drained_begin(base);
- bdrv_graph_wrlock(base);
+ bdrv_graph_wrlock();
if (!top->drv || !base->drv) {
goto exit_wrlock;
GRAPH_RDLOCK_GUARD_MAINLOOP();
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
- AioContext *aio_context = bdrv_get_aio_context(bs);
int ret;
- aio_context_acquire(aio_context);
ret = bdrv_activate(bs, errp);
- aio_context_release(aio_context);
if (ret < 0) {
bdrv_next_cleanup(&it);
return;
BlockDriverState *bs = NULL;
BdrvNextIterator it;
int ret = 0;
- GSList *aio_ctxs = NULL, *ctx;
GLOBAL_STATE_CODE();
GRAPH_RDLOCK_GUARD_MAINLOOP();
- for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
- AioContext *aio_context = bdrv_get_aio_context(bs);
-
- if (!g_slist_find(aio_ctxs, aio_context)) {
- aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
- aio_context_acquire(aio_context);
- }
- }
-
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
/* Nodes with BDS parents are covered by recursion from the last
* parent that gets inactivated. Don't inactivate them a second
ret = bdrv_inactivate_recurse(bs);
if (ret < 0) {
bdrv_next_cleanup(&it);
- goto out;
+ break;
}
}
-out:
- for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
- AioContext *aio_context = ctx->data;
- aio_context_release(aio_context);
- }
- g_slist_free(aio_ctxs);
-
return ret;
}
}
}
+static void bdrv_schedule_unref_bh(void *opaque)
+{
+ BlockDriverState *bs = opaque;
+
+ bdrv_unref(bs);
+}
+
/*
* Release a BlockDriverState reference while holding the graph write lock.
*
if (!bs) {
return;
}
- aio_bh_schedule_oneshot(qemu_get_aio_context(),
- (QEMUBHFunc *) bdrv_unref, bs);
+ aio_bh_schedule_oneshot(qemu_get_aio_context(), bdrv_schedule_unref_bh, bs);
}
struct BdrvOpBlocker {
return;
}
- aio_context_acquire(qemu_get_aio_context());
-
/* Create parameter list */
create_opts = qemu_opts_append(create_opts, drv->create_opts);
create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
qemu_opts_del(opts);
qemu_opts_free(create_opts);
error_propagate(errp, local_err);
- aio_context_release(qemu_get_aio_context());
}
AioContext *bdrv_get_aio_context(BlockDriverState *bs)
bdrv_dec_in_flight(bs);
}
-void coroutine_fn bdrv_co_lock(BlockDriverState *bs)
-{
- AioContext *ctx = bdrv_get_aio_context(bs);
-
- /* In the main thread, bs->aio_context won't change concurrently */
- assert(qemu_get_current_aio_context() == qemu_get_aio_context());
-
- /*
- * We're in coroutine context, so we already hold the lock of the main
- * loop AioContext. Don't lock it twice to avoid deadlocks.
- */
- assert(qemu_in_coroutine());
- if (ctx != qemu_get_aio_context()) {
- aio_context_acquire(ctx);
- }
-}
-
-void coroutine_fn bdrv_co_unlock(BlockDriverState *bs)
-{
- AioContext *ctx = bdrv_get_aio_context(bs);
-
- assert(qemu_in_coroutine());
- if (ctx != qemu_get_aio_context()) {
- aio_context_release(ctx);
- }
-}
-
static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
{
GLOBAL_STATE_CODE();
BdrvStateSetAioContext *state = (BdrvStateSetAioContext *) opaque;
BlockDriverState *bs = (BlockDriverState *) state->bs;
AioContext *new_context = state->new_ctx;
- AioContext *old_context = bdrv_get_aio_context(bs);
- /*
- * Take the old AioContex when detaching it from bs.
- * At this point, new_context lock is already acquired, and we are now
- * also taking old_context. This is safe as long as bdrv_detach_aio_context
- * does not call AIO_POLL_WHILE().
- */
- if (old_context != qemu_get_aio_context()) {
- aio_context_acquire(old_context);
- }
bdrv_detach_aio_context(bs);
- if (old_context != qemu_get_aio_context()) {
- aio_context_release(old_context);
- }
bdrv_attach_aio_context(bs, new_context);
}
*
* Must be called from the main AioContext.
*
- * The caller must own the AioContext lock for the old AioContext of bs, but it
- * must not own the AioContext lock for new_context (unless new_context is the
- * same as the current context of bs).
- *
* @visited will accumulate all visited BdrvChild objects. The caller is
* responsible for freeing the list afterwards.
*/
*
* If ignore_child is not NULL, that child (and its subgraph) will not
* be touched.
- *
- * This function still requires the caller to take the bs current
- * AioContext lock, otherwise draining will fail since AIO_WAIT_WHILE
- * assumes the lock is always held if bs is in another AioContext.
- * For the same reason, it temporarily also holds the new AioContext, since
- * bdrv_drained_end calls BDRV_POLL_WHILE that assumes the lock is taken too.
- * Therefore the new AioContext lock must not be taken by the caller.
*/
int bdrv_try_change_aio_context(BlockDriverState *bs, AioContext *ctx,
BdrvChild *ignore_child, Error **errp)
Transaction *tran;
GHashTable *visited;
int ret;
- AioContext *old_context = bdrv_get_aio_context(bs);
GLOBAL_STATE_CODE();
/*
/*
* Linear phase: go through all callbacks collected in the transaction.
- * Run all callbacks collected in the recursion to switch all nodes
- * AioContext lock (transaction commit), or undo all changes done in the
+ * Run all callbacks collected in the recursion to switch every node's
+ * AioContext (transaction commit), or undo all changes done in the
* recursion (transaction abort).
*/
return -EPERM;
}
- /*
- * Release old AioContext, it won't be needed anymore, as all
- * bdrv_drained_begin() have been called already.
- */
- if (qemu_get_aio_context() != old_context) {
- aio_context_release(old_context);
- }
-
- /*
- * Acquire new AioContext since bdrv_drained_end() is going to be called
- * after we switched all nodes in the new AioContext, and the function
- * assumes that the lock of the bs is always taken.
- */
- if (qemu_get_aio_context() != ctx) {
- aio_context_acquire(ctx);
- }
-
tran_commit(tran);
-
- if (qemu_get_aio_context() != ctx) {
- aio_context_release(ctx);
- }
-
- /* Re-acquire the old AioContext, since the caller takes and releases it. */
- if (qemu_get_aio_context() != old_context) {
- aio_context_acquire(old_context);
- }
-
return 0;
}
const char *node_name, Error **errp)
{
BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
- AioContext *aio_context;
GLOBAL_STATE_CODE();
return NULL;
}
- aio_context = bdrv_get_aio_context(to_replace_bs);
- aio_context_acquire(aio_context);
-
if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
- to_replace_bs = NULL;
- goto out;
+ return NULL;
}
/* We don't want arbitrary node of the BDS chain to be replaced only the top
"because it cannot be guaranteed that doing so would not "
"lead to an abrupt change of visible data",
node_name, parent_bs->node_name);
- to_replace_bs = NULL;
- goto out;
+ return NULL;
}
-out:
- aio_context_release(aio_context);
return to_replace_bs;
}
/* Note: This function may return false positives; it may return true
* even if opening the backing file specified by bs's image header
* would result in exactly bs->backing. */
-static bool bdrv_backing_overridden(BlockDriverState *bs)
+static bool GRAPH_RDLOCK bdrv_backing_overridden(BlockDriverState *bs)
{
GLOBAL_STATE_CODE();
if (bs->backing) {
projects / mirror_qemu.git / blobdiff