blkdebug/blkverify: Allow QMP configuration
v7 cover blkdebug/blkverify: Allow QMP configuration
Currently, the configuration of blkdebug and blkverify is done through the "filename" alone. There is now way of manually choosing blkdebug or blkverify as a driver and using a normal image filename.
In the case of blkdebug, the filename starts with the protocol prefix, follows up with the name of a configuration file and ends with the name of the image file.
In the case of blkverify, the filename starts with the protocol prefix, follows up with the raw reference image filename and ends with the name of the image file.
This patch allows the configuration of both drivers completely through QMP and accordingly command-line options. The driver has to be selected through the driver option (or similar), the image filename may be given either as the filename itself or through a x.filename option, where "x" depends on the driver. Further options may be required depending on the driver.
In case of blkverify, the test image may be specified either through the filename or as a BlockdevRef reference through the "test" option. The raw image is referenced as "raw".
In case of blkdebug, one may either set the "config" option to the filename of a configuration file, or the content of the configuration file may be given directly (as options). The image filename is either specified as the filename or referenced through the "image" option.
v7:
- Addressed Eric's and Stefan's comments (first number is patch number in v6, second is patch number in this series):
- Patch 3/3: Adjusted comment
- Patch 4/4: Hopefully finally fixed
- Patch 5/5: Rebased on Peter's series (don't use qemu_opts_create_nofail); note that this does not add a dependency on that series
- Patch 8/8: Rebased on Fam's series (or rather, Stefan's block branch); the changes in VMDK introduced new calls to bdrv_file_open(), which have to be adjusted as is done in the remainder of the patch
- Patch 21/-: Added
- Patch 22/-: Added
v6:
- Addressed Kevin's and Eric's comments (first number is patch number in v5, second is patch number in this series):
- Patch 4/4: Adjusted comment
- Patch 5/-: Dropped
- Patch 11/10: Guard against !drv && !file before find_image_format()
- Patch -/11: Added
- Patch -/12: Added
- Patch 12/13: Removed unnecessary hunk and squashed next patch into this one
- Patch 13/-: Squashed into previous patch
- Patch 15/15: Dropped static open_image() in favor of the global bdrv_open_image()
- Patch 16/-: Dropped
- Patch 17/16: Dropped static open_image() in favor of the global bdrv_open_image(); also, disable format auto-detection for the raw image
- Patch 18/17: Drop check for !filename since the filename is always passed to this function
- Patch 19/18: Add "errno" to the list of polluted words in qapi.py rather than introduce a new alias
- Patch 20/19: Use enumeration for the blkdebug trigger events; also, we can and must use "errno" now instead of "error"
- Patch 22/21: Fix test by increasing the image size; add actually working tests for blkverify failures; add test for blkverify using an already existing block device as the raw image
- Patch -/22: Added
v5:
- Addressed Fam's comments:
- Patch 4: Asserted against prefix == NULL in qdict_flatten_qlist()
- Patch 4: Support other types than QDicts and QLists in QLists in qdict_flatten_qlist()
- Patch 4: Modified comment above qdict_flatten() to include the functionality of qdict_flatten_qlist()
- Patch 8 (now patch 9): Removed goto fail; in favor of directly returning in the if (reference) patch - this fixes a double QDECREF(options) as well as two bs dereferences with bs being NULL
- Patch 21 (now patch 22): Added reason for not using Python to the commit message
- Added patch 5: Cleans up qdict_flatten_qdict() which contains a now unused delete variable
v4:
- Fixed a memleak in qdict_flatten_qlist() in patch 4
v3:
- The first few patches are probably similar to the ones from the previous series; but it's probably best to see this series as a completely new one.
git-backport-diff against v6:
Key:
[----] : patches are identical
[####] : number of functional differences between upstream/downstream patch [down] : patch is downstream-only
The flags [FC] indicate (F)unctional and (C)ontextual differences, respectively
001/24:[----] [--] 'blkdebug: Use errp for read_config()' 002/24:[----] [--] 'blkdebug: Don't require sophisticated filename' 003/24:[0013] [FC] 'qdict: Add qdict_array_split()' 004/24:[0003] [FC] 'qapi: extend qdict_flatten() for QLists' 005/24:[0007] [FC] 'qemu-option: Add qemu_config_parse_qdict()' 006/24:[----] [--] 'blkdebug: Always call read_config()' 007/24:[----] [--] 'blkdebug: Use command-line in read_config()' 008/24:[0004] [FC] 'block: Allow reference for bdrv_file_open()' 009/24:[----] [--] 'block: Pass reference to bdrv_file_open()' 010/24:[----] [--] 'block: Allow block devices without files' 011/24:[----] [--] 'block: Add bdrv_open_image()' 012/24:[----] [--] 'block: Use bdrv_open_image() in bdrv_open()' 013/24:[----] [--] 'block: Allow recursive "file"s' 014/24:[----] [--] 'blockdev: Move "file" to legacy_opts' 015/24:[----] [-C] 'blkdebug: Allow command-line file configuration' 016/24:[----] [-C] 'blkverify: Allow command-line configuration' 017/24:[----] [--] 'blkverify: Don't require protocol filename' 018/24:[----] [--] 'qapi: Add "errno" to the list of polluted words' 019/24:[----] [--] 'qapi: QMP interface for blkdebug and blkverify' 020/24:[----] [--] 'qemu-io: Make filename optional' 021/24:[down] 'tests: Add test for qdict_array_split()' 022/24:[down] 'tests: Add test for qdict_flatten()' 023/24:[----] [--] 'iotests: Test new blkdebug/blkverify interface' 024/24:[----] [--] 'iotests: Test file format nesting'
Max Reitz (24):
blkdebug: Use errp for read_config()
blkdebug: Don't require sophisticated filename
qdict: Add qdict_array_split()
qapi: extend qdict_flatten() for QLists
qemu-option: Add qemu_config_parse_qdict()
blkdebug: Always call read_config()
blkdebug: Use command-line in read_config()
block: Allow reference for bdrv_file_open()
block: Pass reference to bdrv_file_open()
block: Allow block devices without files
block: Add bdrv_open_image()
block: Use bdrv_open_image() in bdrv_open()
block: Allow recursive "file"s
blockdev: Move "file" to legacy_opts
blkdebug: Allow command-line file configuration
blkverify: Allow command-line configuration
blkverify: Don't require protocol filename
qapi: Add "errno" to the list of polluted words
qapi: QMP interface for blkdebug and blkverify
qemu-io: Make filename optional
tests: Add test for qdict_array_split()
tests: Add test for qdict_flatten()
iotests: Test new blkdebug/blkverify interface
iotests: Test file format nesting
block.c | 123 ++++++++++++++++++++--- block/blkdebug.c | 59 ++++++----- block/blkverify.c | 29 ++---- block/cow.c | 3 +- block/qcow.c | 3 +- block/qcow2.c | 2 +- block/qed.c | 4 +- block/sheepdog.c | 4 +- block/vhdx.c | 2 +- block/vmdk.c | 8 +- blockdev.c | 19 ++-- include/block/block.h | 6 +- include/qapi/qmp/qdict.h | 1 + include/qemu/config-file.h | 6 ++ qapi-schema.json | 113 ++++++++++++++++++++- qemu-io.c | 10 +- qobject/qdict.c | 91 +++++++++++++++-- scripts/qapi.py | 2 +- tests/check-qdict.c | 156 +++++++++++++++++++++++++++++ tests/qemu-iotests/051.out | 2 +- tests/qemu-iotests/071 | 239 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/071.out | 90 +++++++++++++++++ tests/qemu-iotests/072 | 69 +++++++++++++ tests/qemu-iotests/072.out | 21 ++++ tests/qemu-iotests/group | 2 + util/qemu-config.c | 100 +++++++++++++++++++ 26 files changed, 1069 insertions(+), 95 deletions(-) create mode 100755 tests/qemu-iotests/071 create mode 100644 tests/qemu-iotests/071.out create mode 100755 tests/qemu-iotests/072 create mode 100644 tests/qemu-iotests/072.out
Signature · 1 line
1.8.5.1
PATCH v7 1/24 blkdebug: Use errp for read_config()
Use an Error variable in the read_config() function.
--- block/blkdebug.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
block/blkdebug.c +6 -4
@@ -271,7 +271,7 @@ static void remove_rule(BlkdebugRule *rule)g_free (rule); } -static int read_config (BDRVBlkdebugState *s,const char *filename) +static int read_config (BDRVBlkdebugState *s,const char *filename,Error **errp) {FILE *f;int ret;
@@ -279,11 +279,14 @@ static int read_config(BDRVBlkdebugState *s, const char *filename) f =fopen (filename,"r" );if (f ==NULL ) { +error_setg_errno (errp, errno,"Could not read blkdebug config file" );return -errno; } ret =qemu_config_parse (f, config_groups, filename);if (ret <0 ) { +error_setg (errp,"Could not parse blkdebug config file" ); + ret = -EINVAL ; goto fail; }
@@ -370,9 +373,8 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,/* Read rules from config file */ config =qemu_opt_get (opts,"config" );if (config) { - ret =read_config (s, config); -if (ret <0 ) { -error_setg_errno (errp, -ret,"Could not read blkdebug config file" ); + ret =read_config (s, config, errp); +if (ret) { goto fail; } }
Signature · 1 line
1.8.5.1
PATCH v7 2/24 blkdebug: Don't require sophisticated filename
In reply to Max ReitzIf the filename is not prefixed by "blkdebug:" in blkdebug_parse_filename(), the blkdebug driver was not selected through that protocol prefix, but by an explicit command line option (file.driver=blkdebug or something similar). Contrary to the current reaction, this is not a problem at all; we just need to store the filename (in the x-image option) and can go on; the user just has to manually specify the config option.
--- block/blkdebug.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/blkdebug.c +3 -1
@@ -313,7 +313,9 @@ static void blkdebug_parse_filename(const char *filename, QDict *options,/* Parse the blkdebug: prefix */ if (!strstart (filename,"blkdebug:" , &filename)) { -error_setg (errp,"File name string must start with 'blkdebug:'" ); +/* There was no prefix; therefore, all options have to be already +present in the QDict (except for the filename) */ +qdict_put (options,"x-image" ,qstring_from_str (filename));return ; }
Signature · 1 line
1.8.5.1
PATCH v7 3/24 qdict: Add qdict_array_split()
In reply to Max ReitzThis function splits a QDict consisting of entries prefixed by incrementally enumerated indices into a QList of QDicts.
--- include/qapi/qmp/qdict.h | 1 + qobject/qdict.c | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+)
include/qapi/qmp/qdict.h +1 -0
@@ -68,5 +68,6 @@ QDict *qdict_clone_shallow(const QDict *src);void qdict_flatten (QDict *qdict);void qdict_extract_subqdict (QDict *src,QDict **dst,const char *start); +void qdict_array_split (QDict *src,QList **dst);#endif /* QDICT_H */
qobject/qdict.c +37 -0
@@ -554,3 +554,40 @@ void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start) entry = next; } } + +/** +* qdict_array_split(): This function moves array-like elements of a QDict into +* a new QList of QDicts. Every entry in the original QDict with a key prefixed +* "%u.", where %u designates an unsigned integer starting at 0 and +* incrementally counting up, will be moved to a new QDict at index %u in the +* output QList with the key prefix removed. The function terminates when there +* is no entry in the QDict with a prefix directly (incrementally) following the +* last one. +* Example: {"0.a": 42, "0.b": 23, "1.x": 0, "3.y": 1, "o.o": 7} +* (or {"1.x": 0, "3.y": 1, "0.a": 42, "o.o": 7, "0.b": 23}) +* => [{"a": 42, "b": 23}, {"x": 0}] +* and {"3.y": 1, "o.o": 7} (remainder of the old QDict) +*/ +void qdict_array_split (QDict *src,QList **dst) +{ +unsigned i; + + *dst =qlist_new (); + +for (i =0 ; i <UINT_MAX ; i++) { +QDict *subqdict; +char prefix[32 ]; +size_t snprintf_ret; + + snprintf_ret =snprintf (prefix,32 ,"%u." , i); +assert (snprintf_ret <32 ); + +qdict_extract_subqdict (src, &subqdict, prefix); +if (!qdict_size (subqdict)) { +QDECREF (subqdict); +break ; + } + +qlist_append_obj (*dst,QOBJECT (subqdict)); + } +}
Signature · 1 line
1.8.5.1
PATCH v7 4/24 qapi: extend qdict_flatten() for QLists
In reply to Max ReitzReversing qdict_array_split(), qdict_flatten() should flatten QLists as well by interpreting them as QDicts where every entry's key is its index.
This allows bringing QDicts with QLists from QMP commands to the same form as they would be given as command-line options, thereby allowing them to be parsed the same way.
--- qobject/qdict.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 6 deletions(-)
qobject/qdict.c +48 -6
@@ -477,7 +477,43 @@ static void qdict_destroy_obj(QObject *obj)g_free (qdict); } -static void qdict_do_flatten (QDict *qdict,QDict *target,const char *prefix) +static void qdict_flatten_qdict (QDict *qdict,QDict *target, +const char *prefix); + +static void qdict_flatten_qlist (QList *qlist,QDict *target,const char *prefix) +{ +QObject *value; +const QListEntry *entry; +char *new_key; +int i; + +/* This function is never called with prefix == NULL, i.e., it is always +* called from within qdict_flatten_q(list|dict)(). Therefore, it does not +* need to remove list entries during the iteration (the whole list will be +* deleted eventually anyway from qdict_flatten_qdict()). */ +assert (prefix); + + entry =qlist_first (qlist); + +for (i =0 ; entry; entry =qlist_next (entry), i++) { + value =qlist_entry_obj (entry); + new_key =g_strdup_printf ("%s.%i" , prefix, i); + +if (qobject_type (value) ==QTYPE_QDICT ) { +qdict_flatten_qdict (qobject_to_qdict (value), target, new_key); + }else if (qobject_type (value) ==QTYPE_QLIST ) { +qdict_flatten_qlist (qobject_to_qlist (value), target, new_key); + }else { +/* All other types are moved to the target unchanged. */ +qobject_incref (value); +qdict_put_obj (target, new_key, value); + } + +g_free (new_key); + } +} + +static void qdict_flatten_qdict (QDict *qdict,QDict *target,const char *prefix) {QObject *value;const QDictEntry *entry, *next;
@@ -500,8 +536,12 @@ static void qdict_do_flatten(QDict *qdict, QDict *target, const char *prefix)if (qobject_type (value) ==QTYPE_QDICT ) {/* Entries of QDicts are processed recursively, the QDict object * itself disappears. */ -qdict_do_flatten (qobject_to_qdict (value), target, - new_key ? new_key : entry->key); +qdict_flatten_qdict (qobject_to_qdict (value), target, + new_key ? new_key : entry->key); + delete = true; + }else if (qobject_type (value) ==QTYPE_QLIST ) { +qdict_flatten_qlist (qobject_to_qlist (value), target, + new_key ? new_key : entry->key); delete = true; }else if (prefix) {/* All other objects are moved to the target unchanged. */
@@ -526,12 +566,14 @@ static void qdict_do_flatten(QDict *qdict, QDict *target, const char *prefix)/** * qdict_flatten(): For each nested QDict with key x, all fields with key y -* are moved to this QDict and their key is renamed to "x.y". This operation -* is applied recursively for nested QDicts. +* are moved to this QDict and their key is renamed to "x.y". For each nested +* QList with key x, the field at index y is moved to this QDict with the key +* "x.y" (i.e., the reverse of what qdict_array_split() does). +* This operation is applied recursively for nested QDicts and QLists. */ void qdict_flatten (QDict *qdict) { -qdict_do_flatten (qdict, qdict,NULL ); +qdict_flatten_qdict (qdict, qdict,NULL ); }/* extract all the src QDict entries starting by start into dst */
Signature · 1 line
1.8.5.1
Re: [Qemu-devel] [PATCH v7 04/24] qapi: extend qdict_flatten() for QLists
Quoted 4 lines · Max Reitz
Reversing
qdict_array_split(),qdict_flatten()should flatten QLists as well by interpreting them as QDicts where every entry's key is its index.
Quoted 9 lines
This allows bringing QDicts with QLists from QMP commands to the same form as they would be given as command-line options, thereby allowing them to be parsed the same way.
Signed-off-by Max Reitz <[email protected]>--- qobject/qdict.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 6 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
PATCH v7 5/24 qemu-option: Add qemu_config_parse_qdict()
In reply to Max ReitzThis function basically parses command-line options given as a QDict replacing a config file.
For instance, the QDict {"section.opt1": 42, "section.opt2": 23} corresponds to the config file:
[section]
opt1 = 42
opt2 = 23
It is possible to specify multiple sections and also multiple sections of the same type. On the command line, this looks like the following:
inject-error.0.event=reftable_load,\
inject-error.1.event=l2_load,\
set-state.event=l1_update
This would correspond to the following config file:
[inject-error "inject-error.0"]
event = reftable_load
[inject-error "inject-error.1"]
event = l2_load
[set-state]
event = l1_update
--- include/qemu/config-file.h | 6 +++ util/qemu-config.c | 100 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 106 insertions(+)
include/qemu/config-file.h +6 -0
@@ -4,6 +4,7 @@#include <stdio.h> #include "qemu/option.h" #include "qapi/error.h" +#include "qapi/qmp/qdict.h" QemuOptsList *qemu_find_opts (const char *group);QemuOptsList *qemu_find_opts_err (const char *group,Error **errp);
@@ -18,6 +19,11 @@ int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname);int qemu_read_config_file (const char *filename); +/* Parse QDict options as a replacement for a config file (allowing multiple +enumerated (0..(n-1)) configuration "sections") */ +void qemu_config_parse_qdict (QDict *options,QemuOptsList **lists, +Error **errp); +/* Read default QEMU config files */ int qemu_read_default_config_files (bool userconfig);
util/qemu-config.c +100 -0
103 lines not on this page · raw message
Signature · 1 line
1.8.5.1
PATCH v7 6/24 blkdebug: Always call read_config()
In reply to Max ReitzMove the check whether there actually is a config file into the read_config() function.
--- block/blkdebug.c | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-)
block/blkdebug.c +19 -17
@@ -273,21 +273,23 @@ static void remove_rule(BlkdebugRule *rule)static int read_config (BDRVBlkdebugState *s,const char *filename,Error **errp) { -FILE *f; +FILE *f =NULL ;int ret;struct add_rule_data d; - f =fopen (filename,"r" ); -if (f ==NULL ) { -error_setg_errno (errp, errno,"Could not read blkdebug config file" ); -return -errno; - } +if (filename) { + f =fopen (filename,"r" ); +if (f ==NULL ) { +error_setg_errno (errp, errno,"Could not read blkdebug config file" ); +return -errno; + } - ret =qemu_config_parse (f, config_groups, filename); -if (ret <0 ) { -error_setg (errp,"Could not parse blkdebug config file" ); - ret = -EINVAL ; - goto fail; + ret =qemu_config_parse (f, config_groups, filename); +if (ret <0 ) { +error_setg (errp,"Could not parse blkdebug config file" ); + ret = -EINVAL ; + goto fail; + } } d.s = s;
@@ -301,7 +303,9 @@ static int read_config(BDRVBlkdebugState *s, const char *filename, Error **errp) fail:qemu_opts_reset (&inject_error_opts);qemu_opts_reset (&set_state_opts); -fclose (f); +if (f) { +fclose (f); + }return ret; }
@@ -374,11 +378,9 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,/* Read rules from config file */ config =qemu_opt_get (opts,"config" ); -if (config) { - ret =read_config (s, config, errp); -if (ret) { - goto fail; - } + ret =read_config (s, config, errp); +if (ret) { + goto fail; }/* Set initial state */
Signature · 1 line
1.8.5.1
PATCH v7 7/24 blkdebug: Use command-line in read_config()
In reply to Max ReitzUse qemu_config_parse_qdict() to parse the command-line options in addition to the config file.
--- block/blkdebug.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)
block/blkdebug.c +12 -3
@@ -271,11 +271,13 @@ static void remove_rule(BlkdebugRule *rule)g_free (rule); } -static int read_config (BDRVBlkdebugState *s,const char *filename,Error **errp) +static int read_config (BDRVBlkdebugState *s,const char *filename, +QDict *options,Error **errp) {FILE *f =NULL ;int ret;struct add_rule_data d; +Error *local_err =NULL ;if (filename) { f =fopen (filename,"r" );
@@ -292,6 +294,13 @@ static int read_config(BDRVBlkdebugState *s, const char *filename, Error **errp) } } +qemu_config_parse_qdict (options, config_groups, &local_err); +if (error_is_set (&local_err)) { +error_propagate (errp, local_err); + ret = -EINVAL ; + goto fail; + } + d.s = s; d.action =ACTION_INJECT_ERROR ;qemu_opts_foreach (&inject_error_opts, add_rule, &d,0 );
@@ -376,9 +385,9 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } -/* Read rules from config file */ +/* Read rules from config file or command line options */ config =qemu_opt_get (opts,"config" ); - ret =read_config (s, config, errp); + ret =read_config (s, config, options, errp);if (ret) { goto fail; }
Signature · 1 line
1.8.5.1
PATCH v7 8/24 block: Allow reference for bdrv_file_open()
In reply to Max ReitzAllow specifying a reference to an existing block device (by name) for bdrv_file_open() instead of a filename and/or options.
--- block.c | 25 ++++++++++++++++++++++--- block/blkdebug.c | 2 +- block/blkverify.c | 2 +- block/cow.c | 3 ++- block/qcow.c | 3 ++- block/qcow2.c | 2 +- block/qed.c | 4 ++-- block/sheepdog.c | 4 ++-- block/vhdx.c | 2 +- block/vmdk.c | 8 ++++---- include/block/block.h | 3 ++- qemu-io.c | 2 +- 12 files changed, 41 insertions(+), 19 deletions(-)
block.c +22 -3
@@ -858,9 +858,10 @@ free_and_fail:* dictionary, it needs to use QINCREF() before calling bdrv_file_open. */ int bdrv_file_open (BlockDriverState **pbs,const char *filename, -QDict *options,int flags,Error **errp) +const char *reference,QDict *options,int flags, +Error **errp) { -BlockDriverState *bs; +BlockDriverState *bs =NULL ;BlockDriver *drv;const char *drvname;bool allow_protocol_prefix = false;
@@ -872,6 +873,24 @@ int bdrv_file_open(BlockDriverState **pbs, const char *filename, options =qdict_new (); } +if (reference) { +if (filename ||qdict_size (options)) { +error_setg (errp,"Cannot reference an existing block device with " +"additional options or a new filename" ); +return -EINVAL ; + } +QDECREF (options); + + bs =bdrv_find (reference); +if (!bs) { +error_setg (errp,"Cannot find block device '%s'" , reference); +return -ENODEV ; + } +bdrv_ref (bs); + *pbs = bs; +return 0 ; + } + bs =bdrv_new ("" ); bs->options = options; options =qdict_clone_shallow (options);
@@ -1124,7 +1143,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,qdict_extract_subqdict (options, &file_options,"file." ); - ret =bdrv_file_open (&file, filename, file_options, + ret =bdrv_file_open (&file, filename,NULL , file_options,bdrv_open_flags (bs, flags |BDRV_O_UNMAP ), &local_err);if (ret <0 ) { goto fail;
block/blkdebug.c +1 -1
@@ -403,7 +403,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } - ret =bdrv_file_open (&bs->file, filename,NULL , flags, &local_err); + ret =bdrv_file_open (&bs->file, filename,NULL ,NULL , flags, &local_err);if (ret <0 ) {error_propagate (errp, local_err); goto fail;
block/blkverify.c +1 -1
@@ -141,7 +141,7 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } - ret =bdrv_file_open (&bs->file, raw,NULL , flags, &local_err); + ret =bdrv_file_open (&bs->file, raw,NULL ,NULL , flags, &local_err);if (ret <0 ) {error_propagate (errp, local_err); goto fail;
block/cow.c +2 -1
@@ -351,7 +351,8 @@ static int cow_create(const char *filename, QEMUOptionParameter *options,return ret; } - ret =bdrv_file_open (&cow_bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&cow_bs, filename,NULL ,NULL ,BDRV_O_RDWR , + &local_err);if (ret <0 ) {qerror_report_err (local_err);error_free (local_err);
block/qcow.c +2 -1
@@ -691,7 +691,8 @@ static int qcow_create(const char *filename, QEMUOptionParameter *options,return ret; } - ret =bdrv_file_open (&qcow_bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&qcow_bs, filename,NULL ,NULL ,BDRV_O_RDWR , + &local_err);if (ret <0 ) {qerror_report_err (local_err);error_free (local_err);
block/qcow2.c +1 -1
@@ -1483,7 +1483,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,return ret; } - ret =bdrv_file_open (&bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&bs, filename,NULL ,NULL ,BDRV_O_RDWR , &local_err);if (ret <0 ) {error_propagate (errp, local_err);return ret;
block/qed.c +2 -2
@@ -563,8 +563,8 @@ static int qed_create(const char *filename, uint32_t cluster_size,return ret; } - ret =bdrv_file_open (&bs, filename,NULL ,BDRV_O_RDWR |BDRV_O_CACHE_WB , - &local_err); + ret =bdrv_file_open (&bs, filename,NULL ,NULL , +BDRV_O_RDWR |BDRV_O_CACHE_WB , &local_err);if (ret <0 ) {qerror_report_err (local_err);error_free (local_err);
block/sheepdog.c +2 -2
@@ -1534,7 +1534,7 @@ static int sd_prealloc(const char *filename)Error *local_err =NULL ;int ret; - ret =bdrv_file_open (&bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&bs, filename,NULL ,NULL ,BDRV_O_RDWR , &local_err);if (ret <0 ) {qerror_report_err (local_err);error_free (local_err);
@@ -1695,7 +1695,7 @@ static int sd_create(const char *filename, QEMUOptionParameter *options, goto out; } - ret =bdrv_file_open (&bs, backing_file,NULL ,0 , &local_err); + ret =bdrv_file_open (&bs, backing_file,NULL ,NULL ,0 , &local_err);if (ret <0 ) {qerror_report_err (local_err);error_free (local_err);
block/vhdx.c +1 -1
@@ -1797,7 +1797,7 @@ static int vhdx_create(const char *filename, QEMUOptionParameter *options, goto exit; } - ret =bdrv_file_open (&bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&bs, filename,NULL ,NULL ,BDRV_O_RDWR , &local_err);if (ret <0 ) {error_propagate (errp, local_err); goto exit;
block/vmdk.c +4 -4
@@ -769,8 +769,8 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,path_combine (extent_path,sizeof (extent_path), desc_file_path, fname); - ret =bdrv_file_open (&extent_file, extent_path,NULL , bs->open_flags, - errp); + ret =bdrv_file_open (&extent_file, extent_path,NULL ,NULL , + bs->open_flags, errp);if (ret) {return ret; }
@@ -1469,7 +1469,7 @@ static int vmdk_create_extent(const char *filename, int64_t filesize, goto exit; } - ret =bdrv_file_open (&bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&bs, filename,NULL ,NULL ,BDRV_O_RDWR , &local_err);if (ret <0 ) {error_propagate (errp, local_err); goto exit;
@@ -1807,7 +1807,7 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options, goto exit; } } - ret =bdrv_file_open (&new_bs, filename,NULL ,BDRV_O_RDWR , &local_err); + ret =bdrv_file_open (&new_bs, filename,NULL ,NULL ,BDRV_O_RDWR , &local_err);if (ret <0 ) {error_setg_errno (errp, -ret,"Could not write description" ); goto exit;
include/block/block.h +2 -1
@@ -184,7 +184,8 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);int bdrv_parse_cache_flags (const char *mode,int *flags);int bdrv_parse_discard_flags (const char *mode,int *flags);int bdrv_file_open (BlockDriverState **pbs,const char *filename, -QDict *options,int flags,Error **errp); +const char *reference,QDict *options,int flags, +Error **errp);int bdrv_open_backing_file (BlockDriverState *bs,QDict *options,Error **errp);int bdrv_open (BlockDriverState *bs,const char *filename,QDict *options,int flags,BlockDriver *drv,Error **errp);
qemu-io.c +1 -1
@@ -56,7 +56,7 @@ static int openfile(char *name, int flags, int growable, QDict *opts) }if (growable) { -if (bdrv_file_open (&qemuio_bs, name, opts, flags, &local_err)) { +if (bdrv_file_open (&qemuio_bs, name,NULL , opts, flags, &local_err)) {fprintf (stderr,"%s: can't open device %s: %s\n" , progname, name,error_get_pretty (local_err));error_free (local_err);
Signature · 1 line
1.8.5.1
PATCH v7 9/24 block: Pass reference to bdrv_file_open()
In reply to Max ReitzWith that now being possible, bdrv_open() should try to extract a block device reference from the options and pass it to bdrv_file_open().
--- block.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
block.c +4 -1
@@ -1056,6 +1056,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,char tmp_filename[PATH_MAX +1 ];BlockDriverState *file =NULL ;QDict *file_options =NULL ; +const char *file_reference;const char *drvname;Error *local_err =NULL ;
@@ -1142,9 +1143,11 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, }qdict_extract_subqdict (options, &file_options,"file." ); + file_reference =qdict_get_try_str (options,"file" ); - ret =bdrv_file_open (&file, filename,NULL , file_options, + ret =bdrv_file_open (&file, filename, file_reference, file_options,bdrv_open_flags (bs, flags |BDRV_O_UNMAP ), &local_err); +qdict_del (options,"file" );if (ret <0 ) { goto fail; }
Signature · 1 line
1.8.5.1
PATCH v7 10/24 block: Allow block devices without files
In reply to Max Reitzblkdebug and blkverify will, in order to retain compatibility, not support the field "file" implicitly through bdrv_open(). In order to be able to use those drivers without giving a filename anyway, it is necessary to be able to have block devices without files implicitly opened by bdrv_open(). This is the case, if there was neither a file name, a reference to an existing block device to use as a file nor options specific to the file.
--- block.c | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-)
block.c +16 -7
@@ -1145,11 +1145,14 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,qdict_extract_subqdict (options, &file_options,"file." ); file_reference =qdict_get_try_str (options,"file" ); - ret =bdrv_file_open (&file, filename, file_reference, file_options, -bdrv_open_flags (bs, flags |BDRV_O_UNMAP ), &local_err); -qdict_del (options,"file" ); -if (ret <0 ) { - goto fail; +if (filename || file_reference ||qdict_size (file_options)) { + ret =bdrv_file_open (&file, filename, file_reference, file_options, +bdrv_open_flags (bs, flags |BDRV_O_UNMAP ), + &local_err); +qdict_del (options,"file" ); +if (ret <0 ) { + goto fail; + } }/* Find the right image format driver */
@@ -1165,7 +1168,13 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, }if (!drv) { - ret =find_image_format (file, filename, &drv, &local_err); +if (file) { + ret =find_image_format (file, filename, &drv, &local_err); + }else { +error_setg (errp,"Must specify either driver or file" ); + ret = -EINVAL ; + goto unlink_and_fail; + } }if (!drv) {
@@ -1178,7 +1187,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, goto unlink_and_fail; } -if (bs->file != file) { +if (file && (bs->file != file)) {bdrv_unref (file); file =NULL ; }
Signature · 1 line
1.8.5.1
PATCH v7 11/24 block: Add bdrv_open_image()
In reply to Max ReitzAdd a common function for opening images to be used for block drivers specified through BlockdevRefs in an option QDict. The difference from bdrv_file_open() is that this function may invoke bdrv_open() instead, allowing auto-detection of the driver to be used; and second, it automatically extracts the BlockdevRef from the option QDict.
--- block.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++ include/block/block.h | 3 +++ 2 files changed, 76 insertions(+)
block.c +73 -0
@@ -1041,6 +1041,79 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) }/* +* Opens a disk image whose options are given as BlockdevRef in another block +* device's options. +* +* If force_raw is true, bdrv_file_open() will be used, thereby preventing any +* image format auto-detection. If it is false and a filename is given, +* bdrv_open() will be used for auto-detection. +* +* If allow_none is true, no image will be opened if filename is false and no +* BlockdevRef is given. *pbs will remain unchanged and 0 will be returned. +* +* bdrev_key specifies the key for the image's BlockdevRef in the options QDict. +* That QDict has to be flattened; therefore, if the BlockdevRef is a QDict +* itself, all options starting with "${bdref_key}." are considered part of the +* BlockdevRef. +* +* The BlockdevRef will be removed from the options QDict. +*/ +int bdrv_open_image (BlockDriverState **pbs,const char *filename, +QDict *options,const char *bdref_key,int flags, +bool force_raw,bool allow_none,Error **errp) +{ +QDict *image_options; +int ret; +char *bdref_key_dot; +const char *reference; + + bdref_key_dot =g_strdup_printf ("%s." , bdref_key); +qdict_extract_subqdict (options, &image_options, bdref_key_dot); +g_free (bdref_key_dot); + + reference =qdict_get_try_str (options, bdref_key); +if (!filename && !reference && !qdict_size (image_options)) { +if (allow_none) { + ret =0 ; + }else { +error_setg (errp,"A block device must be specified for \"%s\"" , + bdref_key); + ret = -EINVAL ; + } + goto done; + } + +if (filename && !force_raw) { +/* If a filename is given and the block driver should be detected +automatically (instead of using none), use bdrv_open() in order to do +that auto-detection. */ +BlockDriverState *bs; + +if (reference) { +error_setg (errp,"Cannot reference an existing block device while " +"giving a filename" ); + ret = -EINVAL ; + goto done; + } + + bs =bdrv_new ("" ); + ret =bdrv_open (bs, filename, image_options, flags,NULL , errp); +if (ret <0 ) { +bdrv_unref (bs); + }else { + *pbs = bs; + } + }else { + ret =bdrv_file_open (pbs, filename, reference, image_options, flags, + errp); + } + +done: +qdict_del (options, bdref_key); +return ret; +} + +/* * Opens a disk image (raw, qcow2, vmdk, ...) * * options is a QDict of options to pass to the block drivers, or NULL for an
include/block/block.h +3 -0
@@ -186,6 +186,9 @@ int bdrv_parse_discard_flags(const char *mode, int *flags);int bdrv_file_open (BlockDriverState **pbs,const char *filename,const char *reference,QDict *options,int flags,Error **errp); +int bdrv_open_image (BlockDriverState **pbs,const char *filename, +QDict *options,const char *bdref_key,int flags, +bool force_raw,bool allow_none,Error **errp);int bdrv_open_backing_file (BlockDriverState *bs,QDict *options,Error **errp);int bdrv_open (BlockDriverState *bs,const char *filename,QDict *options,int flags,BlockDriver *drv,Error **errp);
Signature · 1 line
1.8.5.1
PATCH v7 12/24 block: Use bdrv_open_image() in bdrv_open()
In reply to Max ReitzUsing bdrv_open_image() instead of bdrv_file_open() directly in bdrv_open() is easier.
--- block.c | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-)
block.c +5 -13
@@ -1128,8 +1128,6 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,/* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ char tmp_filename[PATH_MAX +1 ];BlockDriverState *file =NULL ; -QDict *file_options =NULL ; -const char *file_reference;const char *drvname;Error *local_err =NULL ;
@@ -1215,17 +1213,11 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, flags |=BDRV_O_ALLOW_RDWR ; } -qdict_extract_subqdict (options, &file_options,"file." ); - file_reference =qdict_get_try_str (options,"file" ); - -if (filename || file_reference ||qdict_size (file_options)) { - ret =bdrv_file_open (&file, filename, file_reference, file_options, -bdrv_open_flags (bs, flags |BDRV_O_UNMAP ), - &local_err); -qdict_del (options,"file" ); -if (ret <0 ) { - goto fail; - } + ret =bdrv_open_image (&file, filename, options,"file" , +bdrv_open_flags (bs, flags |BDRV_O_UNMAP ), true, true, + &local_err); +if (ret <0 ) { + goto fail; }/* Find the right image format driver */
Signature · 1 line
1.8.5.1
PATCH v7 13/24 block: Allow recursive "file"s
In reply to Max ReitzIt should be possible to use a format as a driver for a file which in turn requires another file, i.e., nesting file formats.
Allowing nested file formats results in e.g. qcow2 BlockDriverStates never being directly passed to bdrv_open_common() from bdrv_file_open(), but instead being handed through bdrv_open(). This changes the error message when trying to give a filename to qcow2, i.e. trying to use it as a driver for the protocol level. Therefore, change the reference output of I/O test 051 accordingly.
--- block.c | 9 +++++++-- tests/qemu-iotests/051.out | 2 +- 2 files changed, 8 insertions(+), 3 deletions(-)
block.c +7 -2
@@ -948,14 +948,19 @@ int bdrv_file_open(BlockDriverState **pbs, const char *filename, goto fail; } - ret =bdrv_open_common (bs,NULL , options, flags, drv, &local_err); +if (!drv->bdrv_file_open) { + ret =bdrv_open (bs, filename, options, flags, drv, &local_err); + options =NULL ; + }else { + ret =bdrv_open_common (bs,NULL , options, flags, drv, &local_err); + }if (ret <0 ) {error_propagate (errp, local_err); goto fail; }/* Check if any unknown options were used */ -if (qdict_size (options) !=0 ) { +if (options && (qdict_size (options) !=0 )) {const QDictEntry *entry =qdict_first (options);error_setg (errp,"Block protocol '%s' doesn't support the option '%s'" , drv->format_name, entry->key);
tests/qemu-iotests/051.out +1 -1
@@ -222,7 +222,7 @@ QEMU X.Y.Z monitor - type 'help' for more information (qemu) q[K[Dqu[K[D[Dqui[K[D[D[Dquit[K Testing: -drive file=TEST_DIR/t.qcow2,file.driver=qcow2 -QEMU_PROG: -drive file=TEST_DIR/t.qcow2,file.driver=qcow2: could not open disk image TEST_DIR/t.qcow2: Can't use 'qcow2' as a block driver for the protocol level +QEMU_PROG: -drive file=TEST_DIR/t.qcow2,file.driver=qcow2: could not open disk image TEST_DIR/t.qcow2: Block format 'qcow2' used by device '' doesn't support the option 'filename' === Parsing protocol from file name ===
Signature · 1 line
1.8.5.1
PATCH v7 14/24 blockdev: Move "file" to legacy_opts
In reply to Max ReitzSpecifying the image filename through the "file" option is a legacy option and should not be supported by blockdev-add (in that case, giving a string for "file" references an existing block device).
--- blockdev.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-)
blockdev.c +10 -9
@@ -307,12 +307,11 @@ static bool check_throttle_config(ThrottleConfig *cfg, Error **errp)typedef enum {MEDIA_DISK ,MEDIA_CDROM }DriveMediaType ;/* Takes the ownership of bs_opts */ -static DriveInfo *blockdev_init (QDict *bs_opts, +static DriveInfo *blockdev_init (const char *file,QDict *bs_opts,BlockInterfaceType type,Error **errp) {const char *buf; -const char *file =NULL ;const char *serial;int ro =0 ;int bdrv_flags =0 ;
@@ -354,7 +353,6 @@ static DriveInfo *blockdev_init(QDict *bs_opts, ro =qemu_opt_get_bool (opts,"read-only" ,0 ); copy_on_read =qemu_opt_get_bool (opts,"copy-on-read" , false); - file =qemu_opt_get (opts,"file" ); serial =qemu_opt_get (opts,"serial" );if ((buf =qemu_opt_get (opts,"discard" )) !=NULL ) {
@@ -599,6 +597,10 @@ QemuOptsList qemu_legacy_drive_opts = { .name = "addr", .type = QEMU_OPT_STRING, .help = "pci address (virtio only)", + },{ + .name = "file", + .type = QEMU_OPT_STRING, + .help = "file name", },/* Options that are passed on, but have special semantics with -drive */
@@ -629,6 +631,7 @@ DriveInfo *drive_init(QemuOpts *all_opts, BlockInterfaceType block_default_type)const char *devaddr;bool read_only = false;bool copy_on_read; +const char *filename;Error *local_err =NULL ;/* Change legacy command line options into QMP ones */
@@ -867,8 +870,10 @@ DriveInfo *drive_init(QemuOpts *all_opts, BlockInterfaceType block_default_type) } } + filename =qemu_opt_get (legacy_opts,"file" ); +/* Actual block device init: Functionality shared with blockdev-add */ - dinfo =blockdev_init (bs_opts, type, &local_err); + dinfo =blockdev_init (filename, bs_opts, type, &local_err);if (dinfo ==NULL ) {if (error_is_set (&local_err)) {qerror_report_err (local_err);
@@ -2210,7 +2215,7 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp)qdict_flatten (qdict); -blockdev_init (qdict,IF_NONE , &local_err); +blockdev_init (NULL , qdict,IF_NONE , &local_err);if (error_is_set (&local_err)) {error_propagate (errp, local_err); goto fail;
@@ -2251,10 +2256,6 @@ QemuOptsList qemu_common_drive_opts = { .type = QEMU_OPT_BOOL, .help = "enable/disable snapshot mode", },{ - .name = "file", - .type = QEMU_OPT_STRING, - .help = "disk image", - },{ .name = "discard", .type = QEMU_OPT_STRING, .help = "discard operation (ignore/off, unmap/on)",
Signature · 1 line
1.8.5.1
PATCH v7 15/24 blkdebug: Allow command-line file configuration
In reply to Max ReitzIntroduce the "image" option as an alternative to specifying the image through the filename.
--- block/blkdebug.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
block/blkdebug.c +3 -9
@@ -374,7 +374,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,BDRVBlkdebugState *s = bs->opaque;QemuOpts *opts;Error *local_err =NULL ; -const char *filename, *config; +const char *config;int ret; opts =qemu_opts_create (&runtime_opts,NULL ,0 , &error_abort);
@@ -396,14 +396,8 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, s->state =1 ;/* Open the backing file */ - filename =qemu_opt_get (opts,"x-image" ); -if (filename ==NULL ) { -error_setg (errp,"Could not retrieve image file name" ); - ret = -EINVAL ; - goto fail; - } - - ret =bdrv_file_open (&bs->file, filename,NULL ,NULL , flags, &local_err); + ret =bdrv_open_image (&bs->file,qemu_opt_get (opts,"x-image" ), options,"image" , + flags, true, false, &local_err);if (ret <0 ) {error_propagate (errp, local_err); goto fail;
Signature · 1 line
1.8.5.1
PATCH v7 16/24 blkverify: Allow command-line configuration
In reply to Max ReitzIntroduce the "test" and "raw" options for specifying images.
--- block/blkverify.c | 25 +++++-------------------- 1 file changed, 5 insertions(+), 20 deletions(-)
block/blkverify.c +5 -20
@@ -122,7 +122,6 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,BDRVBlkverifyState *s = bs->opaque;QemuOpts *opts;Error *local_err =NULL ; -const char *filename, *raw;int ret; opts =qemu_opts_create (&runtime_opts,NULL ,0 , &error_abort);
@@ -133,33 +132,19 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } -/* Parse the raw image filename */ - raw =qemu_opt_get (opts,"x-raw" ); -if (raw ==NULL ) { -error_setg (errp,"Could not retrieve raw image filename" ); - ret = -EINVAL ; - goto fail; - } - - ret =bdrv_file_open (&bs->file, raw,NULL ,NULL , flags, &local_err); +/* Open the raw file */ + ret =bdrv_open_image (&bs->file,qemu_opt_get (opts,"x-raw" ), options, +"raw" , flags, true, false, &local_err);if (ret <0 ) {error_propagate (errp, local_err); goto fail; }/* Open the test file */ - filename =qemu_opt_get (opts,"x-image" ); -if (filename ==NULL ) { -error_setg (errp,"Could not retrieve test image filename" ); - ret = -EINVAL ; - goto fail; - } - - s->test_file =bdrv_new ("" ); - ret =bdrv_open (s->test_file, filename,NULL , flags,NULL , &local_err); + ret =bdrv_open_image (&s->test_file,qemu_opt_get (opts,"x-image" ), options, +"test" , flags, false, false, &local_err);if (ret <0 ) {error_propagate (errp, local_err); -bdrv_unref (s->test_file); s->test_file =NULL ; goto fail; }
Signature · 1 line
1.8.5.1
PATCH v7 17/24 blkverify: Don't require protocol filename
In reply to Max ReitzIf the filename is not prefixed by "blkverify:" in blkverify_parse_filename(), the blkverify driver was not selected through that protocol prefix, but by an explicit command line (or QMP) option (like driver=blkverify).
If blkverify_parse_filename() has been called, a filename has been given. If it is not prefixed, it is probably really just a plain filename. This is no problem, since we can use it as the test image filename and rely on the user to specify the raw image filename through the new corresponding option.
--- block/blkverify.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/blkverify.c +3 -1
@@ -78,7 +78,9 @@ static void blkverify_parse_filename(const char *filename, QDict *options,/* Parse the blkverify: prefix */ if (!strstart (filename,"blkverify:" , &filename)) { -error_setg (errp,"File name string must start with 'blkverify:'" ); +/* There was no prefix; therefore, all options have to be already +present in the QDict (except for the filename) */ +qdict_put (options,"x-image" ,qstring_from_str (filename));return ; }
Signature · 1 line
1.8.5.1
PATCH v7 18/24 qapi: Add "errno" to the list of polluted words
In reply to Max ReitzUsing "errno" directly as an identifier results in various syntax errors; therefore it should be added to the list of polluted words.
--- scripts/qapi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
scripts/qapi.py +1 -1
@@ -247,7 +247,7 @@ def c_var(name, protect=True): 'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not', 'not_eq', 'or', 'or_eq', 'xor', 'xor_eq']) # namespace pollution: - polluted_words = set(['unix']) + polluted_words = set(['unix', 'errno']) if protect and (name in c89_words | c99_words | c11_words | gcc_words | cpp_words | polluted_words): return "q_" + name return name.replace('-', '_').lstrip("*")
Signature · 1 line
1.8.5.1
PATCH v7 19/24 qapi: QMP interface for blkdebug and blkverify
In reply to Max ReitzAdd structures to support blkdebug and blkverify in blockdev-add.
--- qapi-schema.json | 113 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 109 insertions(+), 4 deletions(-)
qapi-schema.json +109 -4
@@ -4167,6 +4167,113 @@ '*pass-discard-other': 'bool' } } ## +# @BlkdebugEvent +# +# Trigger events supported by blkdebug. +## +{ 'enum': 'BlkdebugEvent', + 'data': [ 'l1_update', 'l1_grow.alloc_table', 'l1_grow.write_table', + 'l1_grow.activate_table', 'l2_load', 'l2_update', + 'l2_update_compressed', 'l2_alloc.cow_read', 'l2_alloc.write', + 'read_aio', 'read_backing_aio', 'read_compressed', 'write_aio', + 'write_compressed', 'vmstate_load', 'vmstate_save', 'cow_read', + 'cow_write', 'reftable_load', 'reftable_grow', 'reftable_update', + 'refblock_load', 'refblock_update', 'refblock_update_part', + 'refblock_alloc', 'refblock_alloc.hookup', 'refblock_alloc.write', + 'refblock_alloc.write_blocks', 'refblock_alloc.write_table', + 'refblock_alloc.switch_table', 'cluster_alloc', + 'cluster_alloc_bytes', 'cluster_free', 'flush_to_os', + 'flush_to_disk' ] } + +## +# @BlkdebugInjectErrorOptions +# +# Describes a single error injection for blkdebug. +# +# @event: trigger event +# +# @state: #optional the state identifier blkdebug needs to be in to +# actually trigger the event; defaults to "any" +# +# @errno: #optional error identifier (errno) to be returned; defaults to +# EIO +# +# @sector: #optional specifies the sector index which has to be affected +# in order to actually trigger the event; defaults to "any +# sector" +# +# @once: #optional disables further events after this one has been +# triggered; defaults to false +# +# @immediately: #optional fail immediately; defaults to false +# +# Since: 2.0 +## +{ 'type': 'BlkdebugInjectErrorOptions', + 'data': { 'event': 'BlkdebugEvent', + '*state': 'int', + '*errno': 'int', + '*sector': 'int', + '*once': 'bool', + '*immediately': 'bool' } } + +## +# @BlkdebugSetStateOptions +# +# Describes a single state-change event for blkdebug. +# +# @event: trigger event +# +# @state: #optional the current state identifier blkdebug needs to be in; +# defaults to "any" +# +# @new_state: the state identifier blkdebug is supposed to assume if +# this event is triggered +# +# Since: 2.0 +## +{ 'type': 'BlkdebugSetStateOptions', + 'data': { 'event': 'BlkdebugEvent', + '*state': 'int', + 'new_state': 'int' } } + +## +# @BlockdevOptionsBlkdebug +# +# Driver specific block device options for blkdebug. +# +# @image: underlying raw block device (or image file) +# +# @config: #optional filename of the configuration file +# +# @inject-error: #optional array of error injection descriptions +# +# @set-state: #optional array of state-change descriptions +# +# Since: 2.0 +## +{ 'type': 'BlockdevOptionsBlkdebug', + 'data': { 'image': 'BlockdevRef', + '*config': 'str', + '*inject-error': ['BlkdebugInjectErrorOptions'], + '*set-state': ['BlkdebugSetStateOptions'] } } + +## +# @BlockdevOptionsBlkverify +# +# Driver specific block device options for blkverify. +# +# @test: block device to be tested +# +# @raw: raw image used for verification +# +# Since: 2.0 +## +{ 'type': 'BlockdevOptionsBlkverify', + 'data': { 'test': 'BlockdevRef', + 'raw': 'BlockdevRef' } } + +## # @BlockdevOptions # # Options for creating a block device.
@@ -4190,10 +4297,8 @@ # TODO sheepdog: Wait for structured options # TODO ssh: Should take InetSocketAddress for 'host'? 'vvfat': 'BlockdevOptionsVVFAT', - -# TODO blkdebug: Wait for structured options -# TODO blkverify: Wait for structured options - + 'blkdebug': 'BlockdevOptionsBlkdebug', + 'blkverify': 'BlockdevOptionsBlkverify', 'bochs': 'BlockdevOptionsGenericFormat', 'cloop': 'BlockdevOptionsGenericFormat', 'cow': 'BlockdevOptionsGenericCOWFormat',
Signature · 1 line
1.8.5.1
PATCH v7 20/24 qemu-io: Make filename optional
In reply to Max ReitzGiving a filename is actually not essential, since it can be specified through the options as well - on the contrary: Sometimes a filename must not be given.
--- qemu-io.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
qemu-io.c +5 -3
@@ -160,11 +160,13 @@ static int open_f(BlockDriverState *bs, int argc, char **argv) flags |=BDRV_O_RDWR ; } -if (optind != argc -1 ) { +if (optind == argc -1 ) { +return openfile (argv[optind], flags, growable, opts); + }else if (optind == argc) { +return openfile (NULL , flags, growable, opts); + }else {return qemuio_command_usage (&open_cmd); } - -return openfile (argv[optind], flags, growable, opts); }static int quit_f (BlockDriverState *bs,int argc,char **argv)
Signature · 1 line
1.8.5.1
PATCH v7 21/24 tests: Add test for qdict_array_split()
In reply to Max ReitzAdd a test case for qdict_array_split() in tests/check-qdict.c.
--- tests/check-qdict.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+)
tests/check-qdict.c +80 -0
@@ -227,6 +227,85 @@ static void qdict_iterapi_test(void)QDECREF (tests_dict); } +static void qdict_array_split_test (void ) +{ +QDict *test_dict =qdict_new (); +QDict *dict1, *dict2; +QList *test_list; + +/* +* Test the split of +* +* { +* "1.x": 0, +* "3.y": 1, +* "0.a": 42, +* "o.o": 7, +* "0.b": 23 +* } +* +* to +* +* [ +* { +* "a": 42 +* }, +* { +* "x": 0, +* "y": 1 +* } +* ] +* +* and +* +* { +* "3.y": 1, +* "o.o": 7 +* } +* +* (remaining in the old QDict) +* +* This example is given in the comment of qdict_array_split(). +*/ + +qdict_put (test_dict,"1.x" ,qint_from_int (0 )); +qdict_put (test_dict,"3.y" ,qint_from_int (1 )); +qdict_put (test_dict,"0.a" ,qint_from_int (42 )); +qdict_put (test_dict,"o.o" ,qint_from_int (7 )); +qdict_put (test_dict,"0.b" ,qint_from_int (23 )); + +qdict_array_split (test_dict, &test_list); + + dict1 =qobject_to_qdict (qlist_pop (test_list)); + dict2 =qobject_to_qdict (qlist_pop (test_list)); + +g_assert (dict1); +g_assert (dict2); +g_assert (qlist_empty (test_list)); + +QDECREF (test_list); + +g_assert (qdict_get_int (dict1,"a" ) ==42 ); +g_assert (qdict_get_int (dict1,"b" ) ==23 ); + +g_assert (qdict_size (dict1) ==2 ); + +QDECREF (dict1); + +g_assert (qdict_get_int (dict2,"x" ) ==0 ); + +g_assert (qdict_size (dict2) ==1 ); + +QDECREF (dict2); + +g_assert (qdict_get_int (test_dict,"3.y" ) ==1 ); +g_assert (qdict_get_int (test_dict,"o.o" ) ==7 ); + +g_assert (qdict_size (test_dict) ==2 ); + +QDECREF (test_dict); +} +/* * Errors test-cases */
@@ -365,6 +444,7 @@ int main(int argc, char **argv)g_test_add_func ("/public/del" , qdict_del_test);g_test_add_func ("/public/to_qdict" , qobject_to_qdict_test);g_test_add_func ("/public/iterapi" , qdict_iterapi_test); +g_test_add_func ("/public/array_split" , qdict_array_split_test);g_test_add_func ("/errors/put_exists" , qdict_put_exists_test);g_test_add_func ("/errors/get_not_exists" , qdict_get_not_exists_test);
Signature · 1 line
1.8.5.1
Re: [Qemu-devel] [PATCH v7 21/24] tests: Add test for qdict_array_split()
Quoted 6 lines · Max Reitz
Add a test case for
qdict_array_split()intests/check-qdict.c.Signed-off-by Max Reitz <[email protected]>--- tests/check-qdict.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
PATCH v7 22/24 tests: Add test for qdict_flatten()
In reply to Max ReitzAdd a test case for qdict_flatten() in tests/check-qdict.c. This test case covers the flattening of subordinate QLists as well.
--- tests/check-qdict.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
tests/check-qdict.c +76 -0
@@ -227,6 +227,81 @@ static void qdict_iterapi_test(void)QDECREF (tests_dict); } +static void qdict_flatten_test (void ) +{ +QList *list1 =qlist_new (); +QList *list2 =qlist_new (); +QDict *dict1 =qdict_new (); +QDict *dict2 =qdict_new (); +QDict *dict3 =qdict_new (); + +/* +* Test the flattening of +* +* { +* "e": [ +* 42, +* [ +* 23, +* 66, +* { +* "a": 0, +* "b": 1 +* } +* ] +* ], +* "f": { +* "c": 2, +* "d": 3, +* }, +* "g": 4 +* } +* +* to +* +* { +* "e.0": 42, +* "e.1.0": 23, +* "e.1.1": 66, +* "e.1.2.a": 0, +* "e.1.2.b": 1, +* "f.c": 2, +* "f.d": 3, +* "g": 4 +* } +*/ + +qdict_put (dict1,"a" ,qint_from_int (0 )); +qdict_put (dict1,"b" ,qint_from_int (1 )); + +qlist_append_obj (list1,QOBJECT (qint_from_int (23 ))); +qlist_append_obj (list1,QOBJECT (qint_from_int (66 ))); +qlist_append_obj (list1,QOBJECT (dict1)); +qlist_append_obj (list2,QOBJECT (qint_from_int (42 ))); +qlist_append_obj (list2,QOBJECT (list1)); + +qdict_put (dict2,"c" ,qint_from_int (2 )); +qdict_put (dict2,"d" ,qint_from_int (3 )); +qdict_put_obj (dict3,"e" ,QOBJECT (list2)); +qdict_put_obj (dict3,"f" ,QOBJECT (dict2)); +qdict_put (dict3,"g" ,qint_from_int (4 )); + +qdict_flatten (dict3); + +g_assert (qdict_get_int (dict3,"e.0" ) ==42 ); +g_assert (qdict_get_int (dict3,"e.1.0" ) ==23 ); +g_assert (qdict_get_int (dict3,"e.1.1" ) ==66 ); +g_assert (qdict_get_int (dict3,"e.1.2.a" ) ==0 ); +g_assert (qdict_get_int (dict3,"e.1.2.b" ) ==1 ); +g_assert (qdict_get_int (dict3,"f.c" ) ==2 ); +g_assert (qdict_get_int (dict3,"f.d" ) ==3 ); +g_assert (qdict_get_int (dict3,"g" ) ==4 ); + +g_assert (qdict_size (dict3) ==8 ); + +QDECREF (dict3); +} +static void qdict_array_split_test (void ) {QDict *test_dict =qdict_new ();
@@ -444,6 +519,7 @@ int main(int argc, char **argv)g_test_add_func ("/public/del" , qdict_del_test);g_test_add_func ("/public/to_qdict" , qobject_to_qdict_test);g_test_add_func ("/public/iterapi" , qdict_iterapi_test); +g_test_add_func ("/public/flatten" , qdict_flatten_test);g_test_add_func ("/public/array_split" , qdict_array_split_test);g_test_add_func ("/errors/put_exists" , qdict_put_exists_test);
Signature · 1 line
1.8.5.1
Re: [Qemu-devel] [PATCH v7 22/24] tests: Add test for qdict_flatten()
Quoted 8 lines · Max Reitz
Add a test case for
qdict_flatten()intests/check-qdict.c. This test case covers the flattening of subordinate QLists as well.Signed-off-by Max Reitz <[email protected]>--- tests/check-qdict.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
PATCH v7 23/24 iotests: Test new blkdebug/blkverify interface
In reply to Max ReitzAdd a test for the new blkdebug/blkverify interface.
This test is not written in Python, although it uses QMP. This is because it invokes the qemu-io HMP command, which outputs errors to stderr instead of returning them through QMP. Filtering and testing that output is easier in a shell script than with the Python infrastructure.
--- tests/qemu-iotests/071 | 239 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/071.out | 90 +++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 330 insertions(+) create mode 100755 tests/qemu-iotests/071 create mode 100644 tests/qemu-iotests/071.out
tests/qemu-iotests/071 new file +239 -0
@@ -0,0 +1,239 @@ +#!/bin/bash +# +# Test case for the QMP blkdebug and blkverify interfaces +# +# Copyright (C) 2013 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator [email protected] + +seq="$(basename $0)" +echo "QA output created by $seq" + +here="$PWD" +tmp=/tmp/$$ +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +_supported_fmt generic +_supported_proto generic +_supported_os Linux + +function do_run_qemu() +{ + echo Testing: "$@" | _filter_imgfmt + $QEMU -nographic -qmp stdio -serial none "$@" + echo +} + +function run_qemu() +{ + do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp | _filter_qemu_io +} + +IMG_SIZE=64M + +echo +echo "=== Testing blkverify through filename ===" +echo + +TEST_IMG="$TEST_IMG.base" IMGOPTS="" IMGFMT="raw" _make_test_img $IMG_SIZE |\ + _filter_imgfmt +_make_test_img $IMG_SIZE +$QEMU_IO -c "open -o file.driver=blkverify,file.raw.filename=$TEST_IMG.base $TEST_IMG" \ + -c 'read 0 512' -c 'write -P 42 0x38000 512' -c 'read -P 42 0x38000 512' | _filter_qemu_io + +$QEMU_IO -c 'write -P 42 0 512' "$TEST_IMG" | _filter_qemu_io + +$QEMU_IO -c "open -o file.driver=blkverify,file.raw.filename=$TEST_IMG.base $TEST_IMG" \ + -c 'read -P 42 0 512' | _filter_qemu_io + +echo +echo "=== Testing blkverify through file blockref ===" +echo + +TEST_IMG="$TEST_IMG.base" IMGOPTS="" IMGFMT="raw" _make_test_img $IMG_SIZE |\ + _filter_imgfmt +_make_test_img $IMG_SIZE +$QEMU_IO -c "open -o file.driver=blkverify,file.raw.filename=$TEST_IMG.base,file.test.driver=$IMGFMT,file.test.file.filename=$TEST_IMG" \ + -c 'read 0 512' -c 'write -P 42 0x38000 512' -c 'read -P 42 0x38000 512' | _filter_qemu_io + +$QEMU_IO -c 'write -P 42 0 512' "$TEST_IMG" | _filter_qemu_io + +$QEMU_IO -c "open -o file.driver=blkverify,file.raw.filename=$TEST_IMG.base $TEST_IMG" \ + -c 'read -P 42 0 512' | _filter_qemu_io + +echo +echo "=== Testing blkdebug through filename ===" +echo + +$QEMU_IO -c "open -o file.driver=blkdebug,file.inject-error.event=l2_load $TEST_IMG" \ + -c 'read -P 42 0x38000 512' + +echo +echo "=== Testing blkdebug through file blockref ===" +echo + +$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.inject-error.event=l2_load,file.image.filename=$TEST_IMG" \ + -c 'read -P 42 0x38000 512' + +echo +echo "=== Testing blkdebug on existing block device ===" +echo + +run_qemu -drive "file=$TEST_IMG,format=raw,if=none,id=drive0" <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", + "arguments": { + "options": { + "driver": "$IMGFMT", + "id": "drive0-debug", + "file": { + "driver": "blkdebug", + "image": "drive0", + "inject-error": [{ + "event": "l2_load" + }] + } + } + } +} +{ "execute": "human-monitor-command", + "arguments": { + "command-line": 'qemu-io drive0-debug "read 0 512"' + } +} +{ "execute": "quit" } +EOF + +echo +echo "=== Testing blkverify on existing block device ===" +echo + +run_qemu -drive "file=$TEST_IMG,format=$IMGFMT,if=none,id=drive0" <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", + "arguments": { + "options": { + "driver": "blkverify", + "id": "drive0-verify", + "test": "drive0", + "raw": { + "driver": "raw", + "file": { + "driver": "file", + "filename": "$TEST_IMG.base" + } + } + } + } +} +{ "execute": "human-monitor-command", + "arguments": { + "command-line": 'qemu-io drive0-verify "read 0 512"' + } +} +{ "execute": "quit" } +EOF + +echo +echo "=== Testing blkverify on existing raw block device ===" +echo + +run_qemu -drive "file=$TEST_IMG.base,if=none,id=drive0" <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", + "arguments": { + "options": { + "driver": "blkverify", + "id": "drive0-verify", + "test": { + "driver": "$IMGFMT", + "file": { + "driver": "file", + "filename": "$TEST_IMG" + } + }, + "raw": "drive0" + } + } +} +{ "execute": "human-monitor-command", + "arguments": { + "command-line": 'qemu-io drive0-verify "read 0 512"' + } +} +{ "execute": "quit" } +EOF + +echo +echo "=== Testing blkdebug's set-state through QMP ===" +echo + +run_qemu -drive "file=$TEST_IMG,format=raw,if=none,id=drive0" <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", + "arguments": { + "options": { + "driver": "$IMGFMT", + "id": "drive0-debug", + "file": { + "driver": "blkdebug", + "image": "drive0", + "inject-error": [{ + "event": "read_aio", + "state": 42 + }], + "set-state": [{ + "event": "write_aio", + "new_state": 42 + }] + } + } + } +} +{ "execute": "human-monitor-command", + "arguments": { + "command-line": 'qemu-io drive0-debug "read 0 512"' + } +} +{ "execute": "human-monitor-command", + "arguments": { + "command-line": 'qemu-io drive0-debug "write 0 512"' + } +} +{ "execute": "human-monitor-command", + "arguments": { + "command-line": 'qemu-io drive0-debug "read 0 512"' + } +} +{ "execute": "quit" } +EOF + +# success, all done +echo "*** done" +rm -f $seq.full +status=0
tests/qemu-iotests/071.out new file +90 -0
90 lines not on this page · raw message
tests/qemu-iotests/group +1 -0
@@ -77,5 +77,6 @@ 068 rw auto 069 rw auto 070 rw auto +071 rw auto 073 rw auto 074 rw auto
Signature · 1 line
1.8.5.1
PATCH v7 24/24 iotests: Test file format nesting
In reply to Max ReitzAdd a test for nested image formats.
--- tests/qemu-iotests/072 | 69 ++++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/072.out | 21 ++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 91 insertions(+) create mode 100755 tests/qemu-iotests/072 create mode 100644 tests/qemu-iotests/072.out
tests/qemu-iotests/072 new file +69 -0
@@ -0,0 +1,69 @@ +#!/bin/bash +# +# Test case for nested image formats +# +# Copyright (C) 2013 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator [email protected] + +seq="$(basename $0)" +echo "QA output created by $seq" + +here="$PWD" +tmp=/tmp/$$ +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +_supported_fmt vpc vmdk vhdx vdi qed qcow2 qcow cow +_supported_proto generic +_supported_os Linux + +IMG_SIZE=64M + +echo +echo "=== Testing nested image formats ===" +echo + +TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE + +$QEMU_IO -c 'write -P 42 0 512' -c 'write -P 23 512 512' \ + -c 'write -P 66 1024 512' "$TEST_IMG.base" | _filter_qemu_io + +$QEMU_IMG convert -f raw -O $IMGFMT "$TEST_IMG.base" "$TEST_IMG" + +$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=$IMGFMT,file.file.filename=$TEST_IMG" \ + -c 'read -P 42 0 512' -c 'read -P 23 512 512' \ + -c 'read -P 66 1024 512' | _filter_qemu_io + +# When not giving any format, qemu should open only one "layer". Therefore, this +# should not work for any image formats with a header. +$QEMU_IO -c 'read -P 42 0 512' "$TEST_IMG" | _filter_qemu_io + +# success, all done +echo "*** done" +rm -f $seq.full +status=0
tests/qemu-iotests/072.out new file +21 -0
@@ -0,0 +1,21 @@ +QA output created by 072 + +=== Testing nested image formats === + +Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +wrote 512/512 bytes at offset 512 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +wrote 512/512 bytes at offset 1024 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +read 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +read 512/512 bytes at offset 512 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +read 512/512 bytes at offset 1024 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +Pattern verification failed at offset 0, 512 bytes +read 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +*** done
tests/qemu-iotests/group +1 -0
@@ -78,5 +78,6 @@ 069 rw auto 070 rw auto 071 rw auto +072 rw auto 073 rw auto 074 rw auto
Signature · 1 line
1.8.5.1
Kevin Wolf
AppliedAm 20.12.2013 um 19:28 hat Max Reitz geschrieben:
Quoted 19 lines
Currently, the configuration of blkdebug and blkverify is done through the "filename" alone. There is now way of manually choosing blkdebug or blkverify as a driver and using a normal image filename.
In the case of blkdebug, the filename starts with the protocol prefix, follows up with the name of a configuration file and ends with the name of the image file.
In the case of blkverify, the filename starts with the protocol prefix, follows up with the raw reference image filename and ends with the name of the image file.
This patch allows the configuration of both drivers completely through QMP and accordingly command-line options. The driver has to be selected through the driver option (or similar), the image filename may be given either as the filename itself or through a x.filename option, where "x" depends on the driver. Further options may be required depending on the driver.
Quoted 8 lines
In case of blkverify, the test image may be specified either through the filename or as a BlockdevRef reference through the "test" option. The raw image is referenced as "raw".
In case of blkdebug, one may either set the "config" option to the filename of a configuration file, or the content of the configuration file may be given directly (as options). The image filename is either specified as the filename or referenced through the "image" option.
Thanks, applied to the block branch.
I guess the next step is to untangle bdrv_file_open() and bdrv_open(), because that part has become really confusing now... But I think this series is a nice step forward.
Kevin