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