diff --git a/block/qapi.c b/block/qapi.c index e9d8b7433f5488bd09d288cbdc1cc8b3b9fbc034..a4bc4113b7fdaed6d5a7fcb1e19f6a08aa036bb1 100644 --- a/block/qapi.c +++ b/block/qapi.c @@ -94,6 +94,13 @@ int bdrv_query_snapshot_info_list(BlockDriverState *bs, * @p_info: location to store image information * @errp: location to store error information * + * Store "flat" image information in @p_info. + * + * "Flat" means it does *not* query backing image information, + * i.e. (*pinfo)->has_backing_image will be set to false and + * (*pinfo)->backing_image to NULL even when the image does in fact have + * a backing image. + * * @p_info will be set only on success. On error, store error in @errp. */ void bdrv_query_image_info(BlockDriverState *bs, @@ -167,9 +174,15 @@ void bdrv_query_image_info(BlockDriverState *bs, *p_info = info; } -BlockInfo *bdrv_query_info(BlockDriverState *bs) +/* @p_info will be set only on success. */ +void bdrv_query_info(BlockDriverState *bs, + BlockInfo **p_info, + Error **errp) { BlockInfo *info = g_malloc0(sizeof(*info)); + BlockDriverState *bs0; + ImageInfo **p_image_info; + Error *local_err = NULL; info->device = g_strdup(bs->device_name); info->type = g_strdup("unknown"); info->locked = bdrv_dev_is_medium_locked(bs); @@ -223,8 +236,30 @@ BlockInfo *bdrv_query_info(BlockDriverState *bs) info->inserted->iops_wr = bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE]; } + + bs0 = bs; + p_image_info = &info->inserted->image; + while (1) { + bdrv_query_image_info(bs0, p_image_info, &local_err); + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); + goto err; + } + if (bs0->drv && bs0->backing_hd) { + bs0 = bs0->backing_hd; + (*p_image_info)->has_backing_image = true; + p_image_info = &((*p_image_info)->backing_image); + } else { + break; + } + } } - return info; + + *p_info = info; + return; + + err: + qapi_free_BlockInfo(info); } BlockStats *bdrv_query_stats(const BlockDriverState *bs) @@ -261,16 +296,25 @@ BlockInfoList *qmp_query_block(Error **errp) { BlockInfoList *head = NULL, **p_next = &head; BlockDriverState *bs = NULL; + Error *local_err = NULL; while ((bs = bdrv_next(bs))) { BlockInfoList *info = g_malloc0(sizeof(*info)); - info->value = bdrv_query_info(bs); + bdrv_query_info(bs, &info->value, &local_err); + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); + goto err; + } *p_next = info; p_next = &info->next; } return head; + + err: + qapi_free_BlockInfoList(head); + return NULL; } BlockStatsList *qmp_query_blockstats(Error **errp) diff --git a/include/block/qapi.h b/include/block/qapi.h index ab1f48f6f71ece218a9d6d6dd9c490be302d374f..0496cc9282372db854513b33abcd951dc17481bf 100644 --- a/include/block/qapi.h +++ b/include/block/qapi.h @@ -35,7 +35,9 @@ int bdrv_query_snapshot_info_list(BlockDriverState *bs, void bdrv_query_image_info(BlockDriverState *bs, ImageInfo **p_info, Error **errp); -BlockInfo *bdrv_query_info(BlockDriverState *s); +void bdrv_query_info(BlockDriverState *bs, + BlockInfo **p_info, + Error **errp); BlockStats *bdrv_query_stats(const BlockDriverState *bs); void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, diff --git a/qapi-schema.json b/qapi-schema.json index ef1f657efb42827f2411fa725ef4a4bec28b31a3..5ad689473806d88f7a5f3585bb99dae50fbfd180 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -236,6 +236,8 @@ # # @snapshots: #optional list of VM snapshots # +# @backing-image: #optional info of the backing image (since 1.6) +# # Since: 1.3 # ## @@ -245,7 +247,8 @@ '*actual-size': 'int', 'virtual-size': 'int', '*cluster-size': 'int', '*encrypted': 'bool', '*backing-filename': 'str', '*full-backing-filename': 'str', - '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'] } } + '*backing-filename-format': 'str', '*snapshots': ['SnapshotInfo'], + '*backing-image': 'ImageInfo' } } ## # @ImageCheck: @@ -756,6 +759,8 @@ # # @iops_wr: write I/O operations per second is specified # +# @image: the info of image used (since: 1.6) +# # Since: 0.14.0 # # Notes: This interface is only found in @BlockInfo. @@ -765,7 +770,8 @@ '*backing_file': 'str', 'backing_file_depth': 'int', 'encrypted': 'bool', 'encryption_key_missing': 'bool', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int', - 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int'} } + 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', + 'image': 'ImageInfo' } } ## # @BlockDeviceIoStatus: diff --git a/qmp-commands.hx b/qmp-commands.hx index ffd130edf637ac885f5fc38d835946b6c1420450..8cea5e554cbaa8274f602c08b6f148a4963c8e50 100644 --- a/qmp-commands.hx +++ b/qmp-commands.hx @@ -1704,6 +1704,47 @@ Each json-object contain the following: - "iops": limit total I/O operations per second (json-int) - "iops_rd": limit read operations per second (json-int) - "iops_wr": limit write operations per second (json-int) + - "image": the detail of the image, it is a json-object containing + the following: + - "filename": image file name (json-string) + - "format": image format (json-string) + - "virtual-size": image capacity in bytes (json-int) + - "dirty-flag": true if image is not cleanly closed, not present + means clean (json-bool, optional) + - "actual-size": actual size on disk in bytes of the image, not + present when image does not support thin + provision (json-int, optional) + - "cluster-size": size of a cluster in bytes, not present if image + format does not support it (json-int, optional) + - "encrypted": true if the image is encrypted, not present means + false or the image format does not support + encryption (json-bool, optional) + - "backing_file": backing file name, not present means no backing + file is used or the image format does not + support backing file chain + (json-string, optional) + - "full-backing-filename": full path of the backing file, not + present if it equals backing_file or no + backing file is used + (json-string, optional) + - "backing-filename-format": the format of the backing file, not + present means unknown or no 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": 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 nanoseconds 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 nanoseconds to be used + with vm-clock-sec (json-int) + - "backing-image": the detail of the backing image, it is an + optional json-object only present when a + backing image present for this image - "io-status": I/O operation status, only present if the device supports it and the VM is configured to stop on errors. It's always reset @@ -1724,14 +1765,38 @@ Example: "ro":false, "drv":"qcow2", "encrypted":false, - "file":"disks/test.img", - "backing_file_depth":0, + "file":"disks/test.qcow2", + "backing_file_depth":1, "bps":1000000, "bps_rd":0, "bps_wr":0, "iops":1000000, "iops_rd":0, "iops_wr":0, + "image":{ + "filename":"disks/test.qcow2", + "format":"qcow2", + "virtual-size":2048000, + "backing_file":"base.qcow2", + "full-backing-filename":"disks/base.qcow2", + "backing-filename-format:"qcow2", + "snapshots":[ + { + "id": "1", + "name": "snapshot1", + "vm-state-size": 0, + "date-sec": 10000200, + "date-nsec": 12, + "vm-clock-sec": 206, + "vm-clock-nsec": 30 + } + ], + "backing-image":{ + "filename":"disks/base.qcow2", + "format":"qcow2", + "virtual-size":2048000 + } + } }, "type":"unknown" },