Commit 8779441b authored by Max Reitz's avatar Max Reitz Committed by Kevin Wolf
Browse files

blkdebug: Simplify and improve filename generation 



Instead of actually recreating the options from scratch, just reuse the
options given for creating the BDS, which are the configuration file
name and additional options. In case there are no additional options we
can thus create a plain filename.

This obviously results in a different output for qemu-iotest 099 which
exactly tests this filename generation. Fix it up as well.

Signed-off-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
Message-id: 1415697825-26678-2-git-send-email-mreitz@redhat.com
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 48fe86f6

block/blkdebug.c

+28 −71
Original line number Diff line number Diff line
@@ -721,91 +721,48 @@ static int64_t blkdebug_getlength(BlockDriverState *bs) 


static void blkdebug_refresh_filename(BlockDriverState *bs)

{

    BDRVBlkdebugState *s = bs->opaque;

    struct BlkdebugRule *rule;

    QDict *opts;

    QList *inject_error_list = NULL, *set_state_list = NULL;

    QList *suspend_list = NULL;

    int event;

    const QDictEntry *e;

    bool force_json = false;



    for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {

        if (strcmp(qdict_entry_key(e), "config") &&

            strcmp(qdict_entry_key(e), "x-image") &&

            strcmp(qdict_entry_key(e), "image") &&

            strncmp(qdict_entry_key(e), "image.", strlen("image.")))

        {

            force_json = true;

            break;

        }

    }



    if (!bs->file->full_open_options) {

    if (force_json && !bs->file->full_open_options) {

        /* The config file cannot be recreated, so creating a plain filename

         * is impossible */

        return;

    }



    if (!force_json && bs->file->exact_filename[0]) {

        snprintf(bs->exact_filename, sizeof(bs->exact_filename),

                 "blkdebug:%s:%s",

                 qdict_get_try_str(bs->options, "config") ?: "",

                 bs->file->exact_filename);

    }



    opts = qdict_new();

    qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkdebug")));



    QINCREF(bs->file->full_open_options);

    qdict_put_obj(opts, "image", QOBJECT(bs->file->full_open_options));



    for (event = 0; event < BLKDBG_EVENT_MAX; event++) {

        QLIST_FOREACH(rule, &s->rules[event], next) {

            if (rule->action == ACTION_INJECT_ERROR) {

                QDict *inject_error = qdict_new();



                qdict_put_obj(inject_error, "event", QOBJECT(qstring_from_str(

                              BlkdebugEvent_lookup[rule->event])));

                qdict_put_obj(inject_error, "state",

                              QOBJECT(qint_from_int(rule->state)));

                qdict_put_obj(inject_error, "errno", QOBJECT(qint_from_int(

                              rule->options.inject.error)));

                qdict_put_obj(inject_error, "sector", QOBJECT(qint_from_int(

                              rule->options.inject.sector)));

                qdict_put_obj(inject_error, "once", QOBJECT(qbool_from_int(

                              rule->options.inject.once)));

                qdict_put_obj(inject_error, "immediately",

                              QOBJECT(qbool_from_int(

                              rule->options.inject.immediately)));



                if (!inject_error_list) {

                    inject_error_list = qlist_new();

                }



                qlist_append_obj(inject_error_list, QOBJECT(inject_error));

            } else if (rule->action == ACTION_SET_STATE) {

                QDict *set_state = qdict_new();



                qdict_put_obj(set_state, "event", QOBJECT(qstring_from_str(

                              BlkdebugEvent_lookup[rule->event])));

                qdict_put_obj(set_state, "state",

                              QOBJECT(qint_from_int(rule->state)));

                qdict_put_obj(set_state, "new_state", QOBJECT(qint_from_int(

                              rule->options.set_state.new_state)));



                if (!set_state_list) {

                    set_state_list = qlist_new();

                }



                qlist_append_obj(set_state_list, QOBJECT(set_state));

            } else if (rule->action == ACTION_SUSPEND) {

                QDict *suspend = qdict_new();



                qdict_put_obj(suspend, "event", QOBJECT(qstring_from_str(

                              BlkdebugEvent_lookup[rule->event])));

                qdict_put_obj(suspend, "state",

                              QOBJECT(qint_from_int(rule->state)));

                qdict_put_obj(suspend, "tag", QOBJECT(qstring_from_str(

                              rule->options.suspend.tag)));



                if (!suspend_list) {

                    suspend_list = qlist_new();

                }



                qlist_append_obj(suspend_list, QOBJECT(suspend));

            }

        }

    }



    if (inject_error_list) {

        qdict_put_obj(opts, "inject-error", QOBJECT(inject_error_list));

    }

    if (set_state_list) {

        qdict_put_obj(opts, "set-state", QOBJECT(set_state_list));

    for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {

        if (strcmp(qdict_entry_key(e), "x-image") &&

            strcmp(qdict_entry_key(e), "image") &&

            strncmp(qdict_entry_key(e), "image.", strlen("image.")))

        {

            qobject_incref(qdict_entry_value(e));

            qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e));

        }

    if (suspend_list) {

        qdict_put_obj(opts, "suspend", QOBJECT(suspend_list));

    }



    bs->full_open_options = opts;

tests/qemu-iotests/099.out

+2 −2
Original line number Diff line number Diff line
@@ -12,9 +12,9 @@ blkverify:TEST_DIR/t.IMGFMT.compare:TEST_DIR/t.IMGFMT 


=== Testing JSON filename for blkdebug ===



json:{"driver": "IMGFMT", "file": {"inject-error": [{"immediately": false, "once": false, "state": 0, "sector": -1, "event": "l1_update", "errno": 5}], "image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug"}}

json:{"driver": "IMGFMT", "file": {"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "l1_update"}}



=== Testing indirectly enforced JSON filename ===



json:{"driver": "raw", "file": {"test": {"driver": "IMGFMT", "file": {"inject-error": [{"immediately": false, "once": false, "state": 0, "sector": -1, "event": "l1_update", "errno": 5}], "image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug"}}, "driver": "blkverify", "raw": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.compare"}}}

json:{"driver": "raw", "file": {"test": {"driver": "IMGFMT", "file": {"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "l1_update"}}, "driver": "blkverify", "raw": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.compare"}}}

*** done