[Qemu-devel] [PATCH v4 0/6] Provide additional info through qemu-img info

[Qemu-devel] [PATCH v4 0/6] Provide additional info through qemu-img info

[Max Reitz]

qemu-img info provides only pretty general information about an image.
For any image format, there might be specific options which cannot be
represented in a universal way; for instance, qcow2 provides the
compatibility and lazy_refcount options whose values are certainly
interesting but currently cannot be output by qemu-img info.

Therefore, this series adds a new ImageInfoSpecific union type to
ImageInfo and BlockDriverInfo which may be used by block drivers as a
template for new types dedicated to the specific information they can
provide. It also adds support to qemu-img info and qemu-io -c info to
print the content of these specific structures.

v4:
 - changed dirty "grep -A 42" for grepping all lines until EOF in test
   064 to cleaner "sed -n '//,$p'" (patch 6)
 - rebased on Kevin's block branch (affects line numbers in patches 2, 3
   and 4 as well as the group file change in patch 6)

v3:
 - implemented Fam's remarks:
   - bdrv_get_info already initializes all fields to NULL, no need to do
     this manually (patch 2)
   - implemented bdrv_put_info as a wrapper to
     qapi_free_ImageInfoSpecific, though this may change with further
     extensions to BlockDriverInfo (patch 2)
   - changed one occurence of puts("foo") to printf("foo\n") in order to
     be consistent with the surrounding code (patch 3)
   - other patches (1, 4, 5, 6) remain unmodified

v2:
 - following Eric's recommendation: changed the representation of the
   format specific information from an uninterpreted blobbed string to a
   union of format specific types

Max Reitz (6):
  qapi: Add ImageInfoSpecific type
  block: Add ImageInfoSpecific to BlockDriverInfo
  block/qapi: Human-readable ImageInfoSpecific dump
  qcow2: Add support for ImageInfoSpecific
  qemu-iotests: Discard specific info in _img_info
  qemu-iotests: Additional info from qemu-img info

 block.c                      |  16 +++++-
 block/mirror.c               |  16 ++++--
 block/qapi.c                 | 125 +++++++++++++++++++++++++++++++++++++++++++
 block/qcow2.c                |  12 +++++
 include/block/block.h        |   3 ++
 include/block/qapi.h         |   2 +
 qapi-schema.json             |  34 +++++++++++-
 qemu-img.c                   |   1 +
 qemu-io-cmds.c               |   8 +++
 tests/qemu-iotests/064       |  72 +++++++++++++++++++++++++
 tests/qemu-iotests/064.out   |  22 ++++++++
 tests/qemu-iotests/common.rc |  19 ++++++-
 tests/qemu-iotests/group     |   1 +
 13 files changed, 323 insertions(+), 8 deletions(-)
 create mode 100755 tests/qemu-iotests/064
 create mode 100644 tests/qemu-iotests/064.out

-- 
1.8.3.1

[Qemu-devel] [PATCH v4 1/6] qapi: Add ImageInfoSpecific type

[Max Reitz]

Add a new type ImageInfoSpecific as a union for image format specific
information in ImageInfo.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qapi-schema.json | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/qapi-schema.json b/qapi-schema.json
index 2b2c8bc..d4c63d9 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -210,6 +210,18 @@
             'vm-clock-sec': 'int', 'vm-clock-nsec': 'int' } }
 
 ##
+# @ImageInfoSpecific:
+#
+# A discriminated record of image format specific information structures.
+#
+# Since: 1.7
+##
+
+{ 'union': 'ImageInfoSpecific',
+  'data': {
+  } }
+
+##
 # @ImageInfo:
 #
 # Information about a QEMU image file
@@ -238,6 +250,9 @@
 #
 # @backing-image: #optional info of the backing image (since 1.6)
 #
+# @info-string: #optional string supplying additional format-specific
+# information (since 1.7)
+#
 # Since: 1.3
 #
 ##
@@ -248,7 +263,8 @@
            '*cluster-size': 'int', '*encrypted': 'bool',
            '*backing-filename': 'str', '*full-backing-filename': 'str',
            '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'],
-           '*backing-image': 'ImageInfo' } }
+           '*backing-image': 'ImageInfo',
+           '*format-specific': 'ImageInfoSpecific' } }
 
 ##
 # @ImageCheck:
-- 
1.8.3.1

[Qemu-devel] [PATCH v4 2/6] block: Add ImageInfoSpecific to BlockDriverInfo

[Max Reitz]

Add the new ImageInfoSpecific type also to BlockDriverInfo, as well as a
bdrv_put_info function which releases all data allocated by
bdrv_get_info from BlockDriverInfo (such as the new ImageInfoSpecific
field).

To prevent memory leaks, bdrv_put_info has to be called on every
BlockDriverInfo object when it is no longer required (and bdrv_get_info
has been successful).

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block.c               | 16 +++++++++++++++-
 block/mirror.c        | 16 +++++++++++-----
 block/qapi.c          |  4 ++++
 include/block/block.h |  3 +++
 qemu-img.c            |  1 +
 qemu-io-cmds.c        |  2 ++
 6 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c
index b81d1e2..604bef0 100644
--- a/block.c
+++ b/block.c
@@ -1953,8 +1953,10 @@ void bdrv_round_to_clusters(BlockDriverState *bs,
                             int *cluster_nb_sectors)
 {
     BlockDriverInfo bdi;
+    int ret;
 
-    if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
+    ret = bdrv_get_info(bs, &bdi);
+    if (ret < 0 || bdi.cluster_size == 0) {
         *cluster_sector_num = sector_num;
         *cluster_nb_sectors = nb_sectors;
     } else {
@@ -1963,6 +1965,9 @@ void bdrv_round_to_clusters(BlockDriverState *bs,
         *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
                                             nb_sectors, c);
     }
+    if (ret >= 0) {
+        bdrv_put_info(bs, &bdi);
+    }
 }
 
 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
@@ -3281,6 +3286,15 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
     return drv->bdrv_get_info(bs, bdi);
 }
 
+/**
+ * Releases all data which has been allocated through bdrv_get_info. This
+ * function should be called if and only if bdrv_get_info was successful.
+ */
+void bdrv_put_info(BlockDriverState *bs, BlockDriverInfo *bdi)
+{
+    qapi_free_ImageInfoSpecific(bdi->format_specific);
+}
+
 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                       int64_t pos, int size)
 {
diff --git a/block/mirror.c b/block/mirror.c
index f61a779..7d3eb29 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -320,10 +320,12 @@ static void coroutine_fn mirror_run(void *opaque)
     bdrv_get_backing_filename(s->target, backing_filename,
                               sizeof(backing_filename));
     if (backing_filename[0] && !s->target->backing_hd) {
-        bdrv_get_info(s->target, &bdi);
-        if (s->granularity < bdi.cluster_size) {
-            s->buf_size = MAX(s->buf_size, bdi.cluster_size);
-            s->cow_bitmap = bitmap_new(length);
+        if (bdrv_get_info(s->target, &bdi) >= 0) {
+            if (s->granularity < bdi.cluster_size) {
+                s->buf_size = MAX(s->buf_size, bdi.cluster_size);
+                s->cow_bitmap = bitmap_new(length);
+            }
+            bdrv_put_info(s->target, &bdi);
         }
     }
 
@@ -545,12 +547,16 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,
         /* Choose the default granularity based on the target file's cluster
          * size, clamped between 4k and 64k.  */
         BlockDriverInfo bdi;
-        if (bdrv_get_info(target, &bdi) >= 0 && bdi.cluster_size != 0) {
+        int ret = bdrv_get_info(target, &bdi);
+        if (ret >= 0 && bdi.cluster_size != 0) {
             granularity = MAX(4096, bdi.cluster_size);
             granularity = MIN(65536, granularity);
         } else {
             granularity = 65536;
         }
+        if (ret >= 0) {
+            bdrv_put_info(target, &bdi);
+        }
     }
 
     assert ((granularity & (granularity - 1)) == 0);
diff --git a/block/qapi.c b/block/qapi.c
index 782051c..738469a 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -133,6 +133,10 @@ void bdrv_query_image_info(BlockDriverState *bs,
         }
         info->dirty_flag = bdi.is_dirty;
         info->has_dirty_flag = true;
+        if (bdi.format_specific) {
+            info->format_specific = bdi.format_specific;
+            info->has_format_specific = true;
+        }
     }
     backing_filename = bs->backing_file;
     if (backing_filename[0] != '\0') {
diff --git a/include/block/block.h b/include/block/block.h
index 1c5f939..a9b3b16 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -18,6 +18,8 @@ typedef struct BlockDriverInfo {
     /* offset at which the VM state can be saved (0 if not possible) */
     int64_t vm_state_offset;
     bool is_dirty;
+    /* additional information; NULL if none */
+    ImageInfoSpecific *format_specific;
 } BlockDriverInfo;
 
 typedef struct BlockFragInfo {
@@ -334,6 +336,7 @@ int bdrv_get_flags(BlockDriverState *bs);
 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
                           const uint8_t *buf, int nb_sectors);
 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
+void bdrv_put_info(BlockDriverState *bs, BlockDriverInfo *bdi);
 void bdrv_round_to_clusters(BlockDriverState *bs,
                             int64_t sector_num, int nb_sectors,
                             int64_t *cluster_sector_num,
diff --git a/qemu-img.c b/qemu-img.c
index 0cf6be2..66bc696 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1393,6 +1393,7 @@ static int img_convert(int argc, char **argv)
             goto out;
         }
         cluster_size = bdi.cluster_size;
+        bdrv_put_info(out_bs, &bdi);
         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
             error_report("invalid cluster size");
             ret = -1;
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index 8565d49..5029b19 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -1699,6 +1699,8 @@ static int info_f(BlockDriverState *bs, int argc, char **argv)
     printf("cluster size: %s\n", s1);
     printf("vm state offset: %s\n", s2);
 
+    bdrv_put_info(bs, &bdi);
+
     return 0;
 }
 
-- 
1.8.3.1

[Qemu-devel] [PATCH v4 3/6] block/qapi: Human-readable ImageInfoSpecific dump

[Max Reitz]

Add a function for generically dumping the ImageInfoSpecific information
in a human-readable format to block/qapi.c.

Use this function in bdrv_image_info_dump and qemu-io-cmds.c:info_f to
allow qemu-img info resp. qemu-io -c info to print that format specific
information.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qapi.c         | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++
 include/block/qapi.h |   2 +
 qemu-io-cmds.c       |   6 +++
 3 files changed, 129 insertions(+)

diff --git a/block/qapi.c b/block/qapi.c
index 738469a..dbf1e7b 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -25,6 +25,9 @@
 #include "block/qapi.h"
 #include "block/block_int.h"
 #include "qmp-commands.h"
+#include "qapi-visit.h"
+#include "qapi/qmp-output-visitor.h"
+#include "qapi/qmp/types.h"
 
 /*
  * Returns 0 on success, with *p_list either set to describe snapshot
@@ -427,6 +430,119 @@ void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f,
     }
 }
 
+static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation,
+                       QDict *dict);
+static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation,
+                       QList *list);
+
+static void dump_qobject(fprintf_function func_fprintf, void *f,
+                         int comp_indent, QObject *obj)
+{
+    switch (qobject_type(obj)) {
+        case QTYPE_QINT: {
+            QInt *value = qobject_to_qint(obj);
+            func_fprintf(f, "%" PRId64, qint_get_int(value));
+            break;
+        }
+        case QTYPE_QSTRING: {
+            QString *value = qobject_to_qstring(obj);
+            func_fprintf(f, "%s", qstring_get_str(value));
+            break;
+        }
+        case QTYPE_QDICT: {
+            QDict *value = qobject_to_qdict(obj);
+            dump_qdict(func_fprintf, f, comp_indent, value);
+            break;
+        }
+        case QTYPE_QLIST: {
+            QList *value = qobject_to_qlist(obj);
+            dump_qlist(func_fprintf, f, comp_indent, value);
+            break;
+        }
+        case QTYPE_QFLOAT: {
+            QFloat *value = qobject_to_qfloat(obj);
+            func_fprintf(f, "%g", qfloat_get_double(value));
+            break;
+        }
+        case QTYPE_QBOOL: {
+            QBool *value = qobject_to_qbool(obj);
+            func_fprintf(f, "%s", qbool_get_int(value) ? "true" : "false");
+            break;
+        }
+        case QTYPE_QERROR: {
+            QString *value = qerror_human((QError *)obj);
+            func_fprintf(f, "%s", qstring_get_str(value));
+            break;
+        }
+        case QTYPE_NONE:
+            break;
+        case QTYPE_MAX:
+        default:
+            abort();
+    }
+}
+
+static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation,
+                       QList *list)
+{
+    const QListEntry *entry;
+    int i = 0;
+
+    for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) {
+        qtype_code type = qobject_type(entry->value);
+        bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST);
+        const char *format = composite ? "%*s[%i]:\n" : "%*s[%i]: ";
+
+        func_fprintf(f, format, indentation * 4, "", i);
+        dump_qobject(func_fprintf, f, indentation + 1, entry->value);
+        if (!composite) {
+            func_fprintf(f, "\n");
+        }
+    }
+}
+
+static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation,
+                       QDict *dict)
+{
+    const QDictEntry *entry;
+
+    for (entry = qdict_first(dict); entry; entry = qdict_next(dict, entry)) {
+        qtype_code type = qobject_type(entry->value);
+        bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST);
+        const char *format = composite ? "%*s%s:\n" : "%*s%s: ";
+        char key[strlen(entry->key) + 1];
+        int i;
+
+        /* replace dashes with spaces in key (variable) names */
+        for (i = 0; entry->key[i]; i++) {
+            key[i] = entry->key[i] == '-' ? ' ' : entry->key[i];
+        }
+        key[i] = 0;
+
+        func_fprintf(f, format, indentation * 4, "", key);
+        dump_qobject(func_fprintf, f, indentation + 1, entry->value);
+        if (!composite) {
+            func_fprintf(f, "\n");
+        }
+    }
+}
+
+void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f,
+                                   ImageInfoSpecific *info_spec)
+{
+    Error *local_err = NULL;
+    QmpOutputVisitor *ov = qmp_output_visitor_new();
+    QObject *obj, *data;
+
+    visit_type_ImageInfoSpecific(qmp_output_get_visitor(ov), &info_spec, NULL,
+                                 &local_err);
+    obj = qmp_output_get_qobject(ov);
+    assert(qobject_type(obj) == QTYPE_QDICT);
+    data = qdict_get(qobject_to_qdict(obj), "data");
+    dump_qobject(func_fprintf, f, 0, data);
+    qmp_output_visitor_cleanup(ov);
+}
+
 void bdrv_image_info_dump(fprintf_function func_fprintf, void *f,
                           ImageInfo *info)
 {
@@ -497,4 +613,9 @@ void bdrv_image_info_dump(fprintf_function func_fprintf, void *f,
             func_fprintf(f, "\n");
         }
     }
+
+    if (info->has_format_specific) {
+        func_fprintf(f, "Format specific information:\n");
+        bdrv_image_info_specific_dump(func_fprintf, f, info->format_specific);
+    }
 }
diff --git a/include/block/qapi.h b/include/block/qapi.h
index 0496cc9..9518ee4 100644
--- a/include/block/qapi.h
+++ b/include/block/qapi.h
@@ -42,6 +42,8 @@ BlockStats *bdrv_query_stats(const BlockDriverState *bs);
 
 void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f,
                         QEMUSnapshotInfo *sn);
+void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f,
+                                   ImageInfoSpecific *info_spec);
 void bdrv_image_info_dump(fprintf_function func_fprintf, void *f,
                           ImageInfo *info);
 #endif
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index 5029b19..dd61a60 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -10,6 +10,7 @@
 
 #include "qemu-io.h"
 #include "block/block_int.h"
+#include "block/qapi.h"
 #include "qemu/main-loop.h"
 
 #define CMD_NOFILE_OK   0x01
@@ -1699,6 +1700,11 @@ static int info_f(BlockDriverState *bs, int argc, char **argv)
     printf("cluster size: %s\n", s1);
     printf("vm state offset: %s\n", s2);
 
+    if (bdi.format_specific) {
+        printf("Format specific information:\n");
+        bdrv_image_info_specific_dump(fprintf, stdout, bdi.format_specific);
+    }
+
     bdrv_put_info(bs, &bdi);
 
     return 0;
-- 
1.8.3.1

[Qemu-devel] [PATCH v4 4/6] qcow2: Add support for ImageInfoSpecific

[Max Reitz]

Add a new ImageInfoSpecificQCow2 type as a subtype of ImageInfoSpecific.
This contains the compatibility level as a string and an optional
lazy_refcounts boolean (optional means mandatory for compat >= 1.1 and
not available for compat == 0.10).

In qcow2_get_info, fill the BlockDriverInfo.format_specific field with
that information.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2.c    | 12 ++++++++++++
 qapi-schema.json | 16 ++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/block/qcow2.c b/block/qcow2.c
index 7c9354c..6bc59c0 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -1761,8 +1761,20 @@ static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 {
     BDRVQcowState *s = bs->opaque;
+
     bdi->cluster_size = s->cluster_size;
     bdi->vm_state_offset = qcow2_vm_state_offset(s);
+
+    bdi->format_specific = g_new0(ImageInfoSpecific, 1);
+    bdi->format_specific->kind = IMAGE_INFO_SPECIFIC_KIND_QCOW2;
+    bdi->format_specific->qcow2 = g_new0(ImageInfoSpecificQCow2, 1);
+    if (s->qcow_version == 2) {
+        bdi->format_specific->qcow2->compat = g_strdup("0.10");
+    } else if (s->qcow_version == 3) {
+        bdi->format_specific->qcow2->compat = g_strdup("1.1");
+        bdi->format_specific->qcow2->lazy_refcounts = s->use_lazy_refcounts;
+        bdi->format_specific->qcow2->has_lazy_refcounts = true;
+    }
     return 0;
 }
 
diff --git a/qapi-schema.json b/qapi-schema.json
index d4c63d9..6de32ea 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -210,6 +210,21 @@
             'vm-clock-sec': 'int', 'vm-clock-nsec': 'int' } }
 
 ##
+# @ImageInfoSpecificQCow2:
+#
+# @compat: compatibility level
+#
+# @lazy-refcounts: #optional on or off; only valid for compat >= 1.1
+#
+# Since: 1.7
+##
+{ 'type': 'ImageInfoSpecificQCow2',
+  'data': {
+      'compat': 'str',
+      '*lazy-refcounts': 'bool'
+  } }
+
+##
 # @ImageInfoSpecific:
 #
 # A discriminated record of image format specific information structures.
@@ -219,6 +234,7 @@
 
 { 'union': 'ImageInfoSpecific',
   'data': {
+      'qcow2': 'ImageInfoSpecificQCow2'
   } }
 
 ##
-- 
1.8.3.1

[Qemu-devel] [PATCH v4 5/6] qemu-iotests: Discard specific info in _img_info

[Max Reitz]

In _img_info, filter out additional information specific to the image
format provided by qemu-img info, since tests designed for multiple
image formats would produce different outputs for every image format
else.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/common.rc | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index 88fecf7..7f68321 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -181,12 +181,29 @@ _check_test_img()
 
 _img_info()
 {
+    discard=0
     $QEMU_IMG info "$@" $TEST_IMG 2>&1 | \
         sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
             -e "s#$TEST_DIR#TEST_DIR#g" \
             -e "s#$IMGFMT#IMGFMT#g" \
             -e "/^disk size:/ D" \
-            -e "/actual-size/ D"
+            -e "/actual-size/ D" | \
+        while IFS='' read line; do
+            if [ "$line" == "Format specific information:" ]; then
+                discard=1
+            elif [ "`echo "$line" | sed -e 's/^ *//'`" == '"format-specific": {' ]; then
+                discard=2
+                json_indent="`echo "$line" | sed -e 's/^\( *\).*$/\1/'`"
+            fi
+            if [ $discard == 0 ]; then
+                echo "$line"
+            elif [ $discard == 1 -a -z "$line" ]; then
+                echo
+                discard=0
+            elif [ $discard == 2 -a "`echo "$line" | sed -e 's/ *$//'`" == "${json_indent}}," ]; then
+                discard=0
+            fi
+        done
 }
 
 _get_pids_by_name()
-- 
1.8.3.1

[Qemu-devel] [PATCH v4 6/6] qemu-iotests: Additional info from qemu-img info

[Max Reitz]

Add a test for the additional information now provided by qemu-img info
when used on qcow2 images.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/064     | 72 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/064.out | 22 ++++++++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 95 insertions(+)
 create mode 100755 tests/qemu-iotests/064
 create mode 100644 tests/qemu-iotests/064.out

diff --git a/tests/qemu-iotests/064 b/tests/qemu-iotests/064
new file mode 100755
index 0000000..5c56b56
--- /dev/null
+++ b/tests/qemu-iotests/064
@@ -0,0 +1,72 @@
+#!/bin/bash
+#
+# Test for additional information emitted by qemu-img info on qcow2
+# images
+#
+# 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
+owner=mreitz@redhat.com
+
+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
+
+# This tests qocw2-specific low-level functionality
+_supported_fmt qcow2
+_supported_proto generic
+_supported_os Linux
+
+IMG_SIZE=64M
+
+echo
+echo "=== Testing qcow2 image with -o compat=0.10 ==="
+echo
+IMGOPTS="compat=0.10" _make_test_img $IMG_SIZE
+# don't use _img_info, since that function will filter out the
+# additional information we're about to test for
+$QEMU_IMG info "$TEST_IMG" | sed -n '/^Format specific information:$/,$p'
+
+echo
+echo "=== Testing qcow2 image with -o compat=1.1,lazy_refcounts=off ==="
+echo
+IMGOPTS="compat=1.1,lazy_refcounts=off" _make_test_img $IMG_SIZE
+$QEMU_IMG info "$TEST_IMG" | sed -n '/^Format specific information:$/,$p'
+
+echo
+echo "=== Testing qcow2 image with -o compat=1.1,lazy_refcounts=on ==="
+echo
+IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img $IMG_SIZE
+$QEMU_IMG info "$TEST_IMG" | sed -n '/^Format specific information:$/,$p'
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/064.out b/tests/qemu-iotests/064.out
new file mode 100644
index 0000000..6ce5b43
--- /dev/null
+++ b/tests/qemu-iotests/064.out
@@ -0,0 +1,22 @@
+QA output created by 064
+
+=== Testing qcow2 image with -o compat=0.10 ===
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 
+Format specific information:
+compat: 0.10
+
+=== Testing qcow2 image with -o compat=1.1,lazy_refcounts=off ===
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 
+Format specific information:
+compat: 1.1
+lazy refcounts: false
+
+=== Testing qcow2 image with -o compat=1.1,lazy_refcounts=on ===
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 
+Format specific information:
+compat: 1.1
+lazy refcounts: true
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index 8012828..49e6d8a 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -68,3 +68,4 @@
 061 rw auto
 062 rw auto
 063 rw auto
+064 rw auto
-- 
1.8.3.1