1 /* 2 * Block protocol for I/O error injection 3 * 4 * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 25 #include "qemu/osdep.h" 26 #include "qapi/error.h" 27 #include "qemu/cutils.h" 28 #include "qemu/config-file.h" 29 #include "block/block_int.h" 30 #include "qemu/module.h" 31 #include "qapi/qmp/qbool.h" 32 #include "qapi/qmp/qdict.h" 33 #include "qapi/qmp/qint.h" 34 #include "qapi/qmp/qstring.h" 35 #include "sysemu/qtest.h" 36 37 typedef struct BDRVBlkdebugState { 38 int state; 39 int new_state; 40 int align; 41 42 QLIST_HEAD(, BlkdebugRule) rules[BLKDBG__MAX]; 43 QSIMPLEQ_HEAD(, BlkdebugRule) active_rules; 44 QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs; 45 } BDRVBlkdebugState; 46 47 typedef struct BlkdebugAIOCB { 48 BlockAIOCB common; 49 QEMUBH *bh; 50 int ret; 51 } BlkdebugAIOCB; 52 53 typedef struct BlkdebugSuspendedReq { 54 Coroutine *co; 55 char *tag; 56 QLIST_ENTRY(BlkdebugSuspendedReq) next; 57 } BlkdebugSuspendedReq; 58 59 static const AIOCBInfo blkdebug_aiocb_info = { 60 .aiocb_size = sizeof(BlkdebugAIOCB), 61 }; 62 63 enum { 64 ACTION_INJECT_ERROR, 65 ACTION_SET_STATE, 66 ACTION_SUSPEND, 67 }; 68 69 typedef struct BlkdebugRule { 70 BlkdebugEvent event; 71 int action; 72 int state; 73 union { 74 struct { 75 int error; 76 int immediately; 77 int once; 78 int64_t sector; 79 } inject; 80 struct { 81 int new_state; 82 } set_state; 83 struct { 84 char *tag; 85 } suspend; 86 } options; 87 QLIST_ENTRY(BlkdebugRule) next; 88 QSIMPLEQ_ENTRY(BlkdebugRule) active_next; 89 } BlkdebugRule; 90 91 static QemuOptsList inject_error_opts = { 92 .name = "inject-error", 93 .head = QTAILQ_HEAD_INITIALIZER(inject_error_opts.head), 94 .desc = { 95 { 96 .name = "event", 97 .type = QEMU_OPT_STRING, 98 }, 99 { 100 .name = "state", 101 .type = QEMU_OPT_NUMBER, 102 }, 103 { 104 .name = "errno", 105 .type = QEMU_OPT_NUMBER, 106 }, 107 { 108 .name = "sector", 109 .type = QEMU_OPT_NUMBER, 110 }, 111 { 112 .name = "once", 113 .type = QEMU_OPT_BOOL, 114 }, 115 { 116 .name = "immediately", 117 .type = QEMU_OPT_BOOL, 118 }, 119 { /* end of list */ } 120 }, 121 }; 122 123 static QemuOptsList set_state_opts = { 124 .name = "set-state", 125 .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head), 126 .desc = { 127 { 128 .name = "event", 129 .type = QEMU_OPT_STRING, 130 }, 131 { 132 .name = "state", 133 .type = QEMU_OPT_NUMBER, 134 }, 135 { 136 .name = "new_state", 137 .type = QEMU_OPT_NUMBER, 138 }, 139 { /* end of list */ } 140 }, 141 }; 142 143 static QemuOptsList *config_groups[] = { 144 &inject_error_opts, 145 &set_state_opts, 146 NULL 147 }; 148 149 static int get_event_by_name(const char *name, BlkdebugEvent *event) 150 { 151 int i; 152 153 for (i = 0; i < BLKDBG__MAX; i++) { 154 if (!strcmp(BlkdebugEvent_lookup[i], name)) { 155 *event = i; 156 return 0; 157 } 158 } 159 160 return -1; 161 } 162 163 struct add_rule_data { 164 BDRVBlkdebugState *s; 165 int action; 166 }; 167 168 static int add_rule(void *opaque, QemuOpts *opts, Error **errp) 169 { 170 struct add_rule_data *d = opaque; 171 BDRVBlkdebugState *s = d->s; 172 const char* event_name; 173 BlkdebugEvent event; 174 struct BlkdebugRule *rule; 175 176 /* Find the right event for the rule */ 177 event_name = qemu_opt_get(opts, "event"); 178 if (!event_name) { 179 error_setg(errp, "Missing event name for rule"); 180 return -1; 181 } else if (get_event_by_name(event_name, &event) < 0) { 182 error_setg(errp, "Invalid event name \"%s\"", event_name); 183 return -1; 184 } 185 186 /* Set attributes common for all actions */ 187 rule = g_malloc0(sizeof(*rule)); 188 *rule = (struct BlkdebugRule) { 189 .event = event, 190 .action = d->action, 191 .state = qemu_opt_get_number(opts, "state", 0), 192 }; 193 194 /* Parse action-specific options */ 195 switch (d->action) { 196 case ACTION_INJECT_ERROR: 197 rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO); 198 rule->options.inject.once = qemu_opt_get_bool(opts, "once", 0); 199 rule->options.inject.immediately = 200 qemu_opt_get_bool(opts, "immediately", 0); 201 rule->options.inject.sector = qemu_opt_get_number(opts, "sector", -1); 202 break; 203 204 case ACTION_SET_STATE: 205 rule->options.set_state.new_state = 206 qemu_opt_get_number(opts, "new_state", 0); 207 break; 208 209 case ACTION_SUSPEND: 210 rule->options.suspend.tag = 211 g_strdup(qemu_opt_get(opts, "tag")); 212 break; 213 }; 214 215 /* Add the rule */ 216 QLIST_INSERT_HEAD(&s->rules[event], rule, next); 217 218 return 0; 219 } 220 221 static void remove_rule(BlkdebugRule *rule) 222 { 223 switch (rule->action) { 224 case ACTION_INJECT_ERROR: 225 case ACTION_SET_STATE: 226 break; 227 case ACTION_SUSPEND: 228 g_free(rule->options.suspend.tag); 229 break; 230 } 231 232 QLIST_REMOVE(rule, next); 233 g_free(rule); 234 } 235 236 static int read_config(BDRVBlkdebugState *s, const char *filename, 237 QDict *options, Error **errp) 238 { 239 FILE *f = NULL; 240 int ret; 241 struct add_rule_data d; 242 Error *local_err = NULL; 243 244 if (filename) { 245 f = fopen(filename, "r"); 246 if (f == NULL) { 247 error_setg_errno(errp, errno, "Could not read blkdebug config file"); 248 return -errno; 249 } 250 251 ret = qemu_config_parse(f, config_groups, filename); 252 if (ret < 0) { 253 error_setg(errp, "Could not parse blkdebug config file"); 254 ret = -EINVAL; 255 goto fail; 256 } 257 } 258 259 qemu_config_parse_qdict(options, config_groups, &local_err); 260 if (local_err) { 261 error_propagate(errp, local_err); 262 ret = -EINVAL; 263 goto fail; 264 } 265 266 d.s = s; 267 d.action = ACTION_INJECT_ERROR; 268 qemu_opts_foreach(&inject_error_opts, add_rule, &d, &local_err); 269 if (local_err) { 270 error_propagate(errp, local_err); 271 ret = -EINVAL; 272 goto fail; 273 } 274 275 d.action = ACTION_SET_STATE; 276 qemu_opts_foreach(&set_state_opts, add_rule, &d, &local_err); 277 if (local_err) { 278 error_propagate(errp, local_err); 279 ret = -EINVAL; 280 goto fail; 281 } 282 283 ret = 0; 284 fail: 285 qemu_opts_reset(&inject_error_opts); 286 qemu_opts_reset(&set_state_opts); 287 if (f) { 288 fclose(f); 289 } 290 return ret; 291 } 292 293 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */ 294 static void blkdebug_parse_filename(const char *filename, QDict *options, 295 Error **errp) 296 { 297 const char *c; 298 299 /* Parse the blkdebug: prefix */ 300 if (!strstart(filename, "blkdebug:", &filename)) { 301 /* There was no prefix; therefore, all options have to be already 302 present in the QDict (except for the filename) */ 303 qdict_put(options, "x-image", qstring_from_str(filename)); 304 return; 305 } 306 307 /* Parse config file path */ 308 c = strchr(filename, ':'); 309 if (c == NULL) { 310 error_setg(errp, "blkdebug requires both config file and image path"); 311 return; 312 } 313 314 if (c != filename) { 315 QString *config_path; 316 config_path = qstring_from_substr(filename, 0, c - filename - 1); 317 qdict_put(options, "config", config_path); 318 } 319 320 /* TODO Allow multi-level nesting and set file.filename here */ 321 filename = c + 1; 322 qdict_put(options, "x-image", qstring_from_str(filename)); 323 } 324 325 static QemuOptsList runtime_opts = { 326 .name = "blkdebug", 327 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 328 .desc = { 329 { 330 .name = "config", 331 .type = QEMU_OPT_STRING, 332 .help = "Path to the configuration file", 333 }, 334 { 335 .name = "x-image", 336 .type = QEMU_OPT_STRING, 337 .help = "[internal use only, will be removed]", 338 }, 339 { 340 .name = "align", 341 .type = QEMU_OPT_SIZE, 342 .help = "Required alignment in bytes", 343 }, 344 { /* end of list */ } 345 }, 346 }; 347 348 static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 349 Error **errp) 350 { 351 BDRVBlkdebugState *s = bs->opaque; 352 QemuOpts *opts; 353 Error *local_err = NULL; 354 const char *config; 355 uint64_t align; 356 int ret; 357 358 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 359 qemu_opts_absorb_qdict(opts, options, &local_err); 360 if (local_err) { 361 error_propagate(errp, local_err); 362 ret = -EINVAL; 363 goto out; 364 } 365 366 /* Read rules from config file or command line options */ 367 config = qemu_opt_get(opts, "config"); 368 ret = read_config(s, config, options, errp); 369 if (ret) { 370 goto out; 371 } 372 373 /* Set initial state */ 374 s->state = 1; 375 376 /* Open the image file */ 377 bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image", 378 bs, &child_file, false, &local_err); 379 if (local_err) { 380 ret = -EINVAL; 381 error_propagate(errp, local_err); 382 goto out; 383 } 384 385 /* Set request alignment */ 386 align = qemu_opt_get_size(opts, "align", 0); 387 if (align < INT_MAX && is_power_of_2(align)) { 388 s->align = align; 389 } else if (align) { 390 error_setg(errp, "Invalid alignment"); 391 ret = -EINVAL; 392 goto fail_unref; 393 } 394 395 ret = 0; 396 goto out; 397 398 fail_unref: 399 bdrv_unref_child(bs, bs->file); 400 out: 401 qemu_opts_del(opts); 402 return ret; 403 } 404 405 static void error_callback_bh(void *opaque) 406 { 407 struct BlkdebugAIOCB *acb = opaque; 408 qemu_bh_delete(acb->bh); 409 acb->common.cb(acb->common.opaque, acb->ret); 410 qemu_aio_unref(acb); 411 } 412 413 static BlockAIOCB *inject_error(BlockDriverState *bs, 414 BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule) 415 { 416 BDRVBlkdebugState *s = bs->opaque; 417 int error = rule->options.inject.error; 418 struct BlkdebugAIOCB *acb; 419 QEMUBH *bh; 420 bool immediately = rule->options.inject.immediately; 421 422 if (rule->options.inject.once) { 423 QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next); 424 remove_rule(rule); 425 } 426 427 if (immediately) { 428 return NULL; 429 } 430 431 acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque); 432 acb->ret = -error; 433 434 bh = aio_bh_new(bdrv_get_aio_context(bs), error_callback_bh, acb); 435 acb->bh = bh; 436 qemu_bh_schedule(bh); 437 438 return &acb->common; 439 } 440 441 static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs, 442 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 443 BlockCompletionFunc *cb, void *opaque) 444 { 445 BDRVBlkdebugState *s = bs->opaque; 446 BlkdebugRule *rule = NULL; 447 448 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { 449 if (rule->options.inject.sector == -1 || 450 (rule->options.inject.sector >= sector_num && 451 rule->options.inject.sector < sector_num + nb_sectors)) { 452 break; 453 } 454 } 455 456 if (rule && rule->options.inject.error) { 457 return inject_error(bs, cb, opaque, rule); 458 } 459 460 return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, 461 cb, opaque); 462 } 463 464 static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs, 465 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 466 BlockCompletionFunc *cb, void *opaque) 467 { 468 BDRVBlkdebugState *s = bs->opaque; 469 BlkdebugRule *rule = NULL; 470 471 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { 472 if (rule->options.inject.sector == -1 || 473 (rule->options.inject.sector >= sector_num && 474 rule->options.inject.sector < sector_num + nb_sectors)) { 475 break; 476 } 477 } 478 479 if (rule && rule->options.inject.error) { 480 return inject_error(bs, cb, opaque, rule); 481 } 482 483 return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, 484 cb, opaque); 485 } 486 487 static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs, 488 BlockCompletionFunc *cb, void *opaque) 489 { 490 BDRVBlkdebugState *s = bs->opaque; 491 BlkdebugRule *rule = NULL; 492 493 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { 494 if (rule->options.inject.sector == -1) { 495 break; 496 } 497 } 498 499 if (rule && rule->options.inject.error) { 500 return inject_error(bs, cb, opaque, rule); 501 } 502 503 return bdrv_aio_flush(bs->file->bs, cb, opaque); 504 } 505 506 507 static void blkdebug_close(BlockDriverState *bs) 508 { 509 BDRVBlkdebugState *s = bs->opaque; 510 BlkdebugRule *rule, *next; 511 int i; 512 513 for (i = 0; i < BLKDBG__MAX; i++) { 514 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { 515 remove_rule(rule); 516 } 517 } 518 } 519 520 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule) 521 { 522 BDRVBlkdebugState *s = bs->opaque; 523 BlkdebugSuspendedReq r; 524 525 r = (BlkdebugSuspendedReq) { 526 .co = qemu_coroutine_self(), 527 .tag = g_strdup(rule->options.suspend.tag), 528 }; 529 530 remove_rule(rule); 531 QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next); 532 533 if (!qtest_enabled()) { 534 printf("blkdebug: Suspended request '%s'\n", r.tag); 535 } 536 qemu_coroutine_yield(); 537 if (!qtest_enabled()) { 538 printf("blkdebug: Resuming request '%s'\n", r.tag); 539 } 540 541 QLIST_REMOVE(&r, next); 542 g_free(r.tag); 543 } 544 545 static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule, 546 bool injected) 547 { 548 BDRVBlkdebugState *s = bs->opaque; 549 550 /* Only process rules for the current state */ 551 if (rule->state && rule->state != s->state) { 552 return injected; 553 } 554 555 /* Take the action */ 556 switch (rule->action) { 557 case ACTION_INJECT_ERROR: 558 if (!injected) { 559 QSIMPLEQ_INIT(&s->active_rules); 560 injected = true; 561 } 562 QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next); 563 break; 564 565 case ACTION_SET_STATE: 566 s->new_state = rule->options.set_state.new_state; 567 break; 568 569 case ACTION_SUSPEND: 570 suspend_request(bs, rule); 571 break; 572 } 573 return injected; 574 } 575 576 static void blkdebug_debug_event(BlockDriverState *bs, BlkdebugEvent event) 577 { 578 BDRVBlkdebugState *s = bs->opaque; 579 struct BlkdebugRule *rule, *next; 580 bool injected; 581 582 assert((int)event >= 0 && event < BLKDBG__MAX); 583 584 injected = false; 585 s->new_state = s->state; 586 QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) { 587 injected = process_rule(bs, rule, injected); 588 } 589 s->state = s->new_state; 590 } 591 592 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event, 593 const char *tag) 594 { 595 BDRVBlkdebugState *s = bs->opaque; 596 struct BlkdebugRule *rule; 597 BlkdebugEvent blkdebug_event; 598 599 if (get_event_by_name(event, &blkdebug_event) < 0) { 600 return -ENOENT; 601 } 602 603 604 rule = g_malloc(sizeof(*rule)); 605 *rule = (struct BlkdebugRule) { 606 .event = blkdebug_event, 607 .action = ACTION_SUSPEND, 608 .state = 0, 609 .options.suspend.tag = g_strdup(tag), 610 }; 611 612 QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next); 613 614 return 0; 615 } 616 617 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag) 618 { 619 BDRVBlkdebugState *s = bs->opaque; 620 BlkdebugSuspendedReq *r, *next; 621 622 QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, next) { 623 if (!strcmp(r->tag, tag)) { 624 qemu_coroutine_enter(r->co); 625 return 0; 626 } 627 } 628 return -ENOENT; 629 } 630 631 static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs, 632 const char *tag) 633 { 634 BDRVBlkdebugState *s = bs->opaque; 635 BlkdebugSuspendedReq *r, *r_next; 636 BlkdebugRule *rule, *next; 637 int i, ret = -ENOENT; 638 639 for (i = 0; i < BLKDBG__MAX; i++) { 640 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { 641 if (rule->action == ACTION_SUSPEND && 642 !strcmp(rule->options.suspend.tag, tag)) { 643 remove_rule(rule); 644 ret = 0; 645 } 646 } 647 } 648 QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, r_next) { 649 if (!strcmp(r->tag, tag)) { 650 qemu_coroutine_enter(r->co); 651 ret = 0; 652 } 653 } 654 return ret; 655 } 656 657 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag) 658 { 659 BDRVBlkdebugState *s = bs->opaque; 660 BlkdebugSuspendedReq *r; 661 662 QLIST_FOREACH(r, &s->suspended_reqs, next) { 663 if (!strcmp(r->tag, tag)) { 664 return true; 665 } 666 } 667 return false; 668 } 669 670 static int64_t blkdebug_getlength(BlockDriverState *bs) 671 { 672 return bdrv_getlength(bs->file->bs); 673 } 674 675 static int blkdebug_truncate(BlockDriverState *bs, int64_t offset) 676 { 677 return bdrv_truncate(bs->file->bs, offset); 678 } 679 680 static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options) 681 { 682 QDict *opts; 683 const QDictEntry *e; 684 bool force_json = false; 685 686 for (e = qdict_first(options); e; e = qdict_next(options, e)) { 687 if (strcmp(qdict_entry_key(e), "config") && 688 strcmp(qdict_entry_key(e), "x-image")) 689 { 690 force_json = true; 691 break; 692 } 693 } 694 695 if (force_json && !bs->file->bs->full_open_options) { 696 /* The config file cannot be recreated, so creating a plain filename 697 * is impossible */ 698 return; 699 } 700 701 if (!force_json && bs->file->bs->exact_filename[0]) { 702 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 703 "blkdebug:%s:%s", 704 qdict_get_try_str(options, "config") ?: "", 705 bs->file->bs->exact_filename); 706 } 707 708 opts = qdict_new(); 709 qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkdebug"))); 710 711 QINCREF(bs->file->bs->full_open_options); 712 qdict_put_obj(opts, "image", QOBJECT(bs->file->bs->full_open_options)); 713 714 for (e = qdict_first(options); e; e = qdict_next(options, e)) { 715 if (strcmp(qdict_entry_key(e), "x-image")) { 716 qobject_incref(qdict_entry_value(e)); 717 qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e)); 718 } 719 } 720 721 bs->full_open_options = opts; 722 } 723 724 static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp) 725 { 726 BDRVBlkdebugState *s = bs->opaque; 727 728 if (s->align) { 729 bs->bl.request_alignment = s->align; 730 } 731 } 732 733 static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state, 734 BlockReopenQueue *queue, Error **errp) 735 { 736 return 0; 737 } 738 739 static BlockDriver bdrv_blkdebug = { 740 .format_name = "blkdebug", 741 .protocol_name = "blkdebug", 742 .instance_size = sizeof(BDRVBlkdebugState), 743 744 .bdrv_parse_filename = blkdebug_parse_filename, 745 .bdrv_file_open = blkdebug_open, 746 .bdrv_close = blkdebug_close, 747 .bdrv_reopen_prepare = blkdebug_reopen_prepare, 748 .bdrv_getlength = blkdebug_getlength, 749 .bdrv_truncate = blkdebug_truncate, 750 .bdrv_refresh_filename = blkdebug_refresh_filename, 751 .bdrv_refresh_limits = blkdebug_refresh_limits, 752 753 .bdrv_aio_readv = blkdebug_aio_readv, 754 .bdrv_aio_writev = blkdebug_aio_writev, 755 .bdrv_aio_flush = blkdebug_aio_flush, 756 757 .bdrv_debug_event = blkdebug_debug_event, 758 .bdrv_debug_breakpoint = blkdebug_debug_breakpoint, 759 .bdrv_debug_remove_breakpoint 760 = blkdebug_debug_remove_breakpoint, 761 .bdrv_debug_resume = blkdebug_debug_resume, 762 .bdrv_debug_is_suspended = blkdebug_debug_is_suspended, 763 }; 764 765 static void bdrv_blkdebug_init(void) 766 { 767 bdrv_register(&bdrv_blkdebug); 768 } 769 770 block_init(bdrv_blkdebug_init); 771