[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH v5 3/8] blockjob: add pause points
From: |
Stefan Hajnoczi |
Subject: |
[Qemu-devel] [PATCH v5 3/8] blockjob: add pause points |
Date: |
Thu, 16 Jun 2016 17:56:24 +0100 |
Block jobs are coroutines that usually perform I/O but sometimes also
sleep or yield. Currently only sleeping or yielded block jobs can be
paused. This means jobs that do not sleep or yield (using
block_job_yield()) are unaffected by block_job_pause().
Add block_job_pause_point() so that block jobs can mark quiescent points
that are suitable for pausing. This solves the problem that it can take
a block job a long time to pause if it is performing a long series of
I/O operations.
Transitioning to paused state involves a .pause()/.resume() callback.
These callbacks are used to ensure that I/O and event loop activity has
ceased while the job is at a pause point.
Note that this patch introduces a stricter pause state than previously.
The job->busy flag was incorrectly documented as a quiescent state
without I/O pending. This is violated by any job that has I/O pending
across sleep or block_job_yield(), like the mirror block job.
Signed-off-by: Stefan Hajnoczi <address@hidden>
---
blockjob.c | 46 ++++++++++++++++++++++++++++++++++++++--------
include/block/blockjob.h | 35 ++++++++++++++++++++++++++++++++---
2 files changed, 70 insertions(+), 11 deletions(-)
diff --git a/blockjob.c b/blockjob.c
index 08ac430..9357456 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -257,6 +257,32 @@ static bool block_job_should_pause(BlockJob *job)
return job->pause_count > 0;
}
+void coroutine_fn block_job_pause_point(BlockJob *job)
+{
+ if (!block_job_should_pause(job)) {
+ return;
+ }
+ if (block_job_is_cancelled(job)) {
+ return;
+ }
+
+ if (job->driver->pause) {
+ job->driver->pause(job);
+ }
+
+ if (!block_job_is_cancelled(job)) {
+ job->paused = true;
+ job->busy = false;
+ qemu_coroutine_yield(); /* wait for block_job_resume() */
+ job->busy = true;
+ job->paused = false;
+ }
+
+ if (job->driver->resume) {
+ job->driver->resume(job);
+ }
+}
+
void block_job_resume(BlockJob *job)
{
assert(job->pause_count > 0);
@@ -360,13 +386,13 @@ void block_job_sleep_ns(BlockJob *job, QEMUClockType
type, int64_t ns)
return;
}
- job->busy = false;
- if (block_job_should_pause(job)) {
- qemu_coroutine_yield();
- } else {
+ if (!block_job_should_pause(job)) {
+ job->busy = false;
co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
+ job->busy = true;
}
- job->busy = true;
+
+ block_job_pause_point(job);
}
void block_job_yield(BlockJob *job)
@@ -378,9 +404,13 @@ void block_job_yield(BlockJob *job)
return;
}
- job->busy = false;
- qemu_coroutine_yield();
- job->busy = true;
+ if (!block_job_should_pause(job)) {
+ job->busy = false;
+ qemu_coroutine_yield();
+ job->busy = true;
+ }
+
+ block_job_pause_point(job);
}
BlockJobInfo *block_job_query(BlockJob *job)
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index 8fcecf9..7739f37 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -70,6 +70,20 @@ typedef struct BlockJobDriver {
* never both.
*/
void (*abort)(BlockJob *job);
+
+ /**
+ * If the callback is not NULL, it will be invoked when the job transitions
+ * into the paused state. Paused jobs must not perform any asynchronous
+ * I/O or event loop activity. This callback is used to quiesce jobs.
+ */
+ void coroutine_fn (*pause)(BlockJob *job);
+
+ /**
+ * If the callback is not NULL, it will be invoked when the job transitions
+ * out of the paused state. Any asynchronous I/O or event loop activity
+ * should be restarted from this callback.
+ */
+ void coroutine_fn (*resume)(BlockJob *job);
} BlockJobDriver;
/**
@@ -119,13 +133,19 @@ struct BlockJob {
bool user_paused;
/**
- * Set to false by the job while it is in a quiescent state, where
- * no I/O is pending and the job has yielded on any condition
- * that is not detected by #aio_poll, such as a timer.
+ * Set to false by the job while the coroutine has yielded and may be
+ * re-entered by block_job_enter(). There may still be I/O or event loop
+ * activity pending.
*/
bool busy;
/**
+ * Set to true by the job while it is in a quiescent state, where
+ * no I/O or event loop activity is pending.
+ */
+ bool paused;
+
+ /**
* Set to true when the job is ready to be completed.
*/
bool ready;
@@ -299,6 +319,15 @@ bool block_job_is_cancelled(BlockJob *job);
BlockJobInfo *block_job_query(BlockJob *job);
/**
+ * block_job_pause_point:
+ * @job: The job that is ready to pause.
+ *
+ * Pause now if block_job_pause() has been called. Block jobs that perform
+ * lots of I/O must call this between requests so that the job can be paused.
+ */
+void coroutine_fn block_job_pause_point(BlockJob *job);
+
+/**
* block_job_pause:
* @job: The job to be paused.
*
--
2.5.5
- [Qemu-devel] [PATCH v5 0/8] blockjob: AioContext change support for mirror and backup, Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 4/8] blockjob: add block_job_get_aio_context(), Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 2/8] blockjob: rename block_job_is_paused(), Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 3/8] blockjob: add pause points,
Stefan Hajnoczi <=
- [Qemu-devel] [PATCH v5 6/8] blockjob: add AioContext attached callback, Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 1/8] blockjob: move iostatus reset out of block_job_enter(), Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 8/8] backup: follow AioContext change gracefully, Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 7/8] mirror: follow AioContext change gracefully, Stefan Hajnoczi, 2016/06/16
- [Qemu-devel] [PATCH v5 5/8] block: use safe iteration over AioContext notifiers, Stefan Hajnoczi, 2016/06/16
- Re: [Qemu-devel] [PATCH v5 0/8] blockjob: AioContext change support for mirror and backup, Paolo Bonzini, 2016/06/16
- Re: [Qemu-devel] [PATCH v5 0/8] blockjob: AioContext change support for mirror and backup, Stefan Hajnoczi, 2016/06/17