2 * Background jobs (long-running operations)
4 * Copyright (c) 2011 IBM Corp.
5 * Copyright (c) 2012, 2018 Red Hat, Inc.
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #include "qemu/osdep.h"
27 #include "qapi/error.h"
30 #include "qemu/main-loop.h"
31 #include "block/aio-wait.h"
32 #include "trace/trace-root.h"
33 #include "qapi/qapi-events-job.h"
36 * job_mutex protects the jobs list, but also makes the
37 * struct job fields thread-safe.
41 static QLIST_HEAD(, Job) jobs = QLIST_HEAD_INITIALIZER(jobs);
43 /* Job State Transition Table */
44 bool JobSTT[JOB_STATUS__MAX][JOB_STATUS__MAX] = {
45 /* U, C, R, P, Y, S, W, D, X, E, N */
46 /* U: */ [JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
47 /* C: */ [JOB_STATUS_CREATED] = {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1},
48 /* R: */ [JOB_STATUS_RUNNING] = {0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0},
49 /* P: */ [JOB_STATUS_PAUSED] = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
50 /* Y: */ [JOB_STATUS_READY] = {0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0},
51 /* S: */ [JOB_STATUS_STANDBY] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
52 /* W: */ [JOB_STATUS_WAITING] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0},
53 /* D: */ [JOB_STATUS_PENDING] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
54 /* X: */ [JOB_STATUS_ABORTING] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
55 /* E: */ [JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
56 /* N: */ [JOB_STATUS_NULL] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
59 bool JobVerbTable[JOB_VERB__MAX][JOB_STATUS__MAX] = {
60 /* U, C, R, P, Y, S, W, D, X, E, N */
61 [JOB_VERB_CANCEL] = {0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0},
62 [JOB_VERB_PAUSE] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
63 [JOB_VERB_RESUME] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
64 [JOB_VERB_SET_SPEED] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
65 [JOB_VERB_COMPLETE] = {0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0},
66 [JOB_VERB_FINALIZE] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
67 [JOB_VERB_DISMISS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
70 /* Transactional group of jobs */
73 /* Is this txn being cancelled? */
77 QLIST_HEAD(, Job) jobs;
93 static void real_job_lock(void)
95 qemu_mutex_lock(&job_mutex);
98 static void real_job_unlock(void)
100 qemu_mutex_unlock(&job_mutex);
103 static void __attribute__((__constructor__)) job_init(void)
105 qemu_mutex_init(&job_mutex);
108 JobTxn *job_txn_new(void)
110 JobTxn *txn = g_new0(JobTxn, 1);
111 QLIST_INIT(&txn->jobs);
116 static void job_txn_ref(JobTxn *txn)
121 void job_txn_unref(JobTxn *txn)
123 if (txn && --txn->refcnt == 0) {
128 void job_txn_add_job(JobTxn *txn, Job *job)
137 QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
141 static void job_txn_del_job(Job *job)
144 QLIST_REMOVE(job, txn_list);
145 job_txn_unref(job->txn);
150 static int job_txn_apply(Job *job, int fn(Job *))
152 AioContext *inner_ctx;
153 Job *other_job, *next;
154 JobTxn *txn = job->txn;
158 * Similar to job_completed_txn_abort, we take each job's lock before
159 * applying fn, but since we assume that outer_ctx is held by the caller,
160 * we need to release it here to avoid holding the lock twice - which would
161 * break AIO_WAIT_WHILE from within fn.
164 aio_context_release(job->aio_context);
166 QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
167 inner_ctx = other_job->aio_context;
168 aio_context_acquire(inner_ctx);
170 aio_context_release(inner_ctx);
177 * Note that job->aio_context might have been changed by calling fn, so we
178 * can't use a local variable to cache it.
180 aio_context_acquire(job->aio_context);
185 bool job_is_internal(Job *job)
187 return (job->id == NULL);
190 static void job_state_transition(Job *job, JobStatus s1)
192 JobStatus s0 = job->status;
193 assert(s1 >= 0 && s1 < JOB_STATUS__MAX);
194 trace_job_state_transition(job, job->ret,
195 JobSTT[s0][s1] ? "allowed" : "disallowed",
196 JobStatus_str(s0), JobStatus_str(s1));
197 assert(JobSTT[s0][s1]);
200 if (!job_is_internal(job) && s1 != s0) {
201 qapi_event_send_job_status_change(job->id, job->status);
205 int job_apply_verb(Job *job, JobVerb verb, Error **errp)
207 JobStatus s0 = job->status;
208 assert(verb >= 0 && verb < JOB_VERB__MAX);
209 trace_job_apply_verb(job, JobStatus_str(s0), JobVerb_str(verb),
210 JobVerbTable[verb][s0] ? "allowed" : "prohibited");
211 if (JobVerbTable[verb][s0]) {
214 error_setg(errp, "Job '%s' in state '%s' cannot accept command verb '%s'",
215 job->id, JobStatus_str(s0), JobVerb_str(verb));
219 JobType job_type(const Job *job)
221 return job->driver->job_type;
224 const char *job_type_str(const Job *job)
226 return JobType_str(job_type(job));
229 bool job_is_cancelled(Job *job)
231 /* force_cancel may be true only if cancelled is true, too */
232 assert(job->cancelled || !job->force_cancel);
233 return job->force_cancel;
236 bool job_cancel_requested(Job *job)
238 return job->cancelled;
241 bool job_is_ready(Job *job)
243 switch (job->status) {
244 case JOB_STATUS_UNDEFINED:
245 case JOB_STATUS_CREATED:
246 case JOB_STATUS_RUNNING:
247 case JOB_STATUS_PAUSED:
248 case JOB_STATUS_WAITING:
249 case JOB_STATUS_PENDING:
250 case JOB_STATUS_ABORTING:
251 case JOB_STATUS_CONCLUDED:
252 case JOB_STATUS_NULL:
254 case JOB_STATUS_READY:
255 case JOB_STATUS_STANDBY:
258 g_assert_not_reached();
263 bool job_is_completed(Job *job)
265 switch (job->status) {
266 case JOB_STATUS_UNDEFINED:
267 case JOB_STATUS_CREATED:
268 case JOB_STATUS_RUNNING:
269 case JOB_STATUS_PAUSED:
270 case JOB_STATUS_READY:
271 case JOB_STATUS_STANDBY:
273 case JOB_STATUS_WAITING:
274 case JOB_STATUS_PENDING:
275 case JOB_STATUS_ABORTING:
276 case JOB_STATUS_CONCLUDED:
277 case JOB_STATUS_NULL:
280 g_assert_not_reached();
285 static bool job_started(Job *job)
290 static bool job_should_pause(Job *job)
292 return job->pause_count > 0;
295 Job *job_next(Job *job)
298 return QLIST_FIRST(&jobs);
300 return QLIST_NEXT(job, job_list);
303 Job *job_get(const char *id)
307 QLIST_FOREACH(job, &jobs, job_list) {
308 if (job->id && !strcmp(id, job->id)) {
316 static void job_sleep_timer_cb(void *opaque)
323 void *job_create(const char *job_id, const JobDriver *driver, JobTxn *txn,
324 AioContext *ctx, int flags, BlockCompletionFunc *cb,
325 void *opaque, Error **errp)
330 if (flags & JOB_INTERNAL) {
331 error_setg(errp, "Cannot specify job ID for internal job");
334 if (!id_wellformed(job_id)) {
335 error_setg(errp, "Invalid job ID '%s'", job_id);
338 if (job_get(job_id)) {
339 error_setg(errp, "Job ID '%s' already in use", job_id);
342 } else if (!(flags & JOB_INTERNAL)) {
343 error_setg(errp, "An explicit job ID is required");
347 job = g_malloc0(driver->instance_size);
348 job->driver = driver;
349 job->id = g_strdup(job_id);
351 job->aio_context = ctx;
354 job->pause_count = 1;
355 job->auto_finalize = !(flags & JOB_MANUAL_FINALIZE);
356 job->auto_dismiss = !(flags & JOB_MANUAL_DISMISS);
358 job->opaque = opaque;
360 progress_init(&job->progress);
362 notifier_list_init(&job->on_finalize_cancelled);
363 notifier_list_init(&job->on_finalize_completed);
364 notifier_list_init(&job->on_pending);
365 notifier_list_init(&job->on_ready);
366 notifier_list_init(&job->on_idle);
368 job_state_transition(job, JOB_STATUS_CREATED);
369 aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
370 QEMU_CLOCK_REALTIME, SCALE_NS,
371 job_sleep_timer_cb, job);
373 QLIST_INSERT_HEAD(&jobs, job, job_list);
375 /* Single jobs are modeled as single-job transactions for sake of
376 * consolidating the job management logic */
379 job_txn_add_job(txn, job);
382 job_txn_add_job(txn, job);
388 void job_ref(Job *job)
393 void job_unref(Job *job)
397 if (--job->refcnt == 0) {
398 assert(job->status == JOB_STATUS_NULL);
399 assert(!timer_pending(&job->sleep_timer));
402 if (job->driver->free) {
403 job->driver->free(job);
406 QLIST_REMOVE(job, job_list);
408 progress_destroy(&job->progress);
409 error_free(job->err);
415 void job_progress_update(Job *job, uint64_t done)
417 progress_work_done(&job->progress, done);
420 void job_progress_set_remaining(Job *job, uint64_t remaining)
422 progress_set_remaining(&job->progress, remaining);
425 void job_progress_increase_remaining(Job *job, uint64_t delta)
427 progress_increase_remaining(&job->progress, delta);
430 void job_event_cancelled(Job *job)
432 notifier_list_notify(&job->on_finalize_cancelled, job);
435 void job_event_completed(Job *job)
437 notifier_list_notify(&job->on_finalize_completed, job);
440 static void job_event_pending(Job *job)
442 notifier_list_notify(&job->on_pending, job);
445 static void job_event_ready(Job *job)
447 notifier_list_notify(&job->on_ready, job);
450 static void job_event_idle(Job *job)
452 notifier_list_notify(&job->on_idle, job);
455 void job_enter_cond(Job *job, bool(*fn)(Job *job))
457 if (!job_started(job)) {
460 if (job->deferred_to_main_loop) {
470 if (fn && !fn(job)) {
475 assert(!job->deferred_to_main_loop);
476 timer_del(&job->sleep_timer);
479 aio_co_enter(job->aio_context, job->co);
482 void job_enter(Job *job)
484 job_enter_cond(job, NULL);
487 /* Yield, and schedule a timer to reenter the coroutine after @ns nanoseconds.
488 * Reentering the job coroutine with job_enter() before the timer has expired
489 * is allowed and cancels the timer.
491 * If @ns is (uint64_t) -1, no timer is scheduled and job_enter() must be
492 * called explicitly. */
493 static void coroutine_fn job_do_yield(Job *job, uint64_t ns)
497 timer_mod(&job->sleep_timer, ns);
502 qemu_coroutine_yield();
504 /* Set by job_enter_cond() before re-entering the coroutine. */
508 void coroutine_fn job_pause_point(Job *job)
510 assert(job && job_started(job));
512 if (!job_should_pause(job)) {
515 if (job_is_cancelled(job)) {
519 if (job->driver->pause) {
520 job->driver->pause(job);
523 if (job_should_pause(job) && !job_is_cancelled(job)) {
524 JobStatus status = job->status;
525 job_state_transition(job, status == JOB_STATUS_READY
527 : JOB_STATUS_PAUSED);
529 job_do_yield(job, -1);
531 job_state_transition(job, status);
534 if (job->driver->resume) {
535 job->driver->resume(job);
539 void coroutine_fn job_yield(Job *job)
543 /* Check cancellation *before* setting busy = false, too! */
544 if (job_is_cancelled(job)) {
548 if (!job_should_pause(job)) {
549 job_do_yield(job, -1);
552 job_pause_point(job);
555 void coroutine_fn job_sleep_ns(Job *job, int64_t ns)
559 /* Check cancellation *before* setting busy = false, too! */
560 if (job_is_cancelled(job)) {
564 if (!job_should_pause(job)) {
565 job_do_yield(job, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ns);
568 job_pause_point(job);
571 /* Assumes the block_job_mutex is held */
572 static bool job_timer_not_pending(Job *job)
574 return !timer_pending(&job->sleep_timer);
577 void job_pause(Job *job)
585 void job_resume(Job *job)
587 assert(job->pause_count > 0);
589 if (job->pause_count) {
593 /* kick only if no timer is pending */
594 job_enter_cond(job, job_timer_not_pending);
597 void job_user_pause(Job *job, Error **errp)
599 if (job_apply_verb(job, JOB_VERB_PAUSE, errp)) {
602 if (job->user_paused) {
603 error_setg(errp, "Job is already paused");
606 job->user_paused = true;
610 bool job_user_paused(Job *job)
612 return job->user_paused;
615 void job_user_resume(Job *job, Error **errp)
619 if (!job->user_paused || job->pause_count <= 0) {
620 error_setg(errp, "Can't resume a job that was not paused");
623 if (job_apply_verb(job, JOB_VERB_RESUME, errp)) {
626 if (job->driver->user_resume) {
627 job->driver->user_resume(job);
629 job->user_paused = false;
633 static void job_do_dismiss(Job *job)
638 job->deferred_to_main_loop = true;
640 job_txn_del_job(job);
642 job_state_transition(job, JOB_STATUS_NULL);
646 void job_dismiss(Job **jobptr, Error **errp)
649 /* similarly to _complete, this is QMP-interface only. */
651 if (job_apply_verb(job, JOB_VERB_DISMISS, errp)) {
659 void job_early_fail(Job *job)
661 assert(job->status == JOB_STATUS_CREATED);
665 static void job_conclude(Job *job)
667 job_state_transition(job, JOB_STATUS_CONCLUDED);
668 if (job->auto_dismiss || !job_started(job)) {
673 static void job_update_rc(Job *job)
675 if (!job->ret && job_is_cancelled(job)) {
676 job->ret = -ECANCELED;
680 error_setg(&job->err, "%s", strerror(-job->ret));
682 job_state_transition(job, JOB_STATUS_ABORTING);
686 static void job_commit(Job *job)
690 if (job->driver->commit) {
691 job->driver->commit(job);
695 static void job_abort(Job *job)
699 if (job->driver->abort) {
700 job->driver->abort(job);
704 static void job_clean(Job *job)
707 if (job->driver->clean) {
708 job->driver->clean(job);
712 static int job_finalize_single(Job *job)
714 assert(job_is_completed(job));
716 /* Ensure abort is called for late-transactional failures */
727 job->cb(job->opaque, job->ret);
730 /* Emit events only if we actually started */
731 if (job_started(job)) {
732 if (job_is_cancelled(job)) {
733 job_event_cancelled(job);
735 job_event_completed(job);
739 job_txn_del_job(job);
744 static void job_cancel_async(Job *job, bool force)
747 if (job->driver->cancel) {
748 force = job->driver->cancel(job, force);
750 /* No .cancel() means the job will behave as if force-cancelled */
754 if (job->user_paused) {
755 /* Do not call job_enter here, the caller will handle it. */
756 if (job->driver->user_resume) {
757 job->driver->user_resume(job);
759 job->user_paused = false;
760 assert(job->pause_count > 0);
765 * Ignore soft cancel requests after the job is already done
766 * (We will still invoke job->driver->cancel() above, but if the
767 * job driver supports soft cancelling and the job is done, that
768 * should be a no-op, too. We still call it so it can override
771 if (force || !job->deferred_to_main_loop) {
772 job->cancelled = true;
773 /* To prevent 'force == false' overriding a previous 'force == true' */
774 job->force_cancel |= force;
778 static void job_completed_txn_abort(Job *job)
781 JobTxn *txn = job->txn;
786 * We are cancelled by another job, which will handle everything.
790 txn->aborting = true;
794 * We can only hold the single job's AioContext lock while calling
795 * job_finalize_single() because the finalization callbacks can involve
796 * calls of AIO_WAIT_WHILE(), which could deadlock otherwise.
797 * Note that the job's AioContext may change when it is finalized.
800 aio_context_release(job->aio_context);
802 /* Other jobs are effectively cancelled by us, set the status for
803 * them; this job, however, may or may not be cancelled, depending
804 * on the caller, so leave it. */
805 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
806 if (other_job != job) {
807 ctx = other_job->aio_context;
808 aio_context_acquire(ctx);
810 * This is a transaction: If one job failed, no result will matter.
811 * Therefore, pass force=true to terminate all other jobs as quickly
814 job_cancel_async(other_job, true);
815 aio_context_release(ctx);
818 while (!QLIST_EMPTY(&txn->jobs)) {
819 other_job = QLIST_FIRST(&txn->jobs);
821 * The job's AioContext may change, so store it in @ctx so we
822 * release the same context that we have acquired before.
824 ctx = other_job->aio_context;
825 aio_context_acquire(ctx);
826 if (!job_is_completed(other_job)) {
827 assert(job_cancel_requested(other_job));
828 job_finish_sync(other_job, NULL, NULL);
830 job_finalize_single(other_job);
831 aio_context_release(ctx);
835 * Use job_ref()/job_unref() so we can read the AioContext here
836 * even if the job went away during job_finalize_single().
838 aio_context_acquire(job->aio_context);
844 static int job_prepare(Job *job)
847 if (job->ret == 0 && job->driver->prepare) {
848 job->ret = job->driver->prepare(job);
854 static int job_needs_finalize(Job *job)
856 return !job->auto_finalize;
859 static void job_do_finalize(Job *job)
862 assert(job && job->txn);
864 /* prepare the transaction to complete */
865 rc = job_txn_apply(job, job_prepare);
867 job_completed_txn_abort(job);
869 job_txn_apply(job, job_finalize_single);
873 void job_finalize(Job *job, Error **errp)
875 assert(job && job->id);
876 if (job_apply_verb(job, JOB_VERB_FINALIZE, errp)) {
879 job_do_finalize(job);
882 static int job_transition_to_pending(Job *job)
884 job_state_transition(job, JOB_STATUS_PENDING);
885 if (!job->auto_finalize) {
886 job_event_pending(job);
891 void job_transition_to_ready(Job *job)
893 job_state_transition(job, JOB_STATUS_READY);
894 job_event_ready(job);
897 static void job_completed_txn_success(Job *job)
899 JobTxn *txn = job->txn;
902 job_state_transition(job, JOB_STATUS_WAITING);
905 * Successful completion, see if there are other running jobs in this
908 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
909 if (!job_is_completed(other_job)) {
912 assert(other_job->ret == 0);
915 job_txn_apply(job, job_transition_to_pending);
917 /* If no jobs need manual finalization, automatically do so */
918 if (job_txn_apply(job, job_needs_finalize) == 0) {
919 job_do_finalize(job);
923 static void job_completed(Job *job)
925 assert(job && job->txn && !job_is_completed(job));
928 trace_job_completed(job, job->ret);
930 job_completed_txn_abort(job);
932 job_completed_txn_success(job);
936 /** Useful only as a type shim for aio_bh_schedule_oneshot. */
937 static void job_exit(void *opaque)
939 Job *job = (Job *)opaque;
943 aio_context_acquire(job->aio_context);
945 /* This is a lie, we're not quiescent, but still doing the completion
946 * callbacks. However, completion callbacks tend to involve operations that
947 * drain block nodes, and if .drained_poll still returned true, we would
955 * Note that calling job_completed can move the job to a different
956 * aio_context, so we cannot cache from above. job_txn_apply takes care of
957 * acquiring the new lock, and we ref/unref to avoid job_completed freeing
958 * the job underneath us.
960 ctx = job->aio_context;
962 aio_context_release(ctx);
966 * All jobs must allow a pause point before entering their job proper. This
967 * ensures that jobs can be paused prior to being started, then resumed later.
969 static void coroutine_fn job_co_entry(void *opaque)
973 assert(job && job->driver && job->driver->run);
974 assert(job->aio_context == qemu_get_current_aio_context());
975 job_pause_point(job);
976 job->ret = job->driver->run(job, &job->err);
977 job->deferred_to_main_loop = true;
979 aio_bh_schedule_oneshot(qemu_get_aio_context(), job_exit, job);
982 void job_start(Job *job)
984 assert(job && !job_started(job) && job->paused &&
985 job->driver && job->driver->run);
986 job->co = qemu_coroutine_create(job_co_entry, job);
990 job_state_transition(job, JOB_STATUS_RUNNING);
991 aio_co_enter(job->aio_context, job->co);
994 void job_cancel(Job *job, bool force)
996 if (job->status == JOB_STATUS_CONCLUDED) {
1000 job_cancel_async(job, force);
1001 if (!job_started(job)) {
1003 } else if (job->deferred_to_main_loop) {
1005 * job_cancel_async() ignores soft-cancel requests for jobs
1006 * that are already done (i.e. deferred to the main loop). We
1007 * have to check again whether the job is really cancelled.
1008 * (job_cancel_requested() and job_is_cancelled() are equivalent
1009 * here, because job_cancel_async() will make soft-cancel
1010 * requests no-ops when deferred_to_main_loop is true. We
1011 * choose to call job_is_cancelled() to show that we invoke
1012 * job_completed_txn_abort() only for force-cancelled jobs.)
1014 if (job_is_cancelled(job)) {
1015 job_completed_txn_abort(job);
1022 void job_user_cancel(Job *job, bool force, Error **errp)
1024 if (job_apply_verb(job, JOB_VERB_CANCEL, errp)) {
1027 job_cancel(job, force);
1030 /* A wrapper around job_cancel() taking an Error ** parameter so it may be
1031 * used with job_finish_sync() without the need for (rather nasty) function
1032 * pointer casts there. */
1033 static void job_cancel_err(Job *job, Error **errp)
1035 job_cancel(job, false);
1039 * Same as job_cancel_err(), but force-cancel.
1041 static void job_force_cancel_err(Job *job, Error **errp)
1043 job_cancel(job, true);
1046 int job_cancel_sync(Job *job, bool force)
1049 return job_finish_sync(job, &job_force_cancel_err, NULL);
1051 return job_finish_sync(job, &job_cancel_err, NULL);
1055 void job_cancel_sync_all(void)
1058 AioContext *aio_context;
1060 while ((job = job_next(NULL))) {
1061 aio_context = job->aio_context;
1062 aio_context_acquire(aio_context);
1063 job_cancel_sync(job, true);
1064 aio_context_release(aio_context);
1068 int job_complete_sync(Job *job, Error **errp)
1070 return job_finish_sync(job, job_complete, errp);
1073 void job_complete(Job *job, Error **errp)
1075 /* Should not be reachable via external interface for internal jobs */
1077 GLOBAL_STATE_CODE();
1078 if (job_apply_verb(job, JOB_VERB_COMPLETE, errp)) {
1081 if (job_cancel_requested(job) || !job->driver->complete) {
1082 error_setg(errp, "The active block job '%s' cannot be completed",
1087 job->driver->complete(job, errp);
1090 int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)
1092 Error *local_err = NULL;
1098 finish(job, &local_err);
1101 error_propagate(errp, local_err);
1106 AIO_WAIT_WHILE(job->aio_context,
1107 (job_enter(job), !job_is_completed(job)));
1109 ret = (job_is_cancelled(job) && job->ret == 0) ? -ECANCELED : job->ret;