blob: 660ce22c56b6115155451f9b60c4f237ff99b8eb [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"
Kevin Wolf33e9e9b2018-04-12 17:29:59 +020027#include "qapi/error.h"
28#include "qemu/job.h"
29#include "qemu/id.h"
Kevin Wolf1908a552018-04-17 16:41:17 +020030#include "qemu/main-loop.h"
Kevin Wolfde0fbe62018-08-17 14:58:49 +020031#include "block/aio-wait.h"
Paolo Bonzini243af022020-02-04 12:20:10 +010032#include "trace/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
Emanuele Giuseppe Esposito55c5a252022-09-26 05:31:54 -040035/*
Emanuele Giuseppe Espositobf61c582022-09-26 05:31:59 -040036 * The job API is composed of two categories of functions.
37 *
38 * The first includes functions used by the monitor. The monitor is
39 * peculiar in that it accesses the job list with job_get, and
40 * therefore needs consistency across job_get and the actual operation
41 * (e.g. job_user_cancel). To achieve this consistency, the caller
42 * calls job_lock/job_unlock itself around the whole operation.
43 *
44 *
45 * The second includes functions used by the job drivers and sometimes
46 * by the core block layer. These delegate the locking to the callee instead.
Emanuele Giuseppe Espositobf61c582022-09-26 05:31:59 -040047 */
48
49/*
Emanuele Giuseppe Esposito55c5a252022-09-26 05:31:54 -040050 * job_mutex protects the jobs list, but also makes the
51 * struct job fields thread-safe.
52 */
53QemuMutex job_mutex;
54
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -040055/* Protected by job_mutex */
Kevin Wolfe7c1d782018-04-12 17:54:37 +020056static QLIST_HEAD(, Job) jobs = QLIST_HEAD_INITIALIZER(jobs);
57
Kevin Wolfa50c2ab2018-04-13 17:19:31 +020058/* Job State Transition Table */
59bool JobSTT[JOB_STATUS__MAX][JOB_STATUS__MAX] = {
60 /* U, C, R, P, Y, S, W, D, X, E, N */
61 /* U: */ [JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
62 /* C: */ [JOB_STATUS_CREATED] = {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1},
63 /* R: */ [JOB_STATUS_RUNNING] = {0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0},
64 /* P: */ [JOB_STATUS_PAUSED] = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
65 /* Y: */ [JOB_STATUS_READY] = {0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0},
66 /* S: */ [JOB_STATUS_STANDBY] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
67 /* W: */ [JOB_STATUS_WAITING] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0},
68 /* D: */ [JOB_STATUS_PENDING] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
69 /* X: */ [JOB_STATUS_ABORTING] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
70 /* E: */ [JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
71 /* N: */ [JOB_STATUS_NULL] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
72};
73
74bool JobVerbTable[JOB_VERB__MAX][JOB_STATUS__MAX] = {
75 /* U, C, R, P, Y, S, W, D, X, E, N */
76 [JOB_VERB_CANCEL] = {0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0},
77 [JOB_VERB_PAUSE] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
78 [JOB_VERB_RESUME] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
79 [JOB_VERB_SET_SPEED] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
Max Reitz53ddb9c2021-04-09 14:04:20 +020080 [JOB_VERB_COMPLETE] = {0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0},
Kevin Wolfa50c2ab2018-04-13 17:19:31 +020081 [JOB_VERB_FINALIZE] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
82 [JOB_VERB_DISMISS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
Fiona Ebner61a3a5a2023-10-31 14:54:22 +010083 [JOB_VERB_CHANGE] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
Kevin Wolfa50c2ab2018-04-13 17:19:31 +020084};
85
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +020086/* Transactional group of jobs */
87struct JobTxn {
88
89 /* Is this txn being cancelled? */
90 bool aborting;
91
92 /* List of jobs */
93 QLIST_HEAD(, Job) jobs;
94
95 /* Reference count */
96 int refcnt;
97};
98
Emanuele Giuseppe Esposito55c5a252022-09-26 05:31:54 -040099void job_lock(void)
100{
Kevin Wolfda01ff72018-04-13 17:31:02 +0200101 qemu_mutex_lock(&job_mutex);
102}
103
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400104void job_unlock(void)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200105{
106 qemu_mutex_unlock(&job_mutex);
107}
108
109static void __attribute__((__constructor__)) job_init(void)
110{
111 qemu_mutex_init(&job_mutex);
112}
113
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200114JobTxn *job_txn_new(void)
115{
116 JobTxn *txn = g_new0(JobTxn, 1);
117 QLIST_INIT(&txn->jobs);
118 txn->refcnt = 1;
119 return txn;
120}
121
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400122/* Called with job_mutex held. */
123static void job_txn_ref_locked(JobTxn *txn)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200124{
125 txn->refcnt++;
126}
127
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400128void job_txn_unref_locked(JobTxn *txn)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200129{
130 if (txn && --txn->refcnt == 0) {
131 g_free(txn);
132 }
133}
134
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400135void job_txn_unref(JobTxn *txn)
136{
137 JOB_LOCK_GUARD();
138 job_txn_unref_locked(txn);
139}
140
Emanuele Giuseppe Esposito544f4d52022-09-26 05:31:56 -0400141/**
142 * @txn: The transaction (may be NULL)
143 * @job: Job to add to the transaction
144 *
145 * Add @job to the transaction. The @job must not already be in a transaction.
146 * The caller must call either job_txn_unref() or job_completed() to release
147 * the reference that is automatically grabbed here.
148 *
149 * If @txn is NULL, the function does nothing.
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400150 *
151 * Called with job_mutex held.
Emanuele Giuseppe Esposito544f4d52022-09-26 05:31:56 -0400152 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400153static void job_txn_add_job_locked(JobTxn *txn, Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200154{
155 if (!txn) {
156 return;
157 }
158
159 assert(!job->txn);
160 job->txn = txn;
161
162 QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400163 job_txn_ref_locked(txn);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200164}
165
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400166/* Called with job_mutex held. */
167static void job_txn_del_job_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200168{
169 if (job->txn) {
170 QLIST_REMOVE(job, txn_list);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400171 job_txn_unref_locked(job->txn);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200172 job->txn = NULL;
173 }
174}
175
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400176/* Called with job_mutex held, but releases it temporarily. */
177static int job_txn_apply_locked(Job *job, int fn(Job *))
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200178{
Stefan Reiterb660a842020-04-07 13:56:49 +0200179 Job *other_job, *next;
180 JobTxn *txn = job->txn;
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200181 int rc = 0;
182
Stefan Reiterb660a842020-04-07 13:56:49 +0200183 /*
184 * Similar to job_completed_txn_abort, we take each job's lock before
185 * applying fn, but since we assume that outer_ctx is held by the caller,
186 * we need to release it here to avoid holding the lock twice - which would
187 * break AIO_WAIT_WHILE from within fn.
188 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400189 job_ref_locked(job);
Stefan Reiterb660a842020-04-07 13:56:49 +0200190
191 QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
Stefan Reiterb660a842020-04-07 13:56:49 +0200192 rc = fn(other_job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200193 if (rc) {
194 break;
195 }
196 }
Stefan Reiterb660a842020-04-07 13:56:49 +0200197
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400198 job_unref_locked(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200199 return rc;
200}
201
Kevin Wolf456273b2018-05-04 16:25:43 +0200202bool job_is_internal(Job *job)
Kevin Wolf1dac83f2018-04-30 19:09:46 +0200203{
204 return (job->id == NULL);
205}
206
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400207/* Called with job_mutex held. */
208static void job_state_transition_locked(Job *job, JobStatus s1)
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200209{
210 JobStatus s0 = job->status;
Liam Merwickc2032282018-11-05 21:38:35 +0000211 assert(s1 >= 0 && s1 < JOB_STATUS__MAX);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200212 trace_job_state_transition(job, job->ret,
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200213 JobSTT[s0][s1] ? "allowed" : "disallowed",
214 JobStatus_str(s0), JobStatus_str(s1));
215 assert(JobSTT[s0][s1]);
216 job->status = s1;
Kevin Wolf1dac83f2018-04-30 19:09:46 +0200217
218 if (!job_is_internal(job) && s1 != s0) {
Peter Xu3ab72382018-08-15 21:37:37 +0800219 qapi_event_send_job_status_change(job->id, job->status);
Kevin Wolf1dac83f2018-04-30 19:09:46 +0200220 }
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200221}
222
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400223int job_apply_verb_locked(Job *job, JobVerb verb, Error **errp)
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200224{
225 JobStatus s0 = job->status;
Liam Merwickc2032282018-11-05 21:38:35 +0000226 assert(verb >= 0 && verb < JOB_VERB__MAX);
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200227 trace_job_apply_verb(job, JobStatus_str(s0), JobVerb_str(verb),
228 JobVerbTable[verb][s0] ? "allowed" : "prohibited");
229 if (JobVerbTable[verb][s0]) {
230 return 0;
231 }
232 error_setg(errp, "Job '%s' in state '%s' cannot accept command verb '%s'",
233 job->id, JobStatus_str(s0), JobVerb_str(verb));
234 return -EPERM;
235}
236
Kevin Wolf252291e2018-04-12 17:57:08 +0200237JobType job_type(const Job *job)
238{
239 return job->driver->job_type;
240}
241
242const char *job_type_str(const Job *job)
243{
244 return JobType_str(job_type(job));
245}
246
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400247bool job_is_cancelled_locked(Job *job)
Kevin Wolfdaa7f2f2018-04-17 12:56:07 +0200248{
Hanna Reitza640fa02021-10-06 17:19:39 +0200249 /* force_cancel may be true only if cancelled is true, too */
250 assert(job->cancelled || !job->force_cancel);
251 return job->force_cancel;
Hanna Reitz08b83bf2021-10-06 17:19:35 +0200252}
253
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400254bool job_is_cancelled(Job *job)
255{
256 JOB_LOCK_GUARD();
257 return job_is_cancelled_locked(job);
258}
259
260/* Called with job_mutex held. */
261static bool job_cancel_requested_locked(Job *job)
Hanna Reitz08b83bf2021-10-06 17:19:35 +0200262{
Kevin Wolfdaa7f2f2018-04-17 12:56:07 +0200263 return job->cancelled;
264}
265
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400266bool job_cancel_requested(Job *job)
267{
268 JOB_LOCK_GUARD();
269 return job_cancel_requested_locked(job);
270}
271
272bool job_is_ready_locked(Job *job)
Kevin Wolfdf956ae2018-04-25 15:09:58 +0200273{
274 switch (job->status) {
275 case JOB_STATUS_UNDEFINED:
276 case JOB_STATUS_CREATED:
277 case JOB_STATUS_RUNNING:
278 case JOB_STATUS_PAUSED:
279 case JOB_STATUS_WAITING:
280 case JOB_STATUS_PENDING:
281 case JOB_STATUS_ABORTING:
282 case JOB_STATUS_CONCLUDED:
283 case JOB_STATUS_NULL:
284 return false;
285 case JOB_STATUS_READY:
286 case JOB_STATUS_STANDBY:
287 return true;
288 default:
289 g_assert_not_reached();
290 }
291 return false;
292}
293
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400294bool job_is_ready(Job *job)
295{
296 JOB_LOCK_GUARD();
297 return job_is_ready_locked(job);
298}
299
300bool job_is_completed_locked(Job *job)
301{
302 switch (job->status) {
303 case JOB_STATUS_UNDEFINED:
304 case JOB_STATUS_CREATED:
305 case JOB_STATUS_RUNNING:
306 case JOB_STATUS_PAUSED:
307 case JOB_STATUS_READY:
308 case JOB_STATUS_STANDBY:
309 return false;
310 case JOB_STATUS_WAITING:
311 case JOB_STATUS_PENDING:
312 case JOB_STATUS_ABORTING:
313 case JOB_STATUS_CONCLUDED:
314 case JOB_STATUS_NULL:
315 return true;
316 default:
317 g_assert_not_reached();
318 }
319 return false;
320}
321
Emanuele Giuseppe Esposito9bd4d3c2022-09-26 05:32:14 -0400322static bool job_is_completed(Job *job)
Kevin Wolfdbe5e6c2018-04-19 13:04:01 +0200323{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400324 JOB_LOCK_GUARD();
325 return job_is_completed_locked(job);
Kevin Wolfdbe5e6c2018-04-19 13:04:01 +0200326}
327
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400328static bool job_started_locked(Job *job)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200329{
330 return job->co;
331}
332
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400333/* Called with job_mutex held. */
334static bool job_should_pause_locked(Job *job)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200335{
336 return job->pause_count > 0;
337}
338
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400339Job *job_next_locked(Job *job)
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200340{
341 if (!job) {
342 return QLIST_FIRST(&jobs);
343 }
344 return QLIST_NEXT(job, job_list);
345}
346
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400347Job *job_next(Job *job)
348{
349 JOB_LOCK_GUARD();
350 return job_next_locked(job);
351}
352
353Job *job_get_locked(const char *id)
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200354{
355 Job *job;
356
357 QLIST_FOREACH(job, &jobs, job_list) {
358 if (job->id && !strcmp(id, job->id)) {
359 return job;
360 }
361 }
362
363 return NULL;
364}
365
Emanuele Giuseppe Esposito3ed4f702022-09-26 05:32:06 -0400366void job_set_aio_context(Job *job, AioContext *ctx)
367{
368 /* protect against read in job_finish_sync_locked and job_start */
369 GLOBAL_STATE_CODE();
370 /* protect against read in job_do_yield_locked */
371 JOB_LOCK_GUARD();
372 /* ensure the job is quiescent while the AioContext is changed */
373 assert(job->paused || job_is_completed_locked(job));
374 job->aio_context = ctx;
375}
376
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400377/* Called with job_mutex *not* held. */
Kevin Wolf5d43e862018-04-18 16:32:20 +0200378static void job_sleep_timer_cb(void *opaque)
379{
380 Job *job = opaque;
381
382 job_enter(job);
383}
384
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200385void *job_create(const char *job_id, const JobDriver *driver, JobTxn *txn,
386 AioContext *ctx, int flags, BlockCompletionFunc *cb,
387 void *opaque, Error **errp)
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200388{
389 Job *job;
390
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400391 JOB_LOCK_GUARD();
392
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200393 if (job_id) {
Kevin Wolfbb02b652018-04-19 17:54:56 +0200394 if (flags & JOB_INTERNAL) {
395 error_setg(errp, "Cannot specify job ID for internal job");
396 return NULL;
397 }
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200398 if (!id_wellformed(job_id)) {
399 error_setg(errp, "Invalid job ID '%s'", job_id);
400 return NULL;
401 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400402 if (job_get_locked(job_id)) {
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200403 error_setg(errp, "Job ID '%s' already in use", job_id);
404 return NULL;
405 }
Kevin Wolfbb02b652018-04-19 17:54:56 +0200406 } else if (!(flags & JOB_INTERNAL)) {
407 error_setg(errp, "An explicit job ID is required");
408 return NULL;
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200409 }
410
411 job = g_malloc0(driver->instance_size);
412 job->driver = driver;
413 job->id = g_strdup(job_id);
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200414 job->refcnt = 1;
Kevin Wolf08be6fe2018-04-17 13:49:33 +0200415 job->aio_context = ctx;
Kevin Wolfda01ff72018-04-13 17:31:02 +0200416 job->busy = false;
417 job->paused = true;
418 job->pause_count = 1;
Kevin Wolfbb02b652018-04-19 17:54:56 +0200419 job->auto_finalize = !(flags & JOB_MANUAL_FINALIZE);
420 job->auto_dismiss = !(flags & JOB_MANUAL_DISMISS);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200421 job->cb = cb;
422 job->opaque = opaque;
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200423
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200424 progress_init(&job->progress);
425
Kevin Wolf139a9f02018-04-23 18:04:57 +0200426 notifier_list_init(&job->on_finalize_cancelled);
427 notifier_list_init(&job->on_finalize_completed);
428 notifier_list_init(&job->on_pending);
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200429 notifier_list_init(&job->on_ready);
Emanuele Giuseppe Esposito252f4092021-11-03 12:21:55 -0400430 notifier_list_init(&job->on_idle);
Kevin Wolf139a9f02018-04-23 18:04:57 +0200431
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400432 job_state_transition_locked(job, JOB_STATUS_CREATED);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200433 aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
434 QEMU_CLOCK_REALTIME, SCALE_NS,
435 job_sleep_timer_cb, job);
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200436
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200437 QLIST_INSERT_HEAD(&jobs, job, job_list);
438
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200439 /* Single jobs are modeled as single-job transactions for sake of
440 * consolidating the job management logic */
441 if (!txn) {
442 txn = job_txn_new();
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400443 job_txn_add_job_locked(txn, job);
444 job_txn_unref_locked(txn);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200445 } else {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400446 job_txn_add_job_locked(txn, job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200447 }
448
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200449 return job;
450}
Kevin Wolffd61a702018-04-12 19:06:53 +0200451
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400452void job_ref_locked(Job *job)
Kevin Wolffd61a702018-04-12 19:06:53 +0200453{
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200454 ++job->refcnt;
455}
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200456
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400457void job_unref_locked(Job *job)
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200458{
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500459 GLOBAL_STATE_CODE();
460
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200461 if (--job->refcnt == 0) {
462 assert(job->status == JOB_STATUS_NULL);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200463 assert(!timer_pending(&job->sleep_timer));
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200464 assert(!job->txn);
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200465
466 if (job->driver->free) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400467 job_unlock();
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200468 job->driver->free(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400469 job_lock();
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200470 }
471
472 QLIST_REMOVE(job, job_list);
473
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200474 progress_destroy(&job->progress);
John Snow3d1f8b02018-08-29 21:57:27 -0400475 error_free(job->err);
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200476 g_free(job->id);
477 g_free(job);
478 }
Kevin Wolffd61a702018-04-12 19:06:53 +0200479}
Kevin Wolf1908a552018-04-17 16:41:17 +0200480
Kevin Wolf30a5c882018-05-04 12:17:20 +0200481void job_progress_update(Job *job, uint64_t done)
482{
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300483 progress_work_done(&job->progress, done);
Kevin Wolf30a5c882018-05-04 12:17:20 +0200484}
485
486void job_progress_set_remaining(Job *job, uint64_t remaining)
487{
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300488 progress_set_remaining(&job->progress, remaining);
Kevin Wolf30a5c882018-05-04 12:17:20 +0200489}
490
Max Reitz62f13602018-06-13 20:18:20 +0200491void job_progress_increase_remaining(Job *job, uint64_t delta)
492{
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300493 progress_increase_remaining(&job->progress, delta);
Max Reitz62f13602018-06-13 20:18:20 +0200494}
495
Emanuele Giuseppe Esposito544f4d52022-09-26 05:31:56 -0400496/**
497 * To be called when a cancelled job is finalised.
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400498 * Called with job_mutex held.
Emanuele Giuseppe Esposito544f4d52022-09-26 05:31:56 -0400499 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400500static void job_event_cancelled_locked(Job *job)
Kevin Wolf139a9f02018-04-23 18:04:57 +0200501{
502 notifier_list_notify(&job->on_finalize_cancelled, job);
503}
504
Emanuele Giuseppe Esposito544f4d52022-09-26 05:31:56 -0400505/**
506 * To be called when a successfully completed job is finalised.
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400507 * Called with job_mutex held.
Emanuele Giuseppe Esposito544f4d52022-09-26 05:31:56 -0400508 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400509static void job_event_completed_locked(Job *job)
Kevin Wolf139a9f02018-04-23 18:04:57 +0200510{
511 notifier_list_notify(&job->on_finalize_completed, job);
512}
513
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400514/* Called with job_mutex held. */
515static void job_event_pending_locked(Job *job)
Kevin Wolf139a9f02018-04-23 18:04:57 +0200516{
517 notifier_list_notify(&job->on_pending, job);
518}
519
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400520/* Called with job_mutex held. */
521static void job_event_ready_locked(Job *job)
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200522{
523 notifier_list_notify(&job->on_ready, job);
524}
525
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400526/* Called with job_mutex held. */
527static void job_event_idle_locked(Job *job)
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200528{
529 notifier_list_notify(&job->on_idle, job);
530}
531
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400532void job_enter_cond_locked(Job *job, bool(*fn)(Job *job))
Kevin Wolfda01ff72018-04-13 17:31:02 +0200533{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400534 if (!job_started_locked(job)) {
Kevin Wolfda01ff72018-04-13 17:31:02 +0200535 return;
536 }
537 if (job->deferred_to_main_loop) {
538 return;
539 }
540
Kevin Wolfda01ff72018-04-13 17:31:02 +0200541 if (job->busy) {
Kevin Wolfda01ff72018-04-13 17:31:02 +0200542 return;
543 }
544
545 if (fn && !fn(job)) {
Kevin Wolfda01ff72018-04-13 17:31:02 +0200546 return;
547 }
548
549 assert(!job->deferred_to_main_loop);
550 timer_del(&job->sleep_timer);
551 job->busy = true;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400552 job_unlock();
Paolo Bonzinief02dac2022-09-26 05:32:05 -0400553 aio_co_wake(job->co);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400554 job_lock();
555}
556
Kevin Wolf5d43e862018-04-18 16:32:20 +0200557void job_enter(Job *job)
558{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400559 JOB_LOCK_GUARD();
560 job_enter_cond_locked(job, NULL);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200561}
562
Kevin Wolfda01ff72018-04-13 17:31:02 +0200563/* Yield, and schedule a timer to reenter the coroutine after @ns nanoseconds.
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200564 * Reentering the job coroutine with job_enter() before the timer has expired
565 * is allowed and cancels the timer.
Kevin Wolfda01ff72018-04-13 17:31:02 +0200566 *
Kevin Wolf3d70ff52018-04-24 16:13:52 +0200567 * If @ns is (uint64_t) -1, no timer is scheduled and job_enter() must be
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400568 * called explicitly.
569 *
570 * Called with job_mutex held, but releases it temporarily.
571 */
572static void coroutine_fn job_do_yield_locked(Job *job, uint64_t ns)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200573{
Paolo Bonzinief02dac2022-09-26 05:32:05 -0400574 AioContext *next_aio_context;
575
Kevin Wolfda01ff72018-04-13 17:31:02 +0200576 if (ns != -1) {
577 timer_mod(&job->sleep_timer, ns);
578 }
579 job->busy = false;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400580 job_event_idle_locked(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400581 job_unlock();
Kevin Wolfda01ff72018-04-13 17:31:02 +0200582 qemu_coroutine_yield();
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400583 job_lock();
Kevin Wolfda01ff72018-04-13 17:31:02 +0200584
Paolo Bonzinief02dac2022-09-26 05:32:05 -0400585 next_aio_context = job->aio_context;
586 /*
587 * Coroutine has resumed, but in the meanwhile the job AioContext
Emanuele Giuseppe Esposito142e6902022-10-25 04:49:52 -0400588 * might have changed via bdrv_try_change_aio_context(), so we need to move
Paolo Bonzinief02dac2022-09-26 05:32:05 -0400589 * the coroutine too in the new aiocontext.
590 */
591 while (qemu_get_current_aio_context() != next_aio_context) {
592 job_unlock();
593 aio_co_reschedule_self(next_aio_context);
594 job_lock();
595 next_aio_context = job->aio_context;
596 }
597
598 /* Set by job_enter_cond_locked() before re-entering the coroutine. */
Kevin Wolfda01ff72018-04-13 17:31:02 +0200599 assert(job->busy);
600}
601
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400602/* Called with job_mutex held, but releases it temporarily. */
603static void coroutine_fn job_pause_point_locked(Job *job)
Kevin Wolfda01ff72018-04-13 17:31:02 +0200604{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400605 assert(job && job_started_locked(job));
Kevin Wolfda01ff72018-04-13 17:31:02 +0200606
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400607 if (!job_should_pause_locked(job)) {
Kevin Wolfda01ff72018-04-13 17:31:02 +0200608 return;
609 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400610 if (job_is_cancelled_locked(job)) {
Kevin Wolfda01ff72018-04-13 17:31:02 +0200611 return;
612 }
613
614 if (job->driver->pause) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400615 job_unlock();
Kevin Wolfda01ff72018-04-13 17:31:02 +0200616 job->driver->pause(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400617 job_lock();
Kevin Wolfda01ff72018-04-13 17:31:02 +0200618 }
619
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400620 if (job_should_pause_locked(job) && !job_is_cancelled_locked(job)) {
Kevin Wolfda01ff72018-04-13 17:31:02 +0200621 JobStatus status = job->status;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400622 job_state_transition_locked(job, status == JOB_STATUS_READY
623 ? JOB_STATUS_STANDBY
624 : JOB_STATUS_PAUSED);
Kevin Wolfda01ff72018-04-13 17:31:02 +0200625 job->paused = true;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400626 job_do_yield_locked(job, -1);
Kevin Wolfda01ff72018-04-13 17:31:02 +0200627 job->paused = false;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400628 job_state_transition_locked(job, status);
Kevin Wolfda01ff72018-04-13 17:31:02 +0200629 }
630
631 if (job->driver->resume) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400632 job_unlock();
Kevin Wolfda01ff72018-04-13 17:31:02 +0200633 job->driver->resume(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400634 job_lock();
Kevin Wolfda01ff72018-04-13 17:31:02 +0200635 }
636}
637
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400638void coroutine_fn job_pause_point(Job *job)
639{
640 JOB_LOCK_GUARD();
641 job_pause_point_locked(job);
642}
643
Emanuele Giuseppe Esposito9bd4d3c2022-09-26 05:32:14 -0400644void coroutine_fn job_yield(Job *job)
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400645{
Emanuele Giuseppe Esposito9bd4d3c2022-09-26 05:32:14 -0400646 JOB_LOCK_GUARD();
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400647 assert(job->busy);
648
649 /* Check cancellation *before* setting busy = false, too! */
650 if (job_is_cancelled_locked(job)) {
651 return;
652 }
653
654 if (!job_should_pause_locked(job)) {
655 job_do_yield_locked(job, -1);
656 }
657
658 job_pause_point_locked(job);
659}
660
Kevin Wolf5d43e862018-04-18 16:32:20 +0200661void coroutine_fn job_sleep_ns(Job *job, int64_t ns)
662{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400663 JOB_LOCK_GUARD();
Kevin Wolf5d43e862018-04-18 16:32:20 +0200664 assert(job->busy);
665
666 /* Check cancellation *before* setting busy = false, too! */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400667 if (job_is_cancelled_locked(job)) {
Kevin Wolf5d43e862018-04-18 16:32:20 +0200668 return;
669 }
670
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400671 if (!job_should_pause_locked(job)) {
672 job_do_yield_locked(job, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ns);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200673 }
674
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400675 job_pause_point_locked(job);
Kevin Wolf5d43e862018-04-18 16:32:20 +0200676}
677
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400678/* Assumes the job_mutex is held */
679static bool job_timer_not_pending_locked(Job *job)
Kevin Wolfb15de822018-04-18 17:10:26 +0200680{
681 return !timer_pending(&job->sleep_timer);
682}
683
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400684void job_pause_locked(Job *job)
Kevin Wolfb15de822018-04-18 17:10:26 +0200685{
686 job->pause_count++;
Vladimir Sementsov-Ogievskiy3ee14832021-01-17 00:46:51 +0300687 if (!job->paused) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400688 job_enter_cond_locked(job, NULL);
Vladimir Sementsov-Ogievskiy3ee14832021-01-17 00:46:51 +0300689 }
Kevin Wolfb15de822018-04-18 17:10:26 +0200690}
691
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400692void job_pause(Job *job)
693{
694 JOB_LOCK_GUARD();
695 job_pause_locked(job);
696}
697
698void job_resume_locked(Job *job)
Kevin Wolfb15de822018-04-18 17:10:26 +0200699{
700 assert(job->pause_count > 0);
701 job->pause_count--;
702 if (job->pause_count) {
703 return;
704 }
705
706 /* kick only if no timer is pending */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400707 job_enter_cond_locked(job, job_timer_not_pending_locked);
Kevin Wolfb15de822018-04-18 17:10:26 +0200708}
709
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400710void job_resume(Job *job)
Kevin Wolfb15de822018-04-18 17:10:26 +0200711{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400712 JOB_LOCK_GUARD();
713 job_resume_locked(job);
714}
715
716void job_user_pause_locked(Job *job, Error **errp)
717{
718 if (job_apply_verb_locked(job, JOB_VERB_PAUSE, errp)) {
Kevin Wolfb15de822018-04-18 17:10:26 +0200719 return;
720 }
721 if (job->user_paused) {
722 error_setg(errp, "Job is already paused");
723 return;
724 }
725 job->user_paused = true;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400726 job_pause_locked(job);
Kevin Wolfb15de822018-04-18 17:10:26 +0200727}
728
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400729bool job_user_paused_locked(Job *job)
Kevin Wolfb15de822018-04-18 17:10:26 +0200730{
731 return job->user_paused;
732}
733
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400734void job_user_resume_locked(Job *job, Error **errp)
Kevin Wolfb15de822018-04-18 17:10:26 +0200735{
736 assert(job);
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500737 GLOBAL_STATE_CODE();
Kevin Wolfb15de822018-04-18 17:10:26 +0200738 if (!job->user_paused || job->pause_count <= 0) {
739 error_setg(errp, "Can't resume a job that was not paused");
740 return;
741 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400742 if (job_apply_verb_locked(job, JOB_VERB_RESUME, errp)) {
Kevin Wolfb15de822018-04-18 17:10:26 +0200743 return;
744 }
745 if (job->driver->user_resume) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400746 job_unlock();
Kevin Wolfb15de822018-04-18 17:10:26 +0200747 job->driver->user_resume(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400748 job_lock();
Kevin Wolfb15de822018-04-18 17:10:26 +0200749 }
750 job->user_paused = false;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400751 job_resume_locked(job);
Kevin Wolfb15de822018-04-18 17:10:26 +0200752}
753
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400754/* Called with job_mutex held, but releases it temporarily. */
755static void job_do_dismiss_locked(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200756{
757 assert(job);
758 job->busy = false;
759 job->paused = false;
760 job->deferred_to_main_loop = true;
761
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400762 job_txn_del_job_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200763
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400764 job_state_transition_locked(job, JOB_STATUS_NULL);
765 job_unref_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200766}
767
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400768void job_dismiss_locked(Job **jobptr, Error **errp)
Kevin Wolf5f9a6a02018-04-24 17:10:12 +0200769{
770 Job *job = *jobptr;
771 /* similarly to _complete, this is QMP-interface only. */
772 assert(job->id);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400773 if (job_apply_verb_locked(job, JOB_VERB_DISMISS, errp)) {
Kevin Wolf5f9a6a02018-04-24 17:10:12 +0200774 return;
775 }
776
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400777 job_do_dismiss_locked(job);
Kevin Wolf5f9a6a02018-04-24 17:10:12 +0200778 *jobptr = NULL;
779}
780
Kevin Wolf4ad35182018-04-19 17:30:16 +0200781void job_early_fail(Job *job)
782{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400783 JOB_LOCK_GUARD();
Kevin Wolf4ad35182018-04-19 17:30:16 +0200784 assert(job->status == JOB_STATUS_CREATED);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400785 job_do_dismiss_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200786}
787
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400788/* Called with job_mutex held. */
789static void job_conclude_locked(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200790{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400791 job_state_transition_locked(job, JOB_STATUS_CONCLUDED);
792 if (job->auto_dismiss || !job_started_locked(job)) {
793 job_do_dismiss_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200794 }
795}
796
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400797/* Called with job_mutex held. */
798static void job_update_rc_locked(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200799{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400800 if (!job->ret && job_is_cancelled_locked(job)) {
Kevin Wolf4ad35182018-04-19 17:30:16 +0200801 job->ret = -ECANCELED;
802 }
803 if (job->ret) {
John Snow3d1f8b02018-08-29 21:57:27 -0400804 if (!job->err) {
805 error_setg(&job->err, "%s", strerror(-job->ret));
Kevin Wolf1266c9b2018-05-24 15:26:10 +0200806 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400807 job_state_transition_locked(job, JOB_STATUS_ABORTING);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200808 }
809}
810
811static void job_commit(Job *job)
812{
813 assert(!job->ret);
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500814 GLOBAL_STATE_CODE();
Kevin Wolf4ad35182018-04-19 17:30:16 +0200815 if (job->driver->commit) {
816 job->driver->commit(job);
817 }
818}
819
820static void job_abort(Job *job)
821{
822 assert(job->ret);
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500823 GLOBAL_STATE_CODE();
Kevin Wolf4ad35182018-04-19 17:30:16 +0200824 if (job->driver->abort) {
825 job->driver->abort(job);
826 }
827}
828
829static void job_clean(Job *job)
830{
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500831 GLOBAL_STATE_CODE();
Kevin Wolf4ad35182018-04-19 17:30:16 +0200832 if (job->driver->clean) {
833 job->driver->clean(job);
834 }
835}
836
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400837/*
838 * Called with job_mutex held, but releases it temporarily.
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400839 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400840static int job_finalize_single_locked(Job *job)
Kevin Wolf4ad35182018-04-19 17:30:16 +0200841{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400842 int job_ret;
843
844 assert(job_is_completed_locked(job));
Kevin Wolf4ad35182018-04-19 17:30:16 +0200845
846 /* Ensure abort is called for late-transactional failures */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400847 job_update_rc_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200848
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400849 job_ret = job->ret;
850 job_unlock();
851
852 if (!job_ret) {
Kevin Wolf4ad35182018-04-19 17:30:16 +0200853 job_commit(job);
854 } else {
855 job_abort(job);
856 }
857 job_clean(job);
858
859 if (job->cb) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400860 job->cb(job->opaque, job_ret);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200861 }
862
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400863 job_lock();
864
Kevin Wolf4ad35182018-04-19 17:30:16 +0200865 /* Emit events only if we actually started */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400866 if (job_started_locked(job)) {
867 if (job_is_cancelled_locked(job)) {
868 job_event_cancelled_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200869 } else {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400870 job_event_completed_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200871 }
872 }
873
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400874 job_txn_del_job_locked(job);
875 job_conclude_locked(job);
Kevin Wolf4ad35182018-04-19 17:30:16 +0200876 return 0;
877}
878
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400879/*
880 * Called with job_mutex held, but releases it temporarily.
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400881 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400882static void job_cancel_async_locked(Job *job, bool force)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200883{
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500884 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy98209332021-02-05 19:37:14 +0300885 if (job->driver->cancel) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400886 job_unlock();
Hanna Reitz73895f32021-10-06 17:19:33 +0200887 force = job->driver->cancel(job, force);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400888 job_lock();
Hanna Reitz73895f32021-10-06 17:19:33 +0200889 } else {
890 /* No .cancel() means the job will behave as if force-cancelled */
891 force = true;
Vladimir Sementsov-Ogievskiy98209332021-02-05 19:37:14 +0300892 }
Hanna Reitz73895f32021-10-06 17:19:33 +0200893
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200894 if (job->user_paused) {
895 /* Do not call job_enter here, the caller will handle it. */
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200896 if (job->driver->user_resume) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400897 job_unlock();
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200898 job->driver->user_resume(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400899 job_lock();
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200900 }
Jeff Codye321c052018-08-21 12:26:19 -0400901 job->user_paused = false;
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200902 assert(job->pause_count > 0);
903 job->pause_count--;
904 }
Hanna Reitz401dd092021-10-06 17:19:34 +0200905
906 /*
907 * Ignore soft cancel requests after the job is already done
908 * (We will still invoke job->driver->cancel() above, but if the
909 * job driver supports soft cancelling and the job is done, that
910 * should be a no-op, too. We still call it so it can override
911 * @force.)
912 */
913 if (force || !job->deferred_to_main_loop) {
914 job->cancelled = true;
915 /* To prevent 'force == false' overriding a previous 'force == true' */
916 job->force_cancel |= force;
917 }
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200918}
919
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400920/*
921 * Called with job_mutex held, but releases it temporarily.
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400922 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400923static void job_completed_txn_abort_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200924{
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200925 JobTxn *txn = job->txn;
926 Job *other_job;
927
928 if (txn->aborting) {
929 /*
930 * We are cancelled by another job, which will handle everything.
931 */
932 return;
933 }
934 txn->aborting = true;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400935 job_txn_ref_locked(txn);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200936
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400937 job_ref_locked(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200938
939 /* Other jobs are effectively cancelled by us, set the status for
940 * them; this job, however, may or may not be cancelled, depending
941 * on the caller, so leave it. */
942 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
943 if (other_job != job) {
Hanna Reitz1d4a43e2021-10-06 17:19:31 +0200944 /*
945 * This is a transaction: If one job failed, no result will matter.
946 * Therefore, pass force=true to terminate all other jobs as quickly
947 * as possible.
948 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400949 job_cancel_async_locked(other_job, true);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200950 }
951 }
952 while (!QLIST_EMPTY(&txn->jobs)) {
953 other_job = QLIST_FIRST(&txn->jobs);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400954 if (!job_is_completed_locked(other_job)) {
955 assert(job_cancel_requested_locked(other_job));
956 job_finish_sync_locked(other_job, NULL, NULL);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200957 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400958 job_finalize_single_locked(other_job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200959 }
960
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400961 job_unref_locked(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400962 job_txn_unref_locked(txn);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200963}
964
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400965/* Called with job_mutex held, but releases it temporarily */
966static int job_prepare_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200967{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400968 int ret;
969
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -0500970 GLOBAL_STATE_CODE();
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400971
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200972 if (job->ret == 0 && job->driver->prepare) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400973 job_unlock();
974 ret = job->driver->prepare(job);
975 job_lock();
976 job->ret = ret;
977 job_update_rc_locked(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200978 }
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -0400979
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200980 return job->ret;
981}
982
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400983/* Called with job_mutex held */
984static int job_needs_finalize_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200985{
986 return !job->auto_finalize;
987}
988
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400989/* Called with job_mutex held */
990static void job_do_finalize_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200991{
992 int rc;
993 assert(job && job->txn);
994
995 /* prepare the transaction to complete */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400996 rc = job_txn_apply_locked(job, job_prepare_locked);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200997 if (rc) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -0400998 job_completed_txn_abort_locked(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200999 } else {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001000 job_txn_apply_locked(job, job_finalize_single_locked);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001001 }
1002}
1003
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001004void job_finalize_locked(Job *job, Error **errp)
1005{
1006 assert(job && job->id);
1007 if (job_apply_verb_locked(job, JOB_VERB_FINALIZE, errp)) {
1008 return;
1009 }
1010 job_do_finalize_locked(job);
1011}
1012
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001013/* Called with job_mutex held. */
1014static int job_transition_to_pending_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001015{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001016 job_state_transition_locked(job, JOB_STATUS_PENDING);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001017 if (!job->auto_finalize) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001018 job_event_pending_locked(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001019 }
1020 return 0;
1021}
1022
Kevin Wolf2e1795b2018-04-25 14:56:09 +02001023void job_transition_to_ready(Job *job)
1024{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001025 JOB_LOCK_GUARD();
1026 job_state_transition_locked(job, JOB_STATUS_READY);
1027 job_event_ready_locked(job);
Kevin Wolf2e1795b2018-04-25 14:56:09 +02001028}
1029
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001030/* Called with job_mutex held. */
1031static void job_completed_txn_success_locked(Job *job)
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001032{
1033 JobTxn *txn = job->txn;
1034 Job *other_job;
1035
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001036 job_state_transition_locked(job, JOB_STATUS_WAITING);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001037
1038 /*
1039 * Successful completion, see if there are other running jobs in this
1040 * txn.
1041 */
1042 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001043 if (!job_is_completed_locked(other_job)) {
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001044 return;
1045 }
1046 assert(other_job->ret == 0);
1047 }
1048
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001049 job_txn_apply_locked(job, job_transition_to_pending_locked);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001050
1051 /* If no jobs need manual finalization, automatically do so */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001052 if (job_txn_apply_locked(job, job_needs_finalize_locked) == 0) {
1053 job_do_finalize_locked(job);
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +02001054 }
1055}
1056
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001057/* Called with job_mutex held. */
1058static void job_completed_locked(Job *job)
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001059{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001060 assert(job && job->txn && !job_is_completed_locked(job));
Kevin Wolf1266c9b2018-05-24 15:26:10 +02001061
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001062 job_update_rc_locked(job);
John Snow404ff282018-08-29 21:57:33 -04001063 trace_job_completed(job, job->ret);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001064 if (job->ret) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001065 job_completed_txn_abort_locked(job);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001066 } else {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001067 job_completed_txn_success_locked(job);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001068 }
1069}
1070
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001071/**
1072 * Useful only as a type shim for aio_bh_schedule_oneshot.
1073 * Called with job_mutex *not* held.
1074 */
John Snowccbfb332018-09-06 09:02:20 -04001075static void job_exit(void *opaque)
1076{
1077 Job *job = (Job *)opaque;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001078 JOB_LOCK_GUARD();
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001079 job_ref_locked(job);
Kevin Wolfb5a7a052018-09-07 15:31:22 +02001080
1081 /* This is a lie, we're not quiescent, but still doing the completion
1082 * callbacks. However, completion callbacks tend to involve operations that
1083 * drain block nodes, and if .drained_poll still returned true, we would
1084 * deadlock. */
1085 job->busy = false;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001086 job_event_idle_locked(job);
Kevin Wolfb5a7a052018-09-07 15:31:22 +02001087
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001088 job_completed_locked(job);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001089 job_unref_locked(job);
John Snowccbfb332018-09-06 09:02:20 -04001090}
1091
1092/**
1093 * All jobs must allow a pause point before entering their job proper. This
1094 * ensures that jobs can be paused prior to being started, then resumed later.
1095 */
1096static void coroutine_fn job_co_entry(void *opaque)
1097{
1098 Job *job = opaque;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001099 int ret;
John Snowccbfb332018-09-06 09:02:20 -04001100
1101 assert(job && job->driver && job->driver->run);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001102 WITH_JOB_LOCK_GUARD() {
1103 assert(job->aio_context == qemu_get_current_aio_context());
1104 job_pause_point_locked(job);
1105 }
1106 ret = job->driver->run(job, &job->err);
1107 WITH_JOB_LOCK_GUARD() {
1108 job->ret = ret;
1109 job->deferred_to_main_loop = true;
1110 job->busy = true;
1111 }
John Snowccbfb332018-09-06 09:02:20 -04001112 aio_bh_schedule_oneshot(qemu_get_aio_context(), job_exit, job);
1113}
1114
1115void job_start(Job *job)
1116{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001117 assert(qemu_in_main_thread());
1118
1119 WITH_JOB_LOCK_GUARD() {
1120 assert(job && !job_started_locked(job) && job->paused &&
1121 job->driver && job->driver->run);
1122 job->co = qemu_coroutine_create(job_co_entry, job);
1123 job->pause_count--;
1124 job->busy = true;
1125 job->paused = false;
1126 job_state_transition_locked(job, JOB_STATUS_RUNNING);
1127 }
John Snowccbfb332018-09-06 09:02:20 -04001128 aio_co_enter(job->aio_context, job->co);
1129}
1130
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001131void job_cancel_locked(Job *job, bool force)
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001132{
1133 if (job->status == JOB_STATUS_CONCLUDED) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001134 job_do_dismiss_locked(job);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001135 return;
1136 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001137 job_cancel_async_locked(job, force);
1138 if (!job_started_locked(job)) {
1139 job_completed_locked(job);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001140 } else if (job->deferred_to_main_loop) {
Hanna Reitz401dd092021-10-06 17:19:34 +02001141 /*
1142 * job_cancel_async() ignores soft-cancel requests for jobs
1143 * that are already done (i.e. deferred to the main loop). We
1144 * have to check again whether the job is really cancelled.
Hanna Reitz08b83bf2021-10-06 17:19:35 +02001145 * (job_cancel_requested() and job_is_cancelled() are equivalent
1146 * here, because job_cancel_async() will make soft-cancel
1147 * requests no-ops when deferred_to_main_loop is true. We
1148 * choose to call job_is_cancelled() to show that we invoke
1149 * job_completed_txn_abort() only for force-cancelled jobs.)
Hanna Reitz401dd092021-10-06 17:19:34 +02001150 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001151 if (job_is_cancelled_locked(job)) {
1152 job_completed_txn_abort_locked(job);
Hanna Reitz401dd092021-10-06 17:19:34 +02001153 }
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001154 } else {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001155 job_enter_cond_locked(job, NULL);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001156 }
1157}
1158
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001159void job_user_cancel_locked(Job *job, bool force, Error **errp)
1160{
1161 if (job_apply_verb_locked(job, JOB_VERB_CANCEL, errp)) {
1162 return;
1163 }
1164 job_cancel_locked(job, force);
1165}
1166
Emanuele Giuseppe Esposito9bd4d3c2022-09-26 05:32:14 -04001167/* A wrapper around job_cancel_locked() taking an Error ** parameter so it may
1168 * be used with job_finish_sync_locked() without the need for (rather nasty)
1169 * function pointer casts there.
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001170 *
1171 * Called with job_mutex held.
1172 */
1173static void job_cancel_err_locked(Job *job, Error **errp)
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001174{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001175 job_cancel_locked(job, false);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001176}
1177
Hanna Reitz4cfb3f02021-10-06 17:19:32 +02001178/**
1179 * Same as job_cancel_err(), but force-cancel.
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001180 * Called with job_mutex held.
Hanna Reitz4cfb3f02021-10-06 17:19:32 +02001181 */
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001182static void job_force_cancel_err_locked(Job *job, Error **errp)
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001183{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001184 job_cancel_locked(job, true);
1185}
1186
1187int job_cancel_sync_locked(Job *job, bool force)
1188{
1189 if (force) {
1190 return job_finish_sync_locked(job, &job_force_cancel_err_locked, NULL);
1191 } else {
1192 return job_finish_sync_locked(job, &job_cancel_err_locked, NULL);
1193 }
Hanna Reitz4cfb3f02021-10-06 17:19:32 +02001194}
1195
1196int job_cancel_sync(Job *job, bool force)
1197{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001198 JOB_LOCK_GUARD();
1199 return job_cancel_sync_locked(job, force);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001200}
1201
1202void job_cancel_sync_all(void)
1203{
1204 Job *job;
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001205 JOB_LOCK_GUARD();
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001206
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001207 while ((job = job_next_locked(NULL))) {
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001208 job_cancel_sync_locked(job, true);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001209 }
1210}
1211
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001212int job_complete_sync_locked(Job *job, Error **errp)
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001213{
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001214 return job_finish_sync_locked(job, job_complete_locked, errp);
Kevin Wolf3d70ff52018-04-24 16:13:52 +02001215}
1216
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001217void job_complete_locked(Job *job, Error **errp)
Kevin Wolf3453d972018-04-23 12:24:16 +02001218{
1219 /* Should not be reachable via external interface for internal jobs */
1220 assert(job->id);
Emanuele Giuseppe Espositoc70b8032022-03-03 10:16:16 -05001221 GLOBAL_STATE_CODE();
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001222 if (job_apply_verb_locked(job, JOB_VERB_COMPLETE, errp)) {
Kevin Wolf3453d972018-04-23 12:24:16 +02001223 return;
1224 }
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001225 if (job_cancel_requested_locked(job) || !job->driver->complete) {
Kevin Wolf3453d972018-04-23 12:24:16 +02001226 error_setg(errp, "The active block job '%s' cannot be completed",
1227 job->id);
1228 return;
1229 }
1230
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001231 job_unlock();
Kevin Wolf3453d972018-04-23 12:24:16 +02001232 job->driver->complete(job, errp);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001233 job_lock();
Kevin Wolf3453d972018-04-23 12:24:16 +02001234}
1235
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001236int job_finish_sync_locked(Job *job,
1237 void (*finish)(Job *, Error **errp),
1238 Error **errp)
Kevin Wolf6a74c072018-04-20 15:33:57 +02001239{
1240 Error *local_err = NULL;
1241 int ret;
Emanuele Giuseppe Esposito3ed4f702022-09-26 05:32:06 -04001242 GLOBAL_STATE_CODE();
Kevin Wolf6a74c072018-04-20 15:33:57 +02001243
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001244 job_ref_locked(job);
Kevin Wolf6a74c072018-04-20 15:33:57 +02001245
1246 if (finish) {
1247 finish(job, &local_err);
1248 }
1249 if (local_err) {
1250 error_propagate(errp, local_err);
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001251 job_unref_locked(job);
Kevin Wolf6a74c072018-04-20 15:33:57 +02001252 return -EBUSY;
1253 }
Kevin Wolfde0fbe62018-08-17 14:58:49 +02001254
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001255 job_unlock();
Emanuele Giuseppe Esposito6f592e52022-09-26 05:32:11 -04001256 AIO_WAIT_WHILE_UNLOCKED(job->aio_context,
1257 (job_enter(job), !job_is_completed(job)));
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001258 job_lock();
Kevin Wolfde0fbe62018-08-17 14:58:49 +02001259
Emanuele Giuseppe Espositoafe1e8a2022-09-26 05:31:58 -04001260 ret = (job_is_cancelled_locked(job) && job->ret == 0)
1261 ? -ECANCELED : job->ret;
1262 job_unref_locked(job);
Kevin Wolf6a74c072018-04-20 15:33:57 +02001263 return ret;
1264}