blockjob.c

   1 /*
   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
  26 #include "qemu/osdep.h"
  27 #include "qemu-common.h"
  28 #include "block/block.h"
  29 #include "block/blockjob_int.h"
  30 #include "block/block_int.h"
  31 #include "block/trace.h"
  32 #include "sysemu/block-backend.h"
  33 #include "qapi/error.h"
  34 #include "qapi/qapi-events-block-core.h"
  35 #include "qapi/qmp/qerror.h"
  36 #include "qemu/coroutine.h"
  37 #include "qemu/timer.h"
  38
  39 /* Transactional group of block jobs */
  40 struct JobTxn {
  41
  42     /* Is this txn being cancelled? */
  43     bool aborting;
  44
  45     /* List of jobs */
  46     QLIST_HEAD(, Job) jobs;
  47
  48     /* Reference count */
  49     int refcnt;
  50 };
  51
  52 /*
  53  * The block job API is composed of two categories of functions.
  54  *
  55  * The first includes functions used by the monitor.  The monitor is
  56  * peculiar in that it accesses the block job list with block_job_get, and
  57  * therefore needs consistency across block_job_get and the actual operation
  58  * (e.g. block_job_set_speed).  The consistency is achieved with
  59  * aio_context_acquire/release.  These functions are declared in blockjob.h.
  60  *
  61  * The second includes functions used by the block job drivers and sometimes
  62  * by the core block layer.  These do not care about locking, because the
  63  * whole coroutine runs under the AioContext lock, and are declared in
  64  * blockjob_int.h.
  65  */
  66
  67 static bool is_block_job(Job *job)
  68 {
  69     return job_type(job) == JOB_TYPE_BACKUP ||
  70            job_type(job) == JOB_TYPE_COMMIT ||
  71            job_type(job) == JOB_TYPE_MIRROR ||
  72            job_type(job) == JOB_TYPE_STREAM;
  73 }
  74
  75 BlockJob *block_job_next(BlockJob *bjob)
  76 {
  77     Job *job = bjob ? &bjob->job : NULL;
  78
  79     do {
  80         job = job_next(job);
  81     } while (job && !is_block_job(job));
  82
  83     return job ? container_of(job, BlockJob, job) : NULL;
  84 }
  85
  86 BlockJob *block_job_get(const char *id)
  87 {
  88     Job *job = job_get(id);
  89
  90     if (job && is_block_job(job)) {
  91         return container_of(job, BlockJob, job);
  92     } else {
  93         return NULL;
  94     }
  95 }
  96
  97 JobTxn *block_job_txn_new(void)
  98 {
  99     JobTxn *txn = g_new0(JobTxn, 1);
 100     QLIST_INIT(&txn->jobs);
 101     txn->refcnt = 1;
 102     return txn;
 103 }
 104
 105 static void block_job_txn_ref(JobTxn *txn)
 106 {
 107     txn->refcnt++;
 108 }
 109
 110 void block_job_txn_unref(JobTxn *txn)
 111 {
 112     if (txn && --txn->refcnt == 0) {
 113         g_free(txn);
 114     }
 115 }
 116
 117 void block_job_txn_add_job(JobTxn *txn, BlockJob *job)
 118 {
 119     if (!txn) {
 120         return;
 121     }
 122
 123     assert(!job->txn);
 124     job->txn = txn;
 125
 126     QLIST_INSERT_HEAD(&txn->jobs, &job->job, txn_list);
 127     block_job_txn_ref(txn);
 128 }
 129
 130 void block_job_txn_del_job(BlockJob *job)
 131 {
 132     if (job->txn) {
 133         QLIST_REMOVE(&job->job, txn_list);
 134         block_job_txn_unref(job->txn);
 135         job->txn = NULL;
 136     }
 137 }
 138
 139 static void block_job_attached_aio_context(AioContext *new_context,
 140                                            void *opaque);
 141 static void block_job_detach_aio_context(void *opaque);
 142
 143 void block_job_free(Job *job)
 144 {
 145     BlockJob *bjob = container_of(job, BlockJob, job);
 146     BlockDriverState *bs = blk_bs(bjob->blk);
 147
 148     assert(!bjob->txn);
 149
 150     bs->job = NULL;
 151     block_job_remove_all_bdrv(bjob);
 152     blk_remove_aio_context_notifier(bjob->blk,
 153                                     block_job_attached_aio_context,
 154                                     block_job_detach_aio_context, bjob);
 155     blk_unref(bjob->blk);
 156     error_free(bjob->blocker);
 157 }
 158
 159 static void block_job_attached_aio_context(AioContext *new_context,
 160                                            void *opaque)
 161 {
 162     BlockJob *job = opaque;
 163
 164     job->job.aio_context = new_context;
 165     if (job->driver->attached_aio_context) {
 166         job->driver->attached_aio_context(job, new_context);
 167     }
 168
 169     job_resume(&job->job);
 170 }
 171
 172 void block_job_drain(Job *job)
 173 {
 174     BlockJob *bjob = container_of(job, BlockJob, job);
 175
 176     blk_drain(bjob->blk);
 177     if (bjob->driver->drain) {
 178         bjob->driver->drain(bjob);
 179     }
 180 }
 181
 182 static void block_job_detach_aio_context(void *opaque)
 183 {
 184     BlockJob *job = opaque;
 185
 186     /* In case the job terminates during aio_poll()... */
 187     job_ref(&job->job);
 188
 189     job_pause(&job->job);
 190
 191     while (!job->job.paused && !job_is_completed(&job->job)) {
 192         job_drain(&job->job);
 193     }
 194
 195     job->job.aio_context = NULL;
 196     job_unref(&job->job);
 197 }
 198
 199 static char *child_job_get_parent_desc(BdrvChild *c)
 200 {
 201     BlockJob *job = c->opaque;
 202     return g_strdup_printf("%s job '%s'", job_type_str(&job->job), job->job.id);
 203 }
 204
 205 static void child_job_drained_begin(BdrvChild *c)
 206 {
 207     BlockJob *job = c->opaque;
 208     job_pause(&job->job);
 209 }
 210
 211 static void child_job_drained_end(BdrvChild *c)
 212 {
 213     BlockJob *job = c->opaque;
 214     job_resume(&job->job);
 215 }
 216
 217 static const BdrvChildRole child_job = {
 218     .get_parent_desc    = child_job_get_parent_desc,
 219     .drained_begin      = child_job_drained_begin,
 220     .drained_end        = child_job_drained_end,
 221     .stay_at_node       = true,
 222 };
 223
 224 void block_job_remove_all_bdrv(BlockJob *job)
 225 {
 226     GSList *l;
 227     for (l = job->nodes; l; l = l->next) {
 228         BdrvChild *c = l->data;
 229         bdrv_op_unblock_all(c->bs, job->blocker);
 230         bdrv_root_unref_child(c);
 231     }
 232     g_slist_free(job->nodes);
 233     job->nodes = NULL;
 234 }
 235
 236 int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
 237                        uint64_t perm, uint64_t shared_perm, Error **errp)
 238 {
 239     BdrvChild *c;
 240
 241     c = bdrv_root_attach_child(bs, name, &child_job, perm, shared_perm,
 242                                job, errp);
 243     if (c == NULL) {
 244         return -EPERM;
 245     }
 246
 247     job->nodes = g_slist_prepend(job->nodes, c);
 248     bdrv_ref(bs);
 249     bdrv_op_block_all(bs, job->blocker);
 250
 251     return 0;
 252 }
 253
 254 bool block_job_is_internal(BlockJob *job)
 255 {
 256     return (job->job.id == NULL);
 257 }
 258
 259 const BlockJobDriver *block_job_driver(BlockJob *job)
 260 {
 261     return job->driver;
 262 }
 263
 264 static int block_job_prepare(BlockJob *job)
 265 {
 266     if (job->job.ret == 0 && job->driver->prepare) {
 267         job->job.ret = job->driver->prepare(job);
 268     }
 269     return job->job.ret;
 270 }
 271
 272 static void job_cancel_async(Job *job, bool force)
 273 {
 274     if (job->user_paused) {
 275         /* Do not call job_enter here, the caller will handle it.  */
 276         job->user_paused = false;
 277         if (job->driver->user_resume) {
 278             job->driver->user_resume(job);
 279         }
 280         assert(job->pause_count > 0);
 281         job->pause_count--;
 282     }
 283     job->cancelled = true;
 284     /* To prevent 'force == false' overriding a previous 'force == true' */
 285     job->force_cancel |= force;
 286 }
 287
 288 static int block_job_txn_apply(JobTxn *txn, int fn(BlockJob *), bool lock)
 289 {
 290     AioContext *ctx;
 291     Job *job, *next;
 292     BlockJob *bjob;
 293     int rc = 0;
 294
 295     QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
 296         assert(is_block_job(job));
 297         bjob = container_of(job, BlockJob, job);
 298
 299         if (lock) {
 300             ctx = job->aio_context;
 301             aio_context_acquire(ctx);
 302         }
 303         rc = fn(bjob);
 304         if (lock) {
 305             aio_context_release(ctx);
 306         }
 307         if (rc) {
 308             break;
 309         }
 310     }
 311     return rc;
 312 }
 313
 314 static void block_job_completed_txn_abort(BlockJob *job)
 315 {
 316     AioContext *ctx;
 317     JobTxn *txn = job->txn;
 318     Job *other_job;
 319
 320     if (txn->aborting) {
 321         /*
 322          * We are cancelled by another job, which will handle everything.
 323          */
 324         return;
 325     }
 326     txn->aborting = true;
 327     block_job_txn_ref(txn);
 328
 329     /* We are the first failed job. Cancel other jobs. */
 330     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
 331         ctx = other_job->aio_context;
 332         aio_context_acquire(ctx);
 333     }
 334
 335     /* Other jobs are effectively cancelled by us, set the status for
 336      * them; this job, however, may or may not be cancelled, depending
 337      * on the caller, so leave it. */
 338     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
 339         if (other_job != &job->job) {
 340             job_cancel_async(other_job, false);
 341         }
 342     }
 343     while (!QLIST_EMPTY(&txn->jobs)) {
 344         other_job = QLIST_FIRST(&txn->jobs);
 345         ctx = other_job->aio_context;
 346         if (!job_is_completed(other_job)) {
 347             assert(job_is_cancelled(other_job));
 348             job_finish_sync(other_job, NULL, NULL);
 349         }
 350         job_finalize_single(other_job);
 351         aio_context_release(ctx);
 352     }
 353
 354     block_job_txn_unref(txn);
 355 }
 356
 357 static int block_job_needs_finalize(BlockJob *job)
 358 {
 359     return !job->job.auto_finalize;
 360 }
 361
 362 static int block_job_finalize_single(BlockJob *job)
 363 {
 364     return job_finalize_single(&job->job);
 365 }
 366
 367 static void block_job_do_finalize(BlockJob *job)
 368 {
 369     int rc;
 370     assert(job && job->txn);
 371
 372     /* prepare the transaction to complete */
 373     rc = block_job_txn_apply(job->txn, block_job_prepare, true);
 374     if (rc) {
 375         block_job_completed_txn_abort(job);
 376     } else {
 377         block_job_txn_apply(job->txn, block_job_finalize_single, true);
 378     }
 379 }
 380
 381 static int block_job_transition_to_pending(BlockJob *job)
 382 {
 383     job_state_transition(&job->job, JOB_STATUS_PENDING);
 384     if (!job->job.auto_finalize) {
 385         job_event_pending(&job->job);
 386     }
 387     return 0;
 388 }
 389
 390 static void block_job_completed_txn_success(BlockJob *job)
 391 {
 392     JobTxn *txn = job->txn;
 393     Job *other_job;
 394
 395     job_state_transition(&job->job, JOB_STATUS_WAITING);
 396
 397     /*
 398      * Successful completion, see if there are other running jobs in this
 399      * txn.
 400      */
 401     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
 402         if (!job_is_completed(other_job)) {
 403             return;
 404         }
 405         assert(other_job->ret == 0);
 406     }
 407
 408     block_job_txn_apply(txn, block_job_transition_to_pending, false);
 409
 410     /* If no jobs need manual finalization, automatically do so */
 411     if (block_job_txn_apply(txn, block_job_needs_finalize, false) == 0) {
 412         block_job_do_finalize(job);
 413     }
 414 }
 415
 416 /* Assumes the job_mutex is held */
 417 static bool job_timer_pending(Job *job)
 418 {
 419     return timer_pending(&job->sleep_timer);
 420 }
 421
 422 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
 423 {
 424     int64_t old_speed = job->speed;
 425
 426     if (job_apply_verb(&job->job, JOB_VERB_SET_SPEED, errp)) {
 427         return;
 428     }
 429     if (speed < 0) {
 430         error_setg(errp, QERR_INVALID_PARAMETER, "speed");
 431         return;
 432     }
 433
 434     ratelimit_set_speed(&job->limit, speed, BLOCK_JOB_SLICE_TIME);
 435
 436     job->speed = speed;
 437     if (speed && speed <= old_speed) {
 438         return;
 439     }
 440
 441     /* kick only if a timer is pending */
 442     job_enter_cond(&job->job, job_timer_pending);
 443 }
 444
 445 int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
 446 {
 447     if (!job->speed) {
 448         return 0;
 449     }
 450
 451     return ratelimit_calculate_delay(&job->limit, n);
 452 }
 453
 454 void block_job_finalize(BlockJob *job, Error **errp)
 455 {
 456     assert(job && job->job.id);
 457     if (job_apply_verb(&job->job, JOB_VERB_FINALIZE, errp)) {
 458         return;
 459     }
 460     block_job_do_finalize(job);
 461 }
 462
 463 void block_job_dismiss(BlockJob **jobptr, Error **errp)
 464 {
 465     BlockJob *job = *jobptr;
 466     /* similarly to _complete, this is QMP-interface only. */
 467     assert(job->job.id);
 468     if (job_apply_verb(&job->job, JOB_VERB_DISMISS, errp)) {
 469         return;
 470     }
 471
 472     job_do_dismiss(&job->job);
 473     *jobptr = NULL;
 474 }
 475
 476 void block_job_cancel(BlockJob *job, bool force)
 477 {
 478     if (job->job.status == JOB_STATUS_CONCLUDED) {
 479         job_do_dismiss(&job->job);
 480         return;
 481     }
 482     job_cancel_async(&job->job, force);
 483     if (!job_started(&job->job)) {
 484         block_job_completed(job, -ECANCELED);
 485     } else if (job->job.deferred_to_main_loop) {
 486         block_job_completed_txn_abort(job);
 487     } else {
 488         block_job_enter(job);
 489     }
 490 }
 491
 492 void block_job_user_cancel(BlockJob *job, bool force, Error **errp)
 493 {
 494     if (job_apply_verb(&job->job, JOB_VERB_CANCEL, errp)) {
 495         return;
 496     }
 497     block_job_cancel(job, force);
 498 }
 499
 500 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
 501  * used with job_finish_sync() without the need for (rather nasty) function
 502  * pointer casts there. */
 503 static void block_job_cancel_err(Job *job, Error **errp)
 504 {
 505     BlockJob *bjob = container_of(job, BlockJob, job);
 506     assert(is_block_job(job));
 507     block_job_cancel(bjob, false);
 508 }
 509
 510 int block_job_cancel_sync(BlockJob *job)
 511 {
 512     return job_finish_sync(&job->job, &block_job_cancel_err, NULL);
 513 }
 514
 515 void block_job_cancel_sync_all(void)
 516 {
 517     BlockJob *job;
 518     AioContext *aio_context;
 519
 520     while ((job = block_job_next(NULL))) {
 521         aio_context = blk_get_aio_context(job->blk);
 522         aio_context_acquire(aio_context);
 523         block_job_cancel_sync(job);
 524         aio_context_release(aio_context);
 525     }
 526 }
 527
 528 int block_job_complete_sync(BlockJob *job, Error **errp)
 529 {
 530     return job_finish_sync(&job->job, job_complete, errp);
 531 }
 532
 533 void block_job_progress_update(BlockJob *job, uint64_t done)
 534 {
 535     job->offset += done;
 536 }
 537
 538 void block_job_progress_set_remaining(BlockJob *job, uint64_t remaining)
 539 {
 540     job->len = job->offset + remaining;
 541 }
 542
 543 BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
 544 {
 545     BlockJobInfo *info;
 546
 547     if (block_job_is_internal(job)) {
 548         error_setg(errp, "Cannot query QEMU internal jobs");
 549         return NULL;
 550     }
 551     info = g_new0(BlockJobInfo, 1);
 552     info->type      = g_strdup(job_type_str(&job->job));
 553     info->device    = g_strdup(job->job.id);
 554     info->len       = job->len;
 555     info->busy      = atomic_read(&job->job.busy);
 556     info->paused    = job->job.pause_count > 0;
 557     info->offset    = job->offset;
 558     info->speed     = job->speed;
 559     info->io_status = job->iostatus;
 560     info->ready     = job->ready;
 561     info->status    = job->job.status;
 562     info->auto_finalize = job->job.auto_finalize;
 563     info->auto_dismiss  = job->job.auto_dismiss;
 564     info->has_error = job->job.ret != 0;
 565     info->error     = job->job.ret ? g_strdup(strerror(-job->job.ret)) : NULL;
 566     return info;
 567 }
 568
 569 static void block_job_iostatus_set_err(BlockJob *job, int error)
 570 {
 571     if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
 572         job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
 573                                           BLOCK_DEVICE_IO_STATUS_FAILED;
 574     }
 575 }
 576
 577 static void block_job_event_cancelled(Notifier *n, void *opaque)
 578 {
 579     BlockJob *job = opaque;
 580
 581     if (block_job_is_internal(job)) {
 582         return;
 583     }
 584
 585     qapi_event_send_block_job_cancelled(job_type(&job->job),
 586                                         job->job.id,
 587                                         job->len,
 588                                         job->offset,
 589                                         job->speed,
 590                                         &error_abort);
 591 }
 592
 593 static void block_job_event_completed(Notifier *n, void *opaque)
 594 {
 595     BlockJob *job = opaque;
 596     const char *msg = NULL;
 597
 598     if (block_job_is_internal(job)) {
 599         return;
 600     }
 601
 602     if (job->job.ret < 0) {
 603         msg = strerror(-job->job.ret);
 604     }
 605
 606     qapi_event_send_block_job_completed(job_type(&job->job),
 607                                         job->job.id,
 608                                         job->len,
 609                                         job->offset,
 610                                         job->speed,
 611                                         !!msg,
 612                                         msg,
 613                                         &error_abort);
 614 }
 615
 616 static void block_job_event_pending(Notifier *n, void *opaque)
 617 {
 618     BlockJob *job = opaque;
 619
 620     if (block_job_is_internal(job)) {
 621         return;
 622     }
 623
 624     qapi_event_send_block_job_pending(job_type(&job->job),
 625                                       job->job.id,
 626                                       &error_abort);
 627 }
 628
 629 /*
 630  * API for block job drivers and the block layer.  These functions are
 631  * declared in blockjob_int.h.
 632  */
 633
 634 void *block_job_create(const char *job_id, const BlockJobDriver *driver,
 635                        JobTxn *txn, BlockDriverState *bs, uint64_t perm,
 636                        uint64_t shared_perm, int64_t speed, int flags,
 637                        BlockCompletionFunc *cb, void *opaque, Error **errp)
 638 {
 639     BlockBackend *blk;
 640     BlockJob *job;
 641     int ret;
 642
 643     if (bs->job) {
 644         error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
 645         return NULL;
 646     }
 647
 648     if (job_id == NULL && !(flags & JOB_INTERNAL)) {
 649         job_id = bdrv_get_device_name(bs);
 650     }
 651
 652     blk = blk_new(perm, shared_perm);
 653     ret = blk_insert_bs(blk, bs, errp);
 654     if (ret < 0) {
 655         blk_unref(blk);
 656         return NULL;
 657     }
 658
 659     job = job_create(job_id, &driver->job_driver, blk_get_aio_context(blk),
 660                      flags, cb, opaque, errp);
 661     if (job == NULL) {
 662         blk_unref(blk);
 663         return NULL;
 664     }
 665
 666     assert(is_block_job(&job->job));
 667     assert(job->job.driver->free == &block_job_free);
 668     assert(job->job.driver->user_resume == &block_job_user_resume);
 669     assert(job->job.driver->drain == &block_job_drain);
 670
 671     job->driver        = driver;
 672     job->blk           = blk;
 673
 674     job->finalize_cancelled_notifier.notify = block_job_event_cancelled;
 675     job->finalize_completed_notifier.notify = block_job_event_completed;
 676     job->pending_notifier.notify = block_job_event_pending;
 677
 678     notifier_list_add(&job->job.on_finalize_cancelled,
 679                       &job->finalize_cancelled_notifier);
 680     notifier_list_add(&job->job.on_finalize_completed,
 681                       &job->finalize_completed_notifier);
 682     notifier_list_add(&job->job.on_pending, &job->pending_notifier);
 683
 684     error_setg(&job->blocker, "block device is in use by block job: %s",
 685                job_type_str(&job->job));
 686     block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
 687     bs->job = job;
 688
 689     bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
 690
 691     blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
 692                                  block_job_detach_aio_context, job);
 693
 694     /* Only set speed when necessary to avoid NotSupported error */
 695     if (speed != 0) {
 696         Error *local_err = NULL;
 697
 698         block_job_set_speed(job, speed, &local_err);
 699         if (local_err) {
 700             job_early_fail(&job->job);
 701             error_propagate(errp, local_err);
 702             return NULL;
 703         }
 704     }
 705
 706     /* Single jobs are modeled as single-job transactions for sake of
 707      * consolidating the job management logic */
 708     if (!txn) {
 709         txn = block_job_txn_new();
 710         block_job_txn_add_job(txn, job);
 711         block_job_txn_unref(txn);
 712     } else {
 713         block_job_txn_add_job(txn, job);
 714     }
 715
 716     return job;
 717 }
 718
 719 void block_job_completed(BlockJob *job, int ret)
 720 {
 721     assert(job && job->txn && !job_is_completed(&job->job));
 722     assert(blk_bs(job->blk)->job == job);
 723     job->job.ret = ret;
 724     job_update_rc(&job->job);
 725     trace_block_job_completed(job, ret, job->job.ret);
 726     if (job->job.ret) {
 727         block_job_completed_txn_abort(job);
 728     } else {
 729         block_job_completed_txn_success(job);
 730     }
 731 }
 732
 733 void block_job_enter(BlockJob *job)
 734 {
 735     job_enter_cond(&job->job, NULL);
 736 }
 737
 738 void block_job_yield(BlockJob *job)
 739 {
 740     assert(job->job.busy);
 741
 742     /* Check cancellation *before* setting busy = false, too!  */
 743     if (job_is_cancelled(&job->job)) {
 744         return;
 745     }
 746
 747     if (!job_should_pause(&job->job)) {
 748         job_do_yield(&job->job, -1);
 749     }
 750
 751     job_pause_point(&job->job);
 752 }
 753
 754 void block_job_iostatus_reset(BlockJob *job)
 755 {
 756     if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
 757         return;
 758     }
 759     assert(job->job.user_paused && job->job.pause_count > 0);
 760     job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
 761 }
 762
 763 void block_job_user_resume(Job *job)
 764 {
 765     BlockJob *bjob = container_of(job, BlockJob, job);
 766     block_job_iostatus_reset(bjob);
 767 }
 768
 769 void block_job_event_ready(BlockJob *job)
 770 {
 771     job_state_transition(&job->job, JOB_STATUS_READY);
 772     job->ready = true;
 773
 774     if (block_job_is_internal(job)) {
 775         return;
 776     }
 777
 778     qapi_event_send_block_job_ready(job_type(&job->job),
 779                                     job->job.id,
 780                                     job->len,
 781                                     job->offset,
 782                                     job->speed, &error_abort);
 783 }
 784
 785 BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
 786                                         int is_read, int error)
 787 {
 788     BlockErrorAction action;
 789
 790     switch (on_err) {
 791     case BLOCKDEV_ON_ERROR_ENOSPC:
 792     case BLOCKDEV_ON_ERROR_AUTO:
 793         action = (error == ENOSPC) ?
 794                  BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
 795         break;
 796     case BLOCKDEV_ON_ERROR_STOP:
 797         action = BLOCK_ERROR_ACTION_STOP;
 798         break;
 799     case BLOCKDEV_ON_ERROR_REPORT:
 800         action = BLOCK_ERROR_ACTION_REPORT;
 801         break;
 802     case BLOCKDEV_ON_ERROR_IGNORE:
 803         action = BLOCK_ERROR_ACTION_IGNORE;
 804         break;
 805     default:
 806         abort();
 807     }
 808     if (!block_job_is_internal(job)) {
 809         qapi_event_send_block_job_error(job->job.id,
 810                                         is_read ? IO_OPERATION_TYPE_READ :
 811                                         IO_OPERATION_TYPE_WRITE,
 812                                         action, &error_abort);
 813     }
 814     if (action == BLOCK_ERROR_ACTION_STOP) {
 815         job_pause(&job->job);
 816         /* make the pause user visible, which will be resumed from QMP. */
 817         job->job.user_paused = true;
 818         block_job_iostatus_set_err(job, error);
 819     }
 820     return action;
 821 }