[Qemu-devel] [PATCH V2 00/11] add qmp/hmp interfaces for snapshot info

[Qemu-devel] [PATCH V2 00/11] add qmp/hmp interfaces for snapshot info

[Wenchao Xia]

  This serial of patches does two things: merge some info code
in qemu-img, and add following interfaces:
1) qmp: query-images
2) qmp: query-snapshots
3) hmp: show snapshot info on a single block device
  These patches follows the rule that use qmp to retieve information,
hmp layer just do a translation from qmp object it got, so almost
every hmp interface may have a correlated qmp interface.
  To make code graceful, snapshot retrieving code in qemu and qemu-img
are merged into block.c, and some function name was adjusted to make it
tips better. Now it works as:

   qemu          qemu-img

dump_monitor    dump_stdout
     |--------------| 
            |
           qmp
            |
          block

Note:
  Last two patches need previous sent patches which extend hmp sub command, at:
http://lists.nongnu.org/archive/html/qemu-devel/2012-12/msg03487.html

v2:
  Rename and adjusted qmp interface according to comments from Eric.
  Spelling fix.
  Information retrieving function in block layer goes to seperated patch.
  Free qmp object after usage in hmp.

Wenchao Xia (11):
  qemu-img: remove unused parameter in collect_image_info()
  block: add bdrv_get_filename() function
  block: add snapshot and image info query function
  qemu-img: switch image retrieving function
  block: rename bdrv_query_info to bdrv_query_block_info
  qmp: add interface query-images.
  block: export function bdrv_find_snapshot()
  qmp: add interface query-snapshots
  hmp: export function hmp_handle_error()
  hmp: retrieve info from qmp for snapshot info
  hmp: show snapshot on single block device

 block.c               |  200 ++++++++++++++++++++++++++++++++++++++++++++++++-
 hmp.c                 |    2 +-
 hmp.h                 |    2 +
 include/block/block.h |   14 +++-
 monitor.c             |    6 +-
 qapi-schema.json      |   40 ++++++++++
 qemu-img.c            |   87 +---------------------
 qmp-commands.hx       |  129 +++++++++++++++++++++++++++++++
 savevm.c              |  137 +++++++++++++++++----------------
 9 files changed, 458 insertions(+), 159 deletions(-)

[Qemu-devel] [PATCH V2 01/11] qemu-img: remove unused parameter in collect_image_info()

[Wenchao Xia]

  Parameter *fmt was not used, so remove it.

Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 qemu-img.c |    5 ++---
 1 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c
index 85d3740..9dab48f 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1186,8 +1186,7 @@ static void dump_json_image_info(ImageInfo *info)
 
 static void collect_image_info(BlockDriverState *bs,
                    ImageInfo *info,
-                   const char *filename,
-                   const char *fmt)
+                   const char *filename)
 {
     uint64_t total_sectors;
     char backing_filename[1024];
@@ -1361,7 +1360,7 @@ static ImageInfoList *collect_image_info_list(const char *filename,
         }
 
         info = g_new0(ImageInfo, 1);
-        collect_image_info(bs, info, filename, fmt);
+        collect_image_info(bs, info, filename);
         collect_snapshots(bs, info);
 
         elem = g_new0(ImageInfoList, 1);
-- 
1.7.1

[Qemu-devel] [PATCH V2 02/11] block: add bdrv_get_filename() function

[Wenchao Xia]

  This function will simply return the uri or filename used
to open the image.

Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c               |    5 +++++
 include/block/block.h |    1 +
 2 files changed, 6 insertions(+), 0 deletions(-)

diff --git a/block.c b/block.c
index 4e28c55..5f95da5 100644
--- a/block.c
+++ b/block.c
@@ -2967,6 +2967,11 @@ BlockStatsList *qmp_query_blockstats(Error **errp)
     return head;
 }
 
+const char *bdrv_get_filename(BlockDriverState *bs)
+{
+    return bs->filename;
+}
+
 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
 {
     if (bs->backing_hd && bs->backing_hd->encrypted)
diff --git a/include/block/block.h b/include/block/block.h
index 0719339..a0fc2a6 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -310,6 +310,7 @@ 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);
 
+const char *bdrv_get_filename(BlockDriverState *bs);
 const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
 void bdrv_get_backing_filename(BlockDriverState *bs,
                                char *filename, int filename_size);
-- 
1.7.1

[Qemu-devel] [PATCH V2 03/11] block: add snapshot and image info query function

[Wenchao Xia]

  This patch added function bdrv_query_image_info() and
bdrv_query_snapshot_infolist(), which will return info in qmp object
format. The implemetion code are mostly copied from collect_image_info()
and collect_snapshot() in qemu-img.c.
  To help filter out snapshot info not needed, a call back function is
added in bdrv_query_snapshot_infolist().

v2:
  Seperate patch for adding these functions.
  Spelling fix.
  Coding style fix due to comments from Eric.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c               |  117 +++++++++++++++++++++++++++++++++++++++++++++++++
 include/block/block.h |    9 ++++
 2 files changed, 126 insertions(+), 0 deletions(-)

diff --git a/block.c b/block.c
index 5f95da5..81765a3 100644
--- a/block.c
+++ b/block.c
@@ -2846,6 +2846,123 @@ int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
     return 0;
 }
 
+SnapshotInfoList *bdrv_query_snapshot_infolist(BlockDriverState *bs,
+                                               SnapshotFilterFunc filter,
+                                               void *opaque,
+                                               Error **errp)
+{
+    int i, sn_count;
+    QEMUSnapshotInfo *sn_tab = NULL;
+    SnapshotInfoList *info_list, *cur_item = NULL, *head = NULL;
+    sn_count = bdrv_snapshot_list(bs, &sn_tab);
+    if (sn_count < 0) {
+        if (errp != NULL) {
+            error_setg(errp, "bdrv_snapshot_list: error %d\n", sn_count);
+        }
+        return NULL;
+    }
+
+    for (i = 0; i < sn_count; i++) {
+        if (filter && filter(&sn_tab[i], opaque) != 0) {
+            continue;
+        }
+
+        info_list = g_new0(SnapshotInfoList, 1);
+
+        info_list->value                = g_new0(SnapshotInfo, 1);
+        info_list->value->id            = g_strdup(sn_tab[i].id_str);
+        info_list->value->name          = g_strdup(sn_tab[i].name);
+        info_list->value->vm_state_size = sn_tab[i].vm_state_size;
+        info_list->value->date_sec      = sn_tab[i].date_sec;
+        info_list->value->date_nsec     = sn_tab[i].date_nsec;
+        info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
+        info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
+
+        /* XXX: waiting for the qapi to support qemu-queue.h types */
+        if (!cur_item) {
+            head = cur_item = info_list;
+        } else {
+            cur_item->next = info_list;
+            cur_item = info_list;
+        }
+
+    }
+
+    g_free(sn_tab);
+    return head;
+}
+
+/* collect all internal snapshot info in a image for ImageInfo */
+static void collect_snapshots_info(BlockDriverState *bs,
+                                   ImageInfo *info,
+                                   Error **errp)
+{
+    SnapshotInfoList *info_list;
+
+    info_list = bdrv_query_snapshot_infolist(bs, NULL, NULL, errp);
+    if (info_list != NULL) {
+        info->has_snapshots = true;
+        info->snapshots = info_list;
+    }
+    return;
+}
+
+static void collect_image_info(BlockDriverState *bs,
+                               ImageInfo *info)
+{
+    uint64_t total_sectors;
+    char backing_filename[1024];
+    char backing_filename2[1024];
+    BlockDriverInfo bdi;
+    const char *filename;
+
+    filename = bdrv_get_filename(bs);
+    bdrv_get_geometry(bs, &total_sectors);
+
+    info->filename        = g_strdup(filename);
+    info->format          = g_strdup(bdrv_get_format_name(bs));
+    info->virtual_size    = total_sectors * 512;
+    info->actual_size     = bdrv_get_allocated_file_size(bs);
+    info->has_actual_size = info->actual_size >= 0;
+    if (bdrv_is_encrypted(bs)) {
+        info->encrypted = true;
+        info->has_encrypted = true;
+    }
+    if (bdrv_get_info(bs, &bdi) >= 0) {
+        if (bdi.cluster_size != 0) {
+            info->cluster_size = bdi.cluster_size;
+            info->has_cluster_size = true;
+        }
+        info->dirty_flag = bdi.is_dirty;
+        info->has_dirty_flag = true;
+    }
+    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
+    if (backing_filename[0] != '\0') {
+        info->backing_filename = g_strdup(backing_filename);
+        info->has_backing_filename = true;
+        bdrv_get_full_backing_filename(bs, backing_filename2,
+                                       sizeof(backing_filename2));
+
+        if (strcmp(backing_filename, backing_filename2) != 0) {
+            info->full_backing_filename = g_strdup(backing_filename2);
+            info->has_full_backing_filename = true;
+        }
+
+        if (bs->backing_format[0]) {
+            info->backing_filename_format = g_strdup(bs->backing_format);
+            info->has_backing_filename_format = true;
+        }
+    }
+}
+
+ImageInfo *bdrv_query_image_info(BlockDriverState *bs, Error **errp)
+{
+    ImageInfo *info = g_new0(ImageInfo, 1);
+    collect_image_info(bs, info);
+    collect_snapshots_info(bs, info, errp);
+    return info;
+}
+
 BlockInfo *bdrv_query_info(BlockDriverState *bs)
 {
     BlockInfo *info = g_malloc0(sizeof(*info));
diff --git a/include/block/block.h b/include/block/block.h
index a0fc2a6..67f0d13 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -316,8 +316,17 @@ void bdrv_get_backing_filename(BlockDriverState *bs,
                                char *filename, int filename_size);
 void bdrv_get_full_backing_filename(BlockDriverState *bs,
                                     char *dest, size_t sz);
+
+typedef int (*SnapshotFilterFunc)(const QEMUSnapshotInfo *sn, void *opaque);
+/* assume bs is already opened, use qapi_free_* to free returned value. */
+SnapshotInfoList *bdrv_query_snapshot_infolist(BlockDriverState *bs,
+                                               SnapshotFilterFunc filter,
+                                               void *opaque,
+                                               Error **errp);
+ImageInfo *bdrv_query_image_info(BlockDriverState *bs, Error **errp);
 BlockInfo *bdrv_query_info(BlockDriverState *s);
 BlockStats *bdrv_query_stats(const BlockDriverState *bs);
+
 int bdrv_can_snapshot(BlockDriverState *bs);
 int bdrv_is_snapshot(BlockDriverState *bs);
 BlockDriverState *bdrv_snapshots(void);
-- 
1.7.1

Re: [Qemu-devel] [PATCH V2 03/11] block: add snapshot and image info query function

[Eric Blake]

[-- Attachment #1: Type: text/plain, Size: 1163 bytes --]

On 01/08/2013 10:12 PM, Wenchao Xia wrote:
>   This patch added function bdrv_query_image_info() and
> bdrv_query_snapshot_infolist(), which will return info in qmp object
> format. The implemetion code are mostly copied from collect_image_info()


s/implemetion/implementation/

> and collect_snapshot() in qemu-img.c.
>   To help filter out snapshot info not needed, a call back function is
> added in bdrv_query_snapshot_infolist().
> 
> v2:

Generally, the v2 information should go...

>   Seperate patch for adding these functions.
>   Spelling fix.
>   Coding style fix due to comments from Eric.
> 
> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
> ---

...here, after the S-o-b and --- separator.  It is useful for email
review, but doesn't need to clutter the final git history.

>  block.c               |  117 +++++++++++++++++++++++++++++++++++++++++++++++++
>  include/block/block.h |    9 ++++
>  2 files changed, 126 insertions(+), 0 deletions(-)
> 

Reviewed-by: Eric Blake <eblake@redhat.com>

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 619 bytes --]

Re: [Qemu-devel] [PATCH V2 03/11] block: add snapshot and image info query function

[Wenchao Xia]

于 2013-1-9 23:56, Eric Blake 写道:
> On 01/08/2013 10:12 PM, Wenchao Xia wrote:
>>    This patch added function bdrv_query_image_info() and
>> bdrv_query_snapshot_infolist(), which will return info in qmp object
>> format. The implemetion code are mostly copied from collect_image_info()
>
>
> s/implemetion/implementation/
>
OK.

>> and collect_snapshot() in qemu-img.c.
>>    To help filter out snapshot info not needed, a call back function is
>> added in bdrv_query_snapshot_infolist().
>>
>> v2:
>
> Generally, the v2 information should go...
>
   Do you know how to put change log under "---" in "git commit"?
I found it inconvenient to edit every ".patch" file, so added the
log directly in commit message.

>>    Seperate patch for adding these functions.
>>    Spelling fix.
>>    Coding style fix due to comments from Eric.
>>
>> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
>> ---
>
> ...here, after the S-o-b and --- separator.  It is useful for email
> review, but doesn't need to clutter the final git history.
>
>>   block.c               |  117 +++++++++++++++++++++++++++++++++++++++++++++++++
>>   include/block/block.h |    9 ++++
>>   2 files changed, 126 insertions(+), 0 deletions(-)
>>
>
> Reviewed-by: Eric Blake <eblake@redhat.com>
>


-- 
Best Regards

Wenchao Xia

Re: [Qemu-devel] [PATCH V2 03/11] block: add snapshot and image info query function

[Eric Blake]

[-- Attachment #1: Type: text/plain, Size: 896 bytes --]

On 01/09/2013 10:43 PM, Wenchao Xia wrote:

>>>
>>> v2:
>>
>> Generally, the v2 information should go...
>>
>   Do you know how to put change log under "---" in "git commit"?
> I found it inconvenient to edit every ".patch" file, so added the
> log directly in commit message.

Sure - manually put a --- as part of your commit message.  'git am'
doesn't care if there is more than one ---.  It does mean that you have
to float your S-o-b higher by hand, but doing it at commit time is
easier than doing post-editing of every .patch file at send-email time.
 Also, if you are editing a v2 of an existing series, you probably
already have a S-o-b line in the commit message that you are amending,
making it easy to scroll to the bottom, add ---, and then your v2 info.

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 619 bytes --]

Re: [Qemu-devel] [PATCH V2 03/11] block: add snapshot and image info query function

[Wenchao Xia]

于 2013-1-10 21:36, Eric Blake 写道:
> On 01/09/2013 10:43 PM, Wenchao Xia wrote:
>
>>>>
>>>> v2:
>>>
>>> Generally, the v2 information should go...
>>>
>>    Do you know how to put change log under "---" in "git commit"?
>> I found it inconvenient to edit every ".patch" file, so added the
>> log directly in commit message.
>
> Sure - manually put a --- as part of your commit message.  'git am'
> doesn't care if there is more than one ---.  It does mean that you have
> to float your S-o-b higher by hand, but doing it at commit time is
> easier than doing post-editing of every .patch file at send-email time.
>   Also, if you are editing a v2 of an existing series, you probably
> already have a S-o-b line in the commit message that you are amending,
> making it easy to scroll to the bottom, add ---, and then your v2 info.
>
   Thank you very much, this really helps.

-- 
Best Regards

Wenchao Xia

[Qemu-devel] [PATCH V2 04/11] qemu-img: switch image retrieving function

[Wenchao Xia]

  Now qemu-img call block layer function to get image info.

v2:
  Seperate patch for function switching in qemu-img.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 qemu-img.c |   86 +----------------------------------------------------------
 1 files changed, 2 insertions(+), 84 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c
index 9dab48f..e20551a 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1134,39 +1134,6 @@ static void dump_json_image_info_list(ImageInfoList *list)
     QDECREF(str);
 }
 
-static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
-{
-    int i, sn_count;
-    QEMUSnapshotInfo *sn_tab = NULL;
-    SnapshotInfoList *info_list, *cur_item = NULL;
-    sn_count = bdrv_snapshot_list(bs, &sn_tab);
-
-    for (i = 0; i < sn_count; i++) {
-        info->has_snapshots = true;
-        info_list = g_new0(SnapshotInfoList, 1);
-
-        info_list->value                = g_new0(SnapshotInfo, 1);
-        info_list->value->id            = g_strdup(sn_tab[i].id_str);
-        info_list->value->name          = g_strdup(sn_tab[i].name);
-        info_list->value->vm_state_size = sn_tab[i].vm_state_size;
-        info_list->value->date_sec      = sn_tab[i].date_sec;
-        info_list->value->date_nsec     = sn_tab[i].date_nsec;
-        info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
-        info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
-
-        /* XXX: waiting for the qapi to support qemu-queue.h types */
-        if (!cur_item) {
-            info->snapshots = cur_item = info_list;
-        } else {
-            cur_item->next = info_list;
-            cur_item = info_list;
-        }
-
-    }
-
-    g_free(sn_tab);
-}
-
 static void dump_json_image_info(ImageInfo *info)
 {
     Error *errp = NULL;
@@ -1184,54 +1151,6 @@ static void dump_json_image_info(ImageInfo *info)
     QDECREF(str);
 }
 
-static void collect_image_info(BlockDriverState *bs,
-                   ImageInfo *info,
-                   const char *filename)
-{
-    uint64_t total_sectors;
-    char backing_filename[1024];
-    char backing_filename2[1024];
-    BlockDriverInfo bdi;
-
-    bdrv_get_geometry(bs, &total_sectors);
-
-    info->filename        = g_strdup(filename);
-    info->format          = g_strdup(bdrv_get_format_name(bs));
-    info->virtual_size    = total_sectors * 512;
-    info->actual_size     = bdrv_get_allocated_file_size(bs);
-    info->has_actual_size = info->actual_size >= 0;
-    if (bdrv_is_encrypted(bs)) {
-        info->encrypted = true;
-        info->has_encrypted = true;
-    }
-    if (bdrv_get_info(bs, &bdi) >= 0) {
-        if (bdi.cluster_size != 0) {
-            info->cluster_size = bdi.cluster_size;
-            info->has_cluster_size = true;
-        }
-        info->dirty_flag = bdi.is_dirty;
-        info->has_dirty_flag = true;
-    }
-    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
-    if (backing_filename[0] != '\0') {
-        info->backing_filename = g_strdup(backing_filename);
-        info->has_backing_filename = true;
-        bdrv_get_full_backing_filename(bs, backing_filename2,
-                                       sizeof(backing_filename2));
-
-        if (strcmp(backing_filename, backing_filename2) != 0) {
-            info->full_backing_filename =
-                        g_strdup(backing_filename2);
-            info->has_full_backing_filename = true;
-        }
-
-        if (bs->backing_format[0]) {
-            info->backing_filename_format = g_strdup(bs->backing_format);
-            info->has_backing_filename_format = true;
-        }
-    }
-}
-
 static void dump_human_image_info(ImageInfo *info)
 {
     char size_buf[128], dsize_buf[128];
@@ -1338,6 +1257,7 @@ static ImageInfoList *collect_image_info_list(const char *filename,
     ImageInfoList *head = NULL;
     ImageInfoList **last = &head;
     GHashTable *filenames;
+    Error *err = NULL;
 
     filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
 
@@ -1359,9 +1279,7 @@ static ImageInfoList *collect_image_info_list(const char *filename,
             goto err;
         }
 
-        info = g_new0(ImageInfo, 1);
-        collect_image_info(bs, info, filename);
-        collect_snapshots(bs, info);
+        info = bdrv_query_image_info(bs, &err);
 
         elem = g_new0(ImageInfoList, 1);
         elem->value = info;
-- 
1.7.1

Re: [Qemu-devel] [PATCH V2 04/11] qemu-img: switch image retrieving function

[Eric Blake]

[-- Attachment #1: Type: text/plain, Size: 538 bytes --]

On 01/08/2013 10:12 PM, Wenchao Xia wrote:
>   Now qemu-img call block layer function to get image info.
> 
> v2:
>   Seperate patch for function switching in qemu-img.
> 
> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
> ---
>  qemu-img.c |   86 +----------------------------------------------------------
>  1 files changed, 2 insertions(+), 84 deletions(-)

Reviewed-by: Eric Blake <eblake@redhat.com>

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 619 bytes --]

[Qemu-devel] [PATCH V2 05/11] block: rename bdrv_query_info to bdrv_query_block_info

[Wenchao Xia]

  Now that we have bdrv_query_image_info, rename this function to make it
more obvious what it is doing.

v2:
  Better commit message.

Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c               |    4 ++--
 include/block/block.h |    2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/block.c b/block.c
index 81765a3..502c06e 100644
--- a/block.c
+++ b/block.c
@@ -2963,7 +2963,7 @@ ImageInfo *bdrv_query_image_info(BlockDriverState *bs, Error **errp)
     return info;
 }
 
-BlockInfo *bdrv_query_info(BlockDriverState *bs)
+BlockInfo *bdrv_query_block_info(BlockDriverState *bs)
 {
     BlockInfo *info = g_malloc0(sizeof(*info));
     info->device = g_strdup(bs->device_name);
@@ -3029,7 +3029,7 @@ BlockInfoList *qmp_query_block(Error **errp)
 
     QTAILQ_FOREACH(bs, &bdrv_states, list) {
         BlockInfoList *info = g_malloc0(sizeof(*info));
-        info->value = bdrv_query_info(bs);
+        info->value = bdrv_query_block_info(bs);
 
         *p_next = info;
         p_next = &info->next;
diff --git a/include/block/block.h b/include/block/block.h
index 67f0d13..5ce817a 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -324,7 +324,7 @@ SnapshotInfoList *bdrv_query_snapshot_infolist(BlockDriverState *bs,
                                                void *opaque,
                                                Error **errp);
 ImageInfo *bdrv_query_image_info(BlockDriverState *bs, Error **errp);
-BlockInfo *bdrv_query_info(BlockDriverState *s);
+BlockInfo *bdrv_query_block_info(BlockDriverState *bs);
 BlockStats *bdrv_query_stats(const BlockDriverState *bs);
 
 int bdrv_can_snapshot(BlockDriverState *bs);
-- 
1.7.1

[Qemu-devel] [PATCH V2 06/11] qmp: add interface query-images.

[Wenchao Xia]

  This mirror function will return all image info including
snapshots. Now Qemu have both query-images and query-block
interfaces.

V2:
  Redesign the interface, it will show related block device name now.
  Added counter part in qmp-commands.hx.
  Using plurals in API name.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c          |   19 +++++++++++++
 qapi-schema.json |   27 +++++++++++++++++++
 qmp-commands.hx  |   76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 122 insertions(+), 0 deletions(-)

diff --git a/block.c b/block.c
index 502c06e..8192d8e 100644
--- a/block.c
+++ b/block.c
@@ -2963,6 +2963,25 @@ ImageInfo *bdrv_query_image_info(BlockDriverState *bs, Error **errp)
     return info;
 }
 
+DeviceImageInfoList *qmp_query_images(Error **errp)
+{
+    DeviceImageInfoList *head = NULL, **p_next = &head;
+    BlockDriverState *bs;
+
+    QTAILQ_FOREACH(bs, &bdrv_states, list) {
+        DeviceImageInfo *dii = g_malloc0(sizeof(*dii));
+        dii->device = g_strdup(bs->device_name);
+        dii->info = bdrv_query_image_info(bs, NULL);
+        DeviceImageInfoList *diil = g_malloc0(sizeof(*diil));
+        diil->value = dii;
+
+        *p_next = diil;
+        p_next = &diil->next;
+    }
+
+    return head;
+}
+
 BlockInfo *bdrv_query_block_info(BlockDriverState *bs)
 {
     BlockInfo *info = g_malloc0(sizeof(*info));
diff --git a/qapi-schema.json b/qapi-schema.json
index 5dfa052..5fe6dc1 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -245,6 +245,22 @@
            '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'] } }
 
 ##
+# @DeviceImageInfo:
+#
+# Information about image used by QEMU block device
+#
+# @device: name of the block device
+#
+# @info: info of the image used.
+#
+# Since: 1.4
+#
+##
+
+{ 'type': 'DeviceImageInfo',
+  'data': {'device': 'str', 'info': 'ImageInfo' } }
+
+##
 # @StatusInfo:
 #
 # Information about VCPU run state
@@ -720,6 +736,17 @@
 { 'command': 'query-block', 'returns': ['BlockInfo'] }
 
 ##
+# @query-images:
+#
+# Get a list of DeviceImageInfo for all virtual block devices.
+#
+# Returns: a list of @DeviceImageInfo describing each virtual block device
+#
+# Since: 1.4
+##
+{ 'command': 'query-images', 'returns': ['DeviceImageInfo'] }
+
+##
 # @BlockDeviceStats:
 #
 # Statistics of a virtual block device or a block backing device.
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 5c692d0..3c95a48 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -1668,6 +1668,82 @@ EQMP
     },
 
 SQMP
+query-images
+-----------
+
+Show the block devices's images.
+
+Each block image information is stored in a json-object and the returned value
+is a json-array of all devices's image.
+
+Each json-object contain the following:
+
+- "device": device name (json-string)
+- "info": related image information, it is a json-object containing the following:
+         - "filename": image file name (json-string)
+         - "format": image format (json-string)
+         - "virtual-size": maximum capacity in bytes of the image (json-int)
+         - "dirty-flag": true if image is not cleanly closed (json-bool, optional)
+         - "actual-size": actual size on disk in bytes of the image (json-int, optional)
+         - "cluster-size": size of a cluster in bytes (json-int, optional)
+         - "encrypted": true if the image is encrypted (json-bool, optional)
+         - "backing_file": backing file name (json-string, optional)
+         - "full-backing-filename": full path of the backing file (json-string, optional)
+         - "backing-filename-format": the format of the backing file (json-string, optional)
+         - "snapshots": the internal snapshot info, it is an optional list of json-object
+            containing the following:
+             - "id": unique snapshot id (json-string)
+             - "name": internal snapshot name (json-string)
+             - "vm-state-size": size of the VM state (json-int)
+             - "date-sec": UTC date of the snapshot in seconds (json-int)
+             - "date-nsec": fractional part in nano seconds to be used with date-sec(json-int)
+             - "vm-clock-sec": VM clock relative to boot in seconds (json-int)
+             - "vm-clock-nsec": fractional part in nano seconds to be used with vm-clock-sec (json-int)
+
+Example:
+
+-> { "execute": "query-images" }
+<- {
+      "return":[
+         {
+            "device":"ide0-hd0",
+            "info":{
+               "filename":"disks/test0.img",
+               "format":"qcow2",
+               "virtual-size":1024000
+            }
+         },
+         {
+            "device":"ide0-hd1",
+            "info":{
+               "filename":"disks/test1.img",
+               "format":"qcow2",
+               "virtual-size":2048000,
+               "snapshots":[
+                  {
+                     "id": "1",
+                     "name": "snapshot1",
+                     "vm-state-size": 0,
+                     "date-sec": 10000200,
+                     "date-nsec": 12,
+                     "vm-clock-sec": 206,
+                     "vm-clock-nsec": 30
+                  }
+               ]
+            }
+         }
+      ]
+   }
+
+EQMP
+
+    {
+        .name       = "query-images",
+        .args_type  = "",
+        .mhandler.cmd_new = qmp_marshal_input_query_images,
+    },
+
+SQMP
 query-blockstats
 ----------------
 
-- 
1.7.1

Re: [Qemu-devel] [PATCH V2 06/11] qmp: add interface query-images.

[Eric Blake]

[-- Attachment #1: Type: text/plain, Size: 1270 bytes --]

On 01/08/2013 10:12 PM, Wenchao Xia wrote:
>   This mirror function will return all image info including
> snapshots. Now Qemu have both query-images and query-block
> interfaces.
> 
> V2:
>   Redesign the interface, it will show related block device name now.
>   Added counter part in qmp-commands.hx.
>   Using plurals in API name.

Again, patch evolution changelog belongs after the S-o-b and (first) ---
line.

> 
> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
> ---
>  block.c          |   19 +++++++++++++
>  qapi-schema.json |   27 +++++++++++++++++++
>  qmp-commands.hx  |   76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  3 files changed, 122 insertions(+), 0 deletions(-)
> 

>  ##
> +# @DeviceImageInfo:
> +#
> +# Information about image used by QEMU block device

s/image/an image/

>  
>  SQMP
> +query-images
> +-----------
> +
> +Show the block devices's images.

s/devices's/devices'/

> +
> +Each block image information is stored in a json-object and the returned value
> +is a json-array of all devices's image.

s/devices's image/devices' images/

The example is nice.

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 619 bytes --]

[Qemu-devel] [PATCH V2 07/11] block: export function bdrv_find_snapshot()

[Wenchao Xia]

  This patch move it from savevm.c to block.c and export it.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c               |   23 +++++++++++++++++++++++
 include/block/block.h |    2 ++
 savevm.c              |   22 ----------------------
 3 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/block.c b/block.c
index 8192d8e..b7d2f03 100644
--- a/block.c
+++ b/block.c
@@ -3351,6 +3351,29 @@ int bdrv_snapshot_load_tmp(BlockDriverState *bs,
     return -ENOTSUP;
 }
 
+int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
+                       const char *name)
+{
+    QEMUSnapshotInfo *sn_tab, *sn;
+    int nb_sns, i, ret;
+
+    ret = -ENOENT;
+    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
+    if (nb_sns < 0) {
+        return ret;
+    }
+    for (i = 0; i < nb_sns; i++) {
+        sn = &sn_tab[i];
+        if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
+            *sn_info = *sn;
+            ret = 0;
+            break;
+        }
+    }
+    g_free(sn_tab);
+    return ret;
+}
+
 /* backing_file can either be relative, or absolute, or a protocol.  If it is
  * relative, it must be relative to the chain.  So, passing in bs->filename
  * from a BDS as backing_file should not be done, as that may be relative to
diff --git a/include/block/block.h b/include/block/block.h
index 5ce817a..c473be5 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -340,6 +340,8 @@ int bdrv_snapshot_list(BlockDriverState *bs,
 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
                            const char *snapshot_name);
 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
+int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
+                       const char *name);
 
 char *get_human_readable_size(char *buf, int buf_size, int64_t size);
 int path_is_absolute(const char *path);
diff --git a/savevm.c b/savevm.c
index 021420f..9af2605 100644
--- a/savevm.c
+++ b/savevm.c
@@ -2036,28 +2036,6 @@ out:
     return ret;
 }
 
-static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
-                              const char *name)
-{
-    QEMUSnapshotInfo *sn_tab, *sn;
-    int nb_sns, i, ret;
-
-    ret = -ENOENT;
-    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
-    if (nb_sns < 0)
-        return ret;
-    for(i = 0; i < nb_sns; i++) {
-        sn = &sn_tab[i];
-        if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
-            *sn_info = *sn;
-            ret = 0;
-            break;
-        }
-    }
-    g_free(sn_tab);
-    return ret;
-}
-
 /*
  * Deletes snapshots of a given name in all opened images.
  */
-- 
1.7.1

[Qemu-devel] [PATCH V2 08/11] qmp: add interface query-snapshots

[Wenchao Xia]

  This interface now return valid internal snapshots.

v2:
  Better tips and spelling fix in qmp-schema.json.
  Change name to plurals.
  Add counter part in qmp-commands.hx.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c          |   32 ++++++++++++++++++++++++++++++++
 qapi-schema.json |   13 +++++++++++++
 qmp-commands.hx  |   53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 98 insertions(+), 0 deletions(-)

diff --git a/block.c b/block.c
index b7d2f03..990a07f 100644
--- a/block.c
+++ b/block.c
@@ -2892,6 +2892,38 @@ SnapshotInfoList *bdrv_query_snapshot_infolist(BlockDriverState *bs,
     return head;
 }
 
+/* check if sn exist on all block devices, 0 means valid */
+static int snapshot_filter_vm(const QEMUSnapshotInfo *sn, void *opaque)
+{
+    BlockDriverState *bs = (BlockDriverState *)opaque, *bs1 = NULL;
+    QEMUSnapshotInfo s, *sn_info = &s;
+    int ret = 0;
+
+    while ((bs1 = bdrv_next(bs1))) {
+        if (bdrv_can_snapshot(bs1) && bs1 != bs) {
+            ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
+            if (ret < 0) {
+                ret = -1;
+                break;
+            }
+        }
+    }
+    return ret;
+}
+
+SnapshotInfoList *qmp_query_snapshots(Error **errp)
+{
+    BlockDriverState *bs;
+
+    bs = bdrv_snapshots();
+    if (!bs) {
+        error_setg(errp, "No available block device supports snapshots\n");
+        return NULL;
+    }
+
+    return bdrv_query_snapshot_infolist(bs, snapshot_filter_vm, bs, errp);
+}
+
 /* collect all internal snapshot info in a image for ImageInfo */
 static void collect_snapshots_info(BlockDriverState *bs,
                                    ImageInfo *info,
diff --git a/qapi-schema.json b/qapi-schema.json
index 5fe6dc1..8b78fa6 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -747,6 +747,19 @@
 { 'command': 'query-images', 'returns': ['DeviceImageInfo'] }
 
 ##
+# @query-snapshots:
+#
+# Get a list of valid snapshots of virtual machine. Note that only valid
+# internal snapshot will be returned, inconsistent ones will not be returned.
+#
+# Returns: a list of @SnapshotInfo describing all consistent virtual machine
+#          snapshots.
+#
+# Since: 1.4
+##
+{ 'command': 'query-snapshots', 'returns': ['SnapshotInfo'] }
+
+##
 # @BlockDeviceStats:
 #
 # Statistics of a virtual block device or a block backing device.
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 3c95a48..1ff4ff7 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -1744,6 +1744,59 @@ EQMP
     },
 
 SQMP
+query-snapshots
+-----------
+
+Show the internal consistent snapshot information.
+
+Each snapshot information is stored in a json-object and the returned value
+is a json-array of all snapshots.
+
+Each json-object contain the following:
+
+- "id": unique snapshot id (json-string)
+- "name": internal snapshot name (json-string)
+- "vm-state-size": size of the VM state (json-int)
+- "date-sec": UTC date of the snapshot in seconds (json-int)
+- "date-nsec": fractional part in nano seconds to be used with date-sec(json-int)
+- "vm-clock-sec": VM clock relative to boot in seconds (json-int)
+- "vm-clock-nsec": fractional part in nano seconds to be used with vm-clock-sec (json-int)
+
+Example:
+
+-> { "execute": "query-snapshots" }
+<- {
+      "return":[
+         {
+            "id": "1",
+            "name": "snapshot1",
+            "vm-state-size": 0,
+            "date-sec": 10000200,
+            "date-nsec": 12,
+            "vm-clock-sec": 206,
+            "vm-clock-nsec": 30
+         },
+         {
+            "id": "2",
+            "name": "snapshot2",
+            "vm-state-size": 24000,
+            "date-sec": 13000200,
+            "date-nsec": 32,
+            "vm-clock-sec": 406,
+            "vm-clock-nsec": 31
+         }
+      ]
+   }
+
+EQMP
+
+    {
+        .name       = "query-snapshots",
+        .args_type  = "",
+        .mhandler.cmd_new = qmp_marshal_input_query_snapshots,
+    },
+
+SQMP
 query-blockstats
 ----------------
 
-- 
1.7.1

Re: [Qemu-devel] [PATCH V2 08/11] qmp: add interface query-snapshots

[Eric Blake]

[-- Attachment #1: Type: text/plain, Size: 848 bytes --]

On 01/08/2013 10:12 PM, Wenchao Xia wrote:
>   This interface now return valid internal snapshots.
> 

> +Each json-object contain the following:
> +
> +- "id": unique snapshot id (json-string)
> +- "name": internal snapshot name (json-string)
> +- "vm-state-size": size of the VM state (json-int)

In bytes?  If not, document it (but bytes would be best).

> +         {
> +            "id": "2",
> +            "name": "snapshot2",
> +            "vm-state-size": 24000,

And if it IS in bytes, then this example value feels suspiciously small
(I don't know of any guest whose memory state occupies just 24000 bytes,
because the state includes RAM and you usually need several megabytes of
RAM as a minimum size).

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 619 bytes --]

[Qemu-devel] [PATCH V2 09/11] hmp: export function hmp_handle_error()

[Wenchao Xia]

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 hmp.c |    2 +-
 hmp.h |    2 ++
 2 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/hmp.c b/hmp.c
index 2465d9b..89a1a8c 100644
--- a/hmp.c
+++ b/hmp.c
@@ -23,7 +23,7 @@
 #include "monitor/monitor.h"
 #include "ui/console.h"
 
-static void hmp_handle_error(Monitor *mon, Error **errp)
+void hmp_handle_error(Monitor *mon, Error **errp)
 {
     if (error_is_set(errp)) {
         monitor_printf(mon, "%s\n", error_get_pretty(*errp));
diff --git a/hmp.h b/hmp.h
index 5cab9c0..da1a35c 100644
--- a/hmp.h
+++ b/hmp.h
@@ -17,7 +17,9 @@
 #include "qemu-common.h"
 #include "qapi-types.h"
 #include "qapi/qmp/qdict.h"
+#include "qapi/error.h"
 
+void hmp_handle_error(Monitor *mon, Error **errp);
 void hmp_info_name(Monitor *mon, const QDict *qdict);
 void hmp_info_version(Monitor *mon, const QDict *qdict);
 void hmp_info_kvm(Monitor *mon, const QDict *qdict);
-- 
1.7.1

[Qemu-devel] [PATCH V2 10/11] hmp: retrieve info from qmp for snapshot info

[Wenchao Xia]

  With this patch, hmp command info snapshot simply call a block
layer funtion which will return a qmp object, and then translate
it in monitor console. Now snapshot info retrieving code in qemu
and qemu-tool are merged by calling same block layer function,
and then they just translate the qmp to stdout or monitor.

Note:
  This patch need previous hmp extention patch which enable
info sub command take qdict * as paramter.

v2:
  free SnapshotInfoList after usage.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 savevm.c |   84 +++++++++++++++++++++++++-------------------------------------
 1 files changed, 34 insertions(+), 50 deletions(-)

diff --git a/savevm.c b/savevm.c
index 9af2605..cabdcb6 100644
--- a/savevm.c
+++ b/savevm.c
@@ -48,6 +48,7 @@
 #include "qmp-commands.h"
 #include "trace.h"
 #include "qemu/bitops.h"
+#include "hmp.h"
 
 #define SELF_ANNOUNCE_ROUNDS 5
 
@@ -2311,68 +2312,51 @@ void do_delvm(Monitor *mon, const QDict *qdict)
     }
 }
 
-void do_info_snapshots(Monitor *mon, const QDict *qdict)
+/* assume list is valid */
+static void monitor_dump_snapshotinfolist(Monitor *mon, SnapshotInfoList *list)
 {
-    BlockDriverState *bs, *bs1;
-    QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
-    int nb_sns, i, ret, available;
-    int total;
-    int *available_snapshots;
+    SnapshotInfoList *elem;
     char buf[256];
 
-    bs = bdrv_snapshots();
-    if (!bs) {
-        monitor_printf(mon, "No available block device supports snapshots\n");
-        return;
-    }
-
-    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
-    if (nb_sns < 0) {
-        monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
-        return;
-    }
+    monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
 
-    if (nb_sns == 0) {
-        monitor_printf(mon, "There is no snapshot available.\n");
-        return;
+    for (elem = list; elem; elem = elem->next) {
+        QEMUSnapshotInfo sn = {
+            .vm_state_size = elem->value->vm_state_size,
+            .date_sec = elem->value->date_sec,
+            .date_nsec = elem->value->date_nsec,
+            .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
+                             elem->value->vm_clock_nsec,
+        };
+        pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
+        pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
+        monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
     }
+}
 
-    available_snapshots = g_malloc0(sizeof(int) * nb_sns);
-    total = 0;
-    for (i = 0; i < nb_sns; i++) {
-        sn = &sn_tab[i];
-        available = 1;
-        bs1 = NULL;
-
-        while ((bs1 = bdrv_next(bs1))) {
-            if (bdrv_can_snapshot(bs1) && bs1 != bs) {
-                ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
-                if (ret < 0) {
-                    available = 0;
-                    break;
-                }
-            }
-        }
+static void do_info_snapshots_vm(Monitor *mon)
+{
+    Error *err = NULL;
+    SnapshotInfoList *list;
 
-        if (available) {
-            available_snapshots[total] = i;
-            total++;
-        }
+    list = qmp_query_snapshots(&err);
+    if (error_is_set(&err)) {
+        hmp_handle_error(mon, &err);
+        return;
     }
-
-    if (total > 0) {
-        monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
-        for (i = 0; i < total; i++) {
-            sn = &sn_tab[available_snapshots[i]];
-            monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
-        }
-    } else {
+    if (list == NULL) {
         monitor_printf(mon, "There is no suitable snapshot available\n");
+        return;
     }
 
-    g_free(sn_tab);
-    g_free(available_snapshots);
+    monitor_dump_snapshotinfolist(mon, list);
+    qapi_free_SnapshotInfoList(list);
+    return;
+}
 
+void do_info_snapshots(Monitor *mon, const QDict *qdict)
+{
+    do_info_snapshots_vm(mon);
 }
 
 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
-- 
1.7.1

[Qemu-devel] [PATCH V2 11/11] hmp: show snapshot on single block device

[Wenchao Xia]

  This patch use block layer API to qmp snapshot info on a block
device, then use the same code dumping vm snapshot info, to print
in monitor.

Note:
  This patch need previous hmp extention patch which enable
info sub command take qdict * as paramter.

v2:
  free SnapshotInfoList after usage.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 monitor.c |    6 +++---
 savevm.c  |   43 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/monitor.c b/monitor.c
index e1bcaa2..3dfdd4d 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2580,9 +2580,9 @@ static mon_cmd_t info_cmds[] = {
     },
     {
         .name       = "snapshots",
-        .args_type  = "",
-        .params     = "",
-        .help       = "show the currently saved VM snapshots",
+        .args_type  = "device:B?",
+        .params     = "[device]",
+        .help       = "show snapshots of whole vm or a single device",
         .mhandler.info = do_info_snapshots,
     },
     {
diff --git a/savevm.c b/savevm.c
index cabdcb6..cd474e9 100644
--- a/savevm.c
+++ b/savevm.c
@@ -2354,9 +2354,50 @@ static void do_info_snapshots_vm(Monitor *mon)
     return;
 }
 
+static void do_info_snapshots_blk(Monitor *mon, const char *device)
+{
+    Error *err = NULL;
+    SnapshotInfoList *list;
+    BlockDriverState *bs;
+
+    /* find the target bs */
+    bs = bdrv_find(device);
+    if (!bs) {
+        monitor_printf(mon, "Device '%s' not found.\n", device);
+        return ;
+    }
+
+    if (!bdrv_can_snapshot(bs)) {
+        monitor_printf(mon, "Device '%s' can't have snapshot.\n", device);
+        return ;
+    }
+
+    list = bdrv_query_snapshot_infolist(bs, NULL, NULL, &err);
+    if (error_is_set(&err)) {
+        hmp_handle_error(mon, &err);
+        return;
+    }
+
+    if (list == NULL) {
+        monitor_printf(mon, "There is no snapshot available.\n");
+        return;
+    }
+
+    monitor_printf(mon, "Device '%s':\n", device);
+    monitor_dump_snapshotinfolist(mon, list);
+    qapi_free_SnapshotInfoList(list);
+    return;
+}
+
 void do_info_snapshots(Monitor *mon, const QDict *qdict)
 {
-    do_info_snapshots_vm(mon);
+    const char *device = qdict_get_try_str(qdict, "device");
+    if (!device) {
+        do_info_snapshots_vm(mon);
+    } else {
+        do_info_snapshots_blk(mon, device);
+    }
+    return;
 }
 
 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
-- 
1.7.1

[Qemu-devel] [PATCH V2 00/11] add qmp/hmp interfaces for snapshot info

[Wenchao Xia]

  This serial of patches does two things: merge some info code
in qemu-img, and add following interfaces:
1) qmp: query-images
2) qmp: query-snapshots
3) hmp: show snapshot info on a single block device
  These patches follows the rule that use qmp to retieve information,
hmp layer just do a translation from qmp object it got, so almost
every hmp interface may have a correlated qmp interface.
  To make code graceful, snapshot retrieving code in qemu and qemu-img
are merged into block.c, and some function name was adjusted to make it
tips better. Now it works as:

   qemu          qemu-img

dump_monitor    dump_stdout
     |--------------| 
            |
           qmp
            |
          block

Note:
  Last two patches need previous sent patches which extend hmp sub command, at:
http://lists.nongnu.org/archive/html/qemu-devel/2012-12/msg03487.html

v2:
  Rename and adjusted qmp interface according to comments from Eric.
  Spelling fix.
  Information retrieving function in block layer goes to seperated patch.
  Free qmp object after usage in hmp.

Wenchao Xia (11):
  qemu-img: remove unused parameter in collect_image_info()
  block: add bdrv_get_filename() function
  block: add snapshot and image info query function
  qemu-img: switch image retrieving function
  block: rename bdrv_query_info to bdrv_query_block_info
  qmp: add interface query-images.
  block: export function bdrv_find_snapshot()
  qmp: add interface query-snapshots
  hmp: export function hmp_handle_error()
  hmp: retrieve info from qmp for snapshot info
  hmp: show snapshot on single block device

 block.c               |  200 ++++++++++++++++++++++++++++++++++++++++++++++++-
 hmp.c                 |    2 +-
 hmp.h                 |    2 +
 include/block/block.h |   14 +++-
 monitor.c             |    6 +-
 qapi-schema.json      |   40 ++++++++++
 qemu-img.c            |   87 +---------------------
 qmp-commands.hx       |  129 +++++++++++++++++++++++++++++++
 savevm.c              |  137 +++++++++++++++++----------------
 9 files changed, 458 insertions(+), 159 deletions(-)