block/blkdebug.c

   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     /* For blkdebug_refresh_filename() */
  43     char *config_file;
  44
  45     QLIST_HEAD(, BlkdebugRule) rules[BLKDBG__MAX];
  46     QSIMPLEQ_HEAD(, BlkdebugRule) active_rules;
  47     QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs;
  48 } BDRVBlkdebugState;
  49
  50 typedef struct BlkdebugAIOCB {
  51     BlockAIOCB common;
  52     int ret;
  53 } BlkdebugAIOCB;
  54
  55 typedef struct BlkdebugSuspendedReq {
  56     Coroutine *co;
  57     char *tag;
  58     QLIST_ENTRY(BlkdebugSuspendedReq) next;
  59 } BlkdebugSuspendedReq;
  60
  61 static const AIOCBInfo blkdebug_aiocb_info = {
  62     .aiocb_size    = sizeof(BlkdebugAIOCB),
  63 };
  64
  65 enum {
  66     ACTION_INJECT_ERROR,
  67     ACTION_SET_STATE,
  68     ACTION_SUSPEND,
  69 };
  70
  71 typedef struct BlkdebugRule {
  72     BlkdebugEvent event;
  73     int action;
  74     int state;
  75     union {
  76         struct {
  77             int error;
  78             int immediately;
  79             int once;
  80             int64_t sector;
  81         } inject;
  82         struct {
  83             int new_state;
  84         } set_state;
  85         struct {
  86             char *tag;
  87         } suspend;
  88     } options;
  89     QLIST_ENTRY(BlkdebugRule) next;
  90     QSIMPLEQ_ENTRY(BlkdebugRule) active_next;
  91 } BlkdebugRule;
  92
  93 static QemuOptsList inject_error_opts = {
  94     .name = "inject-error",
  95     .head = QTAILQ_HEAD_INITIALIZER(inject_error_opts.head),
  96     .desc = {
  97         {
  98             .name = "event",
  99             .type = QEMU_OPT_STRING,
 100         },
 101         {
 102             .name = "state",
 103             .type = QEMU_OPT_NUMBER,
 104         },
 105         {
 106             .name = "errno",
 107             .type = QEMU_OPT_NUMBER,
 108         },
 109         {
 110             .name = "sector",
 111             .type = QEMU_OPT_NUMBER,
 112         },
 113         {
 114             .name = "once",
 115             .type = QEMU_OPT_BOOL,
 116         },
 117         {
 118             .name = "immediately",
 119             .type = QEMU_OPT_BOOL,
 120         },
 121         { /* end of list */ }
 122     },
 123 };
 124
 125 static QemuOptsList set_state_opts = {
 126     .name = "set-state",
 127     .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head),
 128     .desc = {
 129         {
 130             .name = "event",
 131             .type = QEMU_OPT_STRING,
 132         },
 133         {
 134             .name = "state",
 135             .type = QEMU_OPT_NUMBER,
 136         },
 137         {
 138             .name = "new_state",
 139             .type = QEMU_OPT_NUMBER,
 140         },
 141         { /* end of list */ }
 142     },
 143 };
 144
 145 static QemuOptsList *config_groups[] = {
 146     &inject_error_opts,
 147     &set_state_opts,
 148     NULL
 149 };
 150
 151 static int get_event_by_name(const char *name, BlkdebugEvent *event)
 152 {
 153     int i;
 154
 155     for (i = 0; i < BLKDBG__MAX; i++) {
 156         if (!strcmp(BlkdebugEvent_lookup[i], name)) {
 157             *event = i;
 158             return 0;
 159         }
 160     }
 161
 162     return -1;
 163 }
 164
 165 struct add_rule_data {
 166     BDRVBlkdebugState *s;
 167     int action;
 168 };
 169
 170 static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
 171 {
 172     struct add_rule_data *d = opaque;
 173     BDRVBlkdebugState *s = d->s;
 174     const char* event_name;
 175     BlkdebugEvent event;
 176     struct BlkdebugRule *rule;
 177
 178     /* Find the right event for the rule */
 179     event_name = qemu_opt_get(opts, "event");
 180     if (!event_name) {
 181         error_setg(errp, "Missing event name for rule");
 182         return -1;
 183     } else if (get_event_by_name(event_name, &event) < 0) {
 184         error_setg(errp, "Invalid event name \"%s\"", event_name);
 185         return -1;
 186     }
 187
 188     /* Set attributes common for all actions */
 189     rule = g_malloc0(sizeof(*rule));
 190     *rule = (struct BlkdebugRule) {
 191         .event  = event,
 192         .action = d->action,
 193         .state  = qemu_opt_get_number(opts, "state", 0),
 194     };
 195
 196     /* Parse action-specific options */
 197     switch (d->action) {
 198     case ACTION_INJECT_ERROR:
 199         rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO);
 200         rule->options.inject.once  = qemu_opt_get_bool(opts, "once", 0);
 201         rule->options.inject.immediately =
 202             qemu_opt_get_bool(opts, "immediately", 0);
 203         rule->options.inject.sector = qemu_opt_get_number(opts, "sector", -1);
 204         break;
 205
 206     case ACTION_SET_STATE:
 207         rule->options.set_state.new_state =
 208             qemu_opt_get_number(opts, "new_state", 0);
 209         break;
 210
 211     case ACTION_SUSPEND:
 212         rule->options.suspend.tag =
 213             g_strdup(qemu_opt_get(opts, "tag"));
 214         break;
 215     };
 216
 217     /* Add the rule */
 218     QLIST_INSERT_HEAD(&s->rules[event], rule, next);
 219
 220     return 0;
 221 }
 222
 223 static void remove_rule(BlkdebugRule *rule)
 224 {
 225     switch (rule->action) {
 226     case ACTION_INJECT_ERROR:
 227     case ACTION_SET_STATE:
 228         break;
 229     case ACTION_SUSPEND:
 230         g_free(rule->options.suspend.tag);
 231         break;
 232     }
 233
 234     QLIST_REMOVE(rule, next);
 235     g_free(rule);
 236 }
 237
 238 static int read_config(BDRVBlkdebugState *s, const char *filename,
 239                        QDict *options, Error **errp)
 240 {
 241     FILE *f = NULL;
 242     int ret;
 243     struct add_rule_data d;
 244     Error *local_err = NULL;
 245
 246     if (filename) {
 247         f = fopen(filename, "r");
 248         if (f == NULL) {
 249             error_setg_errno(errp, errno, "Could not read blkdebug config file");
 250             return -errno;
 251         }
 252
 253         ret = qemu_config_parse(f, config_groups, filename);
 254         if (ret < 0) {
 255             error_setg(errp, "Could not parse blkdebug config file");
 256             ret = -EINVAL;
 257             goto fail;
 258         }
 259     }
 260
 261     qemu_config_parse_qdict(options, config_groups, &local_err);
 262     if (local_err) {
 263         error_propagate(errp, local_err);
 264         ret = -EINVAL;
 265         goto fail;
 266     }
 267
 268     d.s = s;
 269     d.action = ACTION_INJECT_ERROR;
 270     qemu_opts_foreach(&inject_error_opts, add_rule, &d, &local_err);
 271     if (local_err) {
 272         error_propagate(errp, local_err);
 273         ret = -EINVAL;
 274         goto fail;
 275     }
 276
 277     d.action = ACTION_SET_STATE;
 278     qemu_opts_foreach(&set_state_opts, add_rule, &d, &local_err);
 279     if (local_err) {
 280         error_propagate(errp, local_err);
 281         ret = -EINVAL;
 282         goto fail;
 283     }
 284
 285     ret = 0;
 286 fail:
 287     qemu_opts_reset(&inject_error_opts);
 288     qemu_opts_reset(&set_state_opts);
 289     if (f) {
 290         fclose(f);
 291     }
 292     return ret;
 293 }
 294
 295 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */
 296 static void blkdebug_parse_filename(const char *filename, QDict *options,
 297                                     Error **errp)
 298 {
 299     const char *c;
 300
 301     /* Parse the blkdebug: prefix */
 302     if (!strstart(filename, "blkdebug:", &filename)) {
 303         /* There was no prefix; therefore, all options have to be already
 304            present in the QDict (except for the filename) */
 305         qdict_put(options, "x-image", qstring_from_str(filename));
 306         return;
 307     }
 308
 309     /* Parse config file path */
 310     c = strchr(filename, ':');
 311     if (c == NULL) {
 312         error_setg(errp, "blkdebug requires both config file and image path");
 313         return;
 314     }
 315
 316     if (c != filename) {
 317         QString *config_path;
 318         config_path = qstring_from_substr(filename, 0, c - filename - 1);
 319         qdict_put(options, "config", config_path);
 320     }
 321
 322     /* TODO Allow multi-level nesting and set file.filename here */
 323     filename = c + 1;
 324     qdict_put(options, "x-image", qstring_from_str(filename));
 325 }
 326
 327 static QemuOptsList runtime_opts = {
 328     .name = "blkdebug",
 329     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
 330     .desc = {
 331         {
 332             .name = "config",
 333             .type = QEMU_OPT_STRING,
 334             .help = "Path to the configuration file",
 335         },
 336         {
 337             .name = "x-image",
 338             .type = QEMU_OPT_STRING,
 339             .help = "[internal use only, will be removed]",
 340         },
 341         {
 342             .name = "align",
 343             .type = QEMU_OPT_SIZE,
 344             .help = "Required alignment in bytes",
 345         },
 346         { /* end of list */ }
 347     },
 348 };
 349
 350 static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
 351                          Error **errp)
 352 {
 353     BDRVBlkdebugState *s = bs->opaque;
 354     QemuOpts *opts;
 355     Error *local_err = NULL;
 356     uint64_t align;
 357     int ret;
 358
 359     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
 360     qemu_opts_absorb_qdict(opts, options, &local_err);
 361     if (local_err) {
 362         error_propagate(errp, local_err);
 363         ret = -EINVAL;
 364         goto out;
 365     }
 366
 367     /* Read rules from config file or command line options */
 368     s->config_file = g_strdup(qemu_opt_get(opts, "config"));
 369     ret = read_config(s, s->config_file, options, errp);
 370     if (ret) {
 371         goto out;
 372     }
 373
 374     /* Set initial state */
 375     s->state = 1;
 376
 377     /* Open the image file */
 378     bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",
 379                                bs, &child_file, false, &local_err);
 380     if (local_err) {
 381         ret = -EINVAL;
 382         error_propagate(errp, local_err);
 383         goto out;
 384     }
 385
 386     /* Set request alignment */
 387     align = qemu_opt_get_size(opts, "align", 0);
 388     if (align < INT_MAX && is_power_of_2(align)) {
 389         s->align = align;
 390     } else if (align) {
 391         error_setg(errp, "Invalid alignment");
 392         ret = -EINVAL;
 393         goto fail_unref;
 394     }
 395
 396     ret = 0;
 397     goto out;
 398
 399 fail_unref:
 400     bdrv_unref_child(bs, bs->file);
 401 out:
 402     if (ret < 0) {
 403         g_free(s->config_file);
 404     }
 405     qemu_opts_del(opts);
 406     return ret;
 407 }
 408
 409 static void error_callback_bh(void *opaque)
 410 {
 411     struct BlkdebugAIOCB *acb = opaque;
 412     acb->common.cb(acb->common.opaque, acb->ret);
 413     qemu_aio_unref(acb);
 414 }
 415
 416 static BlockAIOCB *inject_error(BlockDriverState *bs,
 417     BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule)
 418 {
 419     BDRVBlkdebugState *s = bs->opaque;
 420     int error = rule->options.inject.error;
 421     struct BlkdebugAIOCB *acb;
 422     bool immediately = rule->options.inject.immediately;
 423
 424     if (rule->options.inject.once) {
 425         QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next);
 426         remove_rule(rule);
 427     }
 428
 429     if (immediately) {
 430         return NULL;
 431     }
 432
 433     acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque);
 434     acb->ret = -error;
 435
 436     aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), error_callback_bh, acb);
 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     g_free(s->config_file);
 520 }
 521
 522 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule)
 523 {
 524     BDRVBlkdebugState *s = bs->opaque;
 525     BlkdebugSuspendedReq r;
 526
 527     r = (BlkdebugSuspendedReq) {
 528         .co         = qemu_coroutine_self(),
 529         .tag        = g_strdup(rule->options.suspend.tag),
 530     };
 531
 532     remove_rule(rule);
 533     QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next);
 534
 535     if (!qtest_enabled()) {
 536         printf("blkdebug: Suspended request '%s'\n", r.tag);
 537     }
 538     qemu_coroutine_yield();
 539     if (!qtest_enabled()) {
 540         printf("blkdebug: Resuming request '%s'\n", r.tag);
 541     }
 542
 543     QLIST_REMOVE(&r, next);
 544     g_free(r.tag);
 545 }
 546
 547 static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule,
 548     bool injected)
 549 {
 550     BDRVBlkdebugState *s = bs->opaque;
 551
 552     /* Only process rules for the current state */
 553     if (rule->state && rule->state != s->state) {
 554         return injected;
 555     }
 556
 557     /* Take the action */
 558     switch (rule->action) {
 559     case ACTION_INJECT_ERROR:
 560         if (!injected) {
 561             QSIMPLEQ_INIT(&s->active_rules);
 562             injected = true;
 563         }
 564         QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next);
 565         break;
 566
 567     case ACTION_SET_STATE:
 568         s->new_state = rule->options.set_state.new_state;
 569         break;
 570
 571     case ACTION_SUSPEND:
 572         suspend_request(bs, rule);
 573         break;
 574     }
 575     return injected;
 576 }
 577
 578 static void blkdebug_debug_event(BlockDriverState *bs, BlkdebugEvent event)
 579 {
 580     BDRVBlkdebugState *s = bs->opaque;
 581     struct BlkdebugRule *rule, *next;
 582     bool injected;
 583
 584     assert((int)event >= 0 && event < BLKDBG__MAX);
 585
 586     injected = false;
 587     s->new_state = s->state;
 588     QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) {
 589         injected = process_rule(bs, rule, injected);
 590     }
 591     s->state = s->new_state;
 592 }
 593
 594 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event,
 595                                      const char *tag)
 596 {
 597     BDRVBlkdebugState *s = bs->opaque;
 598     struct BlkdebugRule *rule;
 599     BlkdebugEvent blkdebug_event;
 600
 601     if (get_event_by_name(event, &blkdebug_event) < 0) {
 602         return -ENOENT;
 603     }
 604
 605
 606     rule = g_malloc(sizeof(*rule));
 607     *rule = (struct BlkdebugRule) {
 608         .event  = blkdebug_event,
 609         .action = ACTION_SUSPEND,
 610         .state  = 0,
 611         .options.suspend.tag = g_strdup(tag),
 612     };
 613
 614     QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next);
 615
 616     return 0;
 617 }
 618
 619 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag)
 620 {
 621     BDRVBlkdebugState *s = bs->opaque;
 622     BlkdebugSuspendedReq *r, *next;
 623
 624     QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, next) {
 625         if (!strcmp(r->tag, tag)) {
 626             qemu_coroutine_enter(r->co);
 627             return 0;
 628         }
 629     }
 630     return -ENOENT;
 631 }
 632
 633 static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs,
 634                                             const char *tag)
 635 {
 636     BDRVBlkdebugState *s = bs->opaque;
 637     BlkdebugSuspendedReq *r, *r_next;
 638     BlkdebugRule *rule, *next;
 639     int i, ret = -ENOENT;
 640
 641     for (i = 0; i < BLKDBG__MAX; i++) {
 642         QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
 643             if (rule->action == ACTION_SUSPEND &&
 644                 !strcmp(rule->options.suspend.tag, tag)) {
 645                 remove_rule(rule);
 646                 ret = 0;
 647             }
 648         }
 649     }
 650     QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, r_next) {
 651         if (!strcmp(r->tag, tag)) {
 652             qemu_coroutine_enter(r->co);
 653             ret = 0;
 654         }
 655     }
 656     return ret;
 657 }
 658
 659 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag)
 660 {
 661     BDRVBlkdebugState *s = bs->opaque;
 662     BlkdebugSuspendedReq *r;
 663
 664     QLIST_FOREACH(r, &s->suspended_reqs, next) {
 665         if (!strcmp(r->tag, tag)) {
 666             return true;
 667         }
 668     }
 669     return false;
 670 }
 671
 672 static int64_t blkdebug_getlength(BlockDriverState *bs)
 673 {
 674     return bdrv_getlength(bs->file->bs);
 675 }
 676
 677 static int blkdebug_truncate(BlockDriverState *bs, int64_t offset)
 678 {
 679     return bdrv_truncate(bs->file->bs, offset);
 680 }
 681
 682 static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
 683 {
 684     BDRVBlkdebugState *s = bs->opaque;
 685     QDict *opts;
 686     const QDictEntry *e;
 687     bool force_json = false;
 688
 689     for (e = qdict_first(options); e; e = qdict_next(options, e)) {
 690         if (strcmp(qdict_entry_key(e), "config") &&
 691             strcmp(qdict_entry_key(e), "x-image"))
 692         {
 693             force_json = true;
 694             break;
 695         }
 696     }
 697
 698     if (force_json && !bs->file->bs->full_open_options) {
 699         /* The config file cannot be recreated, so creating a plain filename
 700          * is impossible */
 701         return;
 702     }
 703
 704     if (!force_json && bs->file->bs->exact_filename[0]) {
 705         snprintf(bs->exact_filename, sizeof(bs->exact_filename),
 706                  "blkdebug:%s:%s", s->config_file ?: "",
 707                  bs->file->bs->exact_filename);
 708     }
 709
 710     opts = qdict_new();
 711     qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkdebug")));
 712
 713     QINCREF(bs->file->bs->full_open_options);
 714     qdict_put_obj(opts, "image", QOBJECT(bs->file->bs->full_open_options));
 715
 716     for (e = qdict_first(options); e; e = qdict_next(options, e)) {
 717         if (strcmp(qdict_entry_key(e), "x-image")) {
 718             qobject_incref(qdict_entry_value(e));
 719             qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e));
 720         }
 721     }
 722
 723     bs->full_open_options = opts;
 724 }
 725
 726 static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp)
 727 {
 728     BDRVBlkdebugState *s = bs->opaque;
 729
 730     if (s->align) {
 731         bs->bl.request_alignment = s->align;
 732     }
 733 }
 734
 735 static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
 736                                    BlockReopenQueue *queue, Error **errp)
 737 {
 738     return 0;
 739 }
 740
 741 static BlockDriver bdrv_blkdebug = {
 742     .format_name            = "blkdebug",
 743     .protocol_name          = "blkdebug",
 744     .instance_size          = sizeof(BDRVBlkdebugState),
 745
 746     .bdrv_parse_filename    = blkdebug_parse_filename,
 747     .bdrv_file_open         = blkdebug_open,
 748     .bdrv_close             = blkdebug_close,
 749     .bdrv_reopen_prepare    = blkdebug_reopen_prepare,
 750     .bdrv_getlength         = blkdebug_getlength,
 751     .bdrv_truncate          = blkdebug_truncate,
 752     .bdrv_refresh_filename  = blkdebug_refresh_filename,
 753     .bdrv_refresh_limits    = blkdebug_refresh_limits,
 754
 755     .bdrv_aio_readv         = blkdebug_aio_readv,
 756     .bdrv_aio_writev        = blkdebug_aio_writev,
 757     .bdrv_aio_flush         = blkdebug_aio_flush,
 758
 759     .bdrv_debug_event           = blkdebug_debug_event,
 760     .bdrv_debug_breakpoint      = blkdebug_debug_breakpoint,
 761     .bdrv_debug_remove_breakpoint
 762                                 = blkdebug_debug_remove_breakpoint,
 763     .bdrv_debug_resume          = blkdebug_debug_resume,
 764     .bdrv_debug_is_suspended    = blkdebug_debug_is_suspended,
 765 };
 766
 767 static void bdrv_blkdebug_init(void)
 768 {
 769     bdrv_register(&bdrv_blkdebug);
 770 }
 771
 772 block_init(bdrv_blkdebug_init);