blob: 470facfd47a08b3c084796cc64e7521774a3175b [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"
Paolo Bonzini737e1502012-12-17 18:19:44 +010027#include "block/block.h"
John Snowc87621e2016-10-27 12:07:00 -040028#include "block/blockjob_int.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010029#include "block/block_int.h"
John Snowc9de4052018-03-10 03:27:30 -050030#include "block/trace.h"
Max Reitz373340b2015-10-19 17:53:22 +020031#include "sysemu/block-backend.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010032#include "qapi/error.h"
Markus Armbruster9af23982018-02-11 10:36:01 +010033#include "qapi/qapi-events-block-core.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010034#include "qapi/qmp/qerror.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010035#include "qemu/coroutine.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
Paolo Bonzini88691b32017-05-08 16:13:04 +020039/*
40 * The block job API is composed of two categories of functions.
41 *
42 * The first includes functions used by the monitor. The monitor is
43 * peculiar in that it accesses the block job list with block_job_get, and
44 * therefore needs consistency across block_job_get and the actual operation
45 * (e.g. block_job_set_speed). The consistency is achieved with
46 * aio_context_acquire/release. These functions are declared in blockjob.h.
47 *
48 * The second includes functions used by the block job drivers and sometimes
49 * by the core block layer. These do not care about locking, because the
50 * whole coroutine runs under the AioContext lock, and are declared in
51 * blockjob_int.h.
52 */
53
Kevin Wolfe7c1d782018-04-12 17:54:37 +020054static bool is_block_job(Job *job)
Alberto Garciaa7112792016-04-04 16:43:51 +030055{
Kevin Wolfe7c1d782018-04-12 17:54:37 +020056 return job_type(job) == JOB_TYPE_BACKUP ||
57 job_type(job) == JOB_TYPE_COMMIT ||
58 job_type(job) == JOB_TYPE_MIRROR ||
59 job_type(job) == JOB_TYPE_STREAM;
60}
61
62BlockJob *block_job_next(BlockJob *bjob)
63{
64 Job *job = bjob ? &bjob->job : NULL;
65
66 do {
67 job = job_next(job);
68 } while (job && !is_block_job(job));
69
70 return job ? container_of(job, BlockJob, job) : NULL;
Alberto Garciaa7112792016-04-04 16:43:51 +030071}
72
Alberto Garciaffb1f102016-07-05 17:28:54 +030073BlockJob *block_job_get(const char *id)
74{
Kevin Wolfe7c1d782018-04-12 17:54:37 +020075 Job *job = job_get(id);
Alberto Garciaffb1f102016-07-05 17:28:54 +030076
Kevin Wolfe7c1d782018-04-12 17:54:37 +020077 if (job && is_block_job(job)) {
78 return container_of(job, BlockJob, job);
79 } else {
80 return NULL;
Alberto Garciaffb1f102016-07-05 17:28:54 +030081 }
Alberto Garciaffb1f102016-07-05 17:28:54 +030082}
83
Kevin Wolf80fa2c72018-04-13 18:50:05 +020084void block_job_free(Job *job)
Paolo Bonzini05b0d8e2017-05-08 16:13:02 +020085{
Kevin Wolf80fa2c72018-04-13 18:50:05 +020086 BlockJob *bjob = container_of(job, BlockJob, job);
Kevin Wolf80fa2c72018-04-13 18:50:05 +020087
Kevin Wolf80fa2c72018-04-13 18:50:05 +020088 block_job_remove_all_bdrv(bjob);
Kevin Wolf80fa2c72018-04-13 18:50:05 +020089 blk_unref(bjob->blk);
90 error_free(bjob->blocker);
Paolo Bonzini05b0d8e2017-05-08 16:13:02 +020091}
92
Paolo Bonzinif321dcb2017-05-08 16:13:03 +020093static char *child_job_get_parent_desc(BdrvChild *c)
94{
95 BlockJob *job = c->opaque;
Kevin Wolf252291e2018-04-12 17:57:08 +020096 return g_strdup_printf("%s job '%s'", job_type_str(&job->job), job->job.id);
Paolo Bonzinif321dcb2017-05-08 16:13:03 +020097}
98
Kevin Wolfad90feb2017-12-12 19:04:28 +010099static void child_job_drained_begin(BdrvChild *c)
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200100{
Kevin Wolfad90feb2017-12-12 19:04:28 +0100101 BlockJob *job = c->opaque;
Kevin Wolfb15de822018-04-18 17:10:26 +0200102 job_pause(&job->job);
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200103}
104
Kevin Wolf89bd0302018-03-22 14:11:20 +0100105static bool child_job_drained_poll(BdrvChild *c)
106{
107 BlockJob *bjob = c->opaque;
108 Job *job = &bjob->job;
109 const BlockJobDriver *drv = block_job_driver(bjob);
110
111 /* An inactive or completed job doesn't have any pending requests. Jobs
112 * with !job->busy are either already paused or have a pause point after
113 * being reentered, so no job driver code will run before they pause. */
Kevin Wolfb5a7a052018-09-07 15:31:22 +0200114 if (!job->busy || job_is_completed(job)) {
Kevin Wolf89bd0302018-03-22 14:11:20 +0100115 return false;
116 }
117
118 /* Otherwise, assume that it isn't fully stopped yet, but allow the job to
119 * override this assumption. */
120 if (drv->drained_poll) {
121 return drv->drained_poll(bjob);
122 } else {
123 return true;
124 }
125}
126
Max Reitze037c092019-07-19 11:26:14 +0200127static void child_job_drained_end(BdrvChild *c, int *drained_end_counter)
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200128{
Kevin Wolfad90feb2017-12-12 19:04:28 +0100129 BlockJob *job = c->opaque;
Kevin Wolfb15de822018-04-18 17:10:26 +0200130 job_resume(&job->job);
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200131}
132
Kevin Wolf9ff7f0d2019-05-06 19:18:03 +0200133static bool child_job_can_set_aio_ctx(BdrvChild *c, AioContext *ctx,
134 GSList **ignore, Error **errp)
135{
136 BlockJob *job = c->opaque;
137 GSList *l;
138
139 for (l = job->nodes; l; l = l->next) {
140 BdrvChild *sibling = l->data;
141 if (!bdrv_child_can_set_aio_context(sibling, ctx, ignore, errp)) {
142 return false;
143 }
144 }
145 return true;
146}
147
148static void child_job_set_aio_ctx(BdrvChild *c, AioContext *ctx,
149 GSList **ignore)
150{
151 BlockJob *job = c->opaque;
152 GSList *l;
153
154 for (l = job->nodes; l; l = l->next) {
155 BdrvChild *sibling = l->data;
156 if (g_slist_find(*ignore, sibling)) {
157 continue;
158 }
159 *ignore = g_slist_prepend(*ignore, sibling);
160 bdrv_set_aio_context_ignore(sibling->bs, ctx, ignore);
161 }
Kevin Wolf657e1202019-05-06 19:18:04 +0200162
163 job->job.aio_context = ctx;
Kevin Wolf9ff7f0d2019-05-06 19:18:03 +0200164}
165
Max Reitzbd86fb92020-05-13 13:05:13 +0200166static const BdrvChildClass child_job = {
Kevin Wolfad90feb2017-12-12 19:04:28 +0100167 .get_parent_desc = child_job_get_parent_desc,
168 .drained_begin = child_job_drained_begin,
Kevin Wolf89bd0302018-03-22 14:11:20 +0100169 .drained_poll = child_job_drained_poll,
Kevin Wolfad90feb2017-12-12 19:04:28 +0100170 .drained_end = child_job_drained_end,
Kevin Wolf9ff7f0d2019-05-06 19:18:03 +0200171 .can_set_aio_ctx = child_job_can_set_aio_ctx,
172 .set_aio_ctx = child_job_set_aio_ctx,
Kevin Wolfad90feb2017-12-12 19:04:28 +0100173 .stay_at_node = true,
Paolo Bonzinif321dcb2017-05-08 16:13:03 +0200174};
175
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100176void block_job_remove_all_bdrv(BlockJob *job)
177{
Sergio Lopezd876bf62019-09-11 12:03:16 +0200178 /*
179 * bdrv_root_unref_child() may reach child_job_[can_]set_aio_ctx(),
180 * which will also traverse job->nodes, so consume the list one by
181 * one to make sure that such a concurrent access does not attempt
182 * to process an already freed BdrvChild.
183 */
184 while (job->nodes) {
185 GSList *l = job->nodes;
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100186 BdrvChild *c = l->data;
Sergio Lopezd876bf62019-09-11 12:03:16 +0200187
188 job->nodes = l->next;
189
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100190 bdrv_op_unblock_all(c->bs, job->blocker);
191 bdrv_root_unref_child(c);
Sergio Lopezd876bf62019-09-11 12:03:16 +0200192
193 g_slist_free_1(l);
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100194 }
Kevin Wolfbbc02b92017-02-28 12:45:58 +0100195}
196
Vladimir Sementsov-Ogievskiy81641022019-06-06 18:41:31 +0300197bool block_job_has_bdrv(BlockJob *job, BlockDriverState *bs)
198{
199 GSList *el;
200
201 for (el = job->nodes; el; el = el->next) {
202 BdrvChild *c = el->data;
203 if (c->bs == bs) {
204 return true;
205 }
206 }
207
208 return false;
209}
210
Kevin Wolf76d554e2017-01-17 11:56:42 +0100211int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
212 uint64_t perm, uint64_t shared_perm, Error **errp)
Alberto Garcia23d402d2016-10-28 10:08:04 +0300213{
Kevin Wolf76d554e2017-01-17 11:56:42 +0100214 BdrvChild *c;
215
Alberto Garciab441dc72019-05-13 16:46:18 +0300216 bdrv_ref(bs);
Kevin Wolf132ada82019-04-24 17:41:46 +0200217 if (job->job.aio_context != qemu_get_aio_context()) {
218 aio_context_release(job->job.aio_context);
219 }
Max Reitz258b7762020-05-13 13:05:15 +0200220 c = bdrv_root_attach_child(bs, name, &child_job, 0,
221 job->job.aio_context, perm, shared_perm, job,
222 errp);
Kevin Wolf132ada82019-04-24 17:41:46 +0200223 if (job->job.aio_context != qemu_get_aio_context()) {
224 aio_context_acquire(job->job.aio_context);
225 }
Kevin Wolf76d554e2017-01-17 11:56:42 +0100226 if (c == NULL) {
227 return -EPERM;
228 }
229
230 job->nodes = g_slist_prepend(job->nodes, c);
Alberto Garcia23d402d2016-10-28 10:08:04 +0300231 bdrv_op_block_all(bs, job->blocker);
Kevin Wolf76d554e2017-01-17 11:56:42 +0100232
233 return 0;
Alberto Garcia23d402d2016-10-28 10:08:04 +0300234}
235
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200236static void block_job_on_idle(Notifier *n, void *opaque)
237{
Kevin Wolfcfe29d82018-09-18 17:09:16 +0200238 aio_wait_kick();
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200239}
240
John Snow559b9352016-10-27 12:06:55 -0400241bool block_job_is_internal(BlockJob *job)
242{
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200243 return (job->job.id == NULL);
John Snow559b9352016-10-27 12:06:55 -0400244}
245
Kevin Wolfbd219352018-01-19 15:54:40 +0100246const BlockJobDriver *block_job_driver(BlockJob *job)
247{
Kevin Wolf9f6bb4c2018-05-14 14:51:21 +0200248 return container_of(job->job.driver, BlockJobDriver, job_driver);
Kevin Wolfbd219352018-01-19 15:54:40 +0100249}
250
Kevin Wolfda01ff72018-04-13 17:31:02 +0200251/* Assumes the job_mutex is held */
252static bool job_timer_pending(Job *job)
253{
254 return timer_pending(&job->sleep_timer);
255}
256
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200257void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
258{
John Snowaa9ef2e2017-12-13 15:46:11 -0500259 int64_t old_speed = job->speed;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200260
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200261 if (job_apply_verb(&job->job, JOB_VERB_SET_SPEED, errp)) {
John Snow0ec4dfb2018-03-10 03:27:32 -0500262 return;
263 }
Kevin Wolf18bb6922018-01-18 20:25:40 +0100264 if (speed < 0) {
Kevin Wolf1ef7d9d2019-11-26 14:39:55 +0100265 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "speed",
266 "a non-negative value");
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200267 return;
268 }
269
Kevin Wolf18bb6922018-01-18 20:25:40 +0100270 ratelimit_set_speed(&job->limit, speed, BLOCK_JOB_SLICE_TIME);
271
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200272 job->speed = speed;
John Snowd4fce182018-03-10 03:27:26 -0500273 if (speed && speed <= old_speed) {
John Snowaa9ef2e2017-12-13 15:46:11 -0500274 return;
275 }
276
277 /* kick only if a timer is pending */
Kevin Wolfda01ff72018-04-13 17:31:02 +0200278 job_enter_cond(&job->job, job_timer_pending);
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200279}
280
Kevin Wolfdee81d52018-01-18 21:19:38 +0100281int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
282{
283 if (!job->speed) {
284 return 0;
285 }
286
287 return ratelimit_calculate_delay(&job->limit, n);
288}
289
John Snow559b9352016-10-27 12:06:55 -0400290BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200291{
John Snow559b9352016-10-27 12:06:55 -0400292 BlockJobInfo *info;
293
294 if (block_job_is_internal(job)) {
295 error_setg(errp, "Cannot query QEMU internal jobs");
296 return NULL;
297 }
298 info = g_new0(BlockJobInfo, 1);
Kevin Wolf252291e2018-04-12 17:57:08 +0200299 info->type = g_strdup(job_type_str(&job->job));
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200300 info->device = g_strdup(job->job.id);
Kevin Wolfda01ff72018-04-13 17:31:02 +0200301 info->busy = atomic_read(&job->job.busy);
302 info->paused = job->job.pause_count > 0;
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300303 info->offset = job->job.progress.current;
304 info->len = job->job.progress.total;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200305 info->speed = job->speed;
306 info->io_status = job->iostatus;
Kevin Wolfdf956ae2018-04-25 15:09:58 +0200307 info->ready = job_is_ready(&job->job),
Kevin Wolfa50c2ab2018-04-13 17:19:31 +0200308 info->status = job->job.status;
Kevin Wolfbb02b652018-04-19 17:54:56 +0200309 info->auto_finalize = job->job.auto_finalize;
310 info->auto_dismiss = job->job.auto_dismiss;
Kevin Wolf4ad35182018-04-19 17:30:16 +0200311 info->has_error = job->job.ret != 0;
312 info->error = job->job.ret ? g_strdup(strerror(-job->job.ret)) : NULL;
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200313 return info;
314}
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200315
316static void block_job_iostatus_set_err(BlockJob *job, int error)
317{
318 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
319 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
320 BLOCK_DEVICE_IO_STATUS_FAILED;
321 }
322}
323
Kevin Wolf139a9f02018-04-23 18:04:57 +0200324static void block_job_event_cancelled(Notifier *n, void *opaque)
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200325{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200326 BlockJob *job = opaque;
327
John Snow559b9352016-10-27 12:06:55 -0400328 if (block_job_is_internal(job)) {
329 return;
330 }
331
Kevin Wolf252291e2018-04-12 17:57:08 +0200332 qapi_event_send_block_job_cancelled(job_type(&job->job),
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200333 job->job.id,
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300334 job->job.progress.total,
335 job->job.progress.current,
Peter Xu3ab72382018-08-15 21:37:37 +0800336 job->speed);
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200337}
338
Kevin Wolf139a9f02018-04-23 18:04:57 +0200339static void block_job_event_completed(Notifier *n, void *opaque)
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200340{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200341 BlockJob *job = opaque;
342 const char *msg = NULL;
343
John Snow559b9352016-10-27 12:06:55 -0400344 if (block_job_is_internal(job)) {
345 return;
346 }
347
Kevin Wolf4ad35182018-04-19 17:30:16 +0200348 if (job->job.ret < 0) {
349 msg = strerror(-job->job.ret);
Kevin Wolf139a9f02018-04-23 18:04:57 +0200350 }
351
Kevin Wolf252291e2018-04-12 17:57:08 +0200352 qapi_event_send_block_job_completed(job_type(&job->job),
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200353 job->job.id,
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300354 job->job.progress.total,
355 job->job.progress.current,
Wenchao Xiabcada37b2014-06-18 08:43:47 +0200356 job->speed,
357 !!msg,
Peter Xu3ab72382018-08-15 21:37:37 +0800358 msg);
Wenchao Xiabcada37b2014-06-18 08:43:47 +0200359}
360
Kevin Wolf139a9f02018-04-23 18:04:57 +0200361static void block_job_event_pending(Notifier *n, void *opaque)
John Snow5f241592018-03-10 03:27:42 -0500362{
Kevin Wolf139a9f02018-04-23 18:04:57 +0200363 BlockJob *job = opaque;
364
Kevin Wolf5d4f3762018-04-23 17:09:42 +0200365 if (block_job_is_internal(job)) {
366 return;
John Snow5f241592018-03-10 03:27:42 -0500367 }
Kevin Wolf5d4f3762018-04-23 17:09:42 +0200368
369 qapi_event_send_block_job_pending(job_type(&job->job),
Peter Xu3ab72382018-08-15 21:37:37 +0800370 job->job.id);
John Snow5f241592018-03-10 03:27:42 -0500371}
372
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200373static void block_job_event_ready(Notifier *n, void *opaque)
374{
375 BlockJob *job = opaque;
376
377 if (block_job_is_internal(job)) {
378 return;
379 }
380
381 qapi_event_send_block_job_ready(job_type(&job->job),
382 job->job.id,
Vladimir Sementsov-Ogievskiy01fe1ca2020-03-11 13:29:56 +0300383 job->job.progress.total,
384 job->job.progress.current,
Peter Xu3ab72382018-08-15 21:37:37 +0800385 job->speed);
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200386}
387
388
Paolo Bonzini88691b32017-05-08 16:13:04 +0200389/*
390 * API for block job drivers and the block layer. These functions are
391 * declared in blockjob_int.h.
392 */
393
394void *block_job_create(const char *job_id, const BlockJobDriver *driver,
Kevin Wolf62c9e412018-04-19 16:09:52 +0200395 JobTxn *txn, BlockDriverState *bs, uint64_t perm,
Paolo Bonzini88691b32017-05-08 16:13:04 +0200396 uint64_t shared_perm, int64_t speed, int flags,
397 BlockCompletionFunc *cb, void *opaque, Error **errp)
398{
399 BlockBackend *blk;
400 BlockJob *job;
Paolo Bonzini88691b32017-05-08 16:13:04 +0200401
Kevin Wolfbb02b652018-04-19 17:54:56 +0200402 if (job_id == NULL && !(flags & JOB_INTERNAL)) {
Paolo Bonzini88691b32017-05-08 16:13:04 +0200403 job_id = bdrv_get_device_name(bs);
Paolo Bonzini88691b32017-05-08 16:13:04 +0200404 }
405
Eric Blakea3aeeab2020-04-28 14:26:46 -0500406 blk = blk_new_with_bs(bs, perm, shared_perm, errp);
407 if (!blk) {
Paolo Bonzini88691b32017-05-08 16:13:04 +0200408 return NULL;
409 }
410
Kevin Wolf7eaa8fb2018-04-23 16:06:26 +0200411 job = job_create(job_id, &driver->job_driver, txn, blk_get_aio_context(blk),
Kevin Wolf4ad35182018-04-19 17:30:16 +0200412 flags, cb, opaque, errp);
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200413 if (job == NULL) {
414 blk_unref(blk);
415 return NULL;
416 }
417
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200418 assert(is_block_job(&job->job));
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200419 assert(job->job.driver->free == &block_job_free);
Kevin Wolfb15de822018-04-18 17:10:26 +0200420 assert(job->job.driver->user_resume == &block_job_user_resume);
Kevin Wolfe7c1d782018-04-12 17:54:37 +0200421
Kevin Wolf9f6bb4c2018-05-14 14:51:21 +0200422 job->blk = blk;
Paolo Bonzini88691b32017-05-08 16:13:04 +0200423
Kevin Wolf139a9f02018-04-23 18:04:57 +0200424 job->finalize_cancelled_notifier.notify = block_job_event_cancelled;
425 job->finalize_completed_notifier.notify = block_job_event_completed;
426 job->pending_notifier.notify = block_job_event_pending;
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200427 job->ready_notifier.notify = block_job_event_ready;
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200428 job->idle_notifier.notify = block_job_on_idle;
Kevin Wolf139a9f02018-04-23 18:04:57 +0200429
430 notifier_list_add(&job->job.on_finalize_cancelled,
431 &job->finalize_cancelled_notifier);
432 notifier_list_add(&job->job.on_finalize_completed,
433 &job->finalize_completed_notifier);
434 notifier_list_add(&job->job.on_pending, &job->pending_notifier);
Kevin Wolf2e1795b2018-04-25 14:56:09 +0200435 notifier_list_add(&job->job.on_ready, &job->ready_notifier);
Kevin Wolf34dc97b2018-08-17 14:53:05 +0200436 notifier_list_add(&job->job.on_idle, &job->idle_notifier);
Kevin Wolf139a9f02018-04-23 18:04:57 +0200437
Paolo Bonzini88691b32017-05-08 16:13:04 +0200438 error_setg(&job->blocker, "block device is in use by block job: %s",
Kevin Wolf252291e2018-04-12 17:57:08 +0200439 job_type_str(&job->job));
Paolo Bonzini88691b32017-05-08 16:13:04 +0200440 block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
Paolo Bonzini88691b32017-05-08 16:13:04 +0200441
Paolo Bonzini88691b32017-05-08 16:13:04 +0200442 bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
443
Kevin Wolfcf312932019-07-22 17:46:23 +0200444 /* Disable request queuing in the BlockBackend to avoid deadlocks on drain:
445 * The job reports that it's busy until it reaches a pause point. */
446 blk_set_disable_request_queuing(blk, true);
Kevin Wolf9ff7f0d2019-05-06 19:18:03 +0200447 blk_set_allow_aio_context_change(blk, true);
Paolo Bonzini88691b32017-05-08 16:13:04 +0200448
449 /* Only set speed when necessary to avoid NotSupported error */
450 if (speed != 0) {
451 Error *local_err = NULL;
452
453 block_job_set_speed(job, speed, &local_err);
454 if (local_err) {
Kevin Wolf4ad35182018-04-19 17:30:16 +0200455 job_early_fail(&job->job);
Paolo Bonzini88691b32017-05-08 16:13:04 +0200456 error_propagate(errp, local_err);
457 return NULL;
458 }
459 }
John Snow75859b92018-03-10 03:27:27 -0500460
Paolo Bonzini88691b32017-05-08 16:13:04 +0200461 return job;
462}
463
Paolo Bonzini2caf63a2017-05-08 16:13:05 +0200464void block_job_iostatus_reset(BlockJob *job)
465{
Paolo Bonzini4c241cf2017-05-08 16:13:06 +0200466 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
467 return;
468 }
Kevin Wolfb15de822018-04-18 17:10:26 +0200469 assert(job->job.user_paused && job->job.pause_count > 0);
Paolo Bonzini2caf63a2017-05-08 16:13:05 +0200470 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
471}
472
Kevin Wolfb15de822018-04-18 17:10:26 +0200473void block_job_user_resume(Job *job)
474{
475 BlockJob *bjob = container_of(job, BlockJob, job);
476 block_job_iostatus_reset(bjob);
477}
478
Kevin Wolf81e254d2016-04-18 11:36:38 +0200479BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200480 int is_read, int error)
481{
482 BlockErrorAction action;
483
484 switch (on_err) {
485 case BLOCKDEV_ON_ERROR_ENOSPC:
Kevin Wolf8c398252016-06-29 17:41:35 +0200486 case BLOCKDEV_ON_ERROR_AUTO:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200487 action = (error == ENOSPC) ?
488 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200489 break;
490 case BLOCKDEV_ON_ERROR_STOP:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200491 action = BLOCK_ERROR_ACTION_STOP;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200492 break;
493 case BLOCKDEV_ON_ERROR_REPORT:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200494 action = BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200495 break;
496 case BLOCKDEV_ON_ERROR_IGNORE:
Wenchao Xiaa5895692014-06-18 08:43:30 +0200497 action = BLOCK_ERROR_ACTION_IGNORE;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200498 break;
499 default:
500 abort();
501 }
John Snow559b9352016-10-27 12:06:55 -0400502 if (!block_job_is_internal(job)) {
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200503 qapi_event_send_block_job_error(job->job.id,
John Snow559b9352016-10-27 12:06:55 -0400504 is_read ? IO_OPERATION_TYPE_READ :
505 IO_OPERATION_TYPE_WRITE,
Peter Xu3ab72382018-08-15 21:37:37 +0800506 action);
John Snow559b9352016-10-27 12:06:55 -0400507 }
Wenchao Xiaa5895692014-06-18 08:43:30 +0200508 if (action == BLOCK_ERROR_ACTION_STOP) {
Vladimir Sementsov-Ogievskiy8d9648c2019-03-19 12:24:42 +0300509 if (!job->job.user_paused) {
510 job_pause(&job->job);
511 /* make the pause user visible, which will be resumed from QMP. */
512 job->job.user_paused = true;
513 }
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200514 block_job_iostatus_set_err(job, error);
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200515 }
516 return action;
517}