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 "trace.h" 29 #include "block/block.h" 30 #include "block/blockjob_int.h" 31 #include "block/block_int.h" 32 #include "sysemu/block-backend.h" 33 #include "qapi/qmp/qerror.h" 34 #include "qapi/qmp/qjson.h" 35 #include "qemu/coroutine.h" 36 #include "qemu/id.h" 37 #include "qmp-commands.h" 38 #include "qemu/timer.h" 39 #include "qapi-event.h" 40 41 static void block_job_event_cancelled(BlockJob *job); 42 static void block_job_event_completed(BlockJob *job, const char *msg); 43 44 /* Transactional group of block jobs */ 45 struct BlockJobTxn { 46 47 /* Is this txn being cancelled? */ 48 bool aborting; 49 50 /* List of jobs */ 51 QLIST_HEAD(, BlockJob) jobs; 52 53 /* Reference count */ 54 int refcnt; 55 }; 56 57 static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs); 58 59 BlockJob *block_job_next(BlockJob *job) 60 { 61 if (!job) { 62 return QLIST_FIRST(&block_jobs); 63 } 64 return QLIST_NEXT(job, job_list); 65 } 66 67 BlockJob *block_job_get(const char *id) 68 { 69 BlockJob *job; 70 71 QLIST_FOREACH(job, &block_jobs, job_list) { 72 if (job->id && !strcmp(id, job->id)) { 73 return job; 74 } 75 } 76 77 return NULL; 78 } 79 80 static void block_job_attached_aio_context(AioContext *new_context, 81 void *opaque) 82 { 83 BlockJob *job = opaque; 84 85 if (job->driver->attached_aio_context) { 86 job->driver->attached_aio_context(job, new_context); 87 } 88 89 block_job_resume(job); 90 } 91 92 static void block_job_drain(BlockJob *job) 93 { 94 /* If job is !job->busy this kicks it into the next pause point. */ 95 block_job_enter(job); 96 97 blk_drain(job->blk); 98 if (job->driver->drain) { 99 job->driver->drain(job); 100 } 101 } 102 103 static void block_job_detach_aio_context(void *opaque) 104 { 105 BlockJob *job = opaque; 106 107 /* In case the job terminates during aio_poll()... */ 108 block_job_ref(job); 109 110 block_job_pause(job); 111 112 while (!job->paused && !job->completed) { 113 block_job_drain(job); 114 } 115 116 block_job_unref(job); 117 } 118 119 void block_job_add_bdrv(BlockJob *job, BlockDriverState *bs) 120 { 121 job->nodes = g_slist_prepend(job->nodes, bs); 122 bdrv_ref(bs); 123 bdrv_op_block_all(bs, job->blocker); 124 } 125 126 void *block_job_create(const char *job_id, const BlockJobDriver *driver, 127 BlockDriverState *bs, int64_t speed, int flags, 128 BlockCompletionFunc *cb, void *opaque, Error **errp) 129 { 130 BlockBackend *blk; 131 BlockJob *job; 132 133 if (bs->job) { 134 error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); 135 return NULL; 136 } 137 138 if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) { 139 job_id = bdrv_get_device_name(bs); 140 if (!*job_id) { 141 error_setg(errp, "An explicit job ID is required for this node"); 142 return NULL; 143 } 144 } 145 146 if (job_id) { 147 if (flags & BLOCK_JOB_INTERNAL) { 148 error_setg(errp, "Cannot specify job ID for internal block job"); 149 return NULL; 150 } 151 152 if (!id_wellformed(job_id)) { 153 error_setg(errp, "Invalid job ID '%s'", job_id); 154 return NULL; 155 } 156 157 if (block_job_get(job_id)) { 158 error_setg(errp, "Job ID '%s' already in use", job_id); 159 return NULL; 160 } 161 } 162 163 blk = blk_new(); 164 blk_insert_bs(blk, bs); 165 166 job = g_malloc0(driver->instance_size); 167 error_setg(&job->blocker, "block device is in use by block job: %s", 168 BlockJobType_lookup[driver->job_type]); 169 block_job_add_bdrv(job, bs); 170 bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker); 171 172 job->driver = driver; 173 job->id = g_strdup(job_id); 174 job->blk = blk; 175 job->cb = cb; 176 job->opaque = opaque; 177 job->busy = true; 178 job->refcnt = 1; 179 bs->job = job; 180 181 QLIST_INSERT_HEAD(&block_jobs, job, job_list); 182 183 blk_add_aio_context_notifier(blk, block_job_attached_aio_context, 184 block_job_detach_aio_context, job); 185 186 /* Only set speed when necessary to avoid NotSupported error */ 187 if (speed != 0) { 188 Error *local_err = NULL; 189 190 block_job_set_speed(job, speed, &local_err); 191 if (local_err) { 192 block_job_unref(job); 193 error_propagate(errp, local_err); 194 return NULL; 195 } 196 } 197 return job; 198 } 199 200 bool block_job_is_internal(BlockJob *job) 201 { 202 return (job->id == NULL); 203 } 204 205 void block_job_ref(BlockJob *job) 206 { 207 ++job->refcnt; 208 } 209 210 void block_job_unref(BlockJob *job) 211 { 212 if (--job->refcnt == 0) { 213 GSList *l; 214 BlockDriverState *bs = blk_bs(job->blk); 215 bs->job = NULL; 216 for (l = job->nodes; l; l = l->next) { 217 bs = l->data; 218 bdrv_op_unblock_all(bs, job->blocker); 219 bdrv_unref(bs); 220 } 221 g_slist_free(job->nodes); 222 blk_remove_aio_context_notifier(job->blk, 223 block_job_attached_aio_context, 224 block_job_detach_aio_context, job); 225 blk_unref(job->blk); 226 error_free(job->blocker); 227 g_free(job->id); 228 QLIST_REMOVE(job, job_list); 229 g_free(job); 230 } 231 } 232 233 static void block_job_completed_single(BlockJob *job) 234 { 235 if (!job->ret) { 236 if (job->driver->commit) { 237 job->driver->commit(job); 238 } 239 } else { 240 if (job->driver->abort) { 241 job->driver->abort(job); 242 } 243 } 244 245 if (job->cb) { 246 job->cb(job->opaque, job->ret); 247 } 248 if (block_job_is_cancelled(job)) { 249 block_job_event_cancelled(job); 250 } else { 251 const char *msg = NULL; 252 if (job->ret < 0) { 253 msg = strerror(-job->ret); 254 } 255 block_job_event_completed(job, msg); 256 } 257 258 if (job->txn) { 259 QLIST_REMOVE(job, txn_list); 260 block_job_txn_unref(job->txn); 261 } 262 block_job_unref(job); 263 } 264 265 static void block_job_completed_txn_abort(BlockJob *job) 266 { 267 AioContext *ctx; 268 BlockJobTxn *txn = job->txn; 269 BlockJob *other_job, *next; 270 271 if (txn->aborting) { 272 /* 273 * We are cancelled by another job, which will handle everything. 274 */ 275 return; 276 } 277 txn->aborting = true; 278 /* We are the first failed job. Cancel other jobs. */ 279 QLIST_FOREACH(other_job, &txn->jobs, txn_list) { 280 ctx = blk_get_aio_context(other_job->blk); 281 aio_context_acquire(ctx); 282 } 283 QLIST_FOREACH(other_job, &txn->jobs, txn_list) { 284 if (other_job == job || other_job->completed) { 285 /* Other jobs are "effectively" cancelled by us, set the status for 286 * them; this job, however, may or may not be cancelled, depending 287 * on the caller, so leave it. */ 288 if (other_job != job) { 289 other_job->cancelled = true; 290 } 291 continue; 292 } 293 block_job_cancel_sync(other_job); 294 assert(other_job->completed); 295 } 296 QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) { 297 ctx = blk_get_aio_context(other_job->blk); 298 block_job_completed_single(other_job); 299 aio_context_release(ctx); 300 } 301 } 302 303 static void block_job_completed_txn_success(BlockJob *job) 304 { 305 AioContext *ctx; 306 BlockJobTxn *txn = job->txn; 307 BlockJob *other_job, *next; 308 /* 309 * Successful completion, see if there are other running jobs in this 310 * txn. 311 */ 312 QLIST_FOREACH(other_job, &txn->jobs, txn_list) { 313 if (!other_job->completed) { 314 return; 315 } 316 } 317 /* We are the last completed job, commit the transaction. */ 318 QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) { 319 ctx = blk_get_aio_context(other_job->blk); 320 aio_context_acquire(ctx); 321 assert(other_job->ret == 0); 322 block_job_completed_single(other_job); 323 aio_context_release(ctx); 324 } 325 } 326 327 void block_job_completed(BlockJob *job, int ret) 328 { 329 assert(blk_bs(job->blk)->job == job); 330 assert(!job->completed); 331 job->completed = true; 332 job->ret = ret; 333 if (!job->txn) { 334 block_job_completed_single(job); 335 } else if (ret < 0 || block_job_is_cancelled(job)) { 336 block_job_completed_txn_abort(job); 337 } else { 338 block_job_completed_txn_success(job); 339 } 340 } 341 342 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) 343 { 344 Error *local_err = NULL; 345 346 if (!job->driver->set_speed) { 347 error_setg(errp, QERR_UNSUPPORTED); 348 return; 349 } 350 job->driver->set_speed(job, speed, &local_err); 351 if (local_err) { 352 error_propagate(errp, local_err); 353 return; 354 } 355 356 job->speed = speed; 357 } 358 359 void block_job_complete(BlockJob *job, Error **errp) 360 { 361 /* Should not be reachable via external interface for internal jobs */ 362 assert(job->id); 363 if (job->pause_count || job->cancelled || !job->driver->complete) { 364 error_setg(errp, "The active block job '%s' cannot be completed", 365 job->id); 366 return; 367 } 368 369 job->driver->complete(job, errp); 370 } 371 372 void block_job_pause(BlockJob *job) 373 { 374 job->pause_count++; 375 } 376 377 void block_job_user_pause(BlockJob *job) 378 { 379 job->user_paused = true; 380 block_job_pause(job); 381 } 382 383 static bool block_job_should_pause(BlockJob *job) 384 { 385 return job->pause_count > 0; 386 } 387 388 bool block_job_user_paused(BlockJob *job) 389 { 390 return job ? job->user_paused : 0; 391 } 392 393 void coroutine_fn block_job_pause_point(BlockJob *job) 394 { 395 if (!block_job_should_pause(job)) { 396 return; 397 } 398 if (block_job_is_cancelled(job)) { 399 return; 400 } 401 402 if (job->driver->pause) { 403 job->driver->pause(job); 404 } 405 406 if (block_job_should_pause(job) && !block_job_is_cancelled(job)) { 407 job->paused = true; 408 job->busy = false; 409 qemu_coroutine_yield(); /* wait for block_job_resume() */ 410 job->busy = true; 411 job->paused = false; 412 } 413 414 if (job->driver->resume) { 415 job->driver->resume(job); 416 } 417 } 418 419 void block_job_resume(BlockJob *job) 420 { 421 assert(job->pause_count > 0); 422 job->pause_count--; 423 if (job->pause_count) { 424 return; 425 } 426 block_job_enter(job); 427 } 428 429 void block_job_user_resume(BlockJob *job) 430 { 431 if (job && job->user_paused && job->pause_count > 0) { 432 job->user_paused = false; 433 block_job_resume(job); 434 } 435 } 436 437 void block_job_enter(BlockJob *job) 438 { 439 if (job->co && !job->busy) { 440 qemu_coroutine_enter(job->co); 441 } 442 } 443 444 void block_job_cancel(BlockJob *job) 445 { 446 job->cancelled = true; 447 block_job_iostatus_reset(job); 448 block_job_enter(job); 449 } 450 451 bool block_job_is_cancelled(BlockJob *job) 452 { 453 return job->cancelled; 454 } 455 456 void block_job_iostatus_reset(BlockJob *job) 457 { 458 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 459 if (job->driver->iostatus_reset) { 460 job->driver->iostatus_reset(job); 461 } 462 } 463 464 static int block_job_finish_sync(BlockJob *job, 465 void (*finish)(BlockJob *, Error **errp), 466 Error **errp) 467 { 468 Error *local_err = NULL; 469 int ret; 470 471 assert(blk_bs(job->blk)->job == job); 472 473 block_job_ref(job); 474 475 finish(job, &local_err); 476 if (local_err) { 477 error_propagate(errp, local_err); 478 block_job_unref(job); 479 return -EBUSY; 480 } 481 /* block_job_drain calls block_job_enter, and it should be enough to 482 * induce progress until the job completes or moves to the main thread. 483 */ 484 while (!job->deferred_to_main_loop && !job->completed) { 485 block_job_drain(job); 486 } 487 while (!job->completed) { 488 aio_poll(qemu_get_aio_context(), true); 489 } 490 ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret; 491 block_job_unref(job); 492 return ret; 493 } 494 495 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be 496 * used with block_job_finish_sync() without the need for (rather nasty) 497 * function pointer casts there. */ 498 static void block_job_cancel_err(BlockJob *job, Error **errp) 499 { 500 block_job_cancel(job); 501 } 502 503 int block_job_cancel_sync(BlockJob *job) 504 { 505 return block_job_finish_sync(job, &block_job_cancel_err, NULL); 506 } 507 508 void block_job_cancel_sync_all(void) 509 { 510 BlockJob *job; 511 AioContext *aio_context; 512 513 while ((job = QLIST_FIRST(&block_jobs))) { 514 aio_context = blk_get_aio_context(job->blk); 515 aio_context_acquire(aio_context); 516 block_job_cancel_sync(job); 517 aio_context_release(aio_context); 518 } 519 } 520 521 int block_job_complete_sync(BlockJob *job, Error **errp) 522 { 523 return block_job_finish_sync(job, &block_job_complete, errp); 524 } 525 526 void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns) 527 { 528 assert(job->busy); 529 530 /* Check cancellation *before* setting busy = false, too! */ 531 if (block_job_is_cancelled(job)) { 532 return; 533 } 534 535 job->busy = false; 536 if (!block_job_should_pause(job)) { 537 co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns); 538 } 539 job->busy = true; 540 541 block_job_pause_point(job); 542 } 543 544 void block_job_yield(BlockJob *job) 545 { 546 assert(job->busy); 547 548 /* Check cancellation *before* setting busy = false, too! */ 549 if (block_job_is_cancelled(job)) { 550 return; 551 } 552 553 job->busy = false; 554 if (!block_job_should_pause(job)) { 555 qemu_coroutine_yield(); 556 } 557 job->busy = true; 558 559 block_job_pause_point(job); 560 } 561 562 BlockJobInfo *block_job_query(BlockJob *job, Error **errp) 563 { 564 BlockJobInfo *info; 565 566 if (block_job_is_internal(job)) { 567 error_setg(errp, "Cannot query QEMU internal jobs"); 568 return NULL; 569 } 570 info = g_new0(BlockJobInfo, 1); 571 info->type = g_strdup(BlockJobType_lookup[job->driver->job_type]); 572 info->device = g_strdup(job->id); 573 info->len = job->len; 574 info->busy = job->busy; 575 info->paused = job->pause_count > 0; 576 info->offset = job->offset; 577 info->speed = job->speed; 578 info->io_status = job->iostatus; 579 info->ready = job->ready; 580 return info; 581 } 582 583 static void block_job_iostatus_set_err(BlockJob *job, int error) 584 { 585 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 586 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : 587 BLOCK_DEVICE_IO_STATUS_FAILED; 588 } 589 } 590 591 static void block_job_event_cancelled(BlockJob *job) 592 { 593 if (block_job_is_internal(job)) { 594 return; 595 } 596 597 qapi_event_send_block_job_cancelled(job->driver->job_type, 598 job->id, 599 job->len, 600 job->offset, 601 job->speed, 602 &error_abort); 603 } 604 605 static void block_job_event_completed(BlockJob *job, const char *msg) 606 { 607 if (block_job_is_internal(job)) { 608 return; 609 } 610 611 qapi_event_send_block_job_completed(job->driver->job_type, 612 job->id, 613 job->len, 614 job->offset, 615 job->speed, 616 !!msg, 617 msg, 618 &error_abort); 619 } 620 621 void block_job_event_ready(BlockJob *job) 622 { 623 job->ready = true; 624 625 if (block_job_is_internal(job)) { 626 return; 627 } 628 629 qapi_event_send_block_job_ready(job->driver->job_type, 630 job->id, 631 job->len, 632 job->offset, 633 job->speed, &error_abort); 634 } 635 636 BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err, 637 int is_read, int error) 638 { 639 BlockErrorAction action; 640 641 switch (on_err) { 642 case BLOCKDEV_ON_ERROR_ENOSPC: 643 case BLOCKDEV_ON_ERROR_AUTO: 644 action = (error == ENOSPC) ? 645 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT; 646 break; 647 case BLOCKDEV_ON_ERROR_STOP: 648 action = BLOCK_ERROR_ACTION_STOP; 649 break; 650 case BLOCKDEV_ON_ERROR_REPORT: 651 action = BLOCK_ERROR_ACTION_REPORT; 652 break; 653 case BLOCKDEV_ON_ERROR_IGNORE: 654 action = BLOCK_ERROR_ACTION_IGNORE; 655 break; 656 default: 657 abort(); 658 } 659 if (!block_job_is_internal(job)) { 660 qapi_event_send_block_job_error(job->id, 661 is_read ? IO_OPERATION_TYPE_READ : 662 IO_OPERATION_TYPE_WRITE, 663 action, &error_abort); 664 } 665 if (action == BLOCK_ERROR_ACTION_STOP) { 666 /* make the pause user visible, which will be resumed from QMP. */ 667 block_job_user_pause(job); 668 block_job_iostatus_set_err(job, error); 669 } 670 return action; 671 } 672 673 typedef struct { 674 BlockJob *job; 675 AioContext *aio_context; 676 BlockJobDeferToMainLoopFn *fn; 677 void *opaque; 678 } BlockJobDeferToMainLoopData; 679 680 static void block_job_defer_to_main_loop_bh(void *opaque) 681 { 682 BlockJobDeferToMainLoopData *data = opaque; 683 AioContext *aio_context; 684 685 /* Prevent race with block_job_defer_to_main_loop() */ 686 aio_context_acquire(data->aio_context); 687 688 /* Fetch BDS AioContext again, in case it has changed */ 689 aio_context = blk_get_aio_context(data->job->blk); 690 aio_context_acquire(aio_context); 691 692 data->job->deferred_to_main_loop = false; 693 data->fn(data->job, data->opaque); 694 695 aio_context_release(aio_context); 696 697 aio_context_release(data->aio_context); 698 699 g_free(data); 700 } 701 702 void block_job_defer_to_main_loop(BlockJob *job, 703 BlockJobDeferToMainLoopFn *fn, 704 void *opaque) 705 { 706 BlockJobDeferToMainLoopData *data = g_malloc(sizeof(*data)); 707 data->job = job; 708 data->aio_context = blk_get_aio_context(job->blk); 709 data->fn = fn; 710 data->opaque = opaque; 711 job->deferred_to_main_loop = true; 712 713 aio_bh_schedule_oneshot(qemu_get_aio_context(), 714 block_job_defer_to_main_loop_bh, data); 715 } 716 717 BlockJobTxn *block_job_txn_new(void) 718 { 719 BlockJobTxn *txn = g_new0(BlockJobTxn, 1); 720 QLIST_INIT(&txn->jobs); 721 txn->refcnt = 1; 722 return txn; 723 } 724 725 static void block_job_txn_ref(BlockJobTxn *txn) 726 { 727 txn->refcnt++; 728 } 729 730 void block_job_txn_unref(BlockJobTxn *txn) 731 { 732 if (txn && --txn->refcnt == 0) { 733 g_free(txn); 734 } 735 } 736 737 void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job) 738 { 739 if (!txn) { 740 return; 741 } 742 743 assert(!job->txn); 744 job->txn = txn; 745 746 QLIST_INSERT_HEAD(&txn->jobs, job, txn_list); 747 block_job_txn_ref(txn); 748 } 749