1f364ec65SWenchao Xia /* 2f364ec65SWenchao Xia * Block layer qmp and info dump related functions 3f364ec65SWenchao Xia * 4f364ec65SWenchao Xia * Copyright (c) 2003-2008 Fabrice Bellard 5f364ec65SWenchao Xia * 6f364ec65SWenchao Xia * Permission is hereby granted, free of charge, to any person obtaining a copy 7f364ec65SWenchao Xia * of this software and associated documentation files (the "Software"), to deal 8f364ec65SWenchao Xia * in the Software without restriction, including without limitation the rights 9f364ec65SWenchao Xia * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10f364ec65SWenchao Xia * copies of the Software, and to permit persons to whom the Software is 11f364ec65SWenchao Xia * furnished to do so, subject to the following conditions: 12f364ec65SWenchao Xia * 13f364ec65SWenchao Xia * The above copyright notice and this permission notice shall be included in 14f364ec65SWenchao Xia * all copies or substantial portions of the Software. 15f364ec65SWenchao Xia * 16f364ec65SWenchao Xia * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17f364ec65SWenchao Xia * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18f364ec65SWenchao Xia * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19f364ec65SWenchao Xia * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20f364ec65SWenchao Xia * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21f364ec65SWenchao Xia * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22f364ec65SWenchao Xia * THE SOFTWARE. 23f364ec65SWenchao Xia */ 24f364ec65SWenchao Xia 2580c71a24SPeter Maydell #include "qemu/osdep.h" 26f364ec65SWenchao Xia #include "block/qapi.h" 27f364ec65SWenchao Xia #include "block/block_int.h" 2876f4afb4SAlberto Garcia #include "block/throttle-groups.h" 29e2462113SFrancesco Romani #include "block/write-threshold.h" 30f364ec65SWenchao Xia #include "qmp-commands.h" 31a8d8ecb7SMax Reitz #include "qapi-visit.h" 32b3db211fSDaniel P. Berrange #include "qapi/qobject-output-visitor.h" 33a8d8ecb7SMax Reitz #include "qapi/qmp/types.h" 34d829a211SMarkus Armbruster #include "sysemu/block-backend.h" 35f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 36f364ec65SWenchao Xia 37c83f9fbaSKevin Wolf BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk, 38c83f9fbaSKevin Wolf BlockDriverState *bs, Error **errp) 39c13163fbSBenoît Canet { 40d5a8ee60SAlberto Garcia ImageInfo **p_image_info; 41d5a8ee60SAlberto Garcia BlockDriverState *bs0; 42c13163fbSBenoît Canet BlockDeviceInfo *info = g_malloc0(sizeof(*info)); 43c13163fbSBenoît Canet 44c13163fbSBenoît Canet info->file = g_strdup(bs->filename); 45c13163fbSBenoît Canet info->ro = bs->read_only; 46c13163fbSBenoît Canet info->drv = g_strdup(bs->drv->format_name); 47c13163fbSBenoît Canet info->encrypted = bs->encrypted; 48c01c214bSDaniel P. Berrange info->encryption_key_missing = false; 49c13163fbSBenoît Canet 509e193c5aSKevin Wolf info->cache = g_new(BlockdevCacheInfo, 1); 519e193c5aSKevin Wolf *info->cache = (BlockdevCacheInfo) { 52c83f9fbaSKevin Wolf .writeback = blk ? blk_enable_write_cache(blk) : true, 539e193c5aSKevin Wolf .direct = !!(bs->open_flags & BDRV_O_NOCACHE), 549e193c5aSKevin Wolf .no_flush = !!(bs->open_flags & BDRV_O_NO_FLUSH), 559e193c5aSKevin Wolf }; 569e193c5aSKevin Wolf 57c13163fbSBenoît Canet if (bs->node_name[0]) { 58c13163fbSBenoît Canet info->has_node_name = true; 59c13163fbSBenoît Canet info->node_name = g_strdup(bs->node_name); 60c13163fbSBenoît Canet } 61c13163fbSBenoît Canet 62c13163fbSBenoît Canet if (bs->backing_file[0]) { 63c13163fbSBenoît Canet info->has_backing_file = true; 64c13163fbSBenoît Canet info->backing_file = g_strdup(bs->backing_file); 65c13163fbSBenoît Canet } 66c13163fbSBenoît Canet 67465bee1dSPeter Lieven info->detect_zeroes = bs->detect_zeroes; 68c13163fbSBenoît Canet 69*022cdc9fSManos Pitsidianakis if (blk && blk_get_public(blk)->throttle_group_member.throttle_state) { 70c13163fbSBenoît Canet ThrottleConfig cfg; 71*022cdc9fSManos Pitsidianakis BlockBackendPublic *blkp = blk_get_public(blk); 7276f4afb4SAlberto Garcia 73*022cdc9fSManos Pitsidianakis throttle_group_get_config(&blkp->throttle_group_member, &cfg); 7476f4afb4SAlberto Garcia 75c13163fbSBenoît Canet info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg; 76c13163fbSBenoît Canet info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg; 77c13163fbSBenoît Canet info->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE].avg; 78c13163fbSBenoît Canet 79c13163fbSBenoît Canet info->iops = cfg.buckets[THROTTLE_OPS_TOTAL].avg; 80c13163fbSBenoît Canet info->iops_rd = cfg.buckets[THROTTLE_OPS_READ].avg; 81c13163fbSBenoît Canet info->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE].avg; 82c13163fbSBenoît Canet 83c13163fbSBenoît Canet info->has_bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 84c13163fbSBenoît Canet info->bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 85c13163fbSBenoît Canet info->has_bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 86c13163fbSBenoît Canet info->bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 87c13163fbSBenoît Canet info->has_bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 88c13163fbSBenoît Canet info->bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 89c13163fbSBenoît Canet 90c13163fbSBenoît Canet info->has_iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 91c13163fbSBenoît Canet info->iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 92c13163fbSBenoît Canet info->has_iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 93c13163fbSBenoît Canet info->iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 94c13163fbSBenoît Canet info->has_iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 95c13163fbSBenoît Canet info->iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 96c13163fbSBenoît Canet 97398befdfSAlberto Garcia info->has_bps_max_length = info->has_bps_max; 98398befdfSAlberto Garcia info->bps_max_length = 99398befdfSAlberto Garcia cfg.buckets[THROTTLE_BPS_TOTAL].burst_length; 100398befdfSAlberto Garcia info->has_bps_rd_max_length = info->has_bps_rd_max; 101398befdfSAlberto Garcia info->bps_rd_max_length = 102398befdfSAlberto Garcia cfg.buckets[THROTTLE_BPS_READ].burst_length; 103398befdfSAlberto Garcia info->has_bps_wr_max_length = info->has_bps_wr_max; 104398befdfSAlberto Garcia info->bps_wr_max_length = 105398befdfSAlberto Garcia cfg.buckets[THROTTLE_BPS_WRITE].burst_length; 106398befdfSAlberto Garcia 107398befdfSAlberto Garcia info->has_iops_max_length = info->has_iops_max; 108398befdfSAlberto Garcia info->iops_max_length = 109398befdfSAlberto Garcia cfg.buckets[THROTTLE_OPS_TOTAL].burst_length; 110398befdfSAlberto Garcia info->has_iops_rd_max_length = info->has_iops_rd_max; 111398befdfSAlberto Garcia info->iops_rd_max_length = 112398befdfSAlberto Garcia cfg.buckets[THROTTLE_OPS_READ].burst_length; 113398befdfSAlberto Garcia info->has_iops_wr_max_length = info->has_iops_wr_max; 114398befdfSAlberto Garcia info->iops_wr_max_length = 115398befdfSAlberto Garcia cfg.buckets[THROTTLE_OPS_WRITE].burst_length; 116398befdfSAlberto Garcia 117c13163fbSBenoît Canet info->has_iops_size = cfg.op_size; 118c13163fbSBenoît Canet info->iops_size = cfg.op_size; 119b8fe1694SAlberto Garcia 120b8fe1694SAlberto Garcia info->has_group = true; 121*022cdc9fSManos Pitsidianakis info->group = 122*022cdc9fSManos Pitsidianakis g_strdup(throttle_group_get_name(&blkp->throttle_group_member)); 123c13163fbSBenoît Canet } 124c13163fbSBenoît Canet 125e2462113SFrancesco Romani info->write_threshold = bdrv_write_threshold_get(bs); 126e2462113SFrancesco Romani 127d5a8ee60SAlberto Garcia bs0 = bs; 128d5a8ee60SAlberto Garcia p_image_info = &info->image; 129d3c8c674SKevin Wolf info->backing_file_depth = 0; 130d5a8ee60SAlberto Garcia while (1) { 131d5a8ee60SAlberto Garcia Error *local_err = NULL; 132d5a8ee60SAlberto Garcia bdrv_query_image_info(bs0, p_image_info, &local_err); 133d5a8ee60SAlberto Garcia if (local_err) { 134d5a8ee60SAlberto Garcia error_propagate(errp, local_err); 135d5a8ee60SAlberto Garcia qapi_free_BlockDeviceInfo(info); 136d5a8ee60SAlberto Garcia return NULL; 137d5a8ee60SAlberto Garcia } 138d3c8c674SKevin Wolf 139760e0063SKevin Wolf if (bs0->drv && bs0->backing) { 140d3c8c674SKevin Wolf info->backing_file_depth++; 141760e0063SKevin Wolf bs0 = bs0->backing->bs; 142d5a8ee60SAlberto Garcia (*p_image_info)->has_backing_image = true; 143d5a8ee60SAlberto Garcia p_image_info = &((*p_image_info)->backing_image); 144d5a8ee60SAlberto Garcia } else { 145d5a8ee60SAlberto Garcia break; 146d5a8ee60SAlberto Garcia } 147d3c8c674SKevin Wolf 148d3c8c674SKevin Wolf /* Skip automatically inserted nodes that the user isn't aware of for 149d3c8c674SKevin Wolf * query-block (blk != NULL), but not for query-named-block-nodes */ 1508e8eb0a9SKevin Wolf while (blk && bs0->drv && bs0->implicit) { 151d3c8c674SKevin Wolf bs0 = backing_bs(bs0); 1528e8eb0a9SKevin Wolf assert(bs0); 153d3c8c674SKevin Wolf } 154d5a8ee60SAlberto Garcia } 155d5a8ee60SAlberto Garcia 156c13163fbSBenoît Canet return info; 157c13163fbSBenoît Canet } 158c13163fbSBenoît Canet 159fb0ed453SWenchao Xia /* 160fb0ed453SWenchao Xia * Returns 0 on success, with *p_list either set to describe snapshot 161fb0ed453SWenchao Xia * information, or NULL because there are no snapshots. Returns -errno on 162fb0ed453SWenchao Xia * error, with *p_list untouched. 163fb0ed453SWenchao Xia */ 164fb0ed453SWenchao Xia int bdrv_query_snapshot_info_list(BlockDriverState *bs, 165fb0ed453SWenchao Xia SnapshotInfoList **p_list, 166fb0ed453SWenchao Xia Error **errp) 167f364ec65SWenchao Xia { 168f364ec65SWenchao Xia int i, sn_count; 169f364ec65SWenchao Xia QEMUSnapshotInfo *sn_tab = NULL; 170fb0ed453SWenchao Xia SnapshotInfoList *info_list, *cur_item = NULL, *head = NULL; 171fb0ed453SWenchao Xia SnapshotInfo *info; 172fb0ed453SWenchao Xia 173f364ec65SWenchao Xia sn_count = bdrv_snapshot_list(bs, &sn_tab); 174fb0ed453SWenchao Xia if (sn_count < 0) { 175fb0ed453SWenchao Xia const char *dev = bdrv_get_device_name(bs); 176fb0ed453SWenchao Xia switch (sn_count) { 177fb0ed453SWenchao Xia case -ENOMEDIUM: 178fb0ed453SWenchao Xia error_setg(errp, "Device '%s' is not inserted", dev); 179fb0ed453SWenchao Xia break; 180fb0ed453SWenchao Xia case -ENOTSUP: 181fb0ed453SWenchao Xia error_setg(errp, 182fb0ed453SWenchao Xia "Device '%s' does not support internal snapshots", 183fb0ed453SWenchao Xia dev); 184fb0ed453SWenchao Xia break; 185fb0ed453SWenchao Xia default: 186fb0ed453SWenchao Xia error_setg_errno(errp, -sn_count, 187fb0ed453SWenchao Xia "Can't list snapshots of device '%s'", dev); 188fb0ed453SWenchao Xia break; 189fb0ed453SWenchao Xia } 190fb0ed453SWenchao Xia return sn_count; 191fb0ed453SWenchao Xia } 192f364ec65SWenchao Xia 193f364ec65SWenchao Xia for (i = 0; i < sn_count; i++) { 194fb0ed453SWenchao Xia info = g_new0(SnapshotInfo, 1); 195fb0ed453SWenchao Xia info->id = g_strdup(sn_tab[i].id_str); 196fb0ed453SWenchao Xia info->name = g_strdup(sn_tab[i].name); 197fb0ed453SWenchao Xia info->vm_state_size = sn_tab[i].vm_state_size; 198fb0ed453SWenchao Xia info->date_sec = sn_tab[i].date_sec; 199fb0ed453SWenchao Xia info->date_nsec = sn_tab[i].date_nsec; 200fb0ed453SWenchao Xia info->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000; 201fb0ed453SWenchao Xia info->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000; 202f364ec65SWenchao Xia 203fb0ed453SWenchao Xia info_list = g_new0(SnapshotInfoList, 1); 204fb0ed453SWenchao Xia info_list->value = info; 205f364ec65SWenchao Xia 206f364ec65SWenchao Xia /* XXX: waiting for the qapi to support qemu-queue.h types */ 207f364ec65SWenchao Xia if (!cur_item) { 208fb0ed453SWenchao Xia head = cur_item = info_list; 209f364ec65SWenchao Xia } else { 210f364ec65SWenchao Xia cur_item->next = info_list; 211f364ec65SWenchao Xia cur_item = info_list; 212f364ec65SWenchao Xia } 213f364ec65SWenchao Xia 214f364ec65SWenchao Xia } 215f364ec65SWenchao Xia 216f364ec65SWenchao Xia g_free(sn_tab); 217fb0ed453SWenchao Xia *p_list = head; 218fb0ed453SWenchao Xia return 0; 219f364ec65SWenchao Xia } 220f364ec65SWenchao Xia 22143526ec8SWenchao Xia /** 22243526ec8SWenchao Xia * bdrv_query_image_info: 22343526ec8SWenchao Xia * @bs: block device to examine 22443526ec8SWenchao Xia * @p_info: location to store image information 22543526ec8SWenchao Xia * @errp: location to store error information 22643526ec8SWenchao Xia * 227553a7e87SWenchao Xia * Store "flat" image information in @p_info. 228553a7e87SWenchao Xia * 229553a7e87SWenchao Xia * "Flat" means it does *not* query backing image information, 230553a7e87SWenchao Xia * i.e. (*pinfo)->has_backing_image will be set to false and 231553a7e87SWenchao Xia * (*pinfo)->backing_image to NULL even when the image does in fact have 232553a7e87SWenchao Xia * a backing image. 233553a7e87SWenchao Xia * 23443526ec8SWenchao Xia * @p_info will be set only on success. On error, store error in @errp. 23543526ec8SWenchao Xia */ 23643526ec8SWenchao Xia void bdrv_query_image_info(BlockDriverState *bs, 23743526ec8SWenchao Xia ImageInfo **p_info, 23843526ec8SWenchao Xia Error **errp) 239f364ec65SWenchao Xia { 24052bf1e72SMarkus Armbruster int64_t size; 24143526ec8SWenchao Xia const char *backing_filename; 242f364ec65SWenchao Xia BlockDriverInfo bdi; 24343526ec8SWenchao Xia int ret; 24443526ec8SWenchao Xia Error *err = NULL; 24552bf1e72SMarkus Armbruster ImageInfo *info; 246f364ec65SWenchao Xia 2471963f8d5SPaolo Bonzini aio_context_acquire(bdrv_get_aio_context(bs)); 2481963f8d5SPaolo Bonzini 24952bf1e72SMarkus Armbruster size = bdrv_getlength(bs); 25052bf1e72SMarkus Armbruster if (size < 0) { 2519adceb02SFam Zheng error_setg_errno(errp, -size, "Can't get image size '%s'", 2529adceb02SFam Zheng bs->exact_filename); 2531963f8d5SPaolo Bonzini goto out; 25452bf1e72SMarkus Armbruster } 255f364ec65SWenchao Xia 25652bf1e72SMarkus Armbruster info = g_new0(ImageInfo, 1); 25743526ec8SWenchao Xia info->filename = g_strdup(bs->filename); 258f364ec65SWenchao Xia info->format = g_strdup(bdrv_get_format_name(bs)); 25952bf1e72SMarkus Armbruster info->virtual_size = size; 260f364ec65SWenchao Xia info->actual_size = bdrv_get_allocated_file_size(bs); 261f364ec65SWenchao Xia info->has_actual_size = info->actual_size >= 0; 262f364ec65SWenchao Xia if (bdrv_is_encrypted(bs)) { 263f364ec65SWenchao Xia info->encrypted = true; 264f364ec65SWenchao Xia info->has_encrypted = true; 265f364ec65SWenchao Xia } 266f364ec65SWenchao Xia if (bdrv_get_info(bs, &bdi) >= 0) { 267f364ec65SWenchao Xia if (bdi.cluster_size != 0) { 268f364ec65SWenchao Xia info->cluster_size = bdi.cluster_size; 269f364ec65SWenchao Xia info->has_cluster_size = true; 270f364ec65SWenchao Xia } 271f364ec65SWenchao Xia info->dirty_flag = bdi.is_dirty; 272f364ec65SWenchao Xia info->has_dirty_flag = true; 273f364ec65SWenchao Xia } 274eae041feSMax Reitz info->format_specific = bdrv_get_specific_info(bs); 275eae041feSMax Reitz info->has_format_specific = info->format_specific != NULL; 276eae041feSMax Reitz 27743526ec8SWenchao Xia backing_filename = bs->backing_file; 278f364ec65SWenchao Xia if (backing_filename[0] != '\0') { 2799a29e18fSJeff Cody char *backing_filename2 = g_malloc0(PATH_MAX); 280f364ec65SWenchao Xia info->backing_filename = g_strdup(backing_filename); 281f364ec65SWenchao Xia info->has_backing_filename = true; 2829a29e18fSJeff Cody bdrv_get_full_backing_filename(bs, backing_filename2, PATH_MAX, &err); 2839f07429eSMax Reitz if (err) { 284a5002d53SJohn Snow /* Can't reconstruct the full backing filename, so we must omit 285a5002d53SJohn Snow * this field and apply a Best Effort to this query. */ 286564d64bdSJeff Cody g_free(backing_filename2); 287a5002d53SJohn Snow backing_filename2 = NULL; 288a5002d53SJohn Snow error_free(err); 2890fa296ebSFam Zheng err = NULL; 2909f07429eSMax Reitz } 291f364ec65SWenchao Xia 29212dcb1c0SJohn Snow /* Always report the full_backing_filename if present, even if it's the 29312dcb1c0SJohn Snow * same as backing_filename. That they are same is useful info. */ 29412dcb1c0SJohn Snow if (backing_filename2) { 29512dcb1c0SJohn Snow info->full_backing_filename = g_strdup(backing_filename2); 296f364ec65SWenchao Xia info->has_full_backing_filename = true; 297f364ec65SWenchao Xia } 298f364ec65SWenchao Xia 299f364ec65SWenchao Xia if (bs->backing_format[0]) { 300f364ec65SWenchao Xia info->backing_filename_format = g_strdup(bs->backing_format); 301f364ec65SWenchao Xia info->has_backing_filename_format = true; 302f364ec65SWenchao Xia } 303564d64bdSJeff Cody g_free(backing_filename2); 304f364ec65SWenchao Xia } 30543526ec8SWenchao Xia 30643526ec8SWenchao Xia ret = bdrv_query_snapshot_info_list(bs, &info->snapshots, &err); 30743526ec8SWenchao Xia switch (ret) { 30843526ec8SWenchao Xia case 0: 30943526ec8SWenchao Xia if (info->snapshots) { 31043526ec8SWenchao Xia info->has_snapshots = true; 31143526ec8SWenchao Xia } 31243526ec8SWenchao Xia break; 31343526ec8SWenchao Xia /* recoverable error */ 31443526ec8SWenchao Xia case -ENOMEDIUM: 31543526ec8SWenchao Xia case -ENOTSUP: 31643526ec8SWenchao Xia error_free(err); 31743526ec8SWenchao Xia break; 31843526ec8SWenchao Xia default: 31943526ec8SWenchao Xia error_propagate(errp, err); 32043526ec8SWenchao Xia qapi_free_ImageInfo(info); 3211963f8d5SPaolo Bonzini goto out; 32243526ec8SWenchao Xia } 32343526ec8SWenchao Xia 32443526ec8SWenchao Xia *p_info = info; 3251963f8d5SPaolo Bonzini 3261963f8d5SPaolo Bonzini out: 3271963f8d5SPaolo Bonzini aio_context_release(bdrv_get_aio_context(bs)); 328f364ec65SWenchao Xia } 329f364ec65SWenchao Xia 330553a7e87SWenchao Xia /* @p_info will be set only on success. */ 331d829a211SMarkus Armbruster static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info, 332553a7e87SWenchao Xia Error **errp) 333f364ec65SWenchao Xia { 334f364ec65SWenchao Xia BlockInfo *info = g_malloc0(sizeof(*info)); 335d829a211SMarkus Armbruster BlockDriverState *bs = blk_bs(blk); 33646eade7bSKevin Wolf char *qdev; 33746eade7bSKevin Wolf 338d3c8c674SKevin Wolf /* Skip automatically inserted nodes that the user isn't aware of */ 339d3c8c674SKevin Wolf while (bs && bs->drv && bs->implicit) { 340d3c8c674SKevin Wolf bs = backing_bs(bs); 341d3c8c674SKevin Wolf } 342d3c8c674SKevin Wolf 343d829a211SMarkus Armbruster info->device = g_strdup(blk_name(blk)); 344f364ec65SWenchao Xia info->type = g_strdup("unknown"); 345a7f53e26SMarkus Armbruster info->locked = blk_dev_is_medium_locked(blk); 346a7f53e26SMarkus Armbruster info->removable = blk_dev_has_removable_media(blk); 347f364ec65SWenchao Xia 34846eade7bSKevin Wolf qdev = blk_get_attached_dev_id(blk); 34946eade7bSKevin Wolf if (qdev && *qdev) { 35046eade7bSKevin Wolf info->has_qdev = true; 35146eade7bSKevin Wolf info->qdev = qdev; 35246eade7bSKevin Wolf } else { 35346eade7bSKevin Wolf g_free(qdev); 35446eade7bSKevin Wolf } 35546eade7bSKevin Wolf 356327032ceSMax Reitz if (blk_dev_has_tray(blk)) { 357f364ec65SWenchao Xia info->has_tray_open = true; 358a7f53e26SMarkus Armbruster info->tray_open = blk_dev_is_tray_open(blk); 359f364ec65SWenchao Xia } 360f364ec65SWenchao Xia 361373340b2SMax Reitz if (blk_iostatus_is_enabled(blk)) { 362f364ec65SWenchao Xia info->has_io_status = true; 363373340b2SMax Reitz info->io_status = blk_iostatus(blk); 364f364ec65SWenchao Xia } 365f364ec65SWenchao Xia 3665433c24fSMax Reitz if (bs && !QLIST_EMPTY(&bs->dirty_bitmaps)) { 36721b56835SFam Zheng info->has_dirty_bitmaps = true; 36821b56835SFam Zheng info->dirty_bitmaps = bdrv_query_dirty_bitmaps(bs); 36921b56835SFam Zheng } 37021b56835SFam Zheng 3715433c24fSMax Reitz if (bs && bs->drv) { 372f364ec65SWenchao Xia info->has_inserted = true; 373c83f9fbaSKevin Wolf info->inserted = bdrv_block_device_info(blk, bs, errp); 374d5a8ee60SAlberto Garcia if (info->inserted == NULL) { 375553a7e87SWenchao Xia goto err; 376f364ec65SWenchao Xia } 377553a7e87SWenchao Xia } 378553a7e87SWenchao Xia 379553a7e87SWenchao Xia *p_info = info; 380553a7e87SWenchao Xia return; 381553a7e87SWenchao Xia 382553a7e87SWenchao Xia err: 383553a7e87SWenchao Xia qapi_free_BlockInfo(info); 384f364ec65SWenchao Xia } 385f364ec65SWenchao Xia 38654302156SMax Reitz static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk) 387f364ec65SWenchao Xia { 3882b77e60aSKevin Wolf BlockAcctStats *stats = blk_get_stats(blk); 389979e9b03SAlberto Garcia BlockAcctTimedStats *ts = NULL; 3907f0e9da6SMax Reitz 39154302156SMax Reitz ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ]; 39254302156SMax Reitz ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE]; 39354302156SMax Reitz ds->rd_operations = stats->nr_ops[BLOCK_ACCT_READ]; 39454302156SMax Reitz ds->wr_operations = stats->nr_ops[BLOCK_ACCT_WRITE]; 3957ee12dafSAlberto Garcia 39654302156SMax Reitz ds->failed_rd_operations = stats->failed_ops[BLOCK_ACCT_READ]; 39754302156SMax Reitz ds->failed_wr_operations = stats->failed_ops[BLOCK_ACCT_WRITE]; 39854302156SMax Reitz ds->failed_flush_operations = stats->failed_ops[BLOCK_ACCT_FLUSH]; 3997ee12dafSAlberto Garcia 40054302156SMax Reitz ds->invalid_rd_operations = stats->invalid_ops[BLOCK_ACCT_READ]; 40154302156SMax Reitz ds->invalid_wr_operations = stats->invalid_ops[BLOCK_ACCT_WRITE]; 40254302156SMax Reitz ds->invalid_flush_operations = 4037ee12dafSAlberto Garcia stats->invalid_ops[BLOCK_ACCT_FLUSH]; 4047ee12dafSAlberto Garcia 40554302156SMax Reitz ds->rd_merged = stats->merged[BLOCK_ACCT_READ]; 40654302156SMax Reitz ds->wr_merged = stats->merged[BLOCK_ACCT_WRITE]; 40754302156SMax Reitz ds->flush_operations = stats->nr_ops[BLOCK_ACCT_FLUSH]; 40854302156SMax Reitz ds->wr_total_time_ns = stats->total_time_ns[BLOCK_ACCT_WRITE]; 40954302156SMax Reitz ds->rd_total_time_ns = stats->total_time_ns[BLOCK_ACCT_READ]; 41054302156SMax Reitz ds->flush_total_time_ns = stats->total_time_ns[BLOCK_ACCT_FLUSH]; 411cb38fffbSAlberto Garcia 41254302156SMax Reitz ds->has_idle_time_ns = stats->last_access_time_ns > 0; 41354302156SMax Reitz if (ds->has_idle_time_ns) { 41454302156SMax Reitz ds->idle_time_ns = block_acct_idle_time_ns(stats); 415cb38fffbSAlberto Garcia } 416362e9299SAlberto Garcia 41754302156SMax Reitz ds->account_invalid = stats->account_invalid; 41854302156SMax Reitz ds->account_failed = stats->account_failed; 419979e9b03SAlberto Garcia 420979e9b03SAlberto Garcia while ((ts = block_acct_interval_next(stats, ts))) { 421979e9b03SAlberto Garcia BlockDeviceTimedStatsList *timed_stats = 422979e9b03SAlberto Garcia g_malloc0(sizeof(*timed_stats)); 423979e9b03SAlberto Garcia BlockDeviceTimedStats *dev_stats = g_malloc0(sizeof(*dev_stats)); 42454302156SMax Reitz timed_stats->next = ds->timed_stats; 425979e9b03SAlberto Garcia timed_stats->value = dev_stats; 42654302156SMax Reitz ds->timed_stats = timed_stats; 427979e9b03SAlberto Garcia 428979e9b03SAlberto Garcia TimedAverage *rd = &ts->latency[BLOCK_ACCT_READ]; 429979e9b03SAlberto Garcia TimedAverage *wr = &ts->latency[BLOCK_ACCT_WRITE]; 430979e9b03SAlberto Garcia TimedAverage *fl = &ts->latency[BLOCK_ACCT_FLUSH]; 431979e9b03SAlberto Garcia 432979e9b03SAlberto Garcia dev_stats->interval_length = ts->interval_length; 433979e9b03SAlberto Garcia 434979e9b03SAlberto Garcia dev_stats->min_rd_latency_ns = timed_average_min(rd); 435979e9b03SAlberto Garcia dev_stats->max_rd_latency_ns = timed_average_max(rd); 436979e9b03SAlberto Garcia dev_stats->avg_rd_latency_ns = timed_average_avg(rd); 437979e9b03SAlberto Garcia 438979e9b03SAlberto Garcia dev_stats->min_wr_latency_ns = timed_average_min(wr); 439979e9b03SAlberto Garcia dev_stats->max_wr_latency_ns = timed_average_max(wr); 440979e9b03SAlberto Garcia dev_stats->avg_wr_latency_ns = timed_average_avg(wr); 441979e9b03SAlberto Garcia 442979e9b03SAlberto Garcia dev_stats->min_flush_latency_ns = timed_average_min(fl); 443979e9b03SAlberto Garcia dev_stats->max_flush_latency_ns = timed_average_max(fl); 444979e9b03SAlberto Garcia dev_stats->avg_flush_latency_ns = timed_average_avg(fl); 44596e4dedaSAlberto Garcia 44696e4dedaSAlberto Garcia dev_stats->avg_rd_queue_depth = 44796e4dedaSAlberto Garcia block_acct_queue_depth(ts, BLOCK_ACCT_READ); 44896e4dedaSAlberto Garcia dev_stats->avg_wr_queue_depth = 44996e4dedaSAlberto Garcia block_acct_queue_depth(ts, BLOCK_ACCT_WRITE); 450979e9b03SAlberto Garcia } 4517f0e9da6SMax Reitz } 452f364ec65SWenchao Xia 453d3c8c674SKevin Wolf static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs, 454d3c8c674SKevin Wolf bool blk_level) 4552b77e60aSKevin Wolf { 45620a6d768SDou Liyang BlockStats *s = NULL; 45720a6d768SDou Liyang 45820a6d768SDou Liyang s = g_malloc0(sizeof(*s)); 45920a6d768SDou Liyang s->stats = g_malloc0(sizeof(*s->stats)); 46020a6d768SDou Liyang 46120a6d768SDou Liyang if (!bs) { 46220a6d768SDou Liyang return s; 46320a6d768SDou Liyang } 46420a6d768SDou Liyang 465d3c8c674SKevin Wolf /* Skip automatically inserted nodes that the user isn't aware of in 466d3c8c674SKevin Wolf * a BlockBackend-level command. Stay at the exact node for a node-level 467d3c8c674SKevin Wolf * command. */ 468d3c8c674SKevin Wolf while (blk_level && bs->drv && bs->implicit) { 469d3c8c674SKevin Wolf bs = backing_bs(bs); 470d3c8c674SKevin Wolf assert(bs); 471d3c8c674SKevin Wolf } 472d3c8c674SKevin Wolf 4732b77e60aSKevin Wolf if (bdrv_get_node_name(bs)[0]) { 4742b77e60aSKevin Wolf s->has_node_name = true; 4752b77e60aSKevin Wolf s->node_name = g_strdup(bdrv_get_node_name(bs)); 4762b77e60aSKevin Wolf } 4772b77e60aSKevin Wolf 478f7946da2SPaolo Bonzini s->stats->wr_highest_offset = stat64_get(&bs->wr_highest_offset); 47953d8f9d8SMax Reitz 480f364ec65SWenchao Xia if (bs->file) { 481f364ec65SWenchao Xia s->has_parent = true; 482d3c8c674SKevin Wolf s->parent = bdrv_query_bds_stats(bs->file->bs, blk_level); 483f364ec65SWenchao Xia } 484f364ec65SWenchao Xia 485d3c8c674SKevin Wolf if (blk_level && bs->backing) { 486c8059b97SFam Zheng s->has_backing = true; 487d3c8c674SKevin Wolf s->backing = bdrv_query_bds_stats(bs->backing->bs, blk_level); 488c8059b97SFam Zheng } 489c8059b97SFam Zheng 49020a6d768SDou Liyang return s; 491b07363a1SKevin Wolf } 492b07363a1SKevin Wolf 493f364ec65SWenchao Xia BlockInfoList *qmp_query_block(Error **errp) 494f364ec65SWenchao Xia { 495f364ec65SWenchao Xia BlockInfoList *head = NULL, **p_next = &head; 496d829a211SMarkus Armbruster BlockBackend *blk; 497553a7e87SWenchao Xia Error *local_err = NULL; 498f364ec65SWenchao Xia 499d5b68844SKevin Wolf for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) { 500d5b68844SKevin Wolf BlockInfoList *info; 501d5b68844SKevin Wolf 502ec18b0a9SKevin Wolf if (!*blk_name(blk) && !blk_get_attached_dev(blk)) { 503d5b68844SKevin Wolf continue; 504d5b68844SKevin Wolf } 505d5b68844SKevin Wolf 506d5b68844SKevin Wolf info = g_malloc0(sizeof(*info)); 507d829a211SMarkus Armbruster bdrv_query_info(blk, &info->value, &local_err); 50884d18f06SMarkus Armbruster if (local_err) { 509553a7e87SWenchao Xia error_propagate(errp, local_err); 510903c341dSMarkus Armbruster g_free(info); 511903c341dSMarkus Armbruster qapi_free_BlockInfoList(head); 512903c341dSMarkus Armbruster return NULL; 513553a7e87SWenchao Xia } 514f364ec65SWenchao Xia 515f364ec65SWenchao Xia *p_next = info; 516f364ec65SWenchao Xia p_next = &info->next; 517f364ec65SWenchao Xia } 518f364ec65SWenchao Xia 519f364ec65SWenchao Xia return head; 520f364ec65SWenchao Xia } 521f364ec65SWenchao Xia 522f71eaa74SFam Zheng BlockStatsList *qmp_query_blockstats(bool has_query_nodes, 523f71eaa74SFam Zheng bool query_nodes, 524f71eaa74SFam Zheng Error **errp) 525f364ec65SWenchao Xia { 526f364ec65SWenchao Xia BlockStatsList *head = NULL, **p_next = &head; 527a6baa608SDou Liyang BlockBackend *blk; 528a6baa608SDou Liyang BlockDriverState *bs; 529f364ec65SWenchao Xia 530f71eaa74SFam Zheng /* Just to be safe if query_nodes is not always initialized */ 531a6baa608SDou Liyang if (has_query_nodes && query_nodes) { 532a6baa608SDou Liyang for (bs = bdrv_next_node(NULL); bs; bs = bdrv_next_node(bs)) { 533f364ec65SWenchao Xia BlockStatsList *info = g_malloc0(sizeof(*info)); 534a6baa608SDou Liyang AioContext *ctx = bdrv_get_aio_context(bs); 53513344f3aSStefan Hajnoczi 53613344f3aSStefan Hajnoczi aio_context_acquire(ctx); 537a6baa608SDou Liyang info->value = bdrv_query_bds_stats(bs, false); 53813344f3aSStefan Hajnoczi aio_context_release(ctx); 539f364ec65SWenchao Xia 540f364ec65SWenchao Xia *p_next = info; 541f364ec65SWenchao Xia p_next = &info->next; 542f364ec65SWenchao Xia } 543a6baa608SDou Liyang } else { 544a6baa608SDou Liyang for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 545a6baa608SDou Liyang BlockStatsList *info = g_malloc0(sizeof(*info)); 546a6baa608SDou Liyang AioContext *ctx = blk_get_aio_context(blk); 547a6baa608SDou Liyang BlockStats *s; 548a6baa608SDou Liyang 549a6baa608SDou Liyang aio_context_acquire(ctx); 550a6baa608SDou Liyang s = bdrv_query_bds_stats(blk_bs(blk), true); 551a6baa608SDou Liyang s->has_device = true; 552a6baa608SDou Liyang s->device = g_strdup(blk_name(blk)); 553a6baa608SDou Liyang bdrv_query_blk_stats(s->stats, blk); 554a6baa608SDou Liyang aio_context_release(ctx); 555a6baa608SDou Liyang 556a6baa608SDou Liyang info->value = s; 557a6baa608SDou Liyang *p_next = info; 558a6baa608SDou Liyang p_next = &info->next; 559a6baa608SDou Liyang } 560a6baa608SDou Liyang } 561f364ec65SWenchao Xia 562f364ec65SWenchao Xia return head; 563f364ec65SWenchao Xia } 564f364ec65SWenchao Xia 565f364ec65SWenchao Xia #define NB_SUFFIXES 4 566f364ec65SWenchao Xia 567f364ec65SWenchao Xia static char *get_human_readable_size(char *buf, int buf_size, int64_t size) 568f364ec65SWenchao Xia { 5692c20fa2cSStefan Weil static const char suffixes[NB_SUFFIXES] = {'K', 'M', 'G', 'T'}; 570f364ec65SWenchao Xia int64_t base; 571f364ec65SWenchao Xia int i; 572f364ec65SWenchao Xia 573f364ec65SWenchao Xia if (size <= 999) { 574f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64, size); 575f364ec65SWenchao Xia } else { 576f364ec65SWenchao Xia base = 1024; 577f364ec65SWenchao Xia for (i = 0; i < NB_SUFFIXES; i++) { 578f364ec65SWenchao Xia if (size < (10 * base)) { 579f364ec65SWenchao Xia snprintf(buf, buf_size, "%0.1f%c", 580f364ec65SWenchao Xia (double)size / base, 581f364ec65SWenchao Xia suffixes[i]); 582f364ec65SWenchao Xia break; 583f364ec65SWenchao Xia } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 584f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64 "%c", 585f364ec65SWenchao Xia ((size + (base >> 1)) / base), 586f364ec65SWenchao Xia suffixes[i]); 587f364ec65SWenchao Xia break; 588f364ec65SWenchao Xia } 589f364ec65SWenchao Xia base = base * 1024; 590f364ec65SWenchao Xia } 591f364ec65SWenchao Xia } 592f364ec65SWenchao Xia return buf; 593f364ec65SWenchao Xia } 594f364ec65SWenchao Xia 5955b917044SWenchao Xia void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 5965b917044SWenchao Xia QEMUSnapshotInfo *sn) 597f364ec65SWenchao Xia { 598f364ec65SWenchao Xia char buf1[128], date_buf[128], clock_buf[128]; 599f364ec65SWenchao Xia struct tm tm; 600f364ec65SWenchao Xia time_t ti; 601f364ec65SWenchao Xia int64_t secs; 602f364ec65SWenchao Xia 603f364ec65SWenchao Xia if (!sn) { 6045b917044SWenchao Xia func_fprintf(f, 605f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 606f364ec65SWenchao Xia "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 607f364ec65SWenchao Xia } else { 608f364ec65SWenchao Xia ti = sn->date_sec; 609f364ec65SWenchao Xia localtime_r(&ti, &tm); 610f364ec65SWenchao Xia strftime(date_buf, sizeof(date_buf), 611f364ec65SWenchao Xia "%Y-%m-%d %H:%M:%S", &tm); 612f364ec65SWenchao Xia secs = sn->vm_clock_nsec / 1000000000; 613f364ec65SWenchao Xia snprintf(clock_buf, sizeof(clock_buf), 614f364ec65SWenchao Xia "%02d:%02d:%02d.%03d", 615f364ec65SWenchao Xia (int)(secs / 3600), 616f364ec65SWenchao Xia (int)((secs / 60) % 60), 617f364ec65SWenchao Xia (int)(secs % 60), 618f364ec65SWenchao Xia (int)((sn->vm_clock_nsec / 1000000) % 1000)); 6195b917044SWenchao Xia func_fprintf(f, 620f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 621f364ec65SWenchao Xia sn->id_str, sn->name, 6225b917044SWenchao Xia get_human_readable_size(buf1, sizeof(buf1), 6235b917044SWenchao Xia sn->vm_state_size), 624f364ec65SWenchao Xia date_buf, 625f364ec65SWenchao Xia clock_buf); 626f364ec65SWenchao Xia } 627f364ec65SWenchao Xia } 628f364ec65SWenchao Xia 629a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 630a8d8ecb7SMax Reitz QDict *dict); 631a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 632a8d8ecb7SMax Reitz QList *list); 633a8d8ecb7SMax Reitz 634a8d8ecb7SMax Reitz static void dump_qobject(fprintf_function func_fprintf, void *f, 635a8d8ecb7SMax Reitz int comp_indent, QObject *obj) 636a8d8ecb7SMax Reitz { 637a8d8ecb7SMax Reitz switch (qobject_type(obj)) { 63801b2ffceSMarc-André Lureau case QTYPE_QNUM: { 63901b2ffceSMarc-André Lureau QNum *value = qobject_to_qnum(obj); 64001b2ffceSMarc-André Lureau char *tmp = qnum_to_string(value); 64101b2ffceSMarc-André Lureau func_fprintf(f, "%s", tmp); 64201b2ffceSMarc-André Lureau g_free(tmp); 643a8d8ecb7SMax Reitz break; 644a8d8ecb7SMax Reitz } 645a8d8ecb7SMax Reitz case QTYPE_QSTRING: { 646a8d8ecb7SMax Reitz QString *value = qobject_to_qstring(obj); 647a8d8ecb7SMax Reitz func_fprintf(f, "%s", qstring_get_str(value)); 648a8d8ecb7SMax Reitz break; 649a8d8ecb7SMax Reitz } 650a8d8ecb7SMax Reitz case QTYPE_QDICT: { 651a8d8ecb7SMax Reitz QDict *value = qobject_to_qdict(obj); 652a8d8ecb7SMax Reitz dump_qdict(func_fprintf, f, comp_indent, value); 653a8d8ecb7SMax Reitz break; 654a8d8ecb7SMax Reitz } 655a8d8ecb7SMax Reitz case QTYPE_QLIST: { 656a8d8ecb7SMax Reitz QList *value = qobject_to_qlist(obj); 657a8d8ecb7SMax Reitz dump_qlist(func_fprintf, f, comp_indent, value); 658a8d8ecb7SMax Reitz break; 659a8d8ecb7SMax Reitz } 660a8d8ecb7SMax Reitz case QTYPE_QBOOL: { 661a8d8ecb7SMax Reitz QBool *value = qobject_to_qbool(obj); 662fc48ffc3SEric Blake func_fprintf(f, "%s", qbool_get_bool(value) ? "true" : "false"); 663a8d8ecb7SMax Reitz break; 664a8d8ecb7SMax Reitz } 665a8d8ecb7SMax Reitz default: 666a8d8ecb7SMax Reitz abort(); 667a8d8ecb7SMax Reitz } 668a8d8ecb7SMax Reitz } 669a8d8ecb7SMax Reitz 670a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 671a8d8ecb7SMax Reitz QList *list) 672a8d8ecb7SMax Reitz { 673a8d8ecb7SMax Reitz const QListEntry *entry; 674a8d8ecb7SMax Reitz int i = 0; 675a8d8ecb7SMax Reitz 676a8d8ecb7SMax Reitz for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) { 6771310a3d3SEric Blake QType type = qobject_type(entry->value); 678a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 679853ccfedSPeter Xu func_fprintf(f, "%*s[%i]:%c", indentation * 4, "", i, 680853ccfedSPeter Xu composite ? '\n' : ' '); 681a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 682a8d8ecb7SMax Reitz if (!composite) { 683a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 684a8d8ecb7SMax Reitz } 685a8d8ecb7SMax Reitz } 686a8d8ecb7SMax Reitz } 687a8d8ecb7SMax Reitz 688a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 689a8d8ecb7SMax Reitz QDict *dict) 690a8d8ecb7SMax Reitz { 691a8d8ecb7SMax Reitz const QDictEntry *entry; 692a8d8ecb7SMax Reitz 693a8d8ecb7SMax Reitz for (entry = qdict_first(dict); entry; entry = qdict_next(dict, entry)) { 6941310a3d3SEric Blake QType type = qobject_type(entry->value); 695a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 6965eda6227SPeter Xu char *key = g_malloc(strlen(entry->key) + 1); 697a8d8ecb7SMax Reitz int i; 698a8d8ecb7SMax Reitz 699a8d8ecb7SMax Reitz /* replace dashes with spaces in key (variable) names */ 700a8d8ecb7SMax Reitz for (i = 0; entry->key[i]; i++) { 701a8d8ecb7SMax Reitz key[i] = entry->key[i] == '-' ? ' ' : entry->key[i]; 702a8d8ecb7SMax Reitz } 703a8d8ecb7SMax Reitz key[i] = 0; 704853ccfedSPeter Xu func_fprintf(f, "%*s%s:%c", indentation * 4, "", key, 705853ccfedSPeter Xu composite ? '\n' : ' '); 706a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 707a8d8ecb7SMax Reitz if (!composite) { 708a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 709a8d8ecb7SMax Reitz } 7105eda6227SPeter Xu g_free(key); 711a8d8ecb7SMax Reitz } 712a8d8ecb7SMax Reitz } 713a8d8ecb7SMax Reitz 714a8d8ecb7SMax Reitz void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f, 715a8d8ecb7SMax Reitz ImageInfoSpecific *info_spec) 716a8d8ecb7SMax Reitz { 717a8d8ecb7SMax Reitz QObject *obj, *data; 7187d5e199aSDaniel P. Berrange Visitor *v = qobject_output_visitor_new(&obj); 719a8d8ecb7SMax Reitz 7203b098d56SEric Blake visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort); 7213b098d56SEric Blake visit_complete(v, &obj); 722a8d8ecb7SMax Reitz data = qdict_get(qobject_to_qdict(obj), "data"); 723a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, 1, data); 7243ac2f2f7SPino Toscano qobject_decref(obj); 7253b098d56SEric Blake visit_free(v); 726a8d8ecb7SMax Reitz } 727a8d8ecb7SMax Reitz 7285b917044SWenchao Xia void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 7295b917044SWenchao Xia ImageInfo *info) 730f364ec65SWenchao Xia { 731f364ec65SWenchao Xia char size_buf[128], dsize_buf[128]; 732f364ec65SWenchao Xia if (!info->has_actual_size) { 733f364ec65SWenchao Xia snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 734f364ec65SWenchao Xia } else { 735f364ec65SWenchao Xia get_human_readable_size(dsize_buf, sizeof(dsize_buf), 736f364ec65SWenchao Xia info->actual_size); 737f364ec65SWenchao Xia } 738f364ec65SWenchao Xia get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size); 7395b917044SWenchao Xia func_fprintf(f, 7405b917044SWenchao Xia "image: %s\n" 741f364ec65SWenchao Xia "file format: %s\n" 742f364ec65SWenchao Xia "virtual size: %s (%" PRId64 " bytes)\n" 743f364ec65SWenchao Xia "disk size: %s\n", 744f364ec65SWenchao Xia info->filename, info->format, size_buf, 745f364ec65SWenchao Xia info->virtual_size, 746f364ec65SWenchao Xia dsize_buf); 747f364ec65SWenchao Xia 748f364ec65SWenchao Xia if (info->has_encrypted && info->encrypted) { 7495b917044SWenchao Xia func_fprintf(f, "encrypted: yes\n"); 750f364ec65SWenchao Xia } 751f364ec65SWenchao Xia 752f364ec65SWenchao Xia if (info->has_cluster_size) { 7535b917044SWenchao Xia func_fprintf(f, "cluster_size: %" PRId64 "\n", 7545b917044SWenchao Xia info->cluster_size); 755f364ec65SWenchao Xia } 756f364ec65SWenchao Xia 757f364ec65SWenchao Xia if (info->has_dirty_flag && info->dirty_flag) { 7585b917044SWenchao Xia func_fprintf(f, "cleanly shut down: no\n"); 759f364ec65SWenchao Xia } 760f364ec65SWenchao Xia 761f364ec65SWenchao Xia if (info->has_backing_filename) { 7625b917044SWenchao Xia func_fprintf(f, "backing file: %s", info->backing_filename); 7635c9d9ca5SJohn Snow if (!info->has_full_backing_filename) { 7645c9d9ca5SJohn Snow func_fprintf(f, " (cannot determine actual path)"); 7655c9d9ca5SJohn Snow } else if (strcmp(info->backing_filename, 7665c9d9ca5SJohn Snow info->full_backing_filename) != 0) { 7675b917044SWenchao Xia func_fprintf(f, " (actual path: %s)", info->full_backing_filename); 768f364ec65SWenchao Xia } 7695b917044SWenchao Xia func_fprintf(f, "\n"); 770f364ec65SWenchao Xia if (info->has_backing_filename_format) { 7715b917044SWenchao Xia func_fprintf(f, "backing file format: %s\n", 7725b917044SWenchao Xia info->backing_filename_format); 773f364ec65SWenchao Xia } 774f364ec65SWenchao Xia } 775f364ec65SWenchao Xia 776f364ec65SWenchao Xia if (info->has_snapshots) { 777f364ec65SWenchao Xia SnapshotInfoList *elem; 778f364ec65SWenchao Xia 7795b917044SWenchao Xia func_fprintf(f, "Snapshot list:\n"); 7805b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, NULL); 7815b917044SWenchao Xia func_fprintf(f, "\n"); 782f364ec65SWenchao Xia 783f364ec65SWenchao Xia /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but 784f364ec65SWenchao Xia * we convert to the block layer's native QEMUSnapshotInfo for now. 785f364ec65SWenchao Xia */ 786f364ec65SWenchao Xia for (elem = info->snapshots; elem; elem = elem->next) { 787f364ec65SWenchao Xia QEMUSnapshotInfo sn = { 788f364ec65SWenchao Xia .vm_state_size = elem->value->vm_state_size, 789f364ec65SWenchao Xia .date_sec = elem->value->date_sec, 790f364ec65SWenchao Xia .date_nsec = elem->value->date_nsec, 791f364ec65SWenchao Xia .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL + 792f364ec65SWenchao Xia elem->value->vm_clock_nsec, 793f364ec65SWenchao Xia }; 794f364ec65SWenchao Xia 795f364ec65SWenchao Xia pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id); 796f364ec65SWenchao Xia pstrcpy(sn.name, sizeof(sn.name), elem->value->name); 7975b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, &sn); 7985b917044SWenchao Xia func_fprintf(f, "\n"); 799f364ec65SWenchao Xia } 800f364ec65SWenchao Xia } 801a8d8ecb7SMax Reitz 802a8d8ecb7SMax Reitz if (info->has_format_specific) { 803a8d8ecb7SMax Reitz func_fprintf(f, "Format specific information:\n"); 804a8d8ecb7SMax Reitz bdrv_image_info_specific_dump(func_fprintf, f, info->format_specific); 805a8d8ecb7SMax Reitz } 806f364ec65SWenchao Xia } 807