1 /* 2 * Block protocol for I/O error injection 3 * 4 * Copyright (C) 2016-2017 Red Hat, Inc. 5 * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com> 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 "qapi/error.h" 28 #include "qemu/cutils.h" 29 #include "qemu/config-file.h" 30 #include "block/block_int.h" 31 #include "block/qdict.h" 32 #include "qemu/module.h" 33 #include "qemu/option.h" 34 #include "qapi/qapi-visit-block-core.h" 35 #include "qapi/qmp/qdict.h" 36 #include "qapi/qmp/qlist.h" 37 #include "qapi/qmp/qstring.h" 38 #include "qapi/qobject-input-visitor.h" 39 #include "sysemu/qtest.h" 40 41 /* All APIs are thread-safe */ 42 43 typedef struct BDRVBlkdebugState { 44 /* IN: initialized in blkdebug_open() and never changed */ 45 uint64_t align; 46 uint64_t max_transfer; 47 uint64_t opt_write_zero; 48 uint64_t max_write_zero; 49 uint64_t opt_discard; 50 uint64_t max_discard; 51 char *config_file; /* For blkdebug_refresh_filename() */ 52 /* initialized in blkdebug_parse_perms() */ 53 uint64_t take_child_perms; 54 uint64_t unshare_child_perms; 55 56 /* State. Protected by lock */ 57 int state; 58 QLIST_HEAD(, BlkdebugRule) rules[BLKDBG__MAX]; 59 QSIMPLEQ_HEAD(, BlkdebugRule) active_rules; 60 QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs; 61 QemuMutex lock; 62 } BDRVBlkdebugState; 63 64 typedef struct BlkdebugAIOCB { 65 BlockAIOCB common; 66 int ret; 67 } BlkdebugAIOCB; 68 69 typedef struct BlkdebugSuspendedReq { 70 /* IN: initialized in suspend_request() */ 71 Coroutine *co; 72 char *tag; 73 74 /* List entry protected BDRVBlkdebugState's lock */ 75 QLIST_ENTRY(BlkdebugSuspendedReq) next; 76 } BlkdebugSuspendedReq; 77 78 enum { 79 ACTION_INJECT_ERROR, 80 ACTION_SET_STATE, 81 ACTION_SUSPEND, 82 ACTION__MAX, 83 }; 84 85 typedef struct BlkdebugRule { 86 /* IN: initialized in add_rule() or blkdebug_debug_breakpoint() */ 87 BlkdebugEvent event; 88 int action; 89 int state; 90 union { 91 struct { 92 uint64_t iotype_mask; 93 int error; 94 int immediately; 95 int once; 96 int64_t offset; 97 } inject; 98 struct { 99 int new_state; 100 } set_state; 101 struct { 102 char *tag; 103 } suspend; 104 } options; 105 106 /* List entries protected BDRVBlkdebugState's lock */ 107 QLIST_ENTRY(BlkdebugRule) next; 108 QSIMPLEQ_ENTRY(BlkdebugRule) active_next; 109 } BlkdebugRule; 110 111 QEMU_BUILD_BUG_MSG(BLKDEBUG_IO_TYPE__MAX > 64, 112 "BlkdebugIOType mask does not fit into an uint64_t"); 113 114 static QemuOptsList inject_error_opts = { 115 .name = "inject-error", 116 .head = QTAILQ_HEAD_INITIALIZER(inject_error_opts.head), 117 .desc = { 118 { 119 .name = "event", 120 .type = QEMU_OPT_STRING, 121 }, 122 { 123 .name = "state", 124 .type = QEMU_OPT_NUMBER, 125 }, 126 { 127 .name = "iotype", 128 .type = QEMU_OPT_STRING, 129 }, 130 { 131 .name = "errno", 132 .type = QEMU_OPT_NUMBER, 133 }, 134 { 135 .name = "sector", 136 .type = QEMU_OPT_NUMBER, 137 }, 138 { 139 .name = "once", 140 .type = QEMU_OPT_BOOL, 141 }, 142 { 143 .name = "immediately", 144 .type = QEMU_OPT_BOOL, 145 }, 146 { /* end of list */ } 147 }, 148 }; 149 150 static QemuOptsList set_state_opts = { 151 .name = "set-state", 152 .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head), 153 .desc = { 154 { 155 .name = "event", 156 .type = QEMU_OPT_STRING, 157 }, 158 { 159 .name = "state", 160 .type = QEMU_OPT_NUMBER, 161 }, 162 { 163 .name = "new_state", 164 .type = QEMU_OPT_NUMBER, 165 }, 166 { /* end of list */ } 167 }, 168 }; 169 170 static QemuOptsList *config_groups[] = { 171 &inject_error_opts, 172 &set_state_opts, 173 NULL 174 }; 175 176 struct add_rule_data { 177 BDRVBlkdebugState *s; 178 int action; 179 }; 180 181 static int add_rule(void *opaque, QemuOpts *opts, Error **errp) 182 { 183 struct add_rule_data *d = opaque; 184 BDRVBlkdebugState *s = d->s; 185 const char *event_name; 186 int event; 187 struct BlkdebugRule *rule; 188 int64_t sector; 189 BlkdebugIOType iotype; 190 Error *local_error = NULL; 191 192 /* Find the right event for the rule */ 193 event_name = qemu_opt_get(opts, "event"); 194 if (!event_name) { 195 error_setg(errp, "Missing event name for rule"); 196 return -1; 197 } 198 event = qapi_enum_parse(&BlkdebugEvent_lookup, event_name, -1, errp); 199 if (event < 0) { 200 return -1; 201 } 202 203 /* Set attributes common for all actions */ 204 rule = g_malloc0(sizeof(*rule)); 205 *rule = (struct BlkdebugRule) { 206 .event = event, 207 .action = d->action, 208 .state = qemu_opt_get_number(opts, "state", 0), 209 }; 210 211 /* Parse action-specific options */ 212 switch (d->action) { 213 case ACTION_INJECT_ERROR: 214 rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO); 215 rule->options.inject.once = qemu_opt_get_bool(opts, "once", 0); 216 rule->options.inject.immediately = 217 qemu_opt_get_bool(opts, "immediately", 0); 218 sector = qemu_opt_get_number(opts, "sector", -1); 219 rule->options.inject.offset = 220 sector == -1 ? -1 : sector * BDRV_SECTOR_SIZE; 221 222 iotype = qapi_enum_parse(&BlkdebugIOType_lookup, 223 qemu_opt_get(opts, "iotype"), 224 BLKDEBUG_IO_TYPE__MAX, &local_error); 225 if (local_error) { 226 error_propagate(errp, local_error); 227 g_free(rule); 228 return -1; 229 } 230 if (iotype != BLKDEBUG_IO_TYPE__MAX) { 231 rule->options.inject.iotype_mask = (1ull << iotype); 232 } else { 233 /* Apply the default */ 234 rule->options.inject.iotype_mask = 235 (1ull << BLKDEBUG_IO_TYPE_READ) 236 | (1ull << BLKDEBUG_IO_TYPE_WRITE) 237 | (1ull << BLKDEBUG_IO_TYPE_WRITE_ZEROES) 238 | (1ull << BLKDEBUG_IO_TYPE_DISCARD) 239 | (1ull << BLKDEBUG_IO_TYPE_FLUSH); 240 } 241 242 break; 243 244 case ACTION_SET_STATE: 245 rule->options.set_state.new_state = 246 qemu_opt_get_number(opts, "new_state", 0); 247 break; 248 249 case ACTION_SUSPEND: 250 rule->options.suspend.tag = 251 g_strdup(qemu_opt_get(opts, "tag")); 252 break; 253 }; 254 255 /* Add the rule */ 256 qemu_mutex_lock(&s->lock); 257 QLIST_INSERT_HEAD(&s->rules[event], rule, next); 258 qemu_mutex_unlock(&s->lock); 259 260 return 0; 261 } 262 263 /* Called with lock held or from .bdrv_close */ 264 static void remove_rule(BlkdebugRule *rule) 265 { 266 switch (rule->action) { 267 case ACTION_INJECT_ERROR: 268 case ACTION_SET_STATE: 269 break; 270 case ACTION_SUSPEND: 271 g_free(rule->options.suspend.tag); 272 break; 273 } 274 275 QLIST_REMOVE(rule, next); 276 g_free(rule); 277 } 278 279 static int read_config(BDRVBlkdebugState *s, const char *filename, 280 QDict *options, Error **errp) 281 { 282 FILE *f = NULL; 283 int ret; 284 struct add_rule_data d; 285 Error *local_err = NULL; 286 287 if (filename) { 288 f = fopen(filename, "r"); 289 if (f == NULL) { 290 error_setg_errno(errp, errno, "Could not read blkdebug config file"); 291 return -errno; 292 } 293 294 ret = qemu_config_parse(f, config_groups, filename, errp); 295 if (ret < 0) { 296 goto fail; 297 } 298 } 299 300 qemu_config_parse_qdict(options, config_groups, &local_err); 301 if (local_err) { 302 error_propagate(errp, local_err); 303 ret = -EINVAL; 304 goto fail; 305 } 306 307 d.s = s; 308 d.action = ACTION_INJECT_ERROR; 309 qemu_opts_foreach(&inject_error_opts, add_rule, &d, &local_err); 310 if (local_err) { 311 error_propagate(errp, local_err); 312 ret = -EINVAL; 313 goto fail; 314 } 315 316 d.action = ACTION_SET_STATE; 317 qemu_opts_foreach(&set_state_opts, add_rule, &d, &local_err); 318 if (local_err) { 319 error_propagate(errp, local_err); 320 ret = -EINVAL; 321 goto fail; 322 } 323 324 ret = 0; 325 fail: 326 qemu_opts_reset(&inject_error_opts); 327 qemu_opts_reset(&set_state_opts); 328 if (f) { 329 fclose(f); 330 } 331 return ret; 332 } 333 334 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */ 335 static void blkdebug_parse_filename(const char *filename, QDict *options, 336 Error **errp) 337 { 338 const char *c; 339 340 /* Parse the blkdebug: prefix */ 341 if (!strstart(filename, "blkdebug:", &filename)) { 342 /* There was no prefix; therefore, all options have to be already 343 present in the QDict (except for the filename) */ 344 qdict_put_str(options, "x-image", filename); 345 return; 346 } 347 348 /* Parse config file path */ 349 c = strchr(filename, ':'); 350 if (c == NULL) { 351 error_setg(errp, "blkdebug requires both config file and image path"); 352 return; 353 } 354 355 if (c != filename) { 356 QString *config_path; 357 config_path = qstring_from_substr(filename, 0, c - filename); 358 qdict_put(options, "config", config_path); 359 } 360 361 /* TODO Allow multi-level nesting and set file.filename here */ 362 filename = c + 1; 363 qdict_put_str(options, "x-image", filename); 364 } 365 366 static int blkdebug_parse_perm_list(uint64_t *dest, QDict *options, 367 const char *prefix, Error **errp) 368 { 369 int ret = 0; 370 QDict *subqdict = NULL; 371 QObject *crumpled_subqdict = NULL; 372 Visitor *v = NULL; 373 BlockPermissionList *perm_list = NULL, *element; 374 375 *dest = 0; 376 377 qdict_extract_subqdict(options, &subqdict, prefix); 378 if (!qdict_size(subqdict)) { 379 goto out; 380 } 381 382 crumpled_subqdict = qdict_crumple(subqdict, errp); 383 if (!crumpled_subqdict) { 384 ret = -EINVAL; 385 goto out; 386 } 387 388 v = qobject_input_visitor_new(crumpled_subqdict); 389 if (!visit_type_BlockPermissionList(v, NULL, &perm_list, errp)) { 390 ret = -EINVAL; 391 goto out; 392 } 393 394 for (element = perm_list; element; element = element->next) { 395 *dest |= bdrv_qapi_perm_to_blk_perm(element->value); 396 } 397 398 out: 399 qapi_free_BlockPermissionList(perm_list); 400 visit_free(v); 401 qobject_unref(subqdict); 402 qobject_unref(crumpled_subqdict); 403 return ret; 404 } 405 406 static int blkdebug_parse_perms(BDRVBlkdebugState *s, QDict *options, 407 Error **errp) 408 { 409 int ret; 410 411 ret = blkdebug_parse_perm_list(&s->take_child_perms, options, 412 "take-child-perms.", errp); 413 if (ret < 0) { 414 return ret; 415 } 416 417 ret = blkdebug_parse_perm_list(&s->unshare_child_perms, options, 418 "unshare-child-perms.", errp); 419 if (ret < 0) { 420 return ret; 421 } 422 423 return 0; 424 } 425 426 static QemuOptsList runtime_opts = { 427 .name = "blkdebug", 428 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 429 .desc = { 430 { 431 .name = "config", 432 .type = QEMU_OPT_STRING, 433 .help = "Path to the configuration file", 434 }, 435 { 436 .name = "x-image", 437 .type = QEMU_OPT_STRING, 438 .help = "[internal use only, will be removed]", 439 }, 440 { 441 .name = "align", 442 .type = QEMU_OPT_SIZE, 443 .help = "Required alignment in bytes", 444 }, 445 { 446 .name = "max-transfer", 447 .type = QEMU_OPT_SIZE, 448 .help = "Maximum transfer size in bytes", 449 }, 450 { 451 .name = "opt-write-zero", 452 .type = QEMU_OPT_SIZE, 453 .help = "Optimum write zero alignment in bytes", 454 }, 455 { 456 .name = "max-write-zero", 457 .type = QEMU_OPT_SIZE, 458 .help = "Maximum write zero size in bytes", 459 }, 460 { 461 .name = "opt-discard", 462 .type = QEMU_OPT_SIZE, 463 .help = "Optimum discard alignment in bytes", 464 }, 465 { 466 .name = "max-discard", 467 .type = QEMU_OPT_SIZE, 468 .help = "Maximum discard size in bytes", 469 }, 470 { /* end of list */ } 471 }, 472 }; 473 474 static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 475 Error **errp) 476 { 477 BDRVBlkdebugState *s = bs->opaque; 478 QemuOpts *opts; 479 int ret; 480 uint64_t align; 481 482 qemu_mutex_init(&s->lock); 483 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 484 if (!qemu_opts_absorb_qdict(opts, options, errp)) { 485 ret = -EINVAL; 486 goto out; 487 } 488 489 /* Read rules from config file or command line options */ 490 s->config_file = g_strdup(qemu_opt_get(opts, "config")); 491 ret = read_config(s, s->config_file, options, errp); 492 if (ret) { 493 goto out; 494 } 495 496 /* Set initial state */ 497 s->state = 1; 498 499 /* Parse permissions modifiers before opening the image file */ 500 ret = blkdebug_parse_perms(s, options, errp); 501 if (ret < 0) { 502 goto out; 503 } 504 505 /* Open the image file */ 506 ret = bdrv_open_file_child(qemu_opt_get(opts, "x-image"), options, "image", 507 bs, errp); 508 if (ret < 0) { 509 goto out; 510 } 511 512 bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED | 513 (BDRV_REQ_FUA & bs->file->bs->supported_write_flags); 514 bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED | 515 ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) & 516 bs->file->bs->supported_zero_flags); 517 ret = -EINVAL; 518 519 /* Set alignment overrides */ 520 s->align = qemu_opt_get_size(opts, "align", 0); 521 if (s->align && (s->align >= INT_MAX || !is_power_of_2(s->align))) { 522 error_setg(errp, "Cannot meet constraints with align %" PRIu64, 523 s->align); 524 goto out; 525 } 526 align = MAX(s->align, bs->file->bs->bl.request_alignment); 527 528 s->max_transfer = qemu_opt_get_size(opts, "max-transfer", 0); 529 if (s->max_transfer && 530 (s->max_transfer >= INT_MAX || 531 !QEMU_IS_ALIGNED(s->max_transfer, align))) { 532 error_setg(errp, "Cannot meet constraints with max-transfer %" PRIu64, 533 s->max_transfer); 534 goto out; 535 } 536 537 s->opt_write_zero = qemu_opt_get_size(opts, "opt-write-zero", 0); 538 if (s->opt_write_zero && 539 (s->opt_write_zero >= INT_MAX || 540 !QEMU_IS_ALIGNED(s->opt_write_zero, align))) { 541 error_setg(errp, "Cannot meet constraints with opt-write-zero %" PRIu64, 542 s->opt_write_zero); 543 goto out; 544 } 545 546 s->max_write_zero = qemu_opt_get_size(opts, "max-write-zero", 0); 547 if (s->max_write_zero && 548 (s->max_write_zero >= INT_MAX || 549 !QEMU_IS_ALIGNED(s->max_write_zero, 550 MAX(s->opt_write_zero, align)))) { 551 error_setg(errp, "Cannot meet constraints with max-write-zero %" PRIu64, 552 s->max_write_zero); 553 goto out; 554 } 555 556 s->opt_discard = qemu_opt_get_size(opts, "opt-discard", 0); 557 if (s->opt_discard && 558 (s->opt_discard >= INT_MAX || 559 !QEMU_IS_ALIGNED(s->opt_discard, align))) { 560 error_setg(errp, "Cannot meet constraints with opt-discard %" PRIu64, 561 s->opt_discard); 562 goto out; 563 } 564 565 s->max_discard = qemu_opt_get_size(opts, "max-discard", 0); 566 if (s->max_discard && 567 (s->max_discard >= INT_MAX || 568 !QEMU_IS_ALIGNED(s->max_discard, 569 MAX(s->opt_discard, align)))) { 570 error_setg(errp, "Cannot meet constraints with max-discard %" PRIu64, 571 s->max_discard); 572 goto out; 573 } 574 575 bdrv_debug_event(bs, BLKDBG_NONE); 576 577 ret = 0; 578 out: 579 if (ret < 0) { 580 qemu_mutex_destroy(&s->lock); 581 g_free(s->config_file); 582 } 583 qemu_opts_del(opts); 584 return ret; 585 } 586 587 static int rule_check(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 588 BlkdebugIOType iotype) 589 { 590 BDRVBlkdebugState *s = bs->opaque; 591 BlkdebugRule *rule = NULL; 592 int error; 593 bool immediately; 594 595 qemu_mutex_lock(&s->lock); 596 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { 597 uint64_t inject_offset = rule->options.inject.offset; 598 599 if ((inject_offset == -1 || 600 (bytes && inject_offset >= offset && 601 inject_offset < offset + bytes)) && 602 (rule->options.inject.iotype_mask & (1ull << iotype))) 603 { 604 break; 605 } 606 } 607 608 if (!rule || !rule->options.inject.error) { 609 qemu_mutex_unlock(&s->lock); 610 return 0; 611 } 612 613 immediately = rule->options.inject.immediately; 614 error = rule->options.inject.error; 615 616 if (rule->options.inject.once) { 617 QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next); 618 remove_rule(rule); 619 } 620 621 qemu_mutex_unlock(&s->lock); 622 if (!immediately) { 623 aio_co_schedule(qemu_get_current_aio_context(), qemu_coroutine_self()); 624 qemu_coroutine_yield(); 625 } 626 627 return -error; 628 } 629 630 static int coroutine_fn 631 blkdebug_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes, 632 QEMUIOVector *qiov, BdrvRequestFlags flags) 633 { 634 int err; 635 636 /* Sanity check block layer guarantees */ 637 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment)); 638 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment)); 639 if (bs->bl.max_transfer) { 640 assert(bytes <= bs->bl.max_transfer); 641 } 642 643 err = rule_check(bs, offset, bytes, BLKDEBUG_IO_TYPE_READ); 644 if (err) { 645 return err; 646 } 647 648 return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags); 649 } 650 651 static int coroutine_fn 652 blkdebug_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes, 653 QEMUIOVector *qiov, BdrvRequestFlags flags) 654 { 655 int err; 656 657 /* Sanity check block layer guarantees */ 658 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment)); 659 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment)); 660 if (bs->bl.max_transfer) { 661 assert(bytes <= bs->bl.max_transfer); 662 } 663 664 err = rule_check(bs, offset, bytes, BLKDEBUG_IO_TYPE_WRITE); 665 if (err) { 666 return err; 667 } 668 669 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); 670 } 671 672 static int coroutine_fn blkdebug_co_flush(BlockDriverState *bs) 673 { 674 int err = rule_check(bs, 0, 0, BLKDEBUG_IO_TYPE_FLUSH); 675 676 if (err) { 677 return err; 678 } 679 680 return bdrv_co_flush(bs->file->bs); 681 } 682 683 static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs, 684 int64_t offset, int64_t bytes, 685 BdrvRequestFlags flags) 686 { 687 uint32_t align = MAX(bs->bl.request_alignment, 688 bs->bl.pwrite_zeroes_alignment); 689 int err; 690 691 /* Only pass through requests that are larger than requested 692 * preferred alignment (so that we test the fallback to writes on 693 * unaligned portions), and check that the block layer never hands 694 * us anything unaligned that crosses an alignment boundary. */ 695 if (bytes < align) { 696 assert(QEMU_IS_ALIGNED(offset, align) || 697 QEMU_IS_ALIGNED(offset + bytes, align) || 698 DIV_ROUND_UP(offset, align) == 699 DIV_ROUND_UP(offset + bytes, align)); 700 return -ENOTSUP; 701 } 702 assert(QEMU_IS_ALIGNED(offset, align)); 703 assert(QEMU_IS_ALIGNED(bytes, align)); 704 if (bs->bl.max_pwrite_zeroes) { 705 assert(bytes <= bs->bl.max_pwrite_zeroes); 706 } 707 708 err = rule_check(bs, offset, bytes, BLKDEBUG_IO_TYPE_WRITE_ZEROES); 709 if (err) { 710 return err; 711 } 712 713 return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); 714 } 715 716 static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs, 717 int64_t offset, int64_t bytes) 718 { 719 uint32_t align = bs->bl.pdiscard_alignment; 720 int err; 721 722 /* Only pass through requests that are larger than requested 723 * minimum alignment, and ensure that unaligned requests do not 724 * cross optimum discard boundaries. */ 725 if (bytes < bs->bl.request_alignment) { 726 assert(QEMU_IS_ALIGNED(offset, align) || 727 QEMU_IS_ALIGNED(offset + bytes, align) || 728 DIV_ROUND_UP(offset, align) == 729 DIV_ROUND_UP(offset + bytes, align)); 730 return -ENOTSUP; 731 } 732 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment)); 733 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment)); 734 if (align && bytes >= align) { 735 assert(QEMU_IS_ALIGNED(offset, align)); 736 assert(QEMU_IS_ALIGNED(bytes, align)); 737 } 738 if (bs->bl.max_pdiscard) { 739 assert(bytes <= bs->bl.max_pdiscard); 740 } 741 742 err = rule_check(bs, offset, bytes, BLKDEBUG_IO_TYPE_DISCARD); 743 if (err) { 744 return err; 745 } 746 747 return bdrv_co_pdiscard(bs->file, offset, bytes); 748 } 749 750 static int coroutine_fn blkdebug_co_block_status(BlockDriverState *bs, 751 bool want_zero, 752 int64_t offset, 753 int64_t bytes, 754 int64_t *pnum, 755 int64_t *map, 756 BlockDriverState **file) 757 { 758 int err; 759 760 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment)); 761 762 err = rule_check(bs, offset, bytes, BLKDEBUG_IO_TYPE_BLOCK_STATUS); 763 if (err) { 764 return err; 765 } 766 767 assert(bs->file && bs->file->bs); 768 *pnum = bytes; 769 *map = offset; 770 *file = bs->file->bs; 771 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID; 772 } 773 774 static void blkdebug_close(BlockDriverState *bs) 775 { 776 BDRVBlkdebugState *s = bs->opaque; 777 BlkdebugRule *rule, *next; 778 int i; 779 780 for (i = 0; i < BLKDBG__MAX; i++) { 781 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { 782 remove_rule(rule); 783 } 784 } 785 786 g_free(s->config_file); 787 qemu_mutex_destroy(&s->lock); 788 } 789 790 /* Called with lock held. */ 791 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule) 792 { 793 BDRVBlkdebugState *s = bs->opaque; 794 BlkdebugSuspendedReq *r; 795 796 r = g_new(BlkdebugSuspendedReq, 1); 797 798 r->co = qemu_coroutine_self(); 799 r->tag = g_strdup(rule->options.suspend.tag); 800 801 remove_rule(rule); 802 QLIST_INSERT_HEAD(&s->suspended_reqs, r, next); 803 804 if (!qtest_enabled()) { 805 printf("blkdebug: Suspended request '%s'\n", r->tag); 806 } 807 } 808 809 /* Called with lock held. */ 810 static void process_rule(BlockDriverState *bs, struct BlkdebugRule *rule, 811 int *action_count, int *new_state) 812 { 813 BDRVBlkdebugState *s = bs->opaque; 814 815 /* Only process rules for the current state */ 816 if (rule->state && rule->state != s->state) { 817 return; 818 } 819 820 /* Take the action */ 821 action_count[rule->action]++; 822 switch (rule->action) { 823 case ACTION_INJECT_ERROR: 824 if (action_count[ACTION_INJECT_ERROR] == 1) { 825 QSIMPLEQ_INIT(&s->active_rules); 826 } 827 QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next); 828 break; 829 830 case ACTION_SET_STATE: 831 *new_state = rule->options.set_state.new_state; 832 break; 833 834 case ACTION_SUSPEND: 835 suspend_request(bs, rule); 836 break; 837 } 838 } 839 840 static void blkdebug_debug_event(BlockDriverState *bs, BlkdebugEvent event) 841 { 842 BDRVBlkdebugState *s = bs->opaque; 843 struct BlkdebugRule *rule, *next; 844 int new_state; 845 int actions_count[ACTION__MAX] = { 0 }; 846 847 assert((int)event >= 0 && event < BLKDBG__MAX); 848 849 WITH_QEMU_LOCK_GUARD(&s->lock) { 850 new_state = s->state; 851 QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) { 852 process_rule(bs, rule, actions_count, &new_state); 853 } 854 s->state = new_state; 855 } 856 857 while (actions_count[ACTION_SUSPEND] > 0) { 858 qemu_coroutine_yield(); 859 actions_count[ACTION_SUSPEND]--; 860 } 861 } 862 863 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event, 864 const char *tag) 865 { 866 BDRVBlkdebugState *s = bs->opaque; 867 struct BlkdebugRule *rule; 868 int blkdebug_event; 869 870 blkdebug_event = qapi_enum_parse(&BlkdebugEvent_lookup, event, -1, NULL); 871 if (blkdebug_event < 0) { 872 return -ENOENT; 873 } 874 875 rule = g_malloc(sizeof(*rule)); 876 *rule = (struct BlkdebugRule) { 877 .event = blkdebug_event, 878 .action = ACTION_SUSPEND, 879 .state = 0, 880 .options.suspend.tag = g_strdup(tag), 881 }; 882 883 qemu_mutex_lock(&s->lock); 884 QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next); 885 qemu_mutex_unlock(&s->lock); 886 887 return 0; 888 } 889 890 /* Called with lock held. May temporarily release lock. */ 891 static int resume_req_by_tag(BDRVBlkdebugState *s, const char *tag, bool all) 892 { 893 BlkdebugSuspendedReq *r; 894 895 retry: 896 /* 897 * No need for _SAFE, since a different coroutine can remove another node 898 * (not the current one) in this list, and when the current one is removed 899 * the iteration starts back from beginning anyways. 900 */ 901 QLIST_FOREACH(r, &s->suspended_reqs, next) { 902 if (!strcmp(r->tag, tag)) { 903 Coroutine *co = r->co; 904 905 if (!qtest_enabled()) { 906 printf("blkdebug: Resuming request '%s'\n", r->tag); 907 } 908 909 QLIST_REMOVE(r, next); 910 g_free(r->tag); 911 g_free(r); 912 913 qemu_mutex_unlock(&s->lock); 914 qemu_coroutine_enter(co); 915 qemu_mutex_lock(&s->lock); 916 917 if (all) { 918 goto retry; 919 } 920 return 0; 921 } 922 } 923 return -ENOENT; 924 } 925 926 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag) 927 { 928 BDRVBlkdebugState *s = bs->opaque; 929 QEMU_LOCK_GUARD(&s->lock); 930 return resume_req_by_tag(s, tag, false); 931 } 932 933 static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs, 934 const char *tag) 935 { 936 BDRVBlkdebugState *s = bs->opaque; 937 BlkdebugRule *rule, *next; 938 int i, ret = -ENOENT; 939 940 QEMU_LOCK_GUARD(&s->lock); 941 for (i = 0; i < BLKDBG__MAX; i++) { 942 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { 943 if (rule->action == ACTION_SUSPEND && 944 !strcmp(rule->options.suspend.tag, tag)) { 945 remove_rule(rule); 946 ret = 0; 947 } 948 } 949 } 950 if (resume_req_by_tag(s, tag, true) == 0) { 951 ret = 0; 952 } 953 return ret; 954 } 955 956 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag) 957 { 958 BDRVBlkdebugState *s = bs->opaque; 959 BlkdebugSuspendedReq *r; 960 961 QEMU_LOCK_GUARD(&s->lock); 962 QLIST_FOREACH(r, &s->suspended_reqs, next) { 963 if (!strcmp(r->tag, tag)) { 964 return true; 965 } 966 } 967 return false; 968 } 969 970 static int64_t blkdebug_getlength(BlockDriverState *bs) 971 { 972 return bdrv_getlength(bs->file->bs); 973 } 974 975 static void blkdebug_refresh_filename(BlockDriverState *bs) 976 { 977 BDRVBlkdebugState *s = bs->opaque; 978 const QDictEntry *e; 979 int ret; 980 981 if (!bs->file->bs->exact_filename[0]) { 982 return; 983 } 984 985 for (e = qdict_first(bs->full_open_options); e; 986 e = qdict_next(bs->full_open_options, e)) 987 { 988 /* Real child options are under "image", but "x-image" may 989 * contain a filename */ 990 if (strcmp(qdict_entry_key(e), "config") && 991 strcmp(qdict_entry_key(e), "image") && 992 strcmp(qdict_entry_key(e), "x-image") && 993 strcmp(qdict_entry_key(e), "driver")) 994 { 995 return; 996 } 997 } 998 999 ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename), 1000 "blkdebug:%s:%s", 1001 s->config_file ?: "", bs->file->bs->exact_filename); 1002 if (ret >= sizeof(bs->exact_filename)) { 1003 /* An overflow makes the filename unusable, so do not report any */ 1004 bs->exact_filename[0] = 0; 1005 } 1006 } 1007 1008 static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp) 1009 { 1010 BDRVBlkdebugState *s = bs->opaque; 1011 1012 if (s->align) { 1013 bs->bl.request_alignment = s->align; 1014 } 1015 if (s->max_transfer) { 1016 bs->bl.max_transfer = s->max_transfer; 1017 } 1018 if (s->opt_write_zero) { 1019 bs->bl.pwrite_zeroes_alignment = s->opt_write_zero; 1020 } 1021 if (s->max_write_zero) { 1022 bs->bl.max_pwrite_zeroes = s->max_write_zero; 1023 } 1024 if (s->opt_discard) { 1025 bs->bl.pdiscard_alignment = s->opt_discard; 1026 } 1027 if (s->max_discard) { 1028 bs->bl.max_pdiscard = s->max_discard; 1029 } 1030 } 1031 1032 static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state, 1033 BlockReopenQueue *queue, Error **errp) 1034 { 1035 return 0; 1036 } 1037 1038 static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c, 1039 BdrvChildRole role, 1040 BlockReopenQueue *reopen_queue, 1041 uint64_t perm, uint64_t shared, 1042 uint64_t *nperm, uint64_t *nshared) 1043 { 1044 BDRVBlkdebugState *s = bs->opaque; 1045 1046 bdrv_default_perms(bs, c, role, reopen_queue, 1047 perm, shared, nperm, nshared); 1048 1049 *nperm |= s->take_child_perms; 1050 *nshared &= ~s->unshare_child_perms; 1051 } 1052 1053 static const char *const blkdebug_strong_runtime_opts[] = { 1054 "config", 1055 "inject-error.", 1056 "set-state.", 1057 "align", 1058 "max-transfer", 1059 "opt-write-zero", 1060 "max-write-zero", 1061 "opt-discard", 1062 "max-discard", 1063 1064 NULL 1065 }; 1066 1067 static BlockDriver bdrv_blkdebug = { 1068 .format_name = "blkdebug", 1069 .protocol_name = "blkdebug", 1070 .instance_size = sizeof(BDRVBlkdebugState), 1071 .is_filter = true, 1072 1073 .bdrv_parse_filename = blkdebug_parse_filename, 1074 .bdrv_file_open = blkdebug_open, 1075 .bdrv_close = blkdebug_close, 1076 .bdrv_reopen_prepare = blkdebug_reopen_prepare, 1077 .bdrv_child_perm = blkdebug_child_perm, 1078 1079 .bdrv_getlength = blkdebug_getlength, 1080 .bdrv_refresh_filename = blkdebug_refresh_filename, 1081 .bdrv_refresh_limits = blkdebug_refresh_limits, 1082 1083 .bdrv_co_preadv = blkdebug_co_preadv, 1084 .bdrv_co_pwritev = blkdebug_co_pwritev, 1085 .bdrv_co_flush_to_disk = blkdebug_co_flush, 1086 .bdrv_co_pwrite_zeroes = blkdebug_co_pwrite_zeroes, 1087 .bdrv_co_pdiscard = blkdebug_co_pdiscard, 1088 .bdrv_co_block_status = blkdebug_co_block_status, 1089 1090 .bdrv_debug_event = blkdebug_debug_event, 1091 .bdrv_debug_breakpoint = blkdebug_debug_breakpoint, 1092 .bdrv_debug_remove_breakpoint 1093 = blkdebug_debug_remove_breakpoint, 1094 .bdrv_debug_resume = blkdebug_debug_resume, 1095 .bdrv_debug_is_suspended = blkdebug_debug_is_suspended, 1096 1097 .strong_runtime_opts = blkdebug_strong_runtime_opts, 1098 }; 1099 1100 static void bdrv_blkdebug_init(void) 1101 { 1102 bdrv_register(&bdrv_blkdebug); 1103 } 1104 1105 block_init(bdrv_blkdebug_init); 1106