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     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);