[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Qemu-block] [PULL 01/12] mirror: Confirm we're quiesced only if the job

From: Kevin Wolf
Subject: [Qemu-block] [PULL 01/12] mirror: Confirm we're quiesced only if the job is paused or cancelled
Date: Tue, 19 Mar 2019 16:46:09 +0100

From: Sergio Lopez <address@hidden>

While child_job_drained_begin() calls to job_pause(), the job doesn't
actually transition between states until it runs again and reaches a
pause point. This means bdrv_drained_begin() may return with some jobs
using the node still having 'busy == true'.

As a consequence, block_job_detach_aio_context() may get into a
deadlock, waiting for the job to be actually paused, while the coroutine
servicing the job is yielding and doesn't get the opportunity to get
scheduled again. This situation can be reproduced by issuing a
'block-commit' immediately followed by a 'device_del'.

To ensure bdrv_drained_begin() only returns when the jobs have been
paused, we change mirror_drained_poll() to only confirm it's quiesced
when job->paused == true and there aren't any in-flight requests, except
if we reached that point by a drained section initiated by the
mirror/commit job itself.

The other block jobs shouldn't need any changes, as the default
drained_poll() behavior is to only confirm it's quiesced if the job is
not busy or completed.

Signed-off-by: Sergio Lopez <address@hidden>
Signed-off-by: Kevin Wolf <address@hidden>
 block/mirror.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/block/mirror.c b/block/mirror.c
index 010fdafd79..eb9a4cdf56 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -80,6 +80,7 @@ typedef struct MirrorBlockJob {
     bool initial_zeroing_ongoing;
     int in_active_write_counter;
     bool prepared;
+    bool in_drain;
 } MirrorBlockJob;
 typedef struct MirrorBDSOpaque {
@@ -683,6 +684,7 @@ static int mirror_exit_common(Job *job)
         /* The mirror job has no requests in flight any more, but we need to
          * drain potential other users of the BDS before changing the graph. */
+        assert(s->in_drain);
         bdrv_replace_node(to_replace, target_bs, &local_err);
@@ -721,6 +723,7 @@ static int mirror_exit_common(Job *job)
     bs_opaque->job = NULL;
+    s->in_drain = false;
@@ -1004,10 +1007,12 @@ static int coroutine_fn mirror_run(Job *job, Error 
             trace_mirror_before_drain(s, cnt);
+            s->in_drain = true;
             cnt = bdrv_get_dirty_count(s->dirty_bitmap);
             if (cnt > 0 || mirror_flush(s) < 0) {
+                s->in_drain = false;
@@ -1055,6 +1060,7 @@ immediate_exit:
     if (need_drain) {
+        s->in_drain = true;
@@ -1123,6 +1129,16 @@ static void coroutine_fn mirror_pause(Job *job)
 static bool mirror_drained_poll(BlockJob *job)
     MirrorBlockJob *s = container_of(job, MirrorBlockJob, common);
+    /* If the job isn't paused nor cancelled, we can't be sure that it won't
+     * issue more requests. We make an exception if we've reached this point
+     * from one of our own drain sections, to avoid a deadlock waiting for
+     * ourselves.
+     */
+    if (!s->common.job.paused && !s->common.job.cancelled && !s->in_drain) {
+        return true;
+    }
     return !!s->in_flight;

reply via email to

[Prev in Thread] Current Thread [Next in Thread]