target/ppc: Fix TCG temporary leaks in gen_slbia()

[qemu.git] / job.c

diff --git a/job.c b/job.c
index c65e01bbfa34764727530ef04ee632b611ec5e56..53be57a3a0b6d57d21e327d12a75acdfba40c67d 100644 (file)
--- a/job.c
+++ b/job.c
@@ -24,7 +24,6 @@
  */
 
 #include "qemu/osdep.h"
  */
 
 #include "qemu/osdep.h"

-#include "qemu-common.h"

 #include "qapi/error.h"
 #include "qemu/job.h"
 #include "qemu/id.h"
 #include "qapi/error.h"
 #include "qemu/job.h"
 #include "qemu/id.h"


@@ -137,17 +136,38 @@ static void job_txn_del_job(Job *job)
     }
 }
 
     }
 }
 

-static int job_txn_apply(JobTxn *txn, int fn(Job *))
+static int job_txn_apply(Job *job, int fn(Job *))

 {
 {

-    Job *job, *next;
+    AioContext *inner_ctx;
+    Job *other_job, *next;
+    JobTxn *txn = job->txn;

     int rc = 0;
 
     int rc = 0;
 

-    QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
-        rc = fn(job);
+    /*
+     * Similar to job_completed_txn_abort, we take each job's lock before
+     * applying fn, but since we assume that outer_ctx is held by the caller,
+     * we need to release it here to avoid holding the lock twice - which would
+     * break AIO_WAIT_WHILE from within fn.
+     */
+    job_ref(job);
+    aio_context_release(job->aio_context);
+
+    QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
+        inner_ctx = other_job->aio_context;
+        aio_context_acquire(inner_ctx);
+        rc = fn(other_job);
+        aio_context_release(inner_ctx);

         if (rc) {
             break;
         }
     }
         if (rc) {
             break;
         }
     }

+
+    /*
+     * Note that job->aio_context might have been changed by calling fn, so we
+     * can't use a local variable to cache it.
+     */
+    aio_context_acquire(job->aio_context);
+    job_unref(job);

     return rc;
 }
 
     return rc;
 }
 


@@ -159,7 +179,7 @@ bool job_is_internal(Job *job)
 static void job_state_transition(Job *job, JobStatus s1)
 {
     JobStatus s0 = job->status;
 static void job_state_transition(Job *job, JobStatus s1)
 {
     JobStatus s0 = job->status;

-    assert(s1 >= 0 && s1 <= JOB_STATUS__MAX);
+    assert(s1 >= 0 && s1 < JOB_STATUS__MAX);

     trace_job_state_transition(job, job->ret,
                                JobSTT[s0][s1] ? "allowed" : "disallowed",
                                JobStatus_str(s0), JobStatus_str(s1));
     trace_job_state_transition(job, job->ret,
                                JobSTT[s0][s1] ? "allowed" : "disallowed",
                                JobStatus_str(s0), JobStatus_str(s1));


@@ -174,7 +194,7 @@ static void job_state_transition(Job *job, JobStatus s1)
 int job_apply_verb(Job *job, JobVerb verb, Error **errp)
 {
     JobStatus s0 = job->status;
 int job_apply_verb(Job *job, JobVerb verb, Error **errp)
 {
     JobStatus s0 = job->status;

-    assert(verb >= 0 && verb <= JOB_VERB__MAX);
+    assert(verb >= 0 && verb < JOB_VERB__MAX);

     trace_job_apply_verb(job, JobStatus_str(s0), JobVerb_str(verb),
                          JobVerbTable[verb][s0] ? "allowed" : "prohibited");
     if (JobVerbTable[verb][s0]) {
     trace_job_apply_verb(job, JobStatus_str(s0), JobVerb_str(verb),
                          JobVerbTable[verb][s0] ? "allowed" : "prohibited");
     if (JobVerbTable[verb][s0]) {


@@ -370,17 +390,17 @@ void job_unref(Job *job)
 
 void job_progress_update(Job *job, uint64_t done)
 {
 
 void job_progress_update(Job *job, uint64_t done)
 {

-    job->progress_current += done;
+    progress_work_done(&job->progress, done);

 }
 
 void job_progress_set_remaining(Job *job, uint64_t remaining)
 {
 }
 
 void job_progress_set_remaining(Job *job, uint64_t remaining)
 {

-    job->progress_total = job->progress_current + remaining;
+    progress_set_remaining(&job->progress, remaining);

 }
 
 void job_progress_increase_remaining(Job *job, uint64_t delta)
 {
 }
 
 void job_progress_increase_remaining(Job *job, uint64_t delta)
 {

-    job->progress_total += delta;
+    progress_increase_remaining(&job->progress, delta);

 }
 
 void job_event_cancelled(Job *job)
 }
 
 void job_event_cancelled(Job *job)


@@ -432,7 +452,7 @@ void job_enter_cond(Job *job, bool(*fn)(Job *job))
     timer_del(&job->sleep_timer);
     job->busy = true;
     job_unlock();
     timer_del(&job->sleep_timer);
     job->busy = true;
     job_unlock();

-    aio_co_wake(job->co);
+    aio_co_enter(job->aio_context, job->co);

 }
 
 void job_enter(Job *job)
 }
 
 void job_enter(Job *job)


@@ -524,16 +544,6 @@ void coroutine_fn job_sleep_ns(Job *job, int64_t ns)
     job_pause_point(job);
 }
 
     job_pause_point(job);
 }
 

-void job_drain(Job *job)
-{
-    /* If job is !busy this kicks it into the next pause point. */
-    job_enter(job);
-
-    if (job->driver->drain) {
-        job->driver->drain(job);
-    }
-}
-

 /* Assumes the block_job_mutex is held */
 static bool job_timer_not_pending(Job *job)
 {
 /* Assumes the block_job_mutex is held */
 static bool job_timer_not_pending(Job *job)
 {


@@ -785,11 +795,11 @@ static void job_do_finalize(Job *job)
     assert(job && job->txn);
 
     /* prepare the transaction to complete */
     assert(job && job->txn);
 
     /* prepare the transaction to complete */

-    rc = job_txn_apply(job->txn, job_prepare);
+    rc = job_txn_apply(job, job_prepare);

     if (rc) {
         job_completed_txn_abort(job);
     } else {
     if (rc) {
         job_completed_txn_abort(job);
     } else {

-        job_txn_apply(job->txn, job_finalize_single);
+        job_txn_apply(job, job_finalize_single);

     }
 }
 
     }
 }
 


@@ -835,10 +845,10 @@ static void job_completed_txn_success(Job *job)
         assert(other_job->ret == 0);
     }
 
         assert(other_job->ret == 0);
     }
 

-    job_txn_apply(txn, job_transition_to_pending);
+    job_txn_apply(job, job_transition_to_pending);

 
     /* If no jobs need manual finalization, automatically do so */
 
     /* If no jobs need manual finalization, automatically do so */

-    if (job_txn_apply(txn, job_needs_finalize) == 0) {
+    if (job_txn_apply(job, job_needs_finalize) == 0) {

         job_do_finalize(job);
     }
 }
         job_do_finalize(job);
     }
 }


@@ -860,9 +870,10 @@ static void job_completed(Job *job)
 static void job_exit(void *opaque)
 {
     Job *job = (Job *)opaque;
 static void job_exit(void *opaque)
 {
     Job *job = (Job *)opaque;

-    AioContext *ctx = job->aio_context;
+    AioContext *ctx;

 
 

-    aio_context_acquire(ctx);
+    job_ref(job);
+    aio_context_acquire(job->aio_context);

 
     /* This is a lie, we're not quiescent, but still doing the completion
      * callbacks. However, completion callbacks tend to involve operations that
 
     /* This is a lie, we're not quiescent, but still doing the completion
      * callbacks. However, completion callbacks tend to involve operations that


@@ -873,6 +884,14 @@ static void job_exit(void *opaque)
 
     job_completed(job);
 
 
     job_completed(job);
 

+    /*
+     * Note that calling job_completed can move the job to a different
+     * aio_context, so we cannot cache from above. job_txn_apply takes care of
+     * acquiring the new lock, and we ref/unref to avoid job_completed freeing
+     * the job underneath us.
+     */
+    ctx = job->aio_context;
+    job_unref(job);

     aio_context_release(ctx);
 }
 
     aio_context_release(ctx);
 }
 


@@ -992,7 +1011,7 @@ int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)
     }
 
     AIO_WAIT_WHILE(job->aio_context,
     }
 
     AIO_WAIT_WHILE(job->aio_context,

-                   (job_drain(job), !job_is_completed(job)));
+                   (job_enter(job), !job_is_completed(job)));

 
     ret = (job_is_cancelled(job) && job->ret == 0) ? -ECANCELED : job->ret;
     job_unref(job);
 
     ret = (job_is_cancelled(job) && job->ret == 0) ? -ECANCELED : job->ret;
     job_unref(job);