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