Patchwork [V7,08/14] qmp: add interface query-images.

login
register
mail settings
Submitter Wayne Xia
Date Feb. 26, 2013, 10:40 a.m.
Message ID <1361875228-15769-9-git-send-email-xiawenc@linux.vnet.ibm.com>
Download mbox | patch
Permalink /patch/223194/
State New
Headers show

Comments

Wayne Xia - Feb. 26, 2013, 10:40 a.m.
This mirror function will return all image info including
snapshots, if specified backing image's info will also be returned.
Now Qemu have both query-images and query-block interfaces.

Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 block.c          |   83 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 qapi-schema.json |   34 ++++++++++++++++++++++
 qmp-commands.hx  |   76 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 193 insertions(+), 0 deletions(-)
Markus Armbruster - Feb. 27, 2013, 4 p.m.
Humor me: no period at end of subject, please

First pass, concentrating on interfaces, implementation mostly ignored.

Wenchao Xia <xiawenc@linux.vnet.ibm.com> writes:

>   This mirror function will return all image info including
> snapshots, if specified backing image's info will also be returned.
> Now Qemu have both query-images and query-block interfaces.
>
> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
> ---
>  block.c          |   83 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  qapi-schema.json |   34 ++++++++++++++++++++++
>  qmp-commands.hx  |   76 +++++++++++++++++++++++++++++++++++++++++++++++++
>  3 files changed, 193 insertions(+), 0 deletions(-)
>
[...]
> diff --git a/qapi-schema.json b/qapi-schema.json
> index cd7ea25..9122bb9 100644
> --- a/qapi-schema.json
> +++ b/qapi-schema.json
> @@ -245,6 +245,22 @@
>             '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'] } }
>  
>  ##
> +# @DeviceImageInfo:
> +#
> +# Information about an image used by a QEMU block device
> +#
> +# @device: name of the block device
> +#
> +# @image: #optional info of the image used
> +#
> +# Since: 1.5
> +#
> +##
> +
> +{ 'type': 'DeviceImageInfo',
> +  'data': {'device': 'str', '*image': 'ImageInfo' } }
> +
> +##
>  # @StatusInfo:
>  #
>  # Information about VCPU run state
> @@ -789,6 +805,24 @@
>  { 'command': 'query-block', 'returns': ['BlockInfo'] }
>  
>  ##
> +# @query-images:
> +#
> +# Get a list of DeviceImageInfo for all virtual block devices.

# Get block device image information

> +#
> +# @device: #optional the name of the device to get image info from. If not
> +#          specified, all block devices will be queried
> +# @backing: #optional true to show information on backing images, false or
> +#          omitted to show just the top image of a block device

I'm not sure these flags are necessary.

> +#
> +# Returns: a list of @DeviceImageInfo describing each virtual block device
> +#
> +# Since: 1.5
> +##
> +{ 'command': 'query-images',
> +  'data': { '*device': 'str', '*backing': 'bool' },
> +  '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 799adea..292d61e 100644
> --- a/qmp-commands.hx
> +++ b/qmp-commands.hx
> @@ -1743,6 +1743,82 @@ EQMP
>      },
>  
>  SQMP
> +query-images
> +-----------
> +
> +Show the block devices' images.

Show block device image information

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

Each device is represented by a json-object. The returned value is a json-array
of all devices.

> +
> +Each json-object contain the following:
> +
> +- "device": device name (json-string)
> +- "image": related image information, it is a optional json-object containing the following:

- "image": image information (json-object, optional) containing:

> +         - "filename": image file name (json-string)
> +         - "format": image format (json-string)
> +         - "virtual-size": maximum capacity in bytes of the image (json-int)

            - "virtual-size": image capacity in bytes (json-int)

> +         - "dirty-flag": true if image is not cleanly closed (json-bool, optional)

Long line.

What's the meaning of dirty-flag not present in object?

> +         - "actual-size": actual size on disk in bytes of the image (json-int, optional)

            - "actual-size": actual on-disk image size in bytes
              (json-int, optional)

Can you explain when actual-size is present, and when not?  Same for the
other optional members.

> +         - "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)

Long lines.

> +         - "snapshots": the internal snapshot info, it is an optional list of json-object
> +            containing the following:

            - "snapshots": internal snapshot info
              (json-array of json-object, optional)
              Each object contains:

> +             - "id": unique snapshot id (json-string)
> +             - "name": internal snapshot name (json-string)

Suggest to drop "internal"

> +             - "vm-state-size": size of the VM state in bytes (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)

Long lines.

A year has 86400 s == 8.64e13 ns, thus int64_t is good for more than
10000 years.  Why can't we simply measure in ns and dispense with the
awkward (sec, nsec) pair?

> +
> +Example:
> +
> +-> { "execute": "query-images" }
> +<- {
> +      "return":[
> +         {
> +            "device":"ide0-hd0",
> +            "image":{
> +               "filename":"disks/test0.img",
> +               "format":"qcow2",
> +               "virtual-size":1024000
> +            }
> +         },
> +         {
> +            "device":"ide0-hd1",
> +            "image":{
> +               "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  = "device:B?, backing:-b",
> +        .mhandler.cmd_new = qmp_marshal_input_query_images,
> +    },
> +
> +SQMP
>  query-blockstats
>  ----------------
Wayne Xia - Feb. 28, 2013, 2:12 a.m.
于 2013-2-28 0:00, Markus Armbruster 写道:
> Humor me: no period at end of subject, please
> 
  OK.

> First pass, concentrating on interfaces, implementation mostly ignored.
> 
> Wenchao Xia <xiawenc@linux.vnet.ibm.com> writes:
> 
>>    This mirror function will return all image info including
>> snapshots, if specified backing image's info will also be returned.
>> Now Qemu have both query-images and query-block interfaces.
>>
>> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
>> ---
>>   block.c          |   83 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>   qapi-schema.json |   34 ++++++++++++++++++++++
>>   qmp-commands.hx  |   76 +++++++++++++++++++++++++++++++++++++++++++++++++
>>   3 files changed, 193 insertions(+), 0 deletions(-)
>>
> [...]
>> diff --git a/qapi-schema.json b/qapi-schema.json
>> index cd7ea25..9122bb9 100644
>> --- a/qapi-schema.json
>> +++ b/qapi-schema.json
>> @@ -245,6 +245,22 @@
>>              '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'] } }
>>   
>>   ##
>> +# @DeviceImageInfo:
>> +#
>> +# Information about an image used by a QEMU block device
>> +#
>> +# @device: name of the block device
>> +#
>> +# @image: #optional info of the image used
>> +#
>> +# Since: 1.5
>> +#
>> +##
>> +
>> +{ 'type': 'DeviceImageInfo',
>> +  'data': {'device': 'str', '*image': 'ImageInfo' } }
>> +
>> +##
>>   # @StatusInfo:
>>   #
>>   # Information about VCPU run state
>> @@ -789,6 +805,24 @@
>>   { 'command': 'query-block', 'returns': ['BlockInfo'] }
>>   
>>   ##
>> +# @query-images:
>> +#
>> +# Get a list of DeviceImageInfo for all virtual block devices.
> 
> # Get block device image information
> 
  OK.

>> +#
>> +# @device: #optional the name of the device to get image info from. If not
>> +#          specified, all block devices will be queried
>> +# @backing: #optional true to show information on backing images, false or
>> +#          omitted to show just the top image of a block device
> 
> I'm not sure these flags are necessary.
> 
  These flag seems more flex to me. Always querying all info require
caller do a filter operation on what he got, but in many times caller
may be interested on only one device.

>> +#
>> +# Returns: a list of @DeviceImageInfo describing each virtual block device
>> +#
>> +# Since: 1.5
>> +##
>> +{ 'command': 'query-images',
>> +  'data': { '*device': 'str', '*backing': 'bool' },
>> +  '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 799adea..292d61e 100644
>> --- a/qmp-commands.hx
>> +++ b/qmp-commands.hx
>> @@ -1743,6 +1743,82 @@ EQMP
>>       },
>>   
>>   SQMP
>> +query-images
>> +-----------
>> +
>> +Show the block devices' images.
> 
> Show block device image information
> 
  OK.

>> +
>> +Each block image information is stored in a json-object and the returned value
>> +is a json-array of all devices' images.
> 
> Each device is represented by a json-object. The returned value is a json-array
> of all devices.
> 
  OK.

>> +
>> +Each json-object contain the following:
>> +
>> +- "device": device name (json-string)
>> +- "image": related image information, it is a optional json-object containing the following:
> 
> - "image": image information (json-object, optional) containing:
> 
  OK.

>> +         - "filename": image file name (json-string)
>> +         - "format": image format (json-string)
>> +         - "virtual-size": maximum capacity in bytes of the image (json-int)
> 
>              - "virtual-size": image capacity in bytes (json-int)
> 
>> +         - "dirty-flag": true if image is not cleanly closed (json-bool, optional)
> 
> Long line.
> 
> What's the meaning of dirty-flag not present in object?
> 
>> +         - "actual-size": actual size on disk in bytes of the image (json-int, optional)
> 
>              - "actual-size": actual on-disk image size in bytes
>                (json-int, optional)
> 
> Can you explain when actual-size is present, and when not?  Same for the
> other optional members.
> 
  OK, will document them.

>> +         - "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)
> 
> Long lines.
> 
>> +         - "snapshots": the internal snapshot info, it is an optional list of json-object
>> +            containing the following:
> 
>              - "snapshots": internal snapshot info
>                (json-array of json-object, optional)
>                Each object contains:
> 
>> +             - "id": unique snapshot id (json-string)
>> +             - "name": internal snapshot name (json-string)
> 
> Suggest to drop "internal"
> 
>> +             - "vm-state-size": size of the VM state in bytes (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)
> 
> Long lines.
> 
> A year has 86400 s == 8.64e13 ns, thus int64_t is good for more than
> 10000 years.  Why can't we simply measure in ns and dispense with the
> awkward (sec, nsec) pair?
> 
  I am not sure this brings much benefits. In most case the management
stack may need to use the "seconds" to show for end user.

>> +
>> +Example:
>> +
>> +-> { "execute": "query-images" }
>> +<- {
>> +      "return":[
>> +         {
>> +            "device":"ide0-hd0",
>> +            "image":{
>> +               "filename":"disks/test0.img",
>> +               "format":"qcow2",
>> +               "virtual-size":1024000
>> +            }
>> +         },
>> +         {
>> +            "device":"ide0-hd1",
>> +            "image":{
>> +               "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  = "device:B?, backing:-b",
>> +        .mhandler.cmd_new = qmp_marshal_input_query_images,
>> +    },
>> +
>> +SQMP
>>   query-blockstats
>>   ----------------
>
Wayne Xia - March 4, 2013, 2:30 a.m.
>>>    
>>>    ##
>>> +# @query-images:
>>> +#
>>> +# Get a list of DeviceImageInfo for all virtual block devices.
>>
>> # Get block device image information
>>
>    OK.
> 
>>> +#
>>> +# @device: #optional the name of the device to get image info from. If not
>>> +#          specified, all block devices will be queried
>>> +# @backing: #optional true to show information on backing images, false or
>>> +#          omitted to show just the top image of a block device
>>
>> I'm not sure these flags are necessary.
>>
>    These flag seems more flex to me. Always querying all info require
> caller do a filter operation on what he got, but in many times caller
> may be interested on only one device.
>
  Coding for next version, I still feel flag may bring flexbility.
Markus, are u OK with this?


>>> +#
>>> +# Returns: a list of @DeviceImageInfo describing each virtual block device
>>> +#
>>> +# Since: 1.5
>>> +##
>>> +{ 'command': 'query-images',
>>> +  'data': { '*device': 'str', '*backing': 'bool' },
>>> +  'returns': ['DeviceImageInfo'] }
>>> +

Patch

diff --git a/block.c b/block.c
index 79213d2..3976167 100644
--- a/block.c
+++ b/block.c
@@ -2954,6 +2954,89 @@  ImageInfo *bdrv_query_image_info(BlockDriverState *bs, Error **errp)
     return info;
 }
 
+/* collect all info for one bs, p_list point to the empty tail to be filled,
+   return the empty tail of the new list. */
+static DeviceImageInfoList **
+collect_device_image_info_list(BlockDriverState *bs,
+                               bool show_backing,
+                               DeviceImageInfoList **p_list,
+                               Error **errp)
+{
+    DeviceImageInfoList **p_next = p_list;
+
+    while (bs) {
+        DeviceImageInfo *dii = g_malloc0(sizeof(*dii));
+        DeviceImageInfoList *diil = g_malloc0(sizeof(*diil));
+        diil->value = dii;
+        *p_next = diil;
+        p_next = &diil->next;
+
+        dii->device = g_strdup(bs->device_name);
+        if (!bdrv_is_inserted(bs)) {
+            dii->has_image = false;
+            break;
+        }
+        dii->has_image = true;
+        dii->image = bdrv_query_image_info(bs, errp);
+        if (error_is_set(errp)) {
+            break;
+        }
+
+        if (show_backing && bs->drv && bs->backing_hd) {
+            bs = bs->backing_hd;
+        } else {
+            bs = NULL;
+        }
+    }
+    return p_next;
+}
+
+DeviceImageInfoList *qmp_query_images(bool has_device,
+                                      const char *device,
+                                      bool has_backing,
+                                      bool backing,
+                                      Error **errp)
+{
+    DeviceImageInfoList *head = NULL, **p_next = &head;
+    BlockDriverState *bs = NULL;
+    Error *err = NULL;
+    const char *target_device = NULL;
+    bool show_backing = false;
+
+    if (has_device) {
+        target_device = device;
+    }
+    if (has_backing) {
+        show_backing = backing;
+    }
+
+    if (target_device) {
+        bs = bdrv_find(device);
+        if (!bs) {
+            error_set(errp, QERR_DEVICE_NOT_FOUND, device);
+            return NULL;
+        }
+        collect_device_image_info_list(bs, show_backing, p_next, errp);
+        if (error_is_set(&err)) {
+            goto err;
+        }
+    } else {
+        QTAILQ_FOREACH(bs, &bdrv_states, list) {
+            p_next = collect_device_image_info_list(bs, show_backing,
+                                                    p_next, errp);
+            if (error_is_set(&err)) {
+                goto err;
+            }
+        }
+    }
+
+    return head;
+
+ err:
+    qapi_free_DeviceImageInfoList(head);
+    return NULL;
+}
+
 BlockInfo *bdrv_query_block_info(BlockDriverState *bs)
 {
     BlockInfo *info = g_malloc0(sizeof(*info));
diff --git a/qapi-schema.json b/qapi-schema.json
index cd7ea25..9122bb9 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -245,6 +245,22 @@ 
            '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'] } }
 
 ##
+# @DeviceImageInfo:
+#
+# Information about an image used by a QEMU block device
+#
+# @device: name of the block device
+#
+# @image: #optional info of the image used
+#
+# Since: 1.5
+#
+##
+
+{ 'type': 'DeviceImageInfo',
+  'data': {'device': 'str', '*image': 'ImageInfo' } }
+
+##
 # @StatusInfo:
 #
 # Information about VCPU run state
@@ -789,6 +805,24 @@ 
 { 'command': 'query-block', 'returns': ['BlockInfo'] }
 
 ##
+# @query-images:
+#
+# Get a list of DeviceImageInfo for all virtual block devices.
+#
+# @device: #optional the name of the device to get image info from. If not
+#          specified, all block devices will be queried
+# @backing: #optional true to show information on backing images, false or
+#          omitted to show just the top image of a block device
+#
+# Returns: a list of @DeviceImageInfo describing each virtual block device
+#
+# Since: 1.5
+##
+{ 'command': 'query-images',
+  'data': { '*device': 'str', '*backing': 'bool' },
+  '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 799adea..292d61e 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -1743,6 +1743,82 @@  EQMP
     },
 
 SQMP
+query-images
+-----------
+
+Show the block devices' images.
+
+Each block image information is stored in a json-object and the returned value
+is a json-array of all devices' images.
+
+Each json-object contain the following:
+
+- "device": device name (json-string)
+- "image": related image information, it is a optional 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 in bytes (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",
+            "image":{
+               "filename":"disks/test0.img",
+               "format":"qcow2",
+               "virtual-size":1024000
+            }
+         },
+         {
+            "device":"ide0-hd1",
+            "image":{
+               "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  = "device:B?, backing:-b",
+        .mhandler.cmd_new = qmp_marshal_input_query_images,
+    },
+
+SQMP
 query-blockstats
 ----------------