blob: d5f29e14af2ac2835e1939467e61ae9900ec85c5 [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 */
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -0500201 bdrv_graph_wrlock();
Sergio Lopezd876bf62019-09-11 12:03:16 +0200202 while (job->nodes) {
203 GSList *l = job->nodes;
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100204 BdrvChild *c = l->data;
Sergio Lopezd876bf62019-09-11 12:03:16 +0200205
206 job->nodes = l->next;
207
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100208 bdrv_op_unblock_all(c->bs, job->blocker);
209 bdrv_root_unref_child(c);
Sergio Lopezd876bf62019-09-11 12:03:16 +0200210
211 g_slist_free_1(l);
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100212 }
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -0500213 bdrv_graph_wrunlock();
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100214}
215
Vladimir Sementsov-Ogievskiy81641022019-06-06 18:41:31 +0300216bool block_job_has_bdrv(BlockJob *job, BlockDriverState *bs)
217{
218 GSList *el;
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500219 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy81641022019-06-06 18:41:31 +0300220
221 for (el = job->nodes; el; el = el->next) {
222 BdrvChild *c = el->data;
223 if (c->bs == bs) {
224 return true;
225 }
226 }
227
228 return false;
229}
230
Kevin Wolf76d554e2017-01-17 11:56:42 +0100231int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
232 uint64_t perm, uint64_t shared_perm, Error **errp)
Alberto Garcia23d402d2016-10-28 10:08:04 +0300233{
Kevin Wolf76d554e2017-01-17 11:56:42 +0100234 BdrvChild *c;
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500235 GLOBAL_STATE_CODE();
Kevin Wolf76d554e2017-01-17 11:56:42 +0100236
Alberto Garciab441dc72019-05-13 16:46:18 +0300237 bdrv_ref(bs);
Michael Qiu076d4672021-02-03 10:40:59 +0800238
Vladimir Sementsov-Ogievskiy228ca372021-04-28 18:17:34 +0300239 c = bdrv_root_attach_child(bs, name, &child_job, 0, perm, shared_perm, job,
Max Reitz258b7762020-05-13 13:05:15 +0200240 errp);
Kevin Wolf76d554e2017-01-17 11:56:42 +0100241 if (c == NULL) {
242 return -EPERM;
243 }
244
245 job->nodes = g_slist_prepend(job->nodes, c);
Alberto Garcia23d402d2016-10-28 10:08:04 +0300246 bdrv_op_block_all(bs, job->blocker);
Kevin Wolf76d554e2017-01-17 11:56:42 +0100247
248 return 0;
Alberto Garcia23d402d2016-10-28 10:08:04 +0300249}
250
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400251/* Called with job_mutex lock held. */
252static void block_job_on_idle_locked(Notifier *n, void *opaque)
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200253{
Kevin Wolfcfe29d82018-09-18 17:09:16 +0200254 aio_wait_kick();
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200255}
256
John Snow559b9352016-10-27 12:06:55 -0400257bool block_job_is_internal(BlockJob *job)
258{
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200259 return (job->job.id == NULL);
John Snow559b9352016-10-27 12:06:55 -0400260}
261
Kevin Wolfbd219352018-01-19 15:54:40 +0100262const BlockJobDriver *block_job_driver(BlockJob *job)
263{
Kevin Wolf9f6bb4c2018-05-14 14:51:21 +0200264 return container_of(job->job.driver, BlockJobDriver, job_driver);
Kevin Wolfbd219352018-01-19 15:54:40 +0100265}
266
Kevin Wolfda01ff72018-04-13 17:31:02 +0200267/* Assumes the job_mutex is held */
268static bool job_timer_pending(Job *job)
269{
270 return timer_pending(&job->sleep_timer);
271}
272
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400273bool block_job_set_speed_locked(BlockJob *job, int64_t speed, Error **errp)
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200274{
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300275 const BlockJobDriver *drv = block_job_driver(job);
John Snowaa9ef2e2017-12-13 15:46:11 -0500276 int64_t old_speed = job->speed;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200277
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500278 GLOBAL_STATE_CODE();
279
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400280 if (job_apply_verb_locked(&job->job, JOB_VERB_SET_SPEED, errp) < 0) {
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300281 return false;
John Snow0ec4dfb2018-03-10 03:27:32 -0500282 }
Kevin Wolf18bb6922018-01-18 20:25:40 +0100283 if (speed < 0) {
Kevin Wolf1ef7d9d2019-11-26 14:39:55 +0100284 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "speed",
285 "a non-negative value");
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300286 return false;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200287 }
288
Kevin Wolf18bb6922018-01-18 20:25:40 +0100289 ratelimit_set_speed(&job->limit, speed, BLOCK_JOB_SLICE_TIME);
290
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200291 job->speed = speed;
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300292
293 if (drv->set_speed) {
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400294 job_unlock();
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300295 drv->set_speed(job, speed);
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400296 job_lock();
Vladimir Sementsov-Ogievskiye0323a02021-01-17 00:46:50 +0300297 }
298
John Snowd4fce182018-03-10 03:27:26 -0500299 if (speed && speed <= old_speed) {
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300300 return true;
John Snowaa9ef2e2017-12-13 15:46:11 -0500301 }
302
303 /* kick only if a timer is pending */
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400304 job_enter_cond_locked(&job->job, job_timer_pending);
Vladimir Sementsov-Ogievskiy775d0c02021-02-02 15:49:49 +0300305
306 return true;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200307}
308
Emanuele Giuseppe Espositoba6a9102022-09-26 05:32:13 -0400309static bool block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400310{
311 JOB_LOCK_GUARD();
312 return block_job_set_speed_locked(job, speed, errp);
313}
314
Fiona Ebner61a3a5a2023-10-31 14:54:22 +0100315void block_job_change_locked(BlockJob *job, BlockJobChangeOptions *opts,
316 Error **errp)
317{
318 const BlockJobDriver *drv = block_job_driver(job);
319
320 GLOBAL_STATE_CODE();
321
322 if (job_apply_verb_locked(&job->job, JOB_VERB_CHANGE, errp)) {
323 return;
324 }
325
326 if (drv->change) {
327 job_unlock();
328 drv->change(job, opts, errp);
329 job_lock();
330 } else {
331 error_setg(errp, "Job type does not support change");
332 }
333}
334
Kevin Wolf018e5982023-05-10 22:36:00 +0200335void block_job_ratelimit_processed_bytes(BlockJob *job, uint64_t n)
Kevin Wolfdee81d52018-01-18 21:19:38 +0100336{
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500337 IO_CODE();
Kevin Wolf018e5982023-05-10 22:36:00 +0200338 ratelimit_calculate_delay(&job->limit, n);
339}
340
341void block_job_ratelimit_sleep(BlockJob *job)
342{
343 uint64_t delay_ns;
344
345 /*
346 * Sleep at least once. If the job is reentered early, keep waiting until
347 * we've waited for the full time that is necessary to keep the job at the
348 * right speed.
349 *
350 * Make sure to recalculate the delay after each (possibly interrupted)
351 * sleep because the speed can change while the job has yielded.
352 */
353 do {
354 delay_ns = ratelimit_calculate_delay(&job->limit, 0);
355 job_sleep_ns(&job->job, delay_ns);
356 } while (delay_ns && !job_is_cancelled(&job->job));
Kevin Wolfdee81d52018-01-18 21:19:38 +0100357}
358
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400359BlockJobInfo *block_job_query_locked(BlockJob *job, Error **errp)
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200360{
John Snow559b9352016-10-27 12:06:55 -0400361 BlockJobInfo *info;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200362 uint64_t progress_current, progress_total;
Fiona Ebner59fd8252023-10-31 14:54:29 +0100363 const BlockJobDriver *drv = block_job_driver(job);
John Snow559b9352016-10-27 12:06:55 -0400364
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500365 GLOBAL_STATE_CODE();
366
John Snow559b9352016-10-27 12:06:55 -0400367 if (block_job_is_internal(job)) {
368 error_setg(errp, "Cannot query QEMU internal jobs");
369 return NULL;
370 }
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200371
372 progress_get_snapshot(&job->job.progress, &progress_current,
373 &progress_total);
374
John Snow559b9352016-10-27 12:06:55 -0400375 info = g_new0(BlockJobInfo, 1);
Fiona Ebnerd67c54d2023-10-31 14:54:27 +0100376 info->type = job_type(&job->job);
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200377 info->device = g_strdup(job->job.id);
Emanuele Giuseppe Espositofca26312022-09-26 05:32:12 -0400378 info->busy = job->job.busy;
Kevin Wolfda01ff72018-04-13 17:31:02 +0200379 info->paused = job->job.pause_count > 0;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200380 info->offset = progress_current;
381 info->len = progress_total;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200382 info->speed = job->speed;
383 info->io_status = job->iostatus;
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400384 info->ready = job_is_ready_locked(&job->job),
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200385 info->status = job->job.status;
Kevin Wolfbb02b652018-04-19 17:54:56 +0200386 info->auto_finalize = job->job.auto_finalize;
387 info->auto_dismiss = job->job.auto_dismiss;
Stefano Garzarella3b6ad622021-02-25 11:36:33 +0100388 if (job->job.ret) {
Stefano Garzarella3b6ad622021-02-25 11:36:33 +0100389 info->error = job->job.err ?
390 g_strdup(error_get_pretty(job->job.err)) :
391 g_strdup(strerror(-job->job.ret));
392 }
Fiona Ebner59fd8252023-10-31 14:54:29 +0100393 if (drv->query) {
394 job_unlock();
395 drv->query(job, info);
396 job_lock();
397 }
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200398 return info;
399}
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200400
Emanuele Giuseppe Espositod59cb662022-09-26 05:32:09 -0400401/* Called with job lock held */
402static void block_job_iostatus_set_err_locked(BlockJob *job, int error)
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200403{
404 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
405 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
406 BLOCK_DEVICE_IO_STATUS_FAILED;
407 }
408}
409
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400410/* Called with job_mutex lock held. */
411static void block_job_event_cancelled_locked(Notifier *n, void *opaque)
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200412{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200413 BlockJob *job = opaque;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200414 uint64_t progress_current, progress_total;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200415
John Snow559b9352016-10-27 12:06:55 -0400416 if (block_job_is_internal(job)) {
417 return;
418 }
419
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200420 progress_get_snapshot(&job->job.progress, &progress_current,
421 &progress_total);
422
Kevin Wolf252291e2018-04-12 17:57:08 +0200423 qapi_event_send_block_job_cancelled(job_type(&job->job),
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200424 job->job.id,
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200425 progress_total,
426 progress_current,
Peter Xu3ab72382018-08-15 21:37:37 +0800427 job->speed);
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200428}
429
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400430/* Called with job_mutex lock held. */
431static void block_job_event_completed_locked(Notifier *n, void *opaque)
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200432{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200433 BlockJob *job = opaque;
434 const char *msg = NULL;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200435 uint64_t progress_current, progress_total;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200436
John Snow559b9352016-10-27 12:06:55 -0400437 if (block_job_is_internal(job)) {
438 return;
439 }
440
Kevin Wolf4ad35182018-04-19 17:30:16 +0200441 if (job->job.ret < 0) {
Stefano Garzarella3b6ad622021-02-25 11:36:33 +0100442 msg = error_get_pretty(job->job.err);
Kevin Wolf139a9f02018-04-23 18:04:57 +0200443 }
444
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200445 progress_get_snapshot(&job->job.progress, &progress_current,
446 &progress_total);
447
Kevin Wolf252291e2018-04-12 17:57:08 +0200448 qapi_event_send_block_job_completed(job_type(&job->job),
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200449 job->job.id,
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200450 progress_total,
451 progress_current,
Wenchao Xiabcada37b2014-06-18 08:43:47 +0200452 job->speed,
Peter Xu3ab72382018-08-15 21:37:37 +0800453 msg);
Wenchao Xiabcada37b2014-06-18 08:43:47 +0200454}
455
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400456/* Called with job_mutex lock held. */
457static void block_job_event_pending_locked(Notifier *n, void *opaque)
John Snow5f241592018-03-10 03:27:42 -0500458{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200459 BlockJob *job = opaque;
460
Kevin Wolf5d4f3762018-04-23 17:09:42 +0200461 if (block_job_is_internal(job)) {
462 return;
John Snow5f241592018-03-10 03:27:42 -0500463 }
Kevin Wolf5d4f3762018-04-23 17:09:42 +0200464
465 qapi_event_send_block_job_pending(job_type(&job->job),
Peter Xu3ab72382018-08-15 21:37:37 +0800466 job->job.id);
John Snow5f241592018-03-10 03:27:42 -0500467}
468
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400469/* Called with job_mutex lock held. */
470static void block_job_event_ready_locked(Notifier *n, void *opaque)
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200471{
472 BlockJob *job = opaque;
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200473 uint64_t progress_current, progress_total;
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200474
475 if (block_job_is_internal(job)) {
476 return;
477 }
478
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200479 progress_get_snapshot(&job->job.progress, &progress_current,
480 &progress_total);
481
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200482 qapi_event_send_block_job_ready(job_type(&job->job),
483 job->job.id,
Emanuele Giuseppe Espositoa7b4f8f2021-06-14 10:11:29 +0200484 progress_total,
485 progress_current,
Peter Xu3ab72382018-08-15 21:37:37 +0800486 job->speed);
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200487}
488
489
Paolo Bonzini88691b32017-05-08 16:13:04 +0200490void *block_job_create(const char *job_id, const BlockJobDriver *driver,
Kevin Wolf62c9e412018-04-19 16:09:52 +0200491 JobTxn *txn, BlockDriverState *bs, uint64_t perm,
Paolo Bonzini88691b32017-05-08 16:13:04 +0200492 uint64_t shared_perm, int64_t speed, int flags,
493 BlockCompletionFunc *cb, void *opaque, Error **errp)
494{
Paolo Bonzini88691b32017-05-08 16:13:04 +0200495 BlockJob *job;
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300496 int ret;
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500497 GLOBAL_STATE_CODE();
Kevin Wolff3bbc532023-10-27 17:53:14 +0200498
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -0500499 bdrv_graph_wrlock();
Paolo Bonzini88691b32017-05-08 16:13:04 +0200500
Kevin Wolfbb02b652018-04-19 17:54:56 +0200501 if (job_id == NULL && !(flags & JOB_INTERNAL)) {
Paolo Bonzini88691b32017-05-08 16:13:04 +0200502 job_id = bdrv_get_device_name(bs);
Paolo Bonzini88691b32017-05-08 16:13:04 +0200503 }
504
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300505 job = job_create(job_id, &driver->job_driver, txn, bdrv_get_aio_context(bs),
Kevin Wolf4ad35182018-04-19 17:30:16 +0200506 flags, cb, opaque, errp);
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200507 if (job == NULL) {
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -0500508 bdrv_graph_wrunlock();
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200509 return NULL;
510 }
511
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200512 assert(is_block_job(&job->job));
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200513 assert(job->job.driver->free == &block_job_free);
Kevin Wolfb15de822018-04-18 17:10:26 +0200514 assert(job->job.driver->user_resume == &block_job_user_resume);
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200515
Paolo Bonzini49519672021-04-13 10:20:32 +0200516 ratelimit_init(&job->limit);
517
Emanuele Giuseppe Esposito243c6ec2022-09-26 05:32:08 -0400518 job->finalize_cancelled_notifier.notify = block_job_event_cancelled_locked;
519 job->finalize_completed_notifier.notify = block_job_event_completed_locked;
520 job->pending_notifier.notify = block_job_event_pending_locked;
521 job->ready_notifier.notify = block_job_event_ready_locked;
522 job->idle_notifier.notify = block_job_on_idle_locked;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200523
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -0400524 WITH_JOB_LOCK_GUARD() {
525 notifier_list_add(&job->job.on_finalize_cancelled,
526 &job->finalize_cancelled_notifier);
527 notifier_list_add(&job->job.on_finalize_completed,
528 &job->finalize_completed_notifier);
529 notifier_list_add(&job->job.on_pending, &job->pending_notifier);
530 notifier_list_add(&job->job.on_ready, &job->ready_notifier);
531 notifier_list_add(&job->job.on_idle, &job->idle_notifier);
532 }
Kevin Wolf139a9f02018-04-23 18:04:57 +0200533
Paolo Bonzini88691b32017-05-08 16:13:04 +0200534 error_setg(&job->blocker, "block device is in use by block job: %s",
Kevin Wolf252291e2018-04-12 17:57:08 +0200535 job_type_str(&job->job));
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300536
537 ret = block_job_add_bdrv(job, "main node", bs, perm, shared_perm, errp);
538 if (ret < 0) {
539 goto fail;
540 }
Paolo Bonzini88691b32017-05-08 16:13:04 +0200541
Paolo Bonzini88691b32017-05-08 16:13:04 +0200542 bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
543
Paolo Bonzinic02b83e2021-06-14 10:11:28 +0200544 if (!block_job_set_speed(job, speed, errp)) {
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300545 goto fail;
Paolo Bonzini88691b32017-05-08 16:13:04 +0200546 }
John Snow75859b92018-03-10 03:27:27 -0500547
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -0500548 bdrv_graph_wrunlock();
Paolo Bonzini88691b32017-05-08 16:13:04 +0200549 return job;
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300550
551fail:
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -0500552 bdrv_graph_wrunlock();
Vladimir Sementsov-Ogievskiy985cac82021-05-06 17:13:57 +0300553 job_early_fail(&job->job);
554 return NULL;
Paolo Bonzini88691b32017-05-08 16:13:04 +0200555}
556
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400557void block_job_iostatus_reset_locked(BlockJob *job)
Paolo Bonzini2caf63a2017-05-08 16:13:05 +0200558{
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500559 GLOBAL_STATE_CODE();
Paolo Bonzini4c241cf2017-05-08 16:13:06 +0200560 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
561 return;
562 }
Kevin Wolfb15de822018-04-18 17:10:26 +0200563 assert(job->job.user_paused && job->job.pause_count > 0);
Paolo Bonzini2caf63a2017-05-08 16:13:05 +0200564 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
565}
566
Emanuele Giuseppe Espositoba6a9102022-09-26 05:32:13 -0400567static void block_job_iostatus_reset(BlockJob *job)
Emanuele Giuseppe Espositof41ab732022-09-26 05:32:00 -0400568{
569 JOB_LOCK_GUARD();
570 block_job_iostatus_reset_locked(job);
571}
572
Kevin Wolfb15de822018-04-18 17:10:26 +0200573void block_job_user_resume(Job *job)
574{
575 BlockJob *bjob = container_of(job, BlockJob, job);
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500576 GLOBAL_STATE_CODE();
Kevin Wolfb15de822018-04-18 17:10:26 +0200577 block_job_iostatus_reset(bjob);
578}
579
Kevin Wolf81e254d2016-04-18 11:36:38 +0200580BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200581 int is_read, int error)
582{
583 BlockErrorAction action;
Emanuele Giuseppe Espositoe2d9faf2022-03-03 10:16:01 -0500584 IO_CODE();
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200585
586 switch (on_err) {
587 case BLOCKDEV_ON_ERROR_ENOSPC:
Kevin Wolf8c398252016-06-29 17:41:35 +0200588 case BLOCKDEV_ON_ERROR_AUTO:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200589 action = (error == ENOSPC) ?
590 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200591 break;
592 case BLOCKDEV_ON_ERROR_STOP:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200593 action = BLOCK_ERROR_ACTION_STOP;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200594 break;
595 case BLOCKDEV_ON_ERROR_REPORT:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200596 action = BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200597 break;
598 case BLOCKDEV_ON_ERROR_IGNORE:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200599 action = BLOCK_ERROR_ACTION_IGNORE;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200600 break;
601 default:
602 abort();
603 }
John Snow559b9352016-10-27 12:06:55 -0400604 if (!block_job_is_internal(job)) {
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200605 qapi_event_send_block_job_error(job->job.id,
John Snow559b9352016-10-27 12:06:55 -0400606 is_read ? IO_OPERATION_TYPE_READ :
607 IO_OPERATION_TYPE_WRITE,
Peter Xu3ab72382018-08-15 21:37:37 +0800608 action);
John Snow559b9352016-10-27 12:06:55 -0400609 }
Wenchao Xiaa5895692014-06-18 08:43:30 +0200610 if (action == BLOCK_ERROR_ACTION_STOP) {
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -0400611 WITH_JOB_LOCK_GUARD() {
612 if (!job->job.user_paused) {
613 job_pause_locked(&job->job);
614 /*
615 * make the pause user visible, which will be
616 * resumed from QMP.
617 */
618 job->job.user_paused = true;
619 }
Emanuele Giuseppe Espositod59cb662022-09-26 05:32:09 -0400620 block_job_iostatus_set_err_locked(job, error);
Vladimir Sementsov-Ogievskiy8d9648c2019-03-19 12:24:42 +0300621 }
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200622 }
623 return action;
624}
Vladimir Sementsov-Ogievskiydf9a3162021-05-06 17:13:53 +0300625
626AioContext *block_job_get_aio_context(BlockJob *job)
627{
Emanuele Giuseppe Espositocf81ae22022-03-03 10:16:04 -0500628 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiydf9a3162021-05-06 17:13:53 +0300629 return job->job.aio_context;
630}