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