[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH v4 17/19] jobs: protect job.aio_context with BQL and job_mutex
From: |
Emanuele Giuseppe Esposito |
Subject: |
[PATCH v4 17/19] jobs: protect job.aio_context with BQL and job_mutex |
Date: |
Fri, 28 Jan 2022 06:50:29 -0500 |
In order to make it thread safe, implement a "fake rwlock",
where we allow reads under BQL *or* job_mutex held, but
writes only under BQL *and* job_mutex.
The only write we have is in child_job_set_aio_ctx, which always
happens under drain (so the job is paused).
For this reason, introduce job_set_aio_context and make sure that
the context is set under BQL, job_mutex and drain.
Also make sure all other places where the aiocontext is read
are protected.
Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
---
block/replication.c | 2 +-
blockjob.c | 3 ++-
include/qemu/job.h | 19 ++++++++++++++++++-
job.c | 12 ++++++++++++
4 files changed, 33 insertions(+), 3 deletions(-)
diff --git a/block/replication.c b/block/replication.c
index 50ea778937..68018948b9 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -148,8 +148,8 @@ static void replication_close(BlockDriverState *bs)
}
if (s->stage == BLOCK_REPLICATION_FAILOVER) {
commit_job = &s->commit_job->job;
- assert(commit_job->aio_context == qemu_get_current_aio_context());
WITH_JOB_LOCK_GUARD() {
+ assert(commit_job->aio_context == qemu_get_current_aio_context());
job_cancel_sync_locked(commit_job, false);
}
}
diff --git a/blockjob.c b/blockjob.c
index 04d868f020..afb0e9ad5e 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -154,12 +154,13 @@ static void child_job_set_aio_ctx(BdrvChild *c,
AioContext *ctx,
bdrv_set_aio_context_ignore(sibling->bs, ctx, ignore);
}
- job->job.aio_context = ctx;
+ job_set_aio_context(&job->job, ctx);
}
static AioContext *child_job_get_parent_aio_context(BdrvChild *c)
{
BlockJob *job = c->opaque;
+ assert(qemu_in_main_thread());
return job->job.aio_context;
}
diff --git a/include/qemu/job.h b/include/qemu/job.h
index fc57472e84..f335bac46c 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -75,7 +75,12 @@ typedef struct Job {
ProgressMeter progress;
- /** AioContext to run the job coroutine in */
+ /**
+ * AioContext to run the job coroutine in.
+ * This field can be read when holding either the BQL (so we are in
+ * the main loop) or the job_mutex.
+ * Instead, it can be only written when we hold *both* BQL and job_mutex.
+ */
AioContext *aio_context;
/** Reference count of the block job */
@@ -731,4 +736,16 @@ void job_dismiss_locked(Job **job, Error **errp);
int job_finish_sync_locked(Job *job, void (*finish)(Job *, Error **errp),
Error **errp);
+/**
+ * Sets the @job->aio_context.
+ * Called with job_mutex *not* held.
+ *
+ * This function must run in the main thread to protect against
+ * concurrent read in job_finish_sync_locked(),
+ * takes the job_mutex lock to protect against the read in
+ * job_do_yield_locked(), and must be called when the coroutine
+ * is quiescent.
+ */
+void job_set_aio_context(Job *job, AioContext *ctx);
+
#endif
diff --git a/job.c b/job.c
index bce76b21d8..c4e0641bd4 100644
--- a/job.c
+++ b/job.c
@@ -357,6 +357,17 @@ Job *job_get_locked(const char *id)
return NULL;
}
+void job_set_aio_context(Job *job, AioContext *ctx)
+{
+ /* protect against read in job_finish_sync_locked */
+ assert(qemu_in_main_thread());
+ /* protect against read in job_do_yield_locked */
+ JOB_LOCK_GUARD();
+ /* ensure the coroutine is quiescent while the AioContext is changed */
+ assert(job->pause_count > 0);
+ job->aio_context = ctx;
+}
+
/* Called with job_mutex *not* held. */
static void job_sleep_timer_cb(void *opaque)
{
@@ -1274,6 +1285,7 @@ int job_finish_sync_locked(Job *job, void (*finish)(Job
*, Error **errp),
{
Error *local_err = NULL;
int ret;
+ assert(qemu_in_main_thread());
job_ref_locked(job);
--
2.31.1
- [PATCH v4 02/19] job.h: categorize fields in struct Job, (continued)
- [PATCH v4 02/19] job.h: categorize fields in struct Job, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 04/19] job.c: move inner aiocontext lock in callbacks, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 03/19] job.c: make job_event_* functions static, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 05/19] aio-wait.h: introduce AIO_WAIT_WHILE_UNLOCKED, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 07/19] jobs: protect jobs with job_lock/unlock, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 14/19] blockjob: block_job_get_aio_context is a GS function, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 06/19] jobs: remove aiocontext locks since the functions are under BQL, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 09/19] jobs: use job locks also in the unit tests, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 16/19] job: detect change of aiocontext within job coroutine, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 12/19] job.h: define unlocked functions, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 17/19] jobs: protect job.aio_context with BQL and job_mutex,
Emanuele Giuseppe Esposito <=
- [PATCH v4 18/19] job.c: enable job lock/unlock and remove Aiocontext locks, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 19/19] block_job_query: remove atomic read, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 11/19] jobs: document all static functions and add _locked() suffix, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 08/19] jobs: add job lock in find_* functions, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 13/19] block/mirror.c: use of job helpers in drivers to avoid TOC/TOU, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 15/19] commit and mirror: create new nodes using bdrv_get_aio_context, and not the job aiocontext, Emanuele Giuseppe Esposito, 2022/01/28
- [PATCH v4 10/19] job.h: define locked functions, Emanuele Giuseppe Esposito, 2022/01/28