12f0c9fe6SPaolo Bonzini /* 22f0c9fe6SPaolo Bonzini * QEMU System Emulator block driver 32f0c9fe6SPaolo Bonzini * 42f0c9fe6SPaolo Bonzini * Copyright (c) 2011 IBM Corp. 52f0c9fe6SPaolo Bonzini * Copyright (c) 2012 Red Hat, Inc. 62f0c9fe6SPaolo Bonzini * 72f0c9fe6SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 82f0c9fe6SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 92f0c9fe6SPaolo Bonzini * in the Software without restriction, including without limitation the rights 102f0c9fe6SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 112f0c9fe6SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 122f0c9fe6SPaolo Bonzini * furnished to do so, subject to the following conditions: 132f0c9fe6SPaolo Bonzini * 142f0c9fe6SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 152f0c9fe6SPaolo Bonzini * all copies or substantial portions of the Software. 162f0c9fe6SPaolo Bonzini * 172f0c9fe6SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 182f0c9fe6SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 192f0c9fe6SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 202f0c9fe6SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 212f0c9fe6SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 222f0c9fe6SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 232f0c9fe6SPaolo Bonzini * THE SOFTWARE. 242f0c9fe6SPaolo Bonzini */ 252f0c9fe6SPaolo Bonzini 26d38ea87aSPeter Maydell #include "qemu/osdep.h" 272f0c9fe6SPaolo Bonzini #include "qemu-common.h" 28737e150eSPaolo Bonzini #include "block/block.h" 29c87621eaSJohn Snow #include "block/blockjob_int.h" 30737e150eSPaolo Bonzini #include "block/block_int.h" 31c9de4050SJohn Snow #include "block/trace.h" 32373340b2SMax Reitz #include "sysemu/block-backend.h" 33e688df6bSMarkus Armbruster #include "qapi/error.h" 349af23989SMarkus Armbruster #include "qapi/qapi-events-block-core.h" 35cc7a8ea7SMarkus Armbruster #include "qapi/qmp/qerror.h" 3610817bf0SDaniel P. Berrange #include "qemu/coroutine.h" 377f0317cfSAlberto Garcia #include "qemu/id.h" 381de7afc9SPaolo Bonzini #include "qemu/timer.h" 392f0c9fe6SPaolo Bonzini 40fc24908eSPaolo Bonzini /* Right now, this mutex is only needed to synchronize accesses to job->busy 41fc24908eSPaolo Bonzini * and job->sleep_timer, such as concurrent calls to block_job_do_yield and 42fc24908eSPaolo Bonzini * block_job_enter. */ 43fc24908eSPaolo Bonzini static QemuMutex block_job_mutex; 44fc24908eSPaolo Bonzini 45c9de4050SJohn Snow /* BlockJob State Transition Table */ 46c9de4050SJohn Snow bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = { 47c9de4050SJohn Snow /* U, C, R, P, Y, S */ 48c9de4050SJohn Snow /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0}, 49c9de4050SJohn Snow /* C: */ [BLOCK_JOB_STATUS_CREATED] = {0, 0, 1, 0, 0, 0}, 50c9de4050SJohn Snow /* R: */ [BLOCK_JOB_STATUS_RUNNING] = {0, 0, 0, 1, 1, 0}, 51c9de4050SJohn Snow /* P: */ [BLOCK_JOB_STATUS_PAUSED] = {0, 0, 1, 0, 0, 0}, 52c9de4050SJohn Snow /* Y: */ [BLOCK_JOB_STATUS_READY] = {0, 0, 0, 0, 0, 1}, 53c9de4050SJohn Snow /* S: */ [BLOCK_JOB_STATUS_STANDBY] = {0, 0, 0, 0, 1, 0}, 54c9de4050SJohn Snow }; 55c9de4050SJohn Snow 56*0ec4dfb8SJohn Snow bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = { 57*0ec4dfb8SJohn Snow /* U, C, R, P, Y, S */ 58*0ec4dfb8SJohn Snow [BLOCK_JOB_VERB_CANCEL] = {0, 1, 1, 1, 1, 1}, 59*0ec4dfb8SJohn Snow [BLOCK_JOB_VERB_PAUSE] = {0, 1, 1, 1, 1, 1}, 60*0ec4dfb8SJohn Snow [BLOCK_JOB_VERB_RESUME] = {0, 1, 1, 1, 1, 1}, 61*0ec4dfb8SJohn Snow [BLOCK_JOB_VERB_SET_SPEED] = {0, 1, 1, 1, 1, 1}, 62*0ec4dfb8SJohn Snow [BLOCK_JOB_VERB_COMPLETE] = {0, 0, 0, 0, 1, 0}, 63*0ec4dfb8SJohn Snow }; 64*0ec4dfb8SJohn Snow 65c9de4050SJohn Snow static void block_job_state_transition(BlockJob *job, BlockJobStatus s1) 66c9de4050SJohn Snow { 67c9de4050SJohn Snow BlockJobStatus s0 = job->status; 68c9de4050SJohn Snow assert(s1 >= 0 && s1 <= BLOCK_JOB_STATUS__MAX); 69c9de4050SJohn Snow trace_block_job_state_transition(job, job->ret, BlockJobSTT[s0][s1] ? 70c9de4050SJohn Snow "allowed" : "disallowed", 71c9de4050SJohn Snow qapi_enum_lookup(&BlockJobStatus_lookup, 72c9de4050SJohn Snow s0), 73c9de4050SJohn Snow qapi_enum_lookup(&BlockJobStatus_lookup, 74c9de4050SJohn Snow s1)); 75c9de4050SJohn Snow assert(BlockJobSTT[s0][s1]); 76c9de4050SJohn Snow job->status = s1; 77c9de4050SJohn Snow } 78c9de4050SJohn Snow 79*0ec4dfb8SJohn Snow static int block_job_apply_verb(BlockJob *job, BlockJobVerb bv, Error **errp) 80*0ec4dfb8SJohn Snow { 81*0ec4dfb8SJohn Snow assert(bv >= 0 && bv <= BLOCK_JOB_VERB__MAX); 82*0ec4dfb8SJohn Snow trace_block_job_apply_verb(job, qapi_enum_lookup(&BlockJobStatus_lookup, 83*0ec4dfb8SJohn Snow job->status), 84*0ec4dfb8SJohn Snow qapi_enum_lookup(&BlockJobVerb_lookup, bv), 85*0ec4dfb8SJohn Snow BlockJobVerbTable[bv][job->status] ? 86*0ec4dfb8SJohn Snow "allowed" : "prohibited"); 87*0ec4dfb8SJohn Snow if (BlockJobVerbTable[bv][job->status]) { 88*0ec4dfb8SJohn Snow return 0; 89*0ec4dfb8SJohn Snow } 90*0ec4dfb8SJohn Snow error_setg(errp, "Job '%s' in state '%s' cannot accept command verb '%s'", 91*0ec4dfb8SJohn Snow job->id, qapi_enum_lookup(&BlockJobStatus_lookup, job->status), 92*0ec4dfb8SJohn Snow qapi_enum_lookup(&BlockJobVerb_lookup, bv)); 93*0ec4dfb8SJohn Snow return -EPERM; 94*0ec4dfb8SJohn Snow } 95*0ec4dfb8SJohn Snow 96fc24908eSPaolo Bonzini static void block_job_lock(void) 97fc24908eSPaolo Bonzini { 98fc24908eSPaolo Bonzini qemu_mutex_lock(&block_job_mutex); 99fc24908eSPaolo Bonzini } 100fc24908eSPaolo Bonzini 101fc24908eSPaolo Bonzini static void block_job_unlock(void) 102fc24908eSPaolo Bonzini { 103fc24908eSPaolo Bonzini qemu_mutex_unlock(&block_job_mutex); 104fc24908eSPaolo Bonzini } 105fc24908eSPaolo Bonzini 106fc24908eSPaolo Bonzini static void __attribute__((__constructor__)) block_job_init(void) 107fc24908eSPaolo Bonzini { 108fc24908eSPaolo Bonzini qemu_mutex_init(&block_job_mutex); 109fc24908eSPaolo Bonzini } 110fc24908eSPaolo Bonzini 1118254b6d9SJohn Snow static void block_job_event_cancelled(BlockJob *job); 1128254b6d9SJohn Snow static void block_job_event_completed(BlockJob *job, const char *msg); 113aa9ef2e6SJohn Snow static void block_job_enter_cond(BlockJob *job, bool(*fn)(BlockJob *job)); 1148254b6d9SJohn Snow 115c55a832fSFam Zheng /* Transactional group of block jobs */ 116c55a832fSFam Zheng struct BlockJobTxn { 117c55a832fSFam Zheng 118c55a832fSFam Zheng /* Is this txn being cancelled? */ 119c55a832fSFam Zheng bool aborting; 120c55a832fSFam Zheng 121c55a832fSFam Zheng /* List of jobs */ 122c55a832fSFam Zheng QLIST_HEAD(, BlockJob) jobs; 123c55a832fSFam Zheng 124c55a832fSFam Zheng /* Reference count */ 125c55a832fSFam Zheng int refcnt; 126c55a832fSFam Zheng }; 127c55a832fSFam Zheng 128a7112795SAlberto Garcia static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs); 129a7112795SAlberto Garcia 13088691b37SPaolo Bonzini /* 13188691b37SPaolo Bonzini * The block job API is composed of two categories of functions. 13288691b37SPaolo Bonzini * 13388691b37SPaolo Bonzini * The first includes functions used by the monitor. The monitor is 13488691b37SPaolo Bonzini * peculiar in that it accesses the block job list with block_job_get, and 13588691b37SPaolo Bonzini * therefore needs consistency across block_job_get and the actual operation 13688691b37SPaolo Bonzini * (e.g. block_job_set_speed). The consistency is achieved with 13788691b37SPaolo Bonzini * aio_context_acquire/release. These functions are declared in blockjob.h. 13888691b37SPaolo Bonzini * 13988691b37SPaolo Bonzini * The second includes functions used by the block job drivers and sometimes 14088691b37SPaolo Bonzini * by the core block layer. These do not care about locking, because the 14188691b37SPaolo Bonzini * whole coroutine runs under the AioContext lock, and are declared in 14288691b37SPaolo Bonzini * blockjob_int.h. 14388691b37SPaolo Bonzini */ 14488691b37SPaolo Bonzini 145a7112795SAlberto Garcia BlockJob *block_job_next(BlockJob *job) 146a7112795SAlberto Garcia { 147a7112795SAlberto Garcia if (!job) { 148a7112795SAlberto Garcia return QLIST_FIRST(&block_jobs); 149a7112795SAlberto Garcia } 150a7112795SAlberto Garcia return QLIST_NEXT(job, job_list); 151a7112795SAlberto Garcia } 152a7112795SAlberto Garcia 153ffb1f10cSAlberto Garcia BlockJob *block_job_get(const char *id) 154ffb1f10cSAlberto Garcia { 155ffb1f10cSAlberto Garcia BlockJob *job; 156ffb1f10cSAlberto Garcia 157ffb1f10cSAlberto Garcia QLIST_FOREACH(job, &block_jobs, job_list) { 158559b935fSJohn Snow if (job->id && !strcmp(id, job->id)) { 159ffb1f10cSAlberto Garcia return job; 160ffb1f10cSAlberto Garcia } 161ffb1f10cSAlberto Garcia } 162ffb1f10cSAlberto Garcia 163ffb1f10cSAlberto Garcia return NULL; 164ffb1f10cSAlberto Garcia } 165ffb1f10cSAlberto Garcia 166c8ab5c2dSPaolo Bonzini BlockJobTxn *block_job_txn_new(void) 167c8ab5c2dSPaolo Bonzini { 168c8ab5c2dSPaolo Bonzini BlockJobTxn *txn = g_new0(BlockJobTxn, 1); 169c8ab5c2dSPaolo Bonzini QLIST_INIT(&txn->jobs); 170c8ab5c2dSPaolo Bonzini txn->refcnt = 1; 171c8ab5c2dSPaolo Bonzini return txn; 172c8ab5c2dSPaolo Bonzini } 173c8ab5c2dSPaolo Bonzini 174c8ab5c2dSPaolo Bonzini static void block_job_txn_ref(BlockJobTxn *txn) 175c8ab5c2dSPaolo Bonzini { 176c8ab5c2dSPaolo Bonzini txn->refcnt++; 177c8ab5c2dSPaolo Bonzini } 178c8ab5c2dSPaolo Bonzini 179c8ab5c2dSPaolo Bonzini void block_job_txn_unref(BlockJobTxn *txn) 180c8ab5c2dSPaolo Bonzini { 181c8ab5c2dSPaolo Bonzini if (txn && --txn->refcnt == 0) { 182c8ab5c2dSPaolo Bonzini g_free(txn); 183c8ab5c2dSPaolo Bonzini } 184c8ab5c2dSPaolo Bonzini } 185c8ab5c2dSPaolo Bonzini 186c8ab5c2dSPaolo Bonzini void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job) 187c8ab5c2dSPaolo Bonzini { 188c8ab5c2dSPaolo Bonzini if (!txn) { 189c8ab5c2dSPaolo Bonzini return; 190c8ab5c2dSPaolo Bonzini } 191c8ab5c2dSPaolo Bonzini 192c8ab5c2dSPaolo Bonzini assert(!job->txn); 193c8ab5c2dSPaolo Bonzini job->txn = txn; 194c8ab5c2dSPaolo Bonzini 195c8ab5c2dSPaolo Bonzini QLIST_INSERT_HEAD(&txn->jobs, job, txn_list); 196c8ab5c2dSPaolo Bonzini block_job_txn_ref(txn); 197c8ab5c2dSPaolo Bonzini } 198c8ab5c2dSPaolo Bonzini 199f321dcb5SPaolo Bonzini static void block_job_pause(BlockJob *job) 200f321dcb5SPaolo Bonzini { 201f321dcb5SPaolo Bonzini job->pause_count++; 202f321dcb5SPaolo Bonzini } 203f321dcb5SPaolo Bonzini 204f321dcb5SPaolo Bonzini static void block_job_resume(BlockJob *job) 205f321dcb5SPaolo Bonzini { 206f321dcb5SPaolo Bonzini assert(job->pause_count > 0); 207f321dcb5SPaolo Bonzini job->pause_count--; 208f321dcb5SPaolo Bonzini if (job->pause_count) { 209f321dcb5SPaolo Bonzini return; 210f321dcb5SPaolo Bonzini } 211f321dcb5SPaolo Bonzini block_job_enter(job); 212f321dcb5SPaolo Bonzini } 213f321dcb5SPaolo Bonzini 2144172a003Ssochin.jiang void block_job_ref(BlockJob *job) 21505b0d8e3SPaolo Bonzini { 21605b0d8e3SPaolo Bonzini ++job->refcnt; 21705b0d8e3SPaolo Bonzini } 21805b0d8e3SPaolo Bonzini 21905b0d8e3SPaolo Bonzini static void block_job_attached_aio_context(AioContext *new_context, 22005b0d8e3SPaolo Bonzini void *opaque); 22105b0d8e3SPaolo Bonzini static void block_job_detach_aio_context(void *opaque); 22205b0d8e3SPaolo Bonzini 2234172a003Ssochin.jiang void block_job_unref(BlockJob *job) 22405b0d8e3SPaolo Bonzini { 22505b0d8e3SPaolo Bonzini if (--job->refcnt == 0) { 22605b0d8e3SPaolo Bonzini BlockDriverState *bs = blk_bs(job->blk); 2270a3e155fSAlberto Garcia QLIST_REMOVE(job, job_list); 22805b0d8e3SPaolo Bonzini bs->job = NULL; 22905b0d8e3SPaolo Bonzini block_job_remove_all_bdrv(job); 23005b0d8e3SPaolo Bonzini blk_remove_aio_context_notifier(job->blk, 23105b0d8e3SPaolo Bonzini block_job_attached_aio_context, 23205b0d8e3SPaolo Bonzini block_job_detach_aio_context, job); 23305b0d8e3SPaolo Bonzini blk_unref(job->blk); 23405b0d8e3SPaolo Bonzini error_free(job->blocker); 23505b0d8e3SPaolo Bonzini g_free(job->id); 236fc24908eSPaolo Bonzini assert(!timer_pending(&job->sleep_timer)); 23705b0d8e3SPaolo Bonzini g_free(job); 23805b0d8e3SPaolo Bonzini } 23905b0d8e3SPaolo Bonzini } 24005b0d8e3SPaolo Bonzini 241463e0be1SStefan Hajnoczi static void block_job_attached_aio_context(AioContext *new_context, 242463e0be1SStefan Hajnoczi void *opaque) 243463e0be1SStefan Hajnoczi { 244463e0be1SStefan Hajnoczi BlockJob *job = opaque; 245463e0be1SStefan Hajnoczi 246463e0be1SStefan Hajnoczi if (job->driver->attached_aio_context) { 247463e0be1SStefan Hajnoczi job->driver->attached_aio_context(job, new_context); 248463e0be1SStefan Hajnoczi } 249463e0be1SStefan Hajnoczi 250463e0be1SStefan Hajnoczi block_job_resume(job); 251463e0be1SStefan Hajnoczi } 252463e0be1SStefan Hajnoczi 253bae8196dSPaolo Bonzini static void block_job_drain(BlockJob *job) 254bae8196dSPaolo Bonzini { 255bae8196dSPaolo Bonzini /* If job is !job->busy this kicks it into the next pause point. */ 256bae8196dSPaolo Bonzini block_job_enter(job); 257bae8196dSPaolo Bonzini 258bae8196dSPaolo Bonzini blk_drain(job->blk); 259bae8196dSPaolo Bonzini if (job->driver->drain) { 260bae8196dSPaolo Bonzini job->driver->drain(job); 261bae8196dSPaolo Bonzini } 262bae8196dSPaolo Bonzini } 263bae8196dSPaolo Bonzini 264463e0be1SStefan Hajnoczi static void block_job_detach_aio_context(void *opaque) 265463e0be1SStefan Hajnoczi { 266463e0be1SStefan Hajnoczi BlockJob *job = opaque; 267463e0be1SStefan Hajnoczi 268463e0be1SStefan Hajnoczi /* In case the job terminates during aio_poll()... */ 269463e0be1SStefan Hajnoczi block_job_ref(job); 270463e0be1SStefan Hajnoczi 271463e0be1SStefan Hajnoczi block_job_pause(job); 272463e0be1SStefan Hajnoczi 273463e0be1SStefan Hajnoczi while (!job->paused && !job->completed) { 274bae8196dSPaolo Bonzini block_job_drain(job); 275463e0be1SStefan Hajnoczi } 276463e0be1SStefan Hajnoczi 277463e0be1SStefan Hajnoczi block_job_unref(job); 278463e0be1SStefan Hajnoczi } 279463e0be1SStefan Hajnoczi 280f321dcb5SPaolo Bonzini static char *child_job_get_parent_desc(BdrvChild *c) 281f321dcb5SPaolo Bonzini { 282f321dcb5SPaolo Bonzini BlockJob *job = c->opaque; 283f321dcb5SPaolo Bonzini return g_strdup_printf("%s job '%s'", 284977c736fSMarkus Armbruster BlockJobType_str(job->driver->job_type), 285f321dcb5SPaolo Bonzini job->id); 286f321dcb5SPaolo Bonzini } 287f321dcb5SPaolo Bonzini 288ad90febaSKevin Wolf static void child_job_drained_begin(BdrvChild *c) 289f321dcb5SPaolo Bonzini { 290ad90febaSKevin Wolf BlockJob *job = c->opaque; 291f321dcb5SPaolo Bonzini block_job_pause(job); 292f321dcb5SPaolo Bonzini } 293f321dcb5SPaolo Bonzini 294ad90febaSKevin Wolf static void child_job_drained_end(BdrvChild *c) 295f321dcb5SPaolo Bonzini { 296ad90febaSKevin Wolf BlockJob *job = c->opaque; 297f321dcb5SPaolo Bonzini block_job_resume(job); 298f321dcb5SPaolo Bonzini } 299f321dcb5SPaolo Bonzini 300ad90febaSKevin Wolf static const BdrvChildRole child_job = { 301ad90febaSKevin Wolf .get_parent_desc = child_job_get_parent_desc, 302ad90febaSKevin Wolf .drained_begin = child_job_drained_begin, 303ad90febaSKevin Wolf .drained_end = child_job_drained_end, 304ad90febaSKevin Wolf .stay_at_node = true, 305f321dcb5SPaolo Bonzini }; 306f321dcb5SPaolo Bonzini 307bbc02b90SKevin Wolf void block_job_remove_all_bdrv(BlockJob *job) 308bbc02b90SKevin Wolf { 309bbc02b90SKevin Wolf GSList *l; 310bbc02b90SKevin Wolf for (l = job->nodes; l; l = l->next) { 311bbc02b90SKevin Wolf BdrvChild *c = l->data; 312bbc02b90SKevin Wolf bdrv_op_unblock_all(c->bs, job->blocker); 313bbc02b90SKevin Wolf bdrv_root_unref_child(c); 314bbc02b90SKevin Wolf } 315bbc02b90SKevin Wolf g_slist_free(job->nodes); 316bbc02b90SKevin Wolf job->nodes = NULL; 317bbc02b90SKevin Wolf } 318bbc02b90SKevin Wolf 31976d554e2SKevin Wolf int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs, 32076d554e2SKevin Wolf uint64_t perm, uint64_t shared_perm, Error **errp) 32123d402d4SAlberto Garcia { 32276d554e2SKevin Wolf BdrvChild *c; 32376d554e2SKevin Wolf 32476d554e2SKevin Wolf c = bdrv_root_attach_child(bs, name, &child_job, perm, shared_perm, 32576d554e2SKevin Wolf job, errp); 32676d554e2SKevin Wolf if (c == NULL) { 32776d554e2SKevin Wolf return -EPERM; 32876d554e2SKevin Wolf } 32976d554e2SKevin Wolf 33076d554e2SKevin Wolf job->nodes = g_slist_prepend(job->nodes, c); 33123d402d4SAlberto Garcia bdrv_ref(bs); 33223d402d4SAlberto Garcia bdrv_op_block_all(bs, job->blocker); 33376d554e2SKevin Wolf 33476d554e2SKevin Wolf return 0; 33523d402d4SAlberto Garcia } 33623d402d4SAlberto Garcia 337559b935fSJohn Snow bool block_job_is_internal(BlockJob *job) 338559b935fSJohn Snow { 339559b935fSJohn Snow return (job->id == NULL); 340559b935fSJohn Snow } 341559b935fSJohn Snow 3425ccac6f1SJohn Snow static bool block_job_started(BlockJob *job) 3435ccac6f1SJohn Snow { 3445ccac6f1SJohn Snow return job->co; 3455ccac6f1SJohn Snow } 3465ccac6f1SJohn Snow 347e3796a24SJohn Snow /** 348e3796a24SJohn Snow * All jobs must allow a pause point before entering their job proper. This 349e3796a24SJohn Snow * ensures that jobs can be paused prior to being started, then resumed later. 350e3796a24SJohn Snow */ 351e3796a24SJohn Snow static void coroutine_fn block_job_co_entry(void *opaque) 352e3796a24SJohn Snow { 353e3796a24SJohn Snow BlockJob *job = opaque; 354e3796a24SJohn Snow 355e3796a24SJohn Snow assert(job && job->driver && job->driver->start); 356e3796a24SJohn Snow block_job_pause_point(job); 357e3796a24SJohn Snow job->driver->start(job); 358e3796a24SJohn Snow } 359e3796a24SJohn Snow 360fc24908eSPaolo Bonzini static void block_job_sleep_timer_cb(void *opaque) 361fc24908eSPaolo Bonzini { 362fc24908eSPaolo Bonzini BlockJob *job = opaque; 363fc24908eSPaolo Bonzini 364fc24908eSPaolo Bonzini block_job_enter(job); 365fc24908eSPaolo Bonzini } 366fc24908eSPaolo Bonzini 3675ccac6f1SJohn Snow void block_job_start(BlockJob *job) 3685ccac6f1SJohn Snow { 3695ccac6f1SJohn Snow assert(job && !block_job_started(job) && job->paused && 370e3796a24SJohn Snow job->driver && job->driver->start); 371e3796a24SJohn Snow job->co = qemu_coroutine_create(block_job_co_entry, job); 372e3796a24SJohn Snow job->pause_count--; 3735ccac6f1SJohn Snow job->busy = true; 374e3796a24SJohn Snow job->paused = false; 375c9de4050SJohn Snow block_job_state_transition(job, BLOCK_JOB_STATUS_RUNNING); 376aef4278cSFam Zheng bdrv_coroutine_enter(blk_bs(job->blk), job->co); 3775ccac6f1SJohn Snow } 3785ccac6f1SJohn Snow 379c55a832fSFam Zheng static void block_job_completed_single(BlockJob *job) 380c55a832fSFam Zheng { 3814fb588e9SPaolo Bonzini assert(job->completed); 3824fb588e9SPaolo Bonzini 383c55a832fSFam Zheng if (!job->ret) { 384c55a832fSFam Zheng if (job->driver->commit) { 385c55a832fSFam Zheng job->driver->commit(job); 386c55a832fSFam Zheng } 387c55a832fSFam Zheng } else { 388c55a832fSFam Zheng if (job->driver->abort) { 389c55a832fSFam Zheng job->driver->abort(job); 390c55a832fSFam Zheng } 391c55a832fSFam Zheng } 392e8a40bf7SJohn Snow if (job->driver->clean) { 393e8a40bf7SJohn Snow job->driver->clean(job); 394e8a40bf7SJohn Snow } 3958254b6d9SJohn Snow 3968254b6d9SJohn Snow if (job->cb) { 397c55a832fSFam Zheng job->cb(job->opaque, job->ret); 3988254b6d9SJohn Snow } 3995ccac6f1SJohn Snow 4005ccac6f1SJohn Snow /* Emit events only if we actually started */ 4015ccac6f1SJohn Snow if (block_job_started(job)) { 4028254b6d9SJohn Snow if (block_job_is_cancelled(job)) { 4038254b6d9SJohn Snow block_job_event_cancelled(job); 4048254b6d9SJohn Snow } else { 4058254b6d9SJohn Snow const char *msg = NULL; 4068254b6d9SJohn Snow if (job->ret < 0) { 4078254b6d9SJohn Snow msg = strerror(-job->ret); 4088254b6d9SJohn Snow } 4098254b6d9SJohn Snow block_job_event_completed(job, msg); 4108254b6d9SJohn Snow } 4115ccac6f1SJohn Snow } 4128254b6d9SJohn Snow 4131e93b9fbSVladimir Sementsov-Ogievskiy QLIST_REMOVE(job, txn_list); 414c55a832fSFam Zheng block_job_txn_unref(job->txn); 415c55a832fSFam Zheng block_job_unref(job); 416c55a832fSFam Zheng } 417c55a832fSFam Zheng 4184c241cf5SPaolo Bonzini static void block_job_cancel_async(BlockJob *job) 4194c241cf5SPaolo Bonzini { 4204c241cf5SPaolo Bonzini if (job->iostatus != BLOCK_DEVICE_IO_STATUS_OK) { 4214c241cf5SPaolo Bonzini block_job_iostatus_reset(job); 4224c241cf5SPaolo Bonzini } 4234c241cf5SPaolo Bonzini if (job->user_paused) { 4244c241cf5SPaolo Bonzini /* Do not call block_job_enter here, the caller will handle it. */ 4254c241cf5SPaolo Bonzini job->user_paused = false; 4264c241cf5SPaolo Bonzini job->pause_count--; 4274c241cf5SPaolo Bonzini } 4284c241cf5SPaolo Bonzini job->cancelled = true; 4294c241cf5SPaolo Bonzini } 4304c241cf5SPaolo Bonzini 431c8ab5c2dSPaolo Bonzini static int block_job_finish_sync(BlockJob *job, 432c8ab5c2dSPaolo Bonzini void (*finish)(BlockJob *, Error **errp), 433c8ab5c2dSPaolo Bonzini Error **errp) 434c8ab5c2dSPaolo Bonzini { 435c8ab5c2dSPaolo Bonzini Error *local_err = NULL; 436c8ab5c2dSPaolo Bonzini int ret; 437c8ab5c2dSPaolo Bonzini 438c8ab5c2dSPaolo Bonzini assert(blk_bs(job->blk)->job == job); 439c8ab5c2dSPaolo Bonzini 440c8ab5c2dSPaolo Bonzini block_job_ref(job); 441c8ab5c2dSPaolo Bonzini 4424fb588e9SPaolo Bonzini if (finish) { 443c8ab5c2dSPaolo Bonzini finish(job, &local_err); 4444fb588e9SPaolo Bonzini } 445c8ab5c2dSPaolo Bonzini if (local_err) { 446c8ab5c2dSPaolo Bonzini error_propagate(errp, local_err); 447c8ab5c2dSPaolo Bonzini block_job_unref(job); 448c8ab5c2dSPaolo Bonzini return -EBUSY; 449c8ab5c2dSPaolo Bonzini } 450c8ab5c2dSPaolo Bonzini /* block_job_drain calls block_job_enter, and it should be enough to 451c8ab5c2dSPaolo Bonzini * induce progress until the job completes or moves to the main thread. 452c8ab5c2dSPaolo Bonzini */ 453c8ab5c2dSPaolo Bonzini while (!job->deferred_to_main_loop && !job->completed) { 454c8ab5c2dSPaolo Bonzini block_job_drain(job); 455c8ab5c2dSPaolo Bonzini } 456c8ab5c2dSPaolo Bonzini while (!job->completed) { 457c8ab5c2dSPaolo Bonzini aio_poll(qemu_get_aio_context(), true); 458c8ab5c2dSPaolo Bonzini } 459c8ab5c2dSPaolo Bonzini ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret; 460c8ab5c2dSPaolo Bonzini block_job_unref(job); 461c8ab5c2dSPaolo Bonzini return ret; 462c8ab5c2dSPaolo Bonzini } 463c8ab5c2dSPaolo Bonzini 464c55a832fSFam Zheng static void block_job_completed_txn_abort(BlockJob *job) 465c55a832fSFam Zheng { 466c55a832fSFam Zheng AioContext *ctx; 467c55a832fSFam Zheng BlockJobTxn *txn = job->txn; 4684fb588e9SPaolo Bonzini BlockJob *other_job; 469c55a832fSFam Zheng 470c55a832fSFam Zheng if (txn->aborting) { 471c55a832fSFam Zheng /* 472c55a832fSFam Zheng * We are cancelled by another job, which will handle everything. 473c55a832fSFam Zheng */ 474c55a832fSFam Zheng return; 475c55a832fSFam Zheng } 476c55a832fSFam Zheng txn->aborting = true; 4774fb588e9SPaolo Bonzini block_job_txn_ref(txn); 4784fb588e9SPaolo Bonzini 479c55a832fSFam Zheng /* We are the first failed job. Cancel other jobs. */ 480c55a832fSFam Zheng QLIST_FOREACH(other_job, &txn->jobs, txn_list) { 481b6d2e599SKevin Wolf ctx = blk_get_aio_context(other_job->blk); 482c55a832fSFam Zheng aio_context_acquire(ctx); 483c55a832fSFam Zheng } 4844fb588e9SPaolo Bonzini 4854fb588e9SPaolo Bonzini /* Other jobs are effectively cancelled by us, set the status for 486c55a832fSFam Zheng * them; this job, however, may or may not be cancelled, depending 487c55a832fSFam Zheng * on the caller, so leave it. */ 4884fb588e9SPaolo Bonzini QLIST_FOREACH(other_job, &txn->jobs, txn_list) { 489c55a832fSFam Zheng if (other_job != job) { 4904c241cf5SPaolo Bonzini block_job_cancel_async(other_job); 491c55a832fSFam Zheng } 492c55a832fSFam Zheng } 4934fb588e9SPaolo Bonzini while (!QLIST_EMPTY(&txn->jobs)) { 4944fb588e9SPaolo Bonzini other_job = QLIST_FIRST(&txn->jobs); 495b6d2e599SKevin Wolf ctx = blk_get_aio_context(other_job->blk); 4964fb588e9SPaolo Bonzini if (!other_job->completed) { 4974fb588e9SPaolo Bonzini assert(other_job->cancelled); 4984fb588e9SPaolo Bonzini block_job_finish_sync(other_job, NULL, NULL); 4994fb588e9SPaolo Bonzini } 500c55a832fSFam Zheng block_job_completed_single(other_job); 501c55a832fSFam Zheng aio_context_release(ctx); 502c55a832fSFam Zheng } 5034fb588e9SPaolo Bonzini 5044fb588e9SPaolo Bonzini block_job_txn_unref(txn); 505c55a832fSFam Zheng } 506c55a832fSFam Zheng 507c55a832fSFam Zheng static void block_job_completed_txn_success(BlockJob *job) 508c55a832fSFam Zheng { 509c55a832fSFam Zheng AioContext *ctx; 510c55a832fSFam Zheng BlockJobTxn *txn = job->txn; 511c55a832fSFam Zheng BlockJob *other_job, *next; 512c55a832fSFam Zheng /* 513c55a832fSFam Zheng * Successful completion, see if there are other running jobs in this 514c55a832fSFam Zheng * txn. 515c55a832fSFam Zheng */ 516c55a832fSFam Zheng QLIST_FOREACH(other_job, &txn->jobs, txn_list) { 517c55a832fSFam Zheng if (!other_job->completed) { 518c55a832fSFam Zheng return; 519c55a832fSFam Zheng } 520c55a832fSFam Zheng } 521c55a832fSFam Zheng /* We are the last completed job, commit the transaction. */ 522c55a832fSFam Zheng QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) { 523b6d2e599SKevin Wolf ctx = blk_get_aio_context(other_job->blk); 524c55a832fSFam Zheng aio_context_acquire(ctx); 525c55a832fSFam Zheng assert(other_job->ret == 0); 526c55a832fSFam Zheng block_job_completed_single(other_job); 527c55a832fSFam Zheng aio_context_release(ctx); 528c55a832fSFam Zheng } 529c55a832fSFam Zheng } 530c55a832fSFam Zheng 531aa9ef2e6SJohn Snow /* Assumes the block_job_mutex is held */ 532aa9ef2e6SJohn Snow static bool block_job_timer_pending(BlockJob *job) 533aa9ef2e6SJohn Snow { 534aa9ef2e6SJohn Snow return timer_pending(&job->sleep_timer); 535aa9ef2e6SJohn Snow } 536aa9ef2e6SJohn Snow 5372f0c9fe6SPaolo Bonzini void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) 5382f0c9fe6SPaolo Bonzini { 5392f0c9fe6SPaolo Bonzini Error *local_err = NULL; 540aa9ef2e6SJohn Snow int64_t old_speed = job->speed; 5412f0c9fe6SPaolo Bonzini 5423fc4b10aSFam Zheng if (!job->driver->set_speed) { 543c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED); 5442f0c9fe6SPaolo Bonzini return; 5452f0c9fe6SPaolo Bonzini } 546*0ec4dfb8SJohn Snow if (block_job_apply_verb(job, BLOCK_JOB_VERB_SET_SPEED, errp)) { 547*0ec4dfb8SJohn Snow return; 548*0ec4dfb8SJohn Snow } 5493fc4b10aSFam Zheng job->driver->set_speed(job, speed, &local_err); 55084d18f06SMarkus Armbruster if (local_err) { 5512f0c9fe6SPaolo Bonzini error_propagate(errp, local_err); 5522f0c9fe6SPaolo Bonzini return; 5532f0c9fe6SPaolo Bonzini } 5542f0c9fe6SPaolo Bonzini 5552f0c9fe6SPaolo Bonzini job->speed = speed; 556d4fce188SJohn Snow if (speed && speed <= old_speed) { 557aa9ef2e6SJohn Snow return; 558aa9ef2e6SJohn Snow } 559aa9ef2e6SJohn Snow 560aa9ef2e6SJohn Snow /* kick only if a timer is pending */ 561aa9ef2e6SJohn Snow block_job_enter_cond(job, block_job_timer_pending); 5622f0c9fe6SPaolo Bonzini } 5632f0c9fe6SPaolo Bonzini 564aeae883bSPaolo Bonzini void block_job_complete(BlockJob *job, Error **errp) 565aeae883bSPaolo Bonzini { 566559b935fSJohn Snow /* Should not be reachable via external interface for internal jobs */ 567559b935fSJohn Snow assert(job->id); 568*0ec4dfb8SJohn Snow if (block_job_apply_verb(job, BLOCK_JOB_VERB_COMPLETE, errp)) { 569*0ec4dfb8SJohn Snow return; 570*0ec4dfb8SJohn Snow } 571*0ec4dfb8SJohn Snow if (job->pause_count || job->cancelled || !job->driver->complete) { 5729df229c3SAlberto Garcia error_setg(errp, "The active block job '%s' cannot be completed", 5739df229c3SAlberto Garcia job->id); 574aeae883bSPaolo Bonzini return; 575aeae883bSPaolo Bonzini } 576aeae883bSPaolo Bonzini 5773fc4b10aSFam Zheng job->driver->complete(job, errp); 578aeae883bSPaolo Bonzini } 579aeae883bSPaolo Bonzini 580*0ec4dfb8SJohn Snow void block_job_user_pause(BlockJob *job, Error **errp) 5810df4ba58SJohn Snow { 582*0ec4dfb8SJohn Snow if (block_job_apply_verb(job, BLOCK_JOB_VERB_PAUSE, errp)) { 583*0ec4dfb8SJohn Snow return; 584*0ec4dfb8SJohn Snow } 585*0ec4dfb8SJohn Snow if (job->user_paused) { 586*0ec4dfb8SJohn Snow error_setg(errp, "Job is already paused"); 587*0ec4dfb8SJohn Snow return; 588*0ec4dfb8SJohn Snow } 5890df4ba58SJohn Snow job->user_paused = true; 5900df4ba58SJohn Snow block_job_pause(job); 5910df4ba58SJohn Snow } 5920df4ba58SJohn Snow 5930df4ba58SJohn Snow bool block_job_user_paused(BlockJob *job) 5940df4ba58SJohn Snow { 5956573d9c6SPaolo Bonzini return job->user_paused; 5960df4ba58SJohn Snow } 5970df4ba58SJohn Snow 598*0ec4dfb8SJohn Snow void block_job_user_resume(BlockJob *job, Error **errp) 5990df4ba58SJohn Snow { 600*0ec4dfb8SJohn Snow assert(job); 601*0ec4dfb8SJohn Snow if (!job->user_paused || job->pause_count <= 0) { 602*0ec4dfb8SJohn Snow error_setg(errp, "Can't resume a job that was not paused"); 603*0ec4dfb8SJohn Snow return; 604*0ec4dfb8SJohn Snow } 605*0ec4dfb8SJohn Snow if (block_job_apply_verb(job, BLOCK_JOB_VERB_RESUME, errp)) { 606*0ec4dfb8SJohn Snow return; 607*0ec4dfb8SJohn Snow } 6082caf63a9SPaolo Bonzini block_job_iostatus_reset(job); 6094c241cf5SPaolo Bonzini job->user_paused = false; 6100df4ba58SJohn Snow block_job_resume(job); 6110df4ba58SJohn Snow } 6120df4ba58SJohn Snow 6138acc72a4SPaolo Bonzini void block_job_cancel(BlockJob *job) 6148acc72a4SPaolo Bonzini { 6155ccac6f1SJohn Snow if (block_job_started(job)) { 6164c241cf5SPaolo Bonzini block_job_cancel_async(job); 617751ebd76SFam Zheng block_job_enter(job); 6185ccac6f1SJohn Snow } else { 6195ccac6f1SJohn Snow block_job_completed(job, -ECANCELED); 6205ccac6f1SJohn Snow } 6218acc72a4SPaolo Bonzini } 6228acc72a4SPaolo Bonzini 623*0ec4dfb8SJohn Snow void block_job_user_cancel(BlockJob *job, Error **errp) 624*0ec4dfb8SJohn Snow { 625*0ec4dfb8SJohn Snow if (block_job_apply_verb(job, BLOCK_JOB_VERB_CANCEL, errp)) { 626*0ec4dfb8SJohn Snow return; 627*0ec4dfb8SJohn Snow } 628*0ec4dfb8SJohn Snow block_job_cancel(job); 629*0ec4dfb8SJohn Snow } 630*0ec4dfb8SJohn Snow 631345f9e1bSMax Reitz /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be 632345f9e1bSMax Reitz * used with block_job_finish_sync() without the need for (rather nasty) 633345f9e1bSMax Reitz * function pointer casts there. */ 634345f9e1bSMax Reitz static void block_job_cancel_err(BlockJob *job, Error **errp) 635345f9e1bSMax Reitz { 636345f9e1bSMax Reitz block_job_cancel(job); 637345f9e1bSMax Reitz } 638345f9e1bSMax Reitz 639345f9e1bSMax Reitz int block_job_cancel_sync(BlockJob *job) 640345f9e1bSMax Reitz { 641345f9e1bSMax Reitz return block_job_finish_sync(job, &block_job_cancel_err, NULL); 642345f9e1bSMax Reitz } 643345f9e1bSMax Reitz 644a1a2af07SKevin Wolf void block_job_cancel_sync_all(void) 645a1a2af07SKevin Wolf { 646a1a2af07SKevin Wolf BlockJob *job; 647a1a2af07SKevin Wolf AioContext *aio_context; 648a1a2af07SKevin Wolf 649a1a2af07SKevin Wolf while ((job = QLIST_FIRST(&block_jobs))) { 650b6d2e599SKevin Wolf aio_context = blk_get_aio_context(job->blk); 651a1a2af07SKevin Wolf aio_context_acquire(aio_context); 652a1a2af07SKevin Wolf block_job_cancel_sync(job); 653a1a2af07SKevin Wolf aio_context_release(aio_context); 654a1a2af07SKevin Wolf } 655a1a2af07SKevin Wolf } 656a1a2af07SKevin Wolf 657345f9e1bSMax Reitz int block_job_complete_sync(BlockJob *job, Error **errp) 658345f9e1bSMax Reitz { 659345f9e1bSMax Reitz return block_job_finish_sync(job, &block_job_complete, errp); 660345f9e1bSMax Reitz } 661345f9e1bSMax Reitz 662559b935fSJohn Snow BlockJobInfo *block_job_query(BlockJob *job, Error **errp) 66330e628b7SPaolo Bonzini { 664559b935fSJohn Snow BlockJobInfo *info; 665559b935fSJohn Snow 666559b935fSJohn Snow if (block_job_is_internal(job)) { 667559b935fSJohn Snow error_setg(errp, "Cannot query QEMU internal jobs"); 668559b935fSJohn Snow return NULL; 669559b935fSJohn Snow } 670559b935fSJohn Snow info = g_new0(BlockJobInfo, 1); 671977c736fSMarkus Armbruster info->type = g_strdup(BlockJobType_str(job->driver->job_type)); 6728ccb9569SKevin Wolf info->device = g_strdup(job->id); 67330e628b7SPaolo Bonzini info->len = job->len; 674fc24908eSPaolo Bonzini info->busy = atomic_read(&job->busy); 675751ebd76SFam Zheng info->paused = job->pause_count > 0; 67630e628b7SPaolo Bonzini info->offset = job->offset; 67730e628b7SPaolo Bonzini info->speed = job->speed; 67832c81a4aSPaolo Bonzini info->io_status = job->iostatus; 679ef6dbf1eSMax Reitz info->ready = job->ready; 68058b295baSJohn Snow info->status = job->status; 68130e628b7SPaolo Bonzini return info; 68230e628b7SPaolo Bonzini } 68332c81a4aSPaolo Bonzini 68432c81a4aSPaolo Bonzini static void block_job_iostatus_set_err(BlockJob *job, int error) 68532c81a4aSPaolo Bonzini { 68632c81a4aSPaolo Bonzini if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 68732c81a4aSPaolo Bonzini job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : 68832c81a4aSPaolo Bonzini BLOCK_DEVICE_IO_STATUS_FAILED; 68932c81a4aSPaolo Bonzini } 69032c81a4aSPaolo Bonzini } 69132c81a4aSPaolo Bonzini 6928254b6d9SJohn Snow static void block_job_event_cancelled(BlockJob *job) 693a66a2a36SPaolo Bonzini { 694559b935fSJohn Snow if (block_job_is_internal(job)) { 695559b935fSJohn Snow return; 696559b935fSJohn Snow } 697559b935fSJohn Snow 698bcada37bSWenchao Xia qapi_event_send_block_job_cancelled(job->driver->job_type, 6998ccb9569SKevin Wolf job->id, 700a66a2a36SPaolo Bonzini job->len, 701a66a2a36SPaolo Bonzini job->offset, 702bcada37bSWenchao Xia job->speed, 703bcada37bSWenchao Xia &error_abort); 704a66a2a36SPaolo Bonzini } 705a66a2a36SPaolo Bonzini 7068254b6d9SJohn Snow static void block_job_event_completed(BlockJob *job, const char *msg) 707a66a2a36SPaolo Bonzini { 708559b935fSJohn Snow if (block_job_is_internal(job)) { 709559b935fSJohn Snow return; 710559b935fSJohn Snow } 711559b935fSJohn Snow 712bcada37bSWenchao Xia qapi_event_send_block_job_completed(job->driver->job_type, 7138ccb9569SKevin Wolf job->id, 714bcada37bSWenchao Xia job->len, 715bcada37bSWenchao Xia job->offset, 716bcada37bSWenchao Xia job->speed, 717bcada37bSWenchao Xia !!msg, 718bcada37bSWenchao Xia msg, 719bcada37bSWenchao Xia &error_abort); 720bcada37bSWenchao Xia } 721bcada37bSWenchao Xia 72288691b37SPaolo Bonzini /* 72388691b37SPaolo Bonzini * API for block job drivers and the block layer. These functions are 72488691b37SPaolo Bonzini * declared in blockjob_int.h. 72588691b37SPaolo Bonzini */ 72688691b37SPaolo Bonzini 72788691b37SPaolo Bonzini void *block_job_create(const char *job_id, const BlockJobDriver *driver, 72875859b94SJohn Snow BlockJobTxn *txn, BlockDriverState *bs, uint64_t perm, 72988691b37SPaolo Bonzini uint64_t shared_perm, int64_t speed, int flags, 73088691b37SPaolo Bonzini BlockCompletionFunc *cb, void *opaque, Error **errp) 73188691b37SPaolo Bonzini { 73288691b37SPaolo Bonzini BlockBackend *blk; 73388691b37SPaolo Bonzini BlockJob *job; 73488691b37SPaolo Bonzini int ret; 73588691b37SPaolo Bonzini 73688691b37SPaolo Bonzini if (bs->job) { 73788691b37SPaolo Bonzini error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); 73888691b37SPaolo Bonzini return NULL; 73988691b37SPaolo Bonzini } 74088691b37SPaolo Bonzini 74188691b37SPaolo Bonzini if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) { 74288691b37SPaolo Bonzini job_id = bdrv_get_device_name(bs); 74388691b37SPaolo Bonzini if (!*job_id) { 74488691b37SPaolo Bonzini error_setg(errp, "An explicit job ID is required for this node"); 74588691b37SPaolo Bonzini return NULL; 74688691b37SPaolo Bonzini } 74788691b37SPaolo Bonzini } 74888691b37SPaolo Bonzini 74988691b37SPaolo Bonzini if (job_id) { 75088691b37SPaolo Bonzini if (flags & BLOCK_JOB_INTERNAL) { 75188691b37SPaolo Bonzini error_setg(errp, "Cannot specify job ID for internal block job"); 75288691b37SPaolo Bonzini return NULL; 75388691b37SPaolo Bonzini } 75488691b37SPaolo Bonzini 75588691b37SPaolo Bonzini if (!id_wellformed(job_id)) { 75688691b37SPaolo Bonzini error_setg(errp, "Invalid job ID '%s'", job_id); 75788691b37SPaolo Bonzini return NULL; 75888691b37SPaolo Bonzini } 75988691b37SPaolo Bonzini 76088691b37SPaolo Bonzini if (block_job_get(job_id)) { 76188691b37SPaolo Bonzini error_setg(errp, "Job ID '%s' already in use", job_id); 76288691b37SPaolo Bonzini return NULL; 76388691b37SPaolo Bonzini } 76488691b37SPaolo Bonzini } 76588691b37SPaolo Bonzini 76688691b37SPaolo Bonzini blk = blk_new(perm, shared_perm); 76788691b37SPaolo Bonzini ret = blk_insert_bs(blk, bs, errp); 76888691b37SPaolo Bonzini if (ret < 0) { 76988691b37SPaolo Bonzini blk_unref(blk); 77088691b37SPaolo Bonzini return NULL; 77188691b37SPaolo Bonzini } 77288691b37SPaolo Bonzini 77388691b37SPaolo Bonzini job = g_malloc0(driver->instance_size); 77488691b37SPaolo Bonzini job->driver = driver; 77588691b37SPaolo Bonzini job->id = g_strdup(job_id); 77688691b37SPaolo Bonzini job->blk = blk; 77788691b37SPaolo Bonzini job->cb = cb; 77888691b37SPaolo Bonzini job->opaque = opaque; 77988691b37SPaolo Bonzini job->busy = false; 78088691b37SPaolo Bonzini job->paused = true; 78188691b37SPaolo Bonzini job->pause_count = 1; 78288691b37SPaolo Bonzini job->refcnt = 1; 783c9de4050SJohn Snow block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED); 784fc24908eSPaolo Bonzini aio_timer_init(qemu_get_aio_context(), &job->sleep_timer, 785fc24908eSPaolo Bonzini QEMU_CLOCK_REALTIME, SCALE_NS, 786fc24908eSPaolo Bonzini block_job_sleep_timer_cb, job); 78788691b37SPaolo Bonzini 78888691b37SPaolo Bonzini error_setg(&job->blocker, "block device is in use by block job: %s", 789977c736fSMarkus Armbruster BlockJobType_str(driver->job_type)); 79088691b37SPaolo Bonzini block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort); 79188691b37SPaolo Bonzini bs->job = job; 79288691b37SPaolo Bonzini 79388691b37SPaolo Bonzini bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker); 79488691b37SPaolo Bonzini 79588691b37SPaolo Bonzini QLIST_INSERT_HEAD(&block_jobs, job, job_list); 79688691b37SPaolo Bonzini 79788691b37SPaolo Bonzini blk_add_aio_context_notifier(blk, block_job_attached_aio_context, 79888691b37SPaolo Bonzini block_job_detach_aio_context, job); 79988691b37SPaolo Bonzini 80088691b37SPaolo Bonzini /* Only set speed when necessary to avoid NotSupported error */ 80188691b37SPaolo Bonzini if (speed != 0) { 80288691b37SPaolo Bonzini Error *local_err = NULL; 80388691b37SPaolo Bonzini 80488691b37SPaolo Bonzini block_job_set_speed(job, speed, &local_err); 80588691b37SPaolo Bonzini if (local_err) { 80688691b37SPaolo Bonzini block_job_unref(job); 80788691b37SPaolo Bonzini error_propagate(errp, local_err); 80888691b37SPaolo Bonzini return NULL; 80988691b37SPaolo Bonzini } 81088691b37SPaolo Bonzini } 81175859b94SJohn Snow 81275859b94SJohn Snow /* Single jobs are modeled as single-job transactions for sake of 81375859b94SJohn Snow * consolidating the job management logic */ 81475859b94SJohn Snow if (!txn) { 81575859b94SJohn Snow txn = block_job_txn_new(); 81675859b94SJohn Snow block_job_txn_add_job(txn, job); 81775859b94SJohn Snow block_job_txn_unref(txn); 81875859b94SJohn Snow } else { 81975859b94SJohn Snow block_job_txn_add_job(txn, job); 82075859b94SJohn Snow } 82175859b94SJohn Snow 82288691b37SPaolo Bonzini return job; 82388691b37SPaolo Bonzini } 82488691b37SPaolo Bonzini 825f321dcb5SPaolo Bonzini void block_job_pause_all(void) 826f321dcb5SPaolo Bonzini { 827f321dcb5SPaolo Bonzini BlockJob *job = NULL; 828f321dcb5SPaolo Bonzini while ((job = block_job_next(job))) { 829f321dcb5SPaolo Bonzini AioContext *aio_context = blk_get_aio_context(job->blk); 830f321dcb5SPaolo Bonzini 831f321dcb5SPaolo Bonzini aio_context_acquire(aio_context); 8323d5d319eSAlberto Garcia block_job_ref(job); 833f321dcb5SPaolo Bonzini block_job_pause(job); 834f321dcb5SPaolo Bonzini aio_context_release(aio_context); 835f321dcb5SPaolo Bonzini } 836f321dcb5SPaolo Bonzini } 837f321dcb5SPaolo Bonzini 83888691b37SPaolo Bonzini void block_job_early_fail(BlockJob *job) 83988691b37SPaolo Bonzini { 84088691b37SPaolo Bonzini block_job_unref(job); 84188691b37SPaolo Bonzini } 84288691b37SPaolo Bonzini 84388691b37SPaolo Bonzini void block_job_completed(BlockJob *job, int ret) 84488691b37SPaolo Bonzini { 84575859b94SJohn Snow assert(job && job->txn && !job->completed); 84688691b37SPaolo Bonzini assert(blk_bs(job->blk)->job == job); 84788691b37SPaolo Bonzini job->completed = true; 84888691b37SPaolo Bonzini job->ret = ret; 84975859b94SJohn Snow if (ret < 0 || block_job_is_cancelled(job)) { 85088691b37SPaolo Bonzini block_job_completed_txn_abort(job); 85188691b37SPaolo Bonzini } else { 85288691b37SPaolo Bonzini block_job_completed_txn_success(job); 85388691b37SPaolo Bonzini } 85488691b37SPaolo Bonzini } 85588691b37SPaolo Bonzini 85688691b37SPaolo Bonzini static bool block_job_should_pause(BlockJob *job) 85788691b37SPaolo Bonzini { 85888691b37SPaolo Bonzini return job->pause_count > 0; 85988691b37SPaolo Bonzini } 86088691b37SPaolo Bonzini 861fc24908eSPaolo Bonzini /* Yield, and schedule a timer to reenter the coroutine after @ns nanoseconds. 862fc24908eSPaolo Bonzini * Reentering the job coroutine with block_job_enter() before the timer has 863fc24908eSPaolo Bonzini * expired is allowed and cancels the timer. 864fc24908eSPaolo Bonzini * 865fc24908eSPaolo Bonzini * If @ns is (uint64_t) -1, no timer is scheduled and block_job_enter() must be 866fc24908eSPaolo Bonzini * called explicitly. */ 867fc24908eSPaolo Bonzini static void block_job_do_yield(BlockJob *job, uint64_t ns) 868356f59b8SPaolo Bonzini { 869fc24908eSPaolo Bonzini block_job_lock(); 870fc24908eSPaolo Bonzini if (ns != -1) { 871fc24908eSPaolo Bonzini timer_mod(&job->sleep_timer, ns); 872fc24908eSPaolo Bonzini } 873356f59b8SPaolo Bonzini job->busy = false; 874fc24908eSPaolo Bonzini block_job_unlock(); 875356f59b8SPaolo Bonzini qemu_coroutine_yield(); 876356f59b8SPaolo Bonzini 877356f59b8SPaolo Bonzini /* Set by block_job_enter before re-entering the coroutine. */ 878356f59b8SPaolo Bonzini assert(job->busy); 879356f59b8SPaolo Bonzini } 880356f59b8SPaolo Bonzini 88188691b37SPaolo Bonzini void coroutine_fn block_job_pause_point(BlockJob *job) 88288691b37SPaolo Bonzini { 88388691b37SPaolo Bonzini assert(job && block_job_started(job)); 88488691b37SPaolo Bonzini 88588691b37SPaolo Bonzini if (!block_job_should_pause(job)) { 88688691b37SPaolo Bonzini return; 88788691b37SPaolo Bonzini } 88888691b37SPaolo Bonzini if (block_job_is_cancelled(job)) { 88988691b37SPaolo Bonzini return; 89088691b37SPaolo Bonzini } 89188691b37SPaolo Bonzini 89288691b37SPaolo Bonzini if (job->driver->pause) { 89388691b37SPaolo Bonzini job->driver->pause(job); 89488691b37SPaolo Bonzini } 89588691b37SPaolo Bonzini 89688691b37SPaolo Bonzini if (block_job_should_pause(job) && !block_job_is_cancelled(job)) { 89758b295baSJohn Snow BlockJobStatus status = job->status; 898c9de4050SJohn Snow block_job_state_transition(job, status == BLOCK_JOB_STATUS_READY ? \ 89958b295baSJohn Snow BLOCK_JOB_STATUS_STANDBY : \ 900c9de4050SJohn Snow BLOCK_JOB_STATUS_PAUSED); 90188691b37SPaolo Bonzini job->paused = true; 902fc24908eSPaolo Bonzini block_job_do_yield(job, -1); 90388691b37SPaolo Bonzini job->paused = false; 904c9de4050SJohn Snow block_job_state_transition(job, status); 90588691b37SPaolo Bonzini } 90688691b37SPaolo Bonzini 90788691b37SPaolo Bonzini if (job->driver->resume) { 90888691b37SPaolo Bonzini job->driver->resume(job); 90988691b37SPaolo Bonzini } 91088691b37SPaolo Bonzini } 91188691b37SPaolo Bonzini 912f321dcb5SPaolo Bonzini void block_job_resume_all(void) 913f321dcb5SPaolo Bonzini { 9143d5d319eSAlberto Garcia BlockJob *job, *next; 9153d5d319eSAlberto Garcia 9163d5d319eSAlberto Garcia QLIST_FOREACH_SAFE(job, &block_jobs, job_list, next) { 917f321dcb5SPaolo Bonzini AioContext *aio_context = blk_get_aio_context(job->blk); 918f321dcb5SPaolo Bonzini 919f321dcb5SPaolo Bonzini aio_context_acquire(aio_context); 920f321dcb5SPaolo Bonzini block_job_resume(job); 9213d5d319eSAlberto Garcia block_job_unref(job); 922f321dcb5SPaolo Bonzini aio_context_release(aio_context); 923f321dcb5SPaolo Bonzini } 924f321dcb5SPaolo Bonzini } 925f321dcb5SPaolo Bonzini 926aa9ef2e6SJohn Snow /* 927aa9ef2e6SJohn Snow * Conditionally enter a block_job pending a call to fn() while 928aa9ef2e6SJohn Snow * under the block_job_lock critical section. 929aa9ef2e6SJohn Snow */ 930aa9ef2e6SJohn Snow static void block_job_enter_cond(BlockJob *job, bool(*fn)(BlockJob *job)) 93188691b37SPaolo Bonzini { 932eb05e011SPaolo Bonzini if (!block_job_started(job)) { 933eb05e011SPaolo Bonzini return; 934eb05e011SPaolo Bonzini } 935eb05e011SPaolo Bonzini if (job->deferred_to_main_loop) { 936eb05e011SPaolo Bonzini return; 937eb05e011SPaolo Bonzini } 938eb05e011SPaolo Bonzini 939fc24908eSPaolo Bonzini block_job_lock(); 940356f59b8SPaolo Bonzini if (job->busy) { 941fc24908eSPaolo Bonzini block_job_unlock(); 942356f59b8SPaolo Bonzini return; 94388691b37SPaolo Bonzini } 944356f59b8SPaolo Bonzini 945aa9ef2e6SJohn Snow if (fn && !fn(job)) { 946aa9ef2e6SJohn Snow block_job_unlock(); 947aa9ef2e6SJohn Snow return; 948aa9ef2e6SJohn Snow } 949aa9ef2e6SJohn Snow 950fc24908eSPaolo Bonzini assert(!job->deferred_to_main_loop); 951fc24908eSPaolo Bonzini timer_del(&job->sleep_timer); 952356f59b8SPaolo Bonzini job->busy = true; 953fc24908eSPaolo Bonzini block_job_unlock(); 954356f59b8SPaolo Bonzini aio_co_wake(job->co); 95588691b37SPaolo Bonzini } 95688691b37SPaolo Bonzini 957aa9ef2e6SJohn Snow void block_job_enter(BlockJob *job) 958aa9ef2e6SJohn Snow { 959aa9ef2e6SJohn Snow block_job_enter_cond(job, NULL); 960aa9ef2e6SJohn Snow } 961aa9ef2e6SJohn Snow 96288691b37SPaolo Bonzini bool block_job_is_cancelled(BlockJob *job) 96388691b37SPaolo Bonzini { 96488691b37SPaolo Bonzini return job->cancelled; 96588691b37SPaolo Bonzini } 96688691b37SPaolo Bonzini 9675bf1d5a7SPaolo Bonzini void block_job_sleep_ns(BlockJob *job, int64_t ns) 96888691b37SPaolo Bonzini { 96988691b37SPaolo Bonzini assert(job->busy); 97088691b37SPaolo Bonzini 97188691b37SPaolo Bonzini /* Check cancellation *before* setting busy = false, too! */ 97288691b37SPaolo Bonzini if (block_job_is_cancelled(job)) { 97388691b37SPaolo Bonzini return; 97488691b37SPaolo Bonzini } 97588691b37SPaolo Bonzini 97688691b37SPaolo Bonzini if (!block_job_should_pause(job)) { 977fc24908eSPaolo Bonzini block_job_do_yield(job, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ns); 97888691b37SPaolo Bonzini } 97988691b37SPaolo Bonzini 98088691b37SPaolo Bonzini block_job_pause_point(job); 98188691b37SPaolo Bonzini } 98288691b37SPaolo Bonzini 98388691b37SPaolo Bonzini void block_job_yield(BlockJob *job) 98488691b37SPaolo Bonzini { 98588691b37SPaolo Bonzini assert(job->busy); 98688691b37SPaolo Bonzini 98788691b37SPaolo Bonzini /* Check cancellation *before* setting busy = false, too! */ 98888691b37SPaolo Bonzini if (block_job_is_cancelled(job)) { 98988691b37SPaolo Bonzini return; 99088691b37SPaolo Bonzini } 99188691b37SPaolo Bonzini 99288691b37SPaolo Bonzini if (!block_job_should_pause(job)) { 993fc24908eSPaolo Bonzini block_job_do_yield(job, -1); 99488691b37SPaolo Bonzini } 99588691b37SPaolo Bonzini 99688691b37SPaolo Bonzini block_job_pause_point(job); 99788691b37SPaolo Bonzini } 99888691b37SPaolo Bonzini 9992caf63a9SPaolo Bonzini void block_job_iostatus_reset(BlockJob *job) 10002caf63a9SPaolo Bonzini { 10014c241cf5SPaolo Bonzini if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 10024c241cf5SPaolo Bonzini return; 10034c241cf5SPaolo Bonzini } 10044c241cf5SPaolo Bonzini assert(job->user_paused && job->pause_count > 0); 10052caf63a9SPaolo Bonzini job->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 10062caf63a9SPaolo Bonzini } 10072caf63a9SPaolo Bonzini 1008bcada37bSWenchao Xia void block_job_event_ready(BlockJob *job) 1009bcada37bSWenchao Xia { 1010c9de4050SJohn Snow block_job_state_transition(job, BLOCK_JOB_STATUS_READY); 1011ef6dbf1eSMax Reitz job->ready = true; 1012ef6dbf1eSMax Reitz 1013559b935fSJohn Snow if (block_job_is_internal(job)) { 1014559b935fSJohn Snow return; 1015559b935fSJohn Snow } 1016559b935fSJohn Snow 1017518848a2SMarkus Armbruster qapi_event_send_block_job_ready(job->driver->job_type, 10188ccb9569SKevin Wolf job->id, 1019518848a2SMarkus Armbruster job->len, 1020518848a2SMarkus Armbruster job->offset, 1021518848a2SMarkus Armbruster job->speed, &error_abort); 1022a66a2a36SPaolo Bonzini } 1023a66a2a36SPaolo Bonzini 102481e254dcSKevin Wolf BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err, 102532c81a4aSPaolo Bonzini int is_read, int error) 102632c81a4aSPaolo Bonzini { 102732c81a4aSPaolo Bonzini BlockErrorAction action; 102832c81a4aSPaolo Bonzini 102932c81a4aSPaolo Bonzini switch (on_err) { 103032c81a4aSPaolo Bonzini case BLOCKDEV_ON_ERROR_ENOSPC: 10318c398252SKevin Wolf case BLOCKDEV_ON_ERROR_AUTO: 1032a589569fSWenchao Xia action = (error == ENOSPC) ? 1033a589569fSWenchao Xia BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT; 103432c81a4aSPaolo Bonzini break; 103532c81a4aSPaolo Bonzini case BLOCKDEV_ON_ERROR_STOP: 1036a589569fSWenchao Xia action = BLOCK_ERROR_ACTION_STOP; 103732c81a4aSPaolo Bonzini break; 103832c81a4aSPaolo Bonzini case BLOCKDEV_ON_ERROR_REPORT: 1039a589569fSWenchao Xia action = BLOCK_ERROR_ACTION_REPORT; 104032c81a4aSPaolo Bonzini break; 104132c81a4aSPaolo Bonzini case BLOCKDEV_ON_ERROR_IGNORE: 1042a589569fSWenchao Xia action = BLOCK_ERROR_ACTION_IGNORE; 104332c81a4aSPaolo Bonzini break; 104432c81a4aSPaolo Bonzini default: 104532c81a4aSPaolo Bonzini abort(); 104632c81a4aSPaolo Bonzini } 1047559b935fSJohn Snow if (!block_job_is_internal(job)) { 10488ccb9569SKevin Wolf qapi_event_send_block_job_error(job->id, 10495a2d2cbdSWenchao Xia is_read ? IO_OPERATION_TYPE_READ : 10505a2d2cbdSWenchao Xia IO_OPERATION_TYPE_WRITE, 10515a2d2cbdSWenchao Xia action, &error_abort); 1052559b935fSJohn Snow } 1053a589569fSWenchao Xia if (action == BLOCK_ERROR_ACTION_STOP) { 1054*0ec4dfb8SJohn Snow block_job_pause(job); 1055751ebd76SFam Zheng /* make the pause user visible, which will be resumed from QMP. */ 1056*0ec4dfb8SJohn Snow job->user_paused = true; 105732c81a4aSPaolo Bonzini block_job_iostatus_set_err(job, error); 105832c81a4aSPaolo Bonzini } 105932c81a4aSPaolo Bonzini return action; 106032c81a4aSPaolo Bonzini } 1061dec7d421SStefan Hajnoczi 1062dec7d421SStefan Hajnoczi typedef struct { 1063dec7d421SStefan Hajnoczi BlockJob *job; 1064dec7d421SStefan Hajnoczi AioContext *aio_context; 1065dec7d421SStefan Hajnoczi BlockJobDeferToMainLoopFn *fn; 1066dec7d421SStefan Hajnoczi void *opaque; 1067dec7d421SStefan Hajnoczi } BlockJobDeferToMainLoopData; 1068dec7d421SStefan Hajnoczi 1069dec7d421SStefan Hajnoczi static void block_job_defer_to_main_loop_bh(void *opaque) 1070dec7d421SStefan Hajnoczi { 1071dec7d421SStefan Hajnoczi BlockJobDeferToMainLoopData *data = opaque; 1072dec7d421SStefan Hajnoczi AioContext *aio_context; 1073dec7d421SStefan Hajnoczi 1074dec7d421SStefan Hajnoczi /* Prevent race with block_job_defer_to_main_loop() */ 1075dec7d421SStefan Hajnoczi aio_context_acquire(data->aio_context); 1076dec7d421SStefan Hajnoczi 1077dec7d421SStefan Hajnoczi /* Fetch BDS AioContext again, in case it has changed */ 1078b6d2e599SKevin Wolf aio_context = blk_get_aio_context(data->job->blk); 1079d79df2a2SPaolo Bonzini if (aio_context != data->aio_context) { 1080dec7d421SStefan Hajnoczi aio_context_acquire(aio_context); 1081d79df2a2SPaolo Bonzini } 1082dec7d421SStefan Hajnoczi 1083dec7d421SStefan Hajnoczi data->fn(data->job, data->opaque); 1084dec7d421SStefan Hajnoczi 1085d79df2a2SPaolo Bonzini if (aio_context != data->aio_context) { 1086dec7d421SStefan Hajnoczi aio_context_release(aio_context); 1087d79df2a2SPaolo Bonzini } 1088dec7d421SStefan Hajnoczi 1089dec7d421SStefan Hajnoczi aio_context_release(data->aio_context); 1090dec7d421SStefan Hajnoczi 1091dec7d421SStefan Hajnoczi g_free(data); 1092dec7d421SStefan Hajnoczi } 1093dec7d421SStefan Hajnoczi 1094dec7d421SStefan Hajnoczi void block_job_defer_to_main_loop(BlockJob *job, 1095dec7d421SStefan Hajnoczi BlockJobDeferToMainLoopFn *fn, 1096dec7d421SStefan Hajnoczi void *opaque) 1097dec7d421SStefan Hajnoczi { 1098dec7d421SStefan Hajnoczi BlockJobDeferToMainLoopData *data = g_malloc(sizeof(*data)); 1099dec7d421SStefan Hajnoczi data->job = job; 1100b6d2e599SKevin Wolf data->aio_context = blk_get_aio_context(job->blk); 1101dec7d421SStefan Hajnoczi data->fn = fn; 1102dec7d421SStefan Hajnoczi data->opaque = opaque; 1103794f0141SFam Zheng job->deferred_to_main_loop = true; 1104dec7d421SStefan Hajnoczi 1105fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(qemu_get_aio_context(), 1106fffb6e12SPaolo Bonzini block_job_defer_to_main_loop_bh, data); 1107dec7d421SStefan Hajnoczi } 1108