blob: 659c3cb9de651ff8eb579cf5d93086886e55ff2b [file] [log] [blame]
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +02001/*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2011 IBM Corp.
5 * Copyright (c) 2012 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
Peter Maydelld38ea872016-01-29 17:50:05 +000026#include "qemu/osdep.h"
Markus Armbrustere2c1c342022-12-21 14:35:49 +010027#include "block/aio-wait.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010028#include "block/block.h"
John Snowc87621e2016-10-27 12:07:00 -040029#include "block/blockjob_int.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010030#include "block/block_int.h"
John Snowc9de4052018-03-10 03:27:30 -050031#include "block/trace.h"
Max Reitz373340b2015-10-19 17:53:22 +020032#include "sysemu/block-backend.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010033#include "qapi/error.h"
Markus Armbruster9af23982018-02-11 10:36:01 +010034#include "qapi/qapi-events-block-core.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010035#include "qapi/qmp/qerror.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020036#include "qemu/main-loop.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010037#include "qemu/timer.h"
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020038
Kevin Wolfe7c1d782018-04-12 17:54:37 +020039static bool is_block_job(Job *job)
Alberto Garciaa7112792016-04-04 16:43:51 +030040{
Kevin Wolfe7c1d782018-04-12 17:54:37 +020041 return job_type(job) == JOB_TYPE_BACKUP ||
42 job_type(job) == JOB_TYPE_COMMIT ||
43 job_type(job) == JOB_TYPE_MIRROR ||
44 job_type(job) == JOB_TYPE_STREAM;
45}
46
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -040047BlockJob *block_job_next_locked(BlockJob *bjob)
Kevin Wolfe7c1d782018-04-12 17:54:37 +020048{
49 Job *job = bjob ? &bjob->job : NULL;
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -050050 GLOBAL_STATE_CODE();
Kevin Wolfe7c1d782018-04-12 17:54:37 +020051
52 do {
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -040053 job = job_next_locked(job);
Kevin Wolfe7c1d782018-04-12 17:54:37 +020054 } while (job && !is_block_job(job));
55
56 return job ? container_of(job, BlockJob, job) : NULL;
Alberto Garciaa7112792016-04-04 16:43:51 +030057}
58
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -040059BlockJob *block_job_get_locked(const char *id)
60{
61 Job *job = job_get_locked(id);
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -050062 GLOBAL_STATE_CODE();
Alberto Garciaffb1f102016-07-05 17:28:54 +030063
Kevin Wolfe7c1d782018-04-12 17:54:37 +020064 if (job && is_block_job(job)) {
65 return container_of(job, BlockJob, job);
66 } else {
67 return NULL;
Alberto Garciaffb1f102016-07-05 17:28:54 +030068 }
Alberto Garciaffb1f102016-07-05 17:28:54 +030069}
70
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -040071BlockJob *block_job_get(const char *id)
72{
73 JOB_LOCK_GUARD();
74 return block_job_get_locked(id);
75}
76
Kevin Wolf80fa2c72018-04-13 18:50:05 +020077void block_job_free(Job *job)
Paolo Bonzini05b0d8e2017-05-08 16:13:02 +020078{
Kevin Wolf80fa2c72018-04-13 18:50:05 +020079 BlockJob *bjob = container_of(job, BlockJob, job);
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -050080 GLOBAL_STATE_CODE();
Kevin Wolf80fa2c72018-04-13 18:50:05 +020081
Kevin Wolf80fa2c72018-04-13 18:50:05 +020082 block_job_remove_all_bdrv(bjob);
Paolo Bonzini49519672021-04-13 10:20:32 +020083 ratelimit_destroy(&bjob->limit);
Kevin Wolf80fa2c72018-04-13 18:50:05 +020084 error_free(bjob->blocker);
Paolo Bonzini05b0d8e2017-05-08 16:13:02 +020085}
86
Paolo Bonzinif321dcb2017-05-08 16:13:03 +020087static char *child_job_get_parent_desc(BdrvChild *c)
88{
89 BlockJob *job = c->opaque;
Kevin Wolf252291e2018-04-12 17:57:08 +020090 return g_strdup_printf("%s job '%s'", job_type_str(&job->job), job->job.id);
Paolo Bonzinif321dcb2017-05-08 16:13:03 +020091}
92
Kevin Wolfad90feb2017-12-12 19:04:28 +010093static void child_job_drained_begin(BdrvChild *c)
Paolo Bonzinif321dcb2017-05-08 16:13:03 +020094{
Kevin Wolfad90feb2017-12-12 19:04:28 +010095 BlockJob *job = c->opaque;
Kevin Wolfb15de822018-04-18 17:10:26 +020096 job_pause(&job->job);
Paolo Bonzinif321dcb2017-05-08 16:13:03 +020097}
98
Kevin Wolf89bd0302018-03-22 14:11:20 +010099static bool child_job_drained_poll(BdrvChild *c)
100{
101 BlockJob *bjob = c->opaque;
102 Job *job = &bjob->job;
103 const BlockJobDriver *drv = block_job_driver(bjob);
104
105 /* An inactive or completed job doesn't have any pending requests. Jobs
106 * with !job->busy are either already paused or have a pause point after
107 * being reentered, so no job driver code will run before they pause. */
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -0400108 WITH_JOB_LOCK_GUARD() {
109 if (!job->busy || job_is_completed_locked(job)) {
110 return false;
111 }
Kevin Wolf89bd0302018-03-22 14:11:20 +0100112 }
113
114 /* Otherwise, assume that it isn't fully stopped yet, but allow the job to
115 * override this assumption. */
116 if (drv->drained_poll) {
117 return drv->drained_poll(bjob);
118 } else {
119 return true;
120 }
121}
122
Kevin Wolf2f65df62022-11-18 18:40:59 +0100123static void child_job_drained_end(BdrvChild *c)
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200124{
Kevin Wolfad90feb2017-12-12 19:04:28 +0100125 BlockJob *job = c->opaque;
Kevin Wolfb15de822018-04-18 17:10:26 +0200126 job_resume(&job->job);
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200127}
128
Emanuele Giuseppe Esposito3428b102022-10-25 04:49:46 -0400129typedef struct BdrvStateChildJobContext {
130 AioContext *new_ctx;
131 BlockJob *job;
132} BdrvStateChildJobContext;
133
134static void child_job_set_aio_ctx_commit(void *opaque)
135{
136 BdrvStateChildJobContext *s = opaque;
137 BlockJob *job = s->job;
138
139 job_set_aio_context(&job->job, s->new_ctx);
140}
141
142static TransactionActionDrv change_child_job_context = {
143 .commit = child_job_set_aio_ctx_commit,
144 .clean = g_free,
145};
146
147static bool child_job_change_aio_ctx(BdrvChild *c, AioContext *ctx,
148 GHashTable *visited, Transaction *tran,
149 Error **errp)
150{
151 BlockJob *job = c->opaque;
152 BdrvStateChildJobContext *s;
153 GSList *l;
154
155 for (l = job->nodes; l; l = l->next) {
156 BdrvChild *sibling = l->data;
157 if (!bdrv_child_change_aio_context(sibling, ctx, visited,
158 tran, errp)) {
159 return false;
160 }
161 }
162
163 s = g_new(BdrvStateChildJobContext, 1);
164 *s = (BdrvStateChildJobContext) {
165 .new_ctx = ctx,
166 .job = job,
167 };
168
169 tran_add(tran, &change_child_job_context, s);
170 return true;
171}
172
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +0300173static AioContext *child_job_get_parent_aio_context(BdrvChild *c)
174{
175 BlockJob *job = c->opaque;
Hanna Reitzd5f8d792022-11-07 16:13:19 +0100176 IO_CODE();
177 JOB_LOCK_GUARD();
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +0300178
179 return job->job.aio_context;
180}
181
Max Reitzbd86fb92020-05-13 13:05:13 +0200182static const BdrvChildClass child_job = {
Kevin Wolfad90feb2017-12-12 19:04:28 +0100183 .get_parent_desc = child_job_get_parent_desc,
184 .drained_begin = child_job_drained_begin,
Kevin Wolf89bd0302018-03-22 14:11:20 +0100185 .drained_poll = child_job_drained_poll,
Kevin Wolfad90feb2017-12-12 19:04:28 +0100186 .drained_end = child_job_drained_end,
Emanuele Giuseppe Esposito3428b102022-10-25 04:49:46 -0400187 .change_aio_ctx = child_job_change_aio_ctx,
Kevin Wolfad90feb2017-12-12 19:04:28 +0100188 .stay_at_node = true,
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +0300189 .get_parent_aio_context = child_job_get_parent_aio_context,
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200190};
191
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100192void block_job_remove_all_bdrv(BlockJob *job)
193{
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500194 GLOBAL_STATE_CODE();
Sergio Lopezd876bf62019-09-11 12:03:16 +0200195 /*
196 * bdrv_root_unref_child() may reach child_job_[can_]set_aio_ctx(),
197 * which will also traverse job->nodes, so consume the list one by
198 * one to make sure that such a concurrent access does not attempt
199 * to process an already freed BdrvChild.
200 */
201 while (job->nodes) {
202 GSList *l = job->nodes;
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100203 BdrvChild *c = l->data;
Sergio Lopezd876bf62019-09-11 12:03:16 +0200204
205 job->nodes = l->next;
206
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100207 bdrv_op_unblock_all(c->bs, job->blocker);
208 bdrv_root_unref_child(c);
Sergio Lopezd876bf62019-09-11 12:03:16 +0200209
210 g_slist_free_1(l);
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100211 }
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100212}
213
Vladimir Sementsov-Ogievskiy81641022019-06-06 18:41:31 +0300214bool block_job_has_bdrv(BlockJob *job, BlockDriverState *bs)
215{
216 GSList *el;
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500217 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy81641022019-06-06 18:41:31 +0300218
219 for (el = job->nodes; el; el = el->next) {
220 BdrvChild *c = el->data;
221 if (c->bs == bs) {
222 return true;
223 }
224 }
225
226 return false;
227}
228
Kevin Wolf76d554e2017-01-17 11:56:42 +0100229int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
230 uint64_t perm, uint64_t shared_perm, Error **errp)
Alberto Garcia23d402d2016-10-28 10:08:04 +0300231{
Kevin Wolf76d554e2017-01-17 11:56:42 +0100232 BdrvChild *c;
Michael Qiu076d4672021-02-03 10:40:59 +0800233 bool need_context_ops;
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500234 GLOBAL_STATE_CODE();
Kevin Wolf76d554e2017-01-17 11:56:42 +0100235
Alberto Garciab441dc72019-05-13 16:46:18 +0300236 bdrv_ref(bs);
Michael Qiu076d4672021-02-03 10:40:59 +0800237
238 need_context_ops = bdrv_get_aio_context(bs) != job->job.aio_context;
239
240 if (need_context_ops && job->job.aio_context != qemu_get_aio_context()) {
Kevin Wolf132ada82019-04-24 17:41:46 +0200241 aio_context_release(job->job.aio_context);
242 }
Vladimir Sementsov-Ogievskiy228ca372021-04-28 18:17:34 +0300243 c = bdrv_root_attach_child(bs, name, &child_job, 0, perm, shared_perm, job,
Max Reitz258b7762020-05-13 13:05:15 +0200244 errp);
Michael Qiu076d4672021-02-03 10:40:59 +0800245 if (need_context_ops && job->job.aio_context != qemu_get_aio_context()) {
Kevin Wolf132ada82019-04-24 17:41:46 +0200246 aio_context_acquire(job->job.aio_context);
247 }
Kevin Wolf76d554e2017-01-17 11:56:42 +0100248 if (c == NULL) {
249 return -EPERM;
250 }
251
252 job->nodes = g_slist_prepend(job->nodes, c);
Alberto Garcia23d402d2016-10-28 10:08:04 +0300253 bdrv_op_block_all(bs, job->blocker);
Kevin Wolf76d554e2017-01-17 11:56:42 +0100254
255 return 0;
Alberto Garcia23d402d2016-10-28 10:08:04 +0300256}
257
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400258/* Called with job_mutex lock held. */
259static void block_job_on_idle_locked(Notifier *n, void *opaque)
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200260{
Kevin Wolfcfe29d82018-09-18 17:09:16 +0200261 aio_wait_kick();
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200262}
263
John Snow559b9352016-10-27 12:06:55 -0400264bool block_job_is_internal(BlockJob *job)
265{
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200266 return (job->job.id == NULL);
John Snow559b9352016-10-27 12:06:55 -0400267}
268
Kevin Wolfbd219352018-01-19 15:54:40 +0100269const BlockJobDriver *block_job_driver(BlockJob *job)
270{
Kevin Wolf9f6bb4c2018-05-14 14:51:21 +0200271 return container_of(job->job.driver, BlockJobDriver, job_driver);
Kevin Wolfbd219352018-01-19 15:54:40 +0100272}
273
Kevin Wolfda01ff72018-04-13 17:31:02 +0200274/* Assumes the job_mutex is held */
275static bool job_timer_pending(Job *job)
276{
277 return timer_pending(&job->sleep_timer);
278}
279
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400280bool block_job_set_speed_locked(BlockJob *job, int64_t speed, Error **errp)
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200281{
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300282 const BlockJobDriver *drv = block_job_driver(job);
John Snowaa9ef2e2017-12-13 15:46:11 -0500283 int64_t old_speed = job->speed;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200284
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500285 GLOBAL_STATE_CODE();
286
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400287 if (job_apply_verb_locked(&job->job, JOB_VERB_SET_SPEED, errp) < 0) {
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300288 return false;
John Snow0ec4dfb2018-03-10 03:27:32 -0500289 }
Kevin Wolf18bb6922018-01-18 20:25:40 +0100290 if (speed < 0) {
Kevin Wolf1ef7d9d2019-11-26 14:39:55 +0100291 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "speed",
292 "a non-negative value");
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300293 return false;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200294 }
295
Kevin Wolf18bb6922018-01-18 20:25:40 +0100296 ratelimit_set_speed(&job->limit, speed, BLOCK_JOB_SLICE_TIME);
297
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200298 job->speed = speed;
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300299
300 if (drv->set_speed) {
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400301 job_unlock();
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300302 drv->set_speed(job, speed);
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400303 job_lock();
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300304 }
305
John Snowd4fce182018-03-10 03:27:26 -0500306 if (speed && speed <= old_speed) {
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300307 return true;
John Snowaa9ef2e2017-12-13 15:46:11 -0500308 }
309
310 /* kick only if a timer is pending */
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400311 job_enter_cond_locked(&job->job, job_timer_pending);
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300312
313 return true;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200314}
315
Emanuele Giuseppe Espositoba6a9102022-09-26 05:32:13 -0400316static bool block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400317{
318 JOB_LOCK_GUARD();
319 return block_job_set_speed_locked(job, speed, errp);
320}
321
Kevin Wolfdee81d52018-01-18 21:19:38 +0100322int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
323{
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500324 IO_CODE();
Kevin Wolfdee81d52018-01-18 21:19:38 +0100325 return ratelimit_calculate_delay(&job->limit, n);
326}
327
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400328BlockJobInfo *block_job_query_locked(BlockJob *job, Error **errp)
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200329{
John Snow559b9352016-10-27 12:06:55 -0400330 BlockJobInfo *info;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200331 uint64_t progress_current, progress_total;
John Snow559b9352016-10-27 12:06:55 -0400332
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500333 GLOBAL_STATE_CODE();
334
John Snow559b9352016-10-27 12:06:55 -0400335 if (block_job_is_internal(job)) {
336 error_setg(errp, "Cannot query QEMU internal jobs");
337 return NULL;
338 }
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200339
340 progress_get_snapshot(&job->job.progress, &progress_current,
341 &progress_total);
342
John Snow559b9352016-10-27 12:06:55 -0400343 info = g_new0(BlockJobInfo, 1);
Kevin Wolf252291e2018-04-12 17:57:08 +0200344 info->type = g_strdup(job_type_str(&job->job));
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200345 info->device = g_strdup(job->job.id);
Emanuele Giuseppe Espositofca26312022-09-26 05:32:12 -0400346 info->busy = job->job.busy;
Kevin Wolfda01ff72018-04-13 17:31:02 +0200347 info->paused = job->job.pause_count > 0;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200348 info->offset = progress_current;
349 info->len = progress_total;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200350 info->speed = job->speed;
351 info->io_status = job->iostatus;
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400352 info->ready = job_is_ready_locked(&job->job),
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200353 info->status = job->job.status;
Kevin Wolfbb02b652018-04-19 17:54:56 +0200354 info->auto_finalize = job->job.auto_finalize;
355 info->auto_dismiss = job->job.auto_dismiss;
Stefano Garzarella3b6ad622021-02-25 11:36:33 +0100356 if (job->job.ret) {
Stefano Garzarella3b6ad622021-02-25 11:36:33 +0100357 info->error = job->job.err ?
358 g_strdup(error_get_pretty(job->job.err)) :
359 g_strdup(strerror(-job->job.ret));
360 }
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200361 return info;
362}
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200363
Emanuele Giuseppe Espositod59cb662022-09-26 05:32:09 -0400364/* Called with job lock held */
365static void block_job_iostatus_set_err_locked(BlockJob *job, int error)
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200366{
367 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
368 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
369 BLOCK_DEVICE_IO_STATUS_FAILED;
370 }
371}
372
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400373/* Called with job_mutex lock held. */
374static void block_job_event_cancelled_locked(Notifier *n, void *opaque)
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200375{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200376 BlockJob *job = opaque;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200377 uint64_t progress_current, progress_total;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200378
John Snow559b9352016-10-27 12:06:55 -0400379 if (block_job_is_internal(job)) {
380 return;
381 }
382
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200383 progress_get_snapshot(&job->job.progress, &progress_current,
384 &progress_total);
385
Kevin Wolf252291e2018-04-12 17:57:08 +0200386 qapi_event_send_block_job_cancelled(job_type(&job->job),
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200387 job->job.id,
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200388 progress_total,
389 progress_current,
Peter Xu3ab72382018-08-15 21:37:37 +0800390 job->speed);
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200391}
392
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400393/* Called with job_mutex lock held. */
394static void block_job_event_completed_locked(Notifier *n, void *opaque)
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200395{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200396 BlockJob *job = opaque;
397 const char *msg = NULL;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200398 uint64_t progress_current, progress_total;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200399
John Snow559b9352016-10-27 12:06:55 -0400400 if (block_job_is_internal(job)) {
401 return;
402 }
403
Kevin Wolf4ad35182018-04-19 17:30:16 +0200404 if (job->job.ret < 0) {
Stefano Garzarella3b6ad622021-02-25 11:36:33 +0100405 msg = error_get_pretty(job->job.err);
Kevin Wolf139a9f02018-04-23 18:04:57 +0200406 }
407
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200408 progress_get_snapshot(&job->job.progress, &progress_current,
409 &progress_total);
410
Kevin Wolf252291e2018-04-12 17:57:08 +0200411 qapi_event_send_block_job_completed(job_type(&job->job),
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200412 job->job.id,
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200413 progress_total,
414 progress_current,
Wenchao Xiabcada37b2014-06-18 08:43:47 +0200415 job->speed,
Peter Xu3ab72382018-08-15 21:37:37 +0800416 msg);
Wenchao Xiabcada37b2014-06-18 08:43:47 +0200417}
418
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400419/* Called with job_mutex lock held. */
420static void block_job_event_pending_locked(Notifier *n, void *opaque)
John Snow5f241592018-03-10 03:27:42 -0500421{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200422 BlockJob *job = opaque;
423
Kevin Wolf5d4f3762018-04-23 17:09:42 +0200424 if (block_job_is_internal(job)) {
425 return;
John Snow5f241592018-03-10 03:27:42 -0500426 }
Kevin Wolf5d4f3762018-04-23 17:09:42 +0200427
428 qapi_event_send_block_job_pending(job_type(&job->job),
Peter Xu3ab72382018-08-15 21:37:37 +0800429 job->job.id);
John Snow5f241592018-03-10 03:27:42 -0500430}
431
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400432/* Called with job_mutex lock held. */
433static void block_job_event_ready_locked(Notifier *n, void *opaque)
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200434{
435 BlockJob *job = opaque;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200436 uint64_t progress_current, progress_total;
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200437
438 if (block_job_is_internal(job)) {
439 return;
440 }
441
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200442 progress_get_snapshot(&job->job.progress, &progress_current,
443 &progress_total);
444
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200445 qapi_event_send_block_job_ready(job_type(&job->job),
446 job->job.id,
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200447 progress_total,
448 progress_current,
Peter Xu3ab72382018-08-15 21:37:37 +0800449 job->speed);
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200450}
451
452
Paolo Bonzini88691b32017-05-08 16:13:04 +0200453void *block_job_create(const char *job_id, const BlockJobDriver *driver,
Kevin Wolf62c9e412018-04-19 16:09:52 +0200454 JobTxn *txn, BlockDriverState *bs, uint64_t perm,
Paolo Bonzini88691b32017-05-08 16:13:04 +0200455 uint64_t shared_perm, int64_t speed, int flags,
456 BlockCompletionFunc *cb, void *opaque, Error **errp)
457{
Paolo Bonzini88691b32017-05-08 16:13:04 +0200458 BlockJob *job;
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300459 int ret;
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500460 GLOBAL_STATE_CODE();
Paolo Bonzini88691b32017-05-08 16:13:04 +0200461
Kevin Wolfbb02b652018-04-19 17:54:56 +0200462 if (job_id == NULL && !(flags & JOB_INTERNAL)) {
Paolo Bonzini88691b32017-05-08 16:13:04 +0200463 job_id = bdrv_get_device_name(bs);
Paolo Bonzini88691b32017-05-08 16:13:04 +0200464 }
465
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300466 job = job_create(job_id, &driver->job_driver, txn, bdrv_get_aio_context(bs),
Kevin Wolf4ad35182018-04-19 17:30:16 +0200467 flags, cb, opaque, errp);
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200468 if (job == NULL) {
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200469 return NULL;
470 }
471
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200472 assert(is_block_job(&job->job));
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200473 assert(job->job.driver->free == &block_job_free);
Kevin Wolfb15de822018-04-18 17:10:26 +0200474 assert(job->job.driver->user_resume == &block_job_user_resume);
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200475
Paolo Bonzini49519672021-04-13 10:20:32 +0200476 ratelimit_init(&job->limit);
477
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400478 job->finalize_cancelled_notifier.notify = block_job_event_cancelled_locked;
479 job->finalize_completed_notifier.notify = block_job_event_completed_locked;
480 job->pending_notifier.notify = block_job_event_pending_locked;
481 job->ready_notifier.notify = block_job_event_ready_locked;
482 job->idle_notifier.notify = block_job_on_idle_locked;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200483
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -0400484 WITH_JOB_LOCK_GUARD() {
485 notifier_list_add(&job->job.on_finalize_cancelled,
486 &job->finalize_cancelled_notifier);
487 notifier_list_add(&job->job.on_finalize_completed,
488 &job->finalize_completed_notifier);
489 notifier_list_add(&job->job.on_pending, &job->pending_notifier);
490 notifier_list_add(&job->job.on_ready, &job->ready_notifier);
491 notifier_list_add(&job->job.on_idle, &job->idle_notifier);
492 }
Kevin Wolf139a9f02018-04-23 18:04:57 +0200493
Paolo Bonzini88691b32017-05-08 16:13:04 +0200494 error_setg(&job->blocker, "block device is in use by block job: %s",
Kevin Wolf252291e2018-04-12 17:57:08 +0200495 job_type_str(&job->job));
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300496
497 ret = block_job_add_bdrv(job, "main node", bs, perm, shared_perm, errp);
498 if (ret < 0) {
499 goto fail;
500 }
Paolo Bonzini88691b32017-05-08 16:13:04 +0200501
Paolo Bonzini88691b32017-05-08 16:13:04 +0200502 bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
503
Paolo Bonzinic02b83e2021-06-14 10:11:28 +0200504 if (!block_job_set_speed(job, speed, errp)) {
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300505 goto fail;
Paolo Bonzini88691b32017-05-08 16:13:04 +0200506 }
John Snow75859b92018-03-10 03:27:27 -0500507
Paolo Bonzini88691b32017-05-08 16:13:04 +0200508 return job;
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300509
510fail:
511 job_early_fail(&job->job);
512 return NULL;
Paolo Bonzini88691b32017-05-08 16:13:04 +0200513}
514
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400515void block_job_iostatus_reset_locked(BlockJob *job)
Paolo Bonzini2caf63a2017-05-08 16:13:05 +0200516{
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500517 GLOBAL_STATE_CODE();
Paolo Bonzini4c241cf2017-05-08 16:13:06 +0200518 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
519 return;
520 }
Kevin Wolfb15de822018-04-18 17:10:26 +0200521 assert(job->job.user_paused && job->job.pause_count > 0);
Paolo Bonzini2caf63a2017-05-08 16:13:05 +0200522 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
523}
524
Emanuele Giuseppe Espositoba6a9102022-09-26 05:32:13 -0400525static void block_job_iostatus_reset(BlockJob *job)
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400526{
527 JOB_LOCK_GUARD();
528 block_job_iostatus_reset_locked(job);
529}
530
Kevin Wolfb15de822018-04-18 17:10:26 +0200531void block_job_user_resume(Job *job)
532{
533 BlockJob *bjob = container_of(job, BlockJob, job);
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500534 GLOBAL_STATE_CODE();
Kevin Wolfb15de822018-04-18 17:10:26 +0200535 block_job_iostatus_reset(bjob);
536}
537
Kevin Wolf81e254d2016-04-18 11:36:38 +0200538BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200539 int is_read, int error)
540{
541 BlockErrorAction action;
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500542 IO_CODE();
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200543
544 switch (on_err) {
545 case BLOCKDEV_ON_ERROR_ENOSPC:
Kevin Wolf8c398252016-06-29 17:41:35 +0200546 case BLOCKDEV_ON_ERROR_AUTO:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200547 action = (error == ENOSPC) ?
548 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200549 break;
550 case BLOCKDEV_ON_ERROR_STOP:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200551 action = BLOCK_ERROR_ACTION_STOP;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200552 break;
553 case BLOCKDEV_ON_ERROR_REPORT:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200554 action = BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200555 break;
556 case BLOCKDEV_ON_ERROR_IGNORE:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200557 action = BLOCK_ERROR_ACTION_IGNORE;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200558 break;
559 default:
560 abort();
561 }
John Snow559b9352016-10-27 12:06:55 -0400562 if (!block_job_is_internal(job)) {
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200563 qapi_event_send_block_job_error(job->job.id,
John Snow559b9352016-10-27 12:06:55 -0400564 is_read ? IO_OPERATION_TYPE_READ :
565 IO_OPERATION_TYPE_WRITE,
Peter Xu3ab72382018-08-15 21:37:37 +0800566 action);
John Snow559b9352016-10-27 12:06:55 -0400567 }
Wenchao Xiaa5895692014-06-18 08:43:30 +0200568 if (action == BLOCK_ERROR_ACTION_STOP) {
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -0400569 WITH_JOB_LOCK_GUARD() {
570 if (!job->job.user_paused) {
571 job_pause_locked(&job->job);
572 /*
573 * make the pause user visible, which will be
574 * resumed from QMP.
575 */
576 job->job.user_paused = true;
577 }
Emanuele Giuseppe Espositod59cb662022-09-26 05:32:09 -0400578 block_job_iostatus_set_err_locked(job, error);
Vladimir Sementsov-Ogievskiy8d9648c2019-03-19 12:24:42 +0300579 }
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200580 }
581 return action;
582}
Vladimir Sementsov-Ogievskiydf9a3162021-05-06 17:13:53 +0300583
584AioContext *block_job_get_aio_context(BlockJob *job)
585{
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500586 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiydf9a3162021-05-06 17:13:53 +0300587 return job->job.aio_context;
588}