blob: 192f16842367e676e21df549eaa46825edae37fd [file] [log] [blame]
Kevin Wolf33e9e9b2018-04-12 17:29:59 +02001/*
2 * Background jobs (long-running operations)
3 *
4 * Copyright (c) 2011 IBM Corp.
5 * Copyright (c) 2012, 2018 Red Hat, Inc.
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
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
23 * THE SOFTWARE.
24 */
25
26#include "qemu/osdep.h"
27#include "qemu-common.h"
28#include "qapi/error.h"
29#include "qemu/job.h"
30#include "qemu/id.h"
Kevin Wolf1908a552018-04-17 16:41:17 +020031#include "qemu/main-loop.h"
Kevin Wolfa50c2ab2018-04-13 17:19:31 +020032#include "trace-root.h"
Kevin Wolf1dac83f2018-04-30 19:09:46 +020033#include "qapi/qapi-events-job.h"
Kevin Wolf33e9e9b2018-04-12 17:29:59 +020034
Kevin Wolfe7c1d782018-04-12 17:54:37 +020035static QLIST_HEAD(, Job) jobs = QLIST_HEAD_INITIALIZER(jobs);
36
Kevin Wolfa50c2ab2018-04-13 17:19:31 +020037/* Job State Transition Table */
38bool JobSTT[JOB_STATUS__MAX][JOB_STATUS__MAX] = {
39 /* U, C, R, P, Y, S, W, D, X, E, N */
40 /* U: */ [JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
41 /* C: */ [JOB_STATUS_CREATED] = {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1},
42 /* R: */ [JOB_STATUS_RUNNING] = {0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0},
43 /* P: */ [JOB_STATUS_PAUSED] = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
44 /* Y: */ [JOB_STATUS_READY] = {0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0},
45 /* S: */ [JOB_STATUS_STANDBY] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
46 /* W: */ [JOB_STATUS_WAITING] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0},
47 /* D: */ [JOB_STATUS_PENDING] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
48 /* X: */ [JOB_STATUS_ABORTING] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
49 /* E: */ [JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
50 /* N: */ [JOB_STATUS_NULL] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
51};
52
53bool JobVerbTable[JOB_VERB__MAX][JOB_STATUS__MAX] = {
54 /* U, C, R, P, Y, S, W, D, X, E, N */
55 [JOB_VERB_CANCEL] = {0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0},
56 [JOB_VERB_PAUSE] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
57 [JOB_VERB_RESUME] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
58 [JOB_VERB_SET_SPEED] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
59 [JOB_VERB_COMPLETE] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
60 [JOB_VERB_FINALIZE] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
61 [JOB_VERB_DISMISS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
62};
63
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +020064/* Transactional group of jobs */
65struct JobTxn {
66
67 /* Is this txn being cancelled? */
68 bool aborting;
69
70 /* List of jobs */
71 QLIST_HEAD(, Job) jobs;
72
73 /* Reference count */
74 int refcnt;
75};
76
Kevin Wolfda01ff72018-04-13 17:31:02 +020077/* Right now, this mutex is only needed to synchronize accesses to job->busy
78 * and job->sleep_timer, such as concurrent calls to job_do_yield and
79 * job_enter. */
80static QemuMutex job_mutex;
81
82static void job_lock(void)
83{
84 qemu_mutex_lock(&job_mutex);
85}
86
87static void job_unlock(void)
88{
89 qemu_mutex_unlock(&job_mutex);
90}
91
92static void __attribute__((__constructor__)) job_init(void)
93{
94 qemu_mutex_init(&job_mutex);
95}
96
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +020097JobTxn *job_txn_new(void)
98{
99 JobTxn *txn = g_new0(JobTxn, 1);
100 QLIST_INIT(&txn->jobs);
101 txn->refcnt = 1;
102 return txn;
103}
104
105static void job_txn_ref(JobTxn *txn)
106{
107 txn->refcnt++;
108}
109
110void job_txn_unref(JobTxn *txn)
111{
112 if (txn && --txn->refcnt == 0) {
113 g_free(txn);
114 }
115}
116
117void job_txn_add_job(JobTxn *txn, Job *job)
118{
119 if (!txn) {
120 return;
121 }
122
123 assert(!job->txn);
124 job->txn = txn;
125
126 QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
127 job_txn_ref(txn);
128}
129
130static void job_txn_del_job(Job *job)
131{
132 if (job->txn) {
133 QLIST_REMOVE(job, txn_list);
134 job_txn_unref(job->txn);
135 job->txn = NULL;
136 }
137}
138
139static int job_txn_apply(JobTxn *txn, int fn(Job *), bool lock)
140{
141 AioContext *ctx;
142 Job *job, *next;
143 int rc = 0;
144
145 QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
146 if (lock) {
147 ctx = job->aio_context;
148 aio_context_acquire(ctx);
149 }
150 rc = fn(job);
151 if (lock) {
152 aio_context_release(ctx);
153 }
154 if (rc) {
155 break;
156 }
157 }
158 return rc;
159}
160
Kevin Wolf456273b2018-05-04 16:25:43 +0200161bool job_is_internal(Job *job)
Kevin Wolf1dac83f2018-04-30 19:09:46 +0200162{
163 return (job->id == NULL);
164}
165
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200166static void job_state_transition(Job *job, JobStatus s1)
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200167{
168 JobStatus s0 = job->status;
169 assert(s1 >= 0 && s1 <= JOB_STATUS__MAX);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200170 trace_job_state_transition(job, job->ret,
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200171 JobSTT[s0][s1] ? "allowed" : "disallowed",
172 JobStatus_str(s0), JobStatus_str(s1));
173 assert(JobSTT[s0][s1]);
174 job->status = s1;
Kevin Wolf1dac83f2018-04-30 19:09:46 +0200175
176 if (!job_is_internal(job) && s1 != s0) {
Peter Xu3ab72382018-08-15 21:37:37 +0800177 qapi_event_send_job_status_change(job->id, job->status);
Kevin Wolf1dac83f2018-04-30 19:09:46 +0200178 }
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200179}
180
181int job_apply_verb(Job *job, JobVerb verb, Error **errp)
182{
183 JobStatus s0 = job->status;
184 assert(verb >= 0 && verb <= JOB_VERB__MAX);
185 trace_job_apply_verb(job, JobStatus_str(s0), JobVerb_str(verb),
186 JobVerbTable[verb][s0] ? "allowed" : "prohibited");
187 if (JobVerbTable[verb][s0]) {
188 return 0;
189 }
190 error_setg(errp, "Job '%s' in state '%s' cannot accept command verb '%s'",
191 job->id, JobStatus_str(s0), JobVerb_str(verb));
192 return -EPERM;
193}
194
Kevin Wolf252291e2018-04-12 17:57:08 +0200195JobType job_type(const Job *job)
196{
197 return job->driver->job_type;
198}
199
200const char *job_type_str(const Job *job)
201{
202 return JobType_str(job_type(job));
203}
204
Kevin Wolfdaa7f2f2018-04-17 12:56:07 +0200205bool job_is_cancelled(Job *job)
206{
207 return job->cancelled;
208}
209
Kevin Wolfdf956ae2018-04-25 15:09:58 +0200210bool job_is_ready(Job *job)
211{
212 switch (job->status) {
213 case JOB_STATUS_UNDEFINED:
214 case JOB_STATUS_CREATED:
215 case JOB_STATUS_RUNNING:
216 case JOB_STATUS_PAUSED:
217 case JOB_STATUS_WAITING:
218 case JOB_STATUS_PENDING:
219 case JOB_STATUS_ABORTING:
220 case JOB_STATUS_CONCLUDED:
221 case JOB_STATUS_NULL:
222 return false;
223 case JOB_STATUS_READY:
224 case JOB_STATUS_STANDBY:
225 return true;
226 default:
227 g_assert_not_reached();
228 }
229 return false;
230}
231
Kevin Wolfdbe5e6c2018-04-19 13:04:01 +0200232bool job_is_completed(Job *job)
233{
234 switch (job->status) {
235 case JOB_STATUS_UNDEFINED:
236 case JOB_STATUS_CREATED:
237 case JOB_STATUS_RUNNING:
238 case JOB_STATUS_PAUSED:
239 case JOB_STATUS_READY:
240 case JOB_STATUS_STANDBY:
241 return false;
242 case JOB_STATUS_WAITING:
243 case JOB_STATUS_PENDING:
244 case JOB_STATUS_ABORTING:
245 case JOB_STATUS_CONCLUDED:
246 case JOB_STATUS_NULL:
247 return true;
248 default:
249 g_assert_not_reached();
250 }
251 return false;
252}
253
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200254static bool job_started(Job *job)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200255{
256 return job->co;
257}
258
Kevin Wolf198c49c2018-04-24 16:55:04 +0200259static bool job_should_pause(Job *job)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200260{
261 return job->pause_count > 0;
262}
263
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200264Job *job_next(Job *job)
265{
266 if (!job) {
267 return QLIST_FIRST(&jobs);
268 }
269 return QLIST_NEXT(job, job_list);
270}
271
272Job *job_get(const char *id)
273{
274 Job *job;
275
276 QLIST_FOREACH(job, &jobs, job_list) {
277 if (job->id && !strcmp(id, job->id)) {
278 return job;
279 }
280 }
281
282 return NULL;
283}
284
Kevin Wolf5d43e862018-04-18 16:32:20 +0200285static void job_sleep_timer_cb(void *opaque)
286{
287 Job *job = opaque;
288
289 job_enter(job);
290}
291
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200292void *job_create(const char *job_id, const JobDriver *driver, JobTxn *txn,
293 AioContext *ctx, int flags, BlockCompletionFunc *cb,
294 void *opaque, Error **errp)
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200295{
296 Job *job;
297
298 if (job_id) {
Kevin Wolfbb02b652018-04-19 17:54:56 +0200299 if (flags & JOB_INTERNAL) {
300 error_setg(errp, "Cannot specify job ID for internal job");
301 return NULL;
302 }
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200303 if (!id_wellformed(job_id)) {
304 error_setg(errp, "Invalid job ID '%s'", job_id);
305 return NULL;
306 }
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200307 if (job_get(job_id)) {
308 error_setg(errp, "Job ID '%s' already in use", job_id);
309 return NULL;
310 }
Kevin Wolfbb02b652018-04-19 17:54:56 +0200311 } else if (!(flags & JOB_INTERNAL)) {
312 error_setg(errp, "An explicit job ID is required");
313 return NULL;
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200314 }
315
316 job = g_malloc0(driver->instance_size);
317 job->driver = driver;
318 job->id = g_strdup(job_id);
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200319 job->refcnt = 1;
Kevin Wolf08be6fe2018-04-17 13:49:33 +0200320 job->aio_context = ctx;
Kevin Wolfda01ff72018-04-13 17:31:02 +0200321 job->busy = false;
322 job->paused = true;
323 job->pause_count = 1;
Kevin Wolfbb02b652018-04-19 17:54:56 +0200324 job->auto_finalize = !(flags & JOB_MANUAL_FINALIZE);
325 job->auto_dismiss = !(flags & JOB_MANUAL_DISMISS);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200326 job->cb = cb;
327 job->opaque = opaque;
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200328
Kevin Wolf139a9f02018-04-23 18:04:57 +0200329 notifier_list_init(&job->on_finalize_cancelled);
330 notifier_list_init(&job->on_finalize_completed);
331 notifier_list_init(&job->on_pending);
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200332 notifier_list_init(&job->on_ready);
Kevin Wolf139a9f02018-04-23 18:04:57 +0200333
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200334 job_state_transition(job, JOB_STATUS_CREATED);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200335 aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
336 QEMU_CLOCK_REALTIME, SCALE_NS,
337 job_sleep_timer_cb, job);
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200338
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200339 QLIST_INSERT_HEAD(&jobs, job, job_list);
340
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200341 /* Single jobs are modeled as single-job transactions for sake of
342 * consolidating the job management logic */
343 if (!txn) {
344 txn = job_txn_new();
345 job_txn_add_job(txn, job);
346 job_txn_unref(txn);
347 } else {
348 job_txn_add_job(txn, job);
349 }
350
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200351 return job;
352}
Kevin Wolffd61a702018-04-12 19:06:53 +0200353
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200354void job_ref(Job *job)
Kevin Wolffd61a702018-04-12 19:06:53 +0200355{
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200356 ++job->refcnt;
357}
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200358
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200359void job_unref(Job *job)
360{
361 if (--job->refcnt == 0) {
362 assert(job->status == JOB_STATUS_NULL);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200363 assert(!timer_pending(&job->sleep_timer));
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200364 assert(!job->txn);
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200365
366 if (job->driver->free) {
367 job->driver->free(job);
368 }
369
370 QLIST_REMOVE(job, job_list);
371
John Snow3d1f8b02018-08-29 21:57:27 -0400372 error_free(job->err);
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200373 g_free(job->id);
374 g_free(job);
375 }
Kevin Wolffd61a702018-04-12 19:06:53 +0200376}
Kevin Wolf1908a552018-04-17 16:41:17 +0200377
Kevin Wolf30a5c882018-05-04 12:17:20 +0200378void job_progress_update(Job *job, uint64_t done)
379{
380 job->progress_current += done;
381}
382
383void job_progress_set_remaining(Job *job, uint64_t remaining)
384{
385 job->progress_total = job->progress_current + remaining;
386}
387
Max Reitz62f13602018-06-13 20:18:20 +0200388void job_progress_increase_remaining(Job *job, uint64_t delta)
389{
390 job->progress_total += delta;
391}
392
Kevin Wolf139a9f02018-04-23 18:04:57 +0200393void job_event_cancelled(Job *job)
394{
395 notifier_list_notify(&job->on_finalize_cancelled, job);
396}
397
398void job_event_completed(Job *job)
399{
400 notifier_list_notify(&job->on_finalize_completed, job);
401}
402
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200403static void job_event_pending(Job *job)
Kevin Wolf139a9f02018-04-23 18:04:57 +0200404{
405 notifier_list_notify(&job->on_pending, job);
406}
407
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200408static void job_event_ready(Job *job)
409{
410 notifier_list_notify(&job->on_ready, job);
411}
412
Kevin Wolfda01ff72018-04-13 17:31:02 +0200413void job_enter_cond(Job *job, bool(*fn)(Job *job))
414{
415 if (!job_started(job)) {
416 return;
417 }
418 if (job->deferred_to_main_loop) {
419 return;
420 }
421
422 job_lock();
423 if (job->busy) {
424 job_unlock();
425 return;
426 }
427
428 if (fn && !fn(job)) {
429 job_unlock();
430 return;
431 }
432
433 assert(!job->deferred_to_main_loop);
434 timer_del(&job->sleep_timer);
435 job->busy = true;
436 job_unlock();
437 aio_co_wake(job->co);
438}
439
Kevin Wolf5d43e862018-04-18 16:32:20 +0200440void job_enter(Job *job)
441{
442 job_enter_cond(job, NULL);
443}
444
Kevin Wolfda01ff72018-04-13 17:31:02 +0200445/* Yield, and schedule a timer to reenter the coroutine after @ns nanoseconds.
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200446 * Reentering the job coroutine with job_enter() before the timer has expired
447 * is allowed and cancels the timer.
Kevin Wolfda01ff72018-04-13 17:31:02 +0200448 *
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200449 * If @ns is (uint64_t) -1, no timer is scheduled and job_enter() must be
Kevin Wolfda01ff72018-04-13 17:31:02 +0200450 * called explicitly. */
Kevin Wolf198c49c2018-04-24 16:55:04 +0200451static void coroutine_fn job_do_yield(Job *job, uint64_t ns)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200452{
453 job_lock();
454 if (ns != -1) {
455 timer_mod(&job->sleep_timer, ns);
456 }
457 job->busy = false;
458 job_unlock();
459 qemu_coroutine_yield();
460
461 /* Set by job_enter_cond() before re-entering the coroutine. */
462 assert(job->busy);
463}
464
465void coroutine_fn job_pause_point(Job *job)
466{
467 assert(job && job_started(job));
468
469 if (!job_should_pause(job)) {
470 return;
471 }
472 if (job_is_cancelled(job)) {
473 return;
474 }
475
476 if (job->driver->pause) {
477 job->driver->pause(job);
478 }
479
480 if (job_should_pause(job) && !job_is_cancelled(job)) {
481 JobStatus status = job->status;
482 job_state_transition(job, status == JOB_STATUS_READY
483 ? JOB_STATUS_STANDBY
484 : JOB_STATUS_PAUSED);
485 job->paused = true;
486 job_do_yield(job, -1);
487 job->paused = false;
488 job_state_transition(job, status);
489 }
490
491 if (job->driver->resume) {
492 job->driver->resume(job);
493 }
494}
495
Kevin Wolf198c49c2018-04-24 16:55:04 +0200496void job_yield(Job *job)
497{
498 assert(job->busy);
499
500 /* Check cancellation *before* setting busy = false, too! */
501 if (job_is_cancelled(job)) {
502 return;
503 }
504
505 if (!job_should_pause(job)) {
506 job_do_yield(job, -1);
507 }
508
509 job_pause_point(job);
510}
511
Kevin Wolf5d43e862018-04-18 16:32:20 +0200512void coroutine_fn job_sleep_ns(Job *job, int64_t ns)
513{
514 assert(job->busy);
515
516 /* Check cancellation *before* setting busy = false, too! */
517 if (job_is_cancelled(job)) {
518 return;
519 }
520
521 if (!job_should_pause(job)) {
522 job_do_yield(job, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ns);
523 }
524
525 job_pause_point(job);
526}
527
Kevin Wolfb69f7772018-04-20 17:00:29 +0200528void job_drain(Job *job)
529{
530 /* If job is !busy this kicks it into the next pause point. */
531 job_enter(job);
532
533 if (job->driver->drain) {
534 job->driver->drain(job);
535 }
536}
537
Kevin Wolfb15de822018-04-18 17:10:26 +0200538/* Assumes the block_job_mutex is held */
539static bool job_timer_not_pending(Job *job)
540{
541 return !timer_pending(&job->sleep_timer);
542}
543
544void job_pause(Job *job)
545{
546 job->pause_count++;
547}
548
549void job_resume(Job *job)
550{
551 assert(job->pause_count > 0);
552 job->pause_count--;
553 if (job->pause_count) {
554 return;
555 }
556
557 /* kick only if no timer is pending */
558 job_enter_cond(job, job_timer_not_pending);
559}
560
561void job_user_pause(Job *job, Error **errp)
562{
563 if (job_apply_verb(job, JOB_VERB_PAUSE, errp)) {
564 return;
565 }
566 if (job->user_paused) {
567 error_setg(errp, "Job is already paused");
568 return;
569 }
570 job->user_paused = true;
571 job_pause(job);
572}
573
574bool job_user_paused(Job *job)
575{
576 return job->user_paused;
577}
578
579void job_user_resume(Job *job, Error **errp)
580{
581 assert(job);
582 if (!job->user_paused || job->pause_count <= 0) {
583 error_setg(errp, "Can't resume a job that was not paused");
584 return;
585 }
586 if (job_apply_verb(job, JOB_VERB_RESUME, errp)) {
587 return;
588 }
589 if (job->driver->user_resume) {
590 job->driver->user_resume(job);
591 }
592 job->user_paused = false;
593 job_resume(job);
594}
595
Kevin Wolf5f9a6a02018-04-24 17:10:12 +0200596static void job_do_dismiss(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200597{
598 assert(job);
599 job->busy = false;
600 job->paused = false;
601 job->deferred_to_main_loop = true;
602
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200603 job_txn_del_job(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200604
605 job_state_transition(job, JOB_STATUS_NULL);
606 job_unref(job);
607}
608
Kevin Wolf5f9a6a02018-04-24 17:10:12 +0200609void job_dismiss(Job **jobptr, Error **errp)
610{
611 Job *job = *jobptr;
612 /* similarly to _complete, this is QMP-interface only. */
613 assert(job->id);
614 if (job_apply_verb(job, JOB_VERB_DISMISS, errp)) {
615 return;
616 }
617
618 job_do_dismiss(job);
619 *jobptr = NULL;
620}
621
Kevin Wolf4ad35182018-04-19 17:30:16 +0200622void job_early_fail(Job *job)
623{
624 assert(job->status == JOB_STATUS_CREATED);
625 job_do_dismiss(job);
626}
627
628static void job_conclude(Job *job)
629{
630 job_state_transition(job, JOB_STATUS_CONCLUDED);
631 if (job->auto_dismiss || !job_started(job)) {
632 job_do_dismiss(job);
633 }
634}
635
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200636static void job_update_rc(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200637{
638 if (!job->ret && job_is_cancelled(job)) {
639 job->ret = -ECANCELED;
640 }
641 if (job->ret) {
John Snow3d1f8b02018-08-29 21:57:27 -0400642 if (!job->err) {
643 error_setg(&job->err, "%s", strerror(-job->ret));
Kevin Wolf1266c9b2018-05-24 15:26:10 +0200644 }
Kevin Wolf4ad35182018-04-19 17:30:16 +0200645 job_state_transition(job, JOB_STATUS_ABORTING);
646 }
647}
648
649static void job_commit(Job *job)
650{
651 assert(!job->ret);
652 if (job->driver->commit) {
653 job->driver->commit(job);
654 }
655}
656
657static void job_abort(Job *job)
658{
659 assert(job->ret);
660 if (job->driver->abort) {
661 job->driver->abort(job);
662 }
663}
664
665static void job_clean(Job *job)
666{
667 if (job->driver->clean) {
668 job->driver->clean(job);
669 }
670}
671
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200672static int job_finalize_single(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200673{
674 assert(job_is_completed(job));
675
676 /* Ensure abort is called for late-transactional failures */
677 job_update_rc(job);
678
679 if (!job->ret) {
680 job_commit(job);
681 } else {
682 job_abort(job);
683 }
684 job_clean(job);
685
686 if (job->cb) {
687 job->cb(job->opaque, job->ret);
688 }
689
690 /* Emit events only if we actually started */
691 if (job_started(job)) {
692 if (job_is_cancelled(job)) {
693 job_event_cancelled(job);
694 } else {
695 job_event_completed(job);
696 }
697 }
698
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200699 job_txn_del_job(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200700 job_conclude(job);
701 return 0;
702}
703
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200704static void job_cancel_async(Job *job, bool force)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200705{
706 if (job->user_paused) {
707 /* Do not call job_enter here, the caller will handle it. */
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200708 if (job->driver->user_resume) {
709 job->driver->user_resume(job);
710 }
Jeff Codye321c052018-08-21 12:26:19 -0400711 job->user_paused = false;
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200712 assert(job->pause_count > 0);
713 job->pause_count--;
714 }
715 job->cancelled = true;
716 /* To prevent 'force == false' overriding a previous 'force == true' */
717 job->force_cancel |= force;
718}
719
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200720static void job_completed_txn_abort(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200721{
722 AioContext *ctx;
723 JobTxn *txn = job->txn;
724 Job *other_job;
725
726 if (txn->aborting) {
727 /*
728 * We are cancelled by another job, which will handle everything.
729 */
730 return;
731 }
732 txn->aborting = true;
733 job_txn_ref(txn);
734
735 /* We are the first failed job. Cancel other jobs. */
736 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
737 ctx = other_job->aio_context;
738 aio_context_acquire(ctx);
739 }
740
741 /* Other jobs are effectively cancelled by us, set the status for
742 * them; this job, however, may or may not be cancelled, depending
743 * on the caller, so leave it. */
744 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
745 if (other_job != job) {
746 job_cancel_async(other_job, false);
747 }
748 }
749 while (!QLIST_EMPTY(&txn->jobs)) {
750 other_job = QLIST_FIRST(&txn->jobs);
751 ctx = other_job->aio_context;
752 if (!job_is_completed(other_job)) {
753 assert(job_is_cancelled(other_job));
754 job_finish_sync(other_job, NULL, NULL);
755 }
756 job_finalize_single(other_job);
757 aio_context_release(ctx);
758 }
759
760 job_txn_unref(txn);
761}
762
763static int job_prepare(Job *job)
764{
765 if (job->ret == 0 && job->driver->prepare) {
766 job->ret = job->driver->prepare(job);
Kevin Wolf1266c9b2018-05-24 15:26:10 +0200767 job_update_rc(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200768 }
769 return job->ret;
770}
771
772static int job_needs_finalize(Job *job)
773{
774 return !job->auto_finalize;
775}
776
777static void job_do_finalize(Job *job)
778{
779 int rc;
780 assert(job && job->txn);
781
782 /* prepare the transaction to complete */
783 rc = job_txn_apply(job->txn, job_prepare, true);
784 if (rc) {
785 job_completed_txn_abort(job);
786 } else {
787 job_txn_apply(job->txn, job_finalize_single, true);
788 }
789}
790
791void job_finalize(Job *job, Error **errp)
792{
793 assert(job && job->id);
794 if (job_apply_verb(job, JOB_VERB_FINALIZE, errp)) {
795 return;
796 }
797 job_do_finalize(job);
798}
799
800static int job_transition_to_pending(Job *job)
801{
802 job_state_transition(job, JOB_STATUS_PENDING);
803 if (!job->auto_finalize) {
804 job_event_pending(job);
805 }
806 return 0;
807}
808
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200809void job_transition_to_ready(Job *job)
810{
811 job_state_transition(job, JOB_STATUS_READY);
812 job_event_ready(job);
813}
814
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200815static void job_completed_txn_success(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200816{
817 JobTxn *txn = job->txn;
818 Job *other_job;
819
820 job_state_transition(job, JOB_STATUS_WAITING);
821
822 /*
823 * Successful completion, see if there are other running jobs in this
824 * txn.
825 */
826 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
827 if (!job_is_completed(other_job)) {
828 return;
829 }
830 assert(other_job->ret == 0);
831 }
832
833 job_txn_apply(txn, job_transition_to_pending, false);
834
835 /* If no jobs need manual finalization, automatically do so */
836 if (job_txn_apply(txn, job_needs_finalize, false) == 0) {
837 job_do_finalize(job);
838 }
839}
840
John Snow404ff282018-08-29 21:57:33 -0400841static void job_completed(Job *job)
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200842{
843 assert(job && job->txn && !job_is_completed(job));
Kevin Wolf1266c9b2018-05-24 15:26:10 +0200844
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200845 job_update_rc(job);
John Snow404ff282018-08-29 21:57:33 -0400846 trace_job_completed(job, job->ret);
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200847 if (job->ret) {
848 job_completed_txn_abort(job);
849 } else {
850 job_completed_txn_success(job);
851 }
852}
853
John Snowccbfb332018-09-06 09:02:20 -0400854/** Useful only as a type shim for aio_bh_schedule_oneshot. */
855static void job_exit(void *opaque)
856{
857 Job *job = (Job *)opaque;
858 job_completed(job);
859}
860
861/**
862 * All jobs must allow a pause point before entering their job proper. This
863 * ensures that jobs can be paused prior to being started, then resumed later.
864 */
865static void coroutine_fn job_co_entry(void *opaque)
866{
867 Job *job = opaque;
868
869 assert(job && job->driver && job->driver->run);
870 job_pause_point(job);
871 job->ret = job->driver->run(job, &job->err);
872 job->deferred_to_main_loop = true;
873 aio_bh_schedule_oneshot(qemu_get_aio_context(), job_exit, job);
874}
875
876void job_start(Job *job)
877{
878 assert(job && !job_started(job) && job->paused &&
879 job->driver && job->driver->run);
880 job->co = qemu_coroutine_create(job_co_entry, job);
881 job->pause_count--;
882 job->busy = true;
883 job->paused = false;
884 job_state_transition(job, JOB_STATUS_RUNNING);
885 aio_co_enter(job->aio_context, job->co);
886}
887
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200888void job_cancel(Job *job, bool force)
889{
890 if (job->status == JOB_STATUS_CONCLUDED) {
891 job_do_dismiss(job);
892 return;
893 }
894 job_cancel_async(job, force);
895 if (!job_started(job)) {
John Snow404ff282018-08-29 21:57:33 -0400896 job_completed(job);
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200897 } else if (job->deferred_to_main_loop) {
898 job_completed_txn_abort(job);
899 } else {
900 job_enter(job);
901 }
902}
903
904void job_user_cancel(Job *job, bool force, Error **errp)
905{
906 if (job_apply_verb(job, JOB_VERB_CANCEL, errp)) {
907 return;
908 }
909 job_cancel(job, force);
910}
911
912/* A wrapper around job_cancel() taking an Error ** parameter so it may be
913 * used with job_finish_sync() without the need for (rather nasty) function
914 * pointer casts there. */
915static void job_cancel_err(Job *job, Error **errp)
916{
917 job_cancel(job, false);
918}
919
920int job_cancel_sync(Job *job)
921{
922 return job_finish_sync(job, &job_cancel_err, NULL);
923}
924
925void job_cancel_sync_all(void)
926{
927 Job *job;
928 AioContext *aio_context;
929
930 while ((job = job_next(NULL))) {
931 aio_context = job->aio_context;
932 aio_context_acquire(aio_context);
933 job_cancel_sync(job);
934 aio_context_release(aio_context);
935 }
936}
937
938int job_complete_sync(Job *job, Error **errp)
939{
940 return job_finish_sync(job, job_complete, errp);
941}
942
Kevin Wolf3453d972018-04-23 12:24:16 +0200943void job_complete(Job *job, Error **errp)
944{
945 /* Should not be reachable via external interface for internal jobs */
946 assert(job->id);
947 if (job_apply_verb(job, JOB_VERB_COMPLETE, errp)) {
948 return;
949 }
950 if (job->pause_count || job_is_cancelled(job) || !job->driver->complete) {
951 error_setg(errp, "The active block job '%s' cannot be completed",
952 job->id);
953 return;
954 }
955
956 job->driver->complete(job, errp);
957}
958
Kevin Wolf6a74c072018-04-20 15:33:57 +0200959int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)
960{
961 Error *local_err = NULL;
962 int ret;
963
964 job_ref(job);
965
966 if (finish) {
967 finish(job, &local_err);
968 }
969 if (local_err) {
970 error_propagate(errp, local_err);
971 job_unref(job);
972 return -EBUSY;
973 }
974 /* job_drain calls job_enter, and it should be enough to induce progress
975 * until the job completes or moves to the main thread. */
976 while (!job->deferred_to_main_loop && !job_is_completed(job)) {
977 job_drain(job);
978 }
979 while (!job_is_completed(job)) {
980 aio_poll(qemu_get_aio_context(), true);
981 }
982 ret = (job_is_cancelled(job) && job->ret == 0) ? -ECANCELED : job->ret;
983 job_unref(job);
984 return ret;
985}