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" 30e688df6bSMarkus Armbruster #include "qapi/error.h" 319af23989SMarkus Armbruster #include "qapi/qapi-commands-block-core.h" 32b3db211fSDaniel P. Berrange #include "qapi/qobject-output-visitor.h" 339af23989SMarkus Armbruster #include "qapi/qapi-visit-block-core.h" 346b673957SMarkus Armbruster #include "qapi/qmp/qbool.h" 35452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h" 3647e6b297SMarkus Armbruster #include "qapi/qmp/qlist.h" 3715280c36SMarkus Armbruster #include "qapi/qmp/qnum.h" 386b673957SMarkus Armbruster #include "qapi/qmp/qstring.h" 39d829a211SMarkus Armbruster #include "sysemu/block-backend.h" 40f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 41f364ec65SWenchao Xia 42c83f9fbaSKevin Wolf BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk, 43c83f9fbaSKevin Wolf BlockDriverState *bs, Error **errp) 44c13163fbSBenoît Canet { 45d5a8ee60SAlberto Garcia ImageInfo **p_image_info; 46d5a8ee60SAlberto Garcia BlockDriverState *bs0; 47d470ad42SMax Reitz BlockDeviceInfo *info; 48c13163fbSBenoît Canet 49d470ad42SMax Reitz if (!bs->drv) { 50d470ad42SMax Reitz error_setg(errp, "Block device %s is ejected", bs->node_name); 51d470ad42SMax Reitz return NULL; 52d470ad42SMax Reitz } 53d470ad42SMax Reitz 54f30c66baSMax Reitz bdrv_refresh_filename(bs); 55f30c66baSMax Reitz 56d470ad42SMax Reitz info = g_malloc0(sizeof(*info)); 57c13163fbSBenoît Canet info->file = g_strdup(bs->filename); 58c13163fbSBenoît Canet info->ro = bs->read_only; 59c13163fbSBenoît Canet info->drv = g_strdup(bs->drv->format_name); 60c13163fbSBenoît Canet info->encrypted = bs->encrypted; 61c01c214bSDaniel P. Berrange info->encryption_key_missing = false; 62c13163fbSBenoît Canet 639e193c5aSKevin Wolf info->cache = g_new(BlockdevCacheInfo, 1); 649e193c5aSKevin Wolf *info->cache = (BlockdevCacheInfo) { 65c83f9fbaSKevin Wolf .writeback = blk ? blk_enable_write_cache(blk) : true, 669e193c5aSKevin Wolf .direct = !!(bs->open_flags & BDRV_O_NOCACHE), 679e193c5aSKevin Wolf .no_flush = !!(bs->open_flags & BDRV_O_NO_FLUSH), 689e193c5aSKevin Wolf }; 699e193c5aSKevin Wolf 70c13163fbSBenoît Canet if (bs->node_name[0]) { 71c13163fbSBenoît Canet info->has_node_name = true; 72c13163fbSBenoît Canet info->node_name = g_strdup(bs->node_name); 73c13163fbSBenoît Canet } 74c13163fbSBenoît Canet 75c13163fbSBenoît Canet if (bs->backing_file[0]) { 76c13163fbSBenoît Canet info->has_backing_file = true; 77c13163fbSBenoît Canet info->backing_file = g_strdup(bs->backing_file); 78c13163fbSBenoît Canet } 79c13163fbSBenoît Canet 80465bee1dSPeter Lieven info->detect_zeroes = bs->detect_zeroes; 81c13163fbSBenoît Canet 82022cdc9fSManos Pitsidianakis if (blk && blk_get_public(blk)->throttle_group_member.throttle_state) { 83c13163fbSBenoît Canet ThrottleConfig cfg; 84022cdc9fSManos Pitsidianakis BlockBackendPublic *blkp = blk_get_public(blk); 8576f4afb4SAlberto Garcia 86022cdc9fSManos Pitsidianakis throttle_group_get_config(&blkp->throttle_group_member, &cfg); 8776f4afb4SAlberto Garcia 88c13163fbSBenoît Canet info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg; 89c13163fbSBenoît Canet info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg; 90c13163fbSBenoît Canet info->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE].avg; 91c13163fbSBenoît Canet 92c13163fbSBenoît Canet info->iops = cfg.buckets[THROTTLE_OPS_TOTAL].avg; 93c13163fbSBenoît Canet info->iops_rd = cfg.buckets[THROTTLE_OPS_READ].avg; 94c13163fbSBenoît Canet info->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE].avg; 95c13163fbSBenoît Canet 96c13163fbSBenoît Canet info->has_bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 97c13163fbSBenoît Canet info->bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 98c13163fbSBenoît Canet info->has_bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 99c13163fbSBenoît Canet info->bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 100c13163fbSBenoît Canet info->has_bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 101c13163fbSBenoît Canet info->bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 102c13163fbSBenoît Canet 103c13163fbSBenoît Canet info->has_iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 104c13163fbSBenoît Canet info->iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 105c13163fbSBenoît Canet info->has_iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 106c13163fbSBenoît Canet info->iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 107c13163fbSBenoît Canet info->has_iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 108c13163fbSBenoît Canet info->iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 109c13163fbSBenoît Canet 110398befdfSAlberto Garcia info->has_bps_max_length = info->has_bps_max; 111398befdfSAlberto Garcia info->bps_max_length = 112398befdfSAlberto Garcia cfg.buckets[THROTTLE_BPS_TOTAL].burst_length; 113398befdfSAlberto Garcia info->has_bps_rd_max_length = info->has_bps_rd_max; 114398befdfSAlberto Garcia info->bps_rd_max_length = 115398befdfSAlberto Garcia cfg.buckets[THROTTLE_BPS_READ].burst_length; 116398befdfSAlberto Garcia info->has_bps_wr_max_length = info->has_bps_wr_max; 117398befdfSAlberto Garcia info->bps_wr_max_length = 118398befdfSAlberto Garcia cfg.buckets[THROTTLE_BPS_WRITE].burst_length; 119398befdfSAlberto Garcia 120398befdfSAlberto Garcia info->has_iops_max_length = info->has_iops_max; 121398befdfSAlberto Garcia info->iops_max_length = 122398befdfSAlberto Garcia cfg.buckets[THROTTLE_OPS_TOTAL].burst_length; 123398befdfSAlberto Garcia info->has_iops_rd_max_length = info->has_iops_rd_max; 124398befdfSAlberto Garcia info->iops_rd_max_length = 125398befdfSAlberto Garcia cfg.buckets[THROTTLE_OPS_READ].burst_length; 126398befdfSAlberto Garcia info->has_iops_wr_max_length = info->has_iops_wr_max; 127398befdfSAlberto Garcia info->iops_wr_max_length = 128398befdfSAlberto Garcia cfg.buckets[THROTTLE_OPS_WRITE].burst_length; 129398befdfSAlberto Garcia 130c13163fbSBenoît Canet info->has_iops_size = cfg.op_size; 131c13163fbSBenoît Canet info->iops_size = cfg.op_size; 132b8fe1694SAlberto Garcia 133b8fe1694SAlberto Garcia info->has_group = true; 134022cdc9fSManos Pitsidianakis info->group = 135022cdc9fSManos Pitsidianakis g_strdup(throttle_group_get_name(&blkp->throttle_group_member)); 136c13163fbSBenoît Canet } 137c13163fbSBenoît Canet 138e2462113SFrancesco Romani info->write_threshold = bdrv_write_threshold_get(bs); 139e2462113SFrancesco Romani 140d5a8ee60SAlberto Garcia bs0 = bs; 141d5a8ee60SAlberto Garcia p_image_info = &info->image; 142d3c8c674SKevin Wolf info->backing_file_depth = 0; 143d5a8ee60SAlberto Garcia while (1) { 144d5a8ee60SAlberto Garcia Error *local_err = NULL; 145d5a8ee60SAlberto Garcia bdrv_query_image_info(bs0, p_image_info, &local_err); 146d5a8ee60SAlberto Garcia if (local_err) { 147d5a8ee60SAlberto Garcia error_propagate(errp, local_err); 148d5a8ee60SAlberto Garcia qapi_free_BlockDeviceInfo(info); 149d5a8ee60SAlberto Garcia return NULL; 150d5a8ee60SAlberto Garcia } 151d3c8c674SKevin Wolf 152760e0063SKevin Wolf if (bs0->drv && bs0->backing) { 153d3c8c674SKevin Wolf info->backing_file_depth++; 154760e0063SKevin Wolf bs0 = bs0->backing->bs; 155d5a8ee60SAlberto Garcia (*p_image_info)->has_backing_image = true; 156d5a8ee60SAlberto Garcia p_image_info = &((*p_image_info)->backing_image); 157d5a8ee60SAlberto Garcia } else { 158d5a8ee60SAlberto Garcia break; 159d5a8ee60SAlberto Garcia } 160d3c8c674SKevin Wolf 161d3c8c674SKevin Wolf /* Skip automatically inserted nodes that the user isn't aware of for 162d3c8c674SKevin Wolf * query-block (blk != NULL), but not for query-named-block-nodes */ 1638e8eb0a9SKevin Wolf while (blk && bs0->drv && bs0->implicit) { 164d3c8c674SKevin Wolf bs0 = backing_bs(bs0); 1658e8eb0a9SKevin Wolf assert(bs0); 166d3c8c674SKevin Wolf } 167d5a8ee60SAlberto Garcia } 168d5a8ee60SAlberto Garcia 169c13163fbSBenoît Canet return info; 170c13163fbSBenoît Canet } 171c13163fbSBenoît Canet 172fb0ed453SWenchao Xia /* 173fb0ed453SWenchao Xia * Returns 0 on success, with *p_list either set to describe snapshot 174fb0ed453SWenchao Xia * information, or NULL because there are no snapshots. Returns -errno on 175fb0ed453SWenchao Xia * error, with *p_list untouched. 176fb0ed453SWenchao Xia */ 177fb0ed453SWenchao Xia int bdrv_query_snapshot_info_list(BlockDriverState *bs, 178fb0ed453SWenchao Xia SnapshotInfoList **p_list, 179fb0ed453SWenchao Xia Error **errp) 180f364ec65SWenchao Xia { 181f364ec65SWenchao Xia int i, sn_count; 182f364ec65SWenchao Xia QEMUSnapshotInfo *sn_tab = NULL; 183fb0ed453SWenchao Xia SnapshotInfoList *info_list, *cur_item = NULL, *head = NULL; 184fb0ed453SWenchao Xia SnapshotInfo *info; 185fb0ed453SWenchao Xia 186f364ec65SWenchao Xia sn_count = bdrv_snapshot_list(bs, &sn_tab); 187fb0ed453SWenchao Xia if (sn_count < 0) { 188fb0ed453SWenchao Xia const char *dev = bdrv_get_device_name(bs); 189fb0ed453SWenchao Xia switch (sn_count) { 190fb0ed453SWenchao Xia case -ENOMEDIUM: 191fb0ed453SWenchao Xia error_setg(errp, "Device '%s' is not inserted", dev); 192fb0ed453SWenchao Xia break; 193fb0ed453SWenchao Xia case -ENOTSUP: 194fb0ed453SWenchao Xia error_setg(errp, 195fb0ed453SWenchao Xia "Device '%s' does not support internal snapshots", 196fb0ed453SWenchao Xia dev); 197fb0ed453SWenchao Xia break; 198fb0ed453SWenchao Xia default: 199fb0ed453SWenchao Xia error_setg_errno(errp, -sn_count, 200fb0ed453SWenchao Xia "Can't list snapshots of device '%s'", dev); 201fb0ed453SWenchao Xia break; 202fb0ed453SWenchao Xia } 203fb0ed453SWenchao Xia return sn_count; 204fb0ed453SWenchao Xia } 205f364ec65SWenchao Xia 206f364ec65SWenchao Xia for (i = 0; i < sn_count; i++) { 207fb0ed453SWenchao Xia info = g_new0(SnapshotInfo, 1); 208fb0ed453SWenchao Xia info->id = g_strdup(sn_tab[i].id_str); 209fb0ed453SWenchao Xia info->name = g_strdup(sn_tab[i].name); 210fb0ed453SWenchao Xia info->vm_state_size = sn_tab[i].vm_state_size; 211fb0ed453SWenchao Xia info->date_sec = sn_tab[i].date_sec; 212fb0ed453SWenchao Xia info->date_nsec = sn_tab[i].date_nsec; 213fb0ed453SWenchao Xia info->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000; 214fb0ed453SWenchao Xia info->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000; 215f364ec65SWenchao Xia 216fb0ed453SWenchao Xia info_list = g_new0(SnapshotInfoList, 1); 217fb0ed453SWenchao Xia info_list->value = info; 218f364ec65SWenchao Xia 219f364ec65SWenchao Xia /* XXX: waiting for the qapi to support qemu-queue.h types */ 220f364ec65SWenchao Xia if (!cur_item) { 221fb0ed453SWenchao Xia head = cur_item = info_list; 222f364ec65SWenchao Xia } else { 223f364ec65SWenchao Xia cur_item->next = info_list; 224f364ec65SWenchao Xia cur_item = info_list; 225f364ec65SWenchao Xia } 226f364ec65SWenchao Xia 227f364ec65SWenchao Xia } 228f364ec65SWenchao Xia 229f364ec65SWenchao Xia g_free(sn_tab); 230fb0ed453SWenchao Xia *p_list = head; 231fb0ed453SWenchao Xia return 0; 232f364ec65SWenchao Xia } 233f364ec65SWenchao Xia 23443526ec8SWenchao Xia /** 23543526ec8SWenchao Xia * bdrv_query_image_info: 23643526ec8SWenchao Xia * @bs: block device to examine 23743526ec8SWenchao Xia * @p_info: location to store image information 23843526ec8SWenchao Xia * @errp: location to store error information 23943526ec8SWenchao Xia * 240553a7e87SWenchao Xia * Store "flat" image information in @p_info. 241553a7e87SWenchao Xia * 242553a7e87SWenchao Xia * "Flat" means it does *not* query backing image information, 243553a7e87SWenchao Xia * i.e. (*pinfo)->has_backing_image will be set to false and 244553a7e87SWenchao Xia * (*pinfo)->backing_image to NULL even when the image does in fact have 245553a7e87SWenchao Xia * a backing image. 246553a7e87SWenchao Xia * 24743526ec8SWenchao Xia * @p_info will be set only on success. On error, store error in @errp. 24843526ec8SWenchao Xia */ 24943526ec8SWenchao Xia void bdrv_query_image_info(BlockDriverState *bs, 25043526ec8SWenchao Xia ImageInfo **p_info, 25143526ec8SWenchao Xia Error **errp) 252f364ec65SWenchao Xia { 25352bf1e72SMarkus Armbruster int64_t size; 25443526ec8SWenchao Xia const char *backing_filename; 255f364ec65SWenchao Xia BlockDriverInfo bdi; 25643526ec8SWenchao Xia int ret; 25743526ec8SWenchao Xia Error *err = NULL; 25852bf1e72SMarkus Armbruster ImageInfo *info; 259f364ec65SWenchao Xia 2601963f8d5SPaolo Bonzini aio_context_acquire(bdrv_get_aio_context(bs)); 2611963f8d5SPaolo Bonzini 26252bf1e72SMarkus Armbruster size = bdrv_getlength(bs); 26352bf1e72SMarkus Armbruster if (size < 0) { 2649adceb02SFam Zheng error_setg_errno(errp, -size, "Can't get image size '%s'", 2659adceb02SFam Zheng bs->exact_filename); 2661963f8d5SPaolo Bonzini goto out; 26752bf1e72SMarkus Armbruster } 268f364ec65SWenchao Xia 269f30c66baSMax Reitz bdrv_refresh_filename(bs); 270f30c66baSMax Reitz 27152bf1e72SMarkus Armbruster info = g_new0(ImageInfo, 1); 27243526ec8SWenchao Xia info->filename = g_strdup(bs->filename); 273f364ec65SWenchao Xia info->format = g_strdup(bdrv_get_format_name(bs)); 27452bf1e72SMarkus Armbruster info->virtual_size = size; 275f364ec65SWenchao Xia info->actual_size = bdrv_get_allocated_file_size(bs); 276f364ec65SWenchao Xia info->has_actual_size = info->actual_size >= 0; 277f364ec65SWenchao Xia if (bdrv_is_encrypted(bs)) { 278f364ec65SWenchao Xia info->encrypted = true; 279f364ec65SWenchao Xia info->has_encrypted = true; 280f364ec65SWenchao Xia } 281f364ec65SWenchao Xia if (bdrv_get_info(bs, &bdi) >= 0) { 282f364ec65SWenchao Xia if (bdi.cluster_size != 0) { 283f364ec65SWenchao Xia info->cluster_size = bdi.cluster_size; 284f364ec65SWenchao Xia info->has_cluster_size = true; 285f364ec65SWenchao Xia } 286f364ec65SWenchao Xia info->dirty_flag = bdi.is_dirty; 287f364ec65SWenchao Xia info->has_dirty_flag = true; 288f364ec65SWenchao Xia } 2891bf6e9caSAndrey Shinkevich info->format_specific = bdrv_get_specific_info(bs, &err); 2901bf6e9caSAndrey Shinkevich if (err) { 2911bf6e9caSAndrey Shinkevich error_propagate(errp, err); 2921bf6e9caSAndrey Shinkevich qapi_free_ImageInfo(info); 2931bf6e9caSAndrey Shinkevich goto out; 2941bf6e9caSAndrey Shinkevich } 295eae041feSMax Reitz info->has_format_specific = info->format_specific != NULL; 296eae041feSMax Reitz 29743526ec8SWenchao Xia backing_filename = bs->backing_file; 298f364ec65SWenchao Xia if (backing_filename[0] != '\0') { 2996b6833c1SMax Reitz char *backing_filename2; 300f364ec65SWenchao Xia info->backing_filename = g_strdup(backing_filename); 301f364ec65SWenchao Xia info->has_backing_filename = true; 3026b6833c1SMax Reitz backing_filename2 = bdrv_get_full_backing_filename(bs, NULL); 303f364ec65SWenchao Xia 30412dcb1c0SJohn Snow /* Always report the full_backing_filename if present, even if it's the 30512dcb1c0SJohn Snow * same as backing_filename. That they are same is useful info. */ 30612dcb1c0SJohn Snow if (backing_filename2) { 30712dcb1c0SJohn Snow info->full_backing_filename = g_strdup(backing_filename2); 308f364ec65SWenchao Xia info->has_full_backing_filename = true; 309f364ec65SWenchao Xia } 310f364ec65SWenchao Xia 311f364ec65SWenchao Xia if (bs->backing_format[0]) { 312f364ec65SWenchao Xia info->backing_filename_format = g_strdup(bs->backing_format); 313f364ec65SWenchao Xia info->has_backing_filename_format = true; 314f364ec65SWenchao Xia } 315564d64bdSJeff Cody g_free(backing_filename2); 316f364ec65SWenchao Xia } 31743526ec8SWenchao Xia 31843526ec8SWenchao Xia ret = bdrv_query_snapshot_info_list(bs, &info->snapshots, &err); 31943526ec8SWenchao Xia switch (ret) { 32043526ec8SWenchao Xia case 0: 32143526ec8SWenchao Xia if (info->snapshots) { 32243526ec8SWenchao Xia info->has_snapshots = true; 32343526ec8SWenchao Xia } 32443526ec8SWenchao Xia break; 32543526ec8SWenchao Xia /* recoverable error */ 32643526ec8SWenchao Xia case -ENOMEDIUM: 32743526ec8SWenchao Xia case -ENOTSUP: 32843526ec8SWenchao Xia error_free(err); 32943526ec8SWenchao Xia break; 33043526ec8SWenchao Xia default: 33143526ec8SWenchao Xia error_propagate(errp, err); 33243526ec8SWenchao Xia qapi_free_ImageInfo(info); 3331963f8d5SPaolo Bonzini goto out; 33443526ec8SWenchao Xia } 33543526ec8SWenchao Xia 33643526ec8SWenchao Xia *p_info = info; 3371963f8d5SPaolo Bonzini 3381963f8d5SPaolo Bonzini out: 3391963f8d5SPaolo Bonzini aio_context_release(bdrv_get_aio_context(bs)); 340f364ec65SWenchao Xia } 341f364ec65SWenchao Xia 342553a7e87SWenchao Xia /* @p_info will be set only on success. */ 343d829a211SMarkus Armbruster static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info, 344553a7e87SWenchao Xia Error **errp) 345f364ec65SWenchao Xia { 346f364ec65SWenchao Xia BlockInfo *info = g_malloc0(sizeof(*info)); 347d829a211SMarkus Armbruster BlockDriverState *bs = blk_bs(blk); 34846eade7bSKevin Wolf char *qdev; 34946eade7bSKevin Wolf 350d3c8c674SKevin Wolf /* Skip automatically inserted nodes that the user isn't aware of */ 351d3c8c674SKevin Wolf while (bs && bs->drv && bs->implicit) { 352d3c8c674SKevin Wolf bs = backing_bs(bs); 353d3c8c674SKevin Wolf } 354d3c8c674SKevin Wolf 355d829a211SMarkus Armbruster info->device = g_strdup(blk_name(blk)); 356f364ec65SWenchao Xia info->type = g_strdup("unknown"); 357a7f53e26SMarkus Armbruster info->locked = blk_dev_is_medium_locked(blk); 358a7f53e26SMarkus Armbruster info->removable = blk_dev_has_removable_media(blk); 359f364ec65SWenchao Xia 36046eade7bSKevin Wolf qdev = blk_get_attached_dev_id(blk); 36146eade7bSKevin Wolf if (qdev && *qdev) { 36246eade7bSKevin Wolf info->has_qdev = true; 36346eade7bSKevin Wolf info->qdev = qdev; 36446eade7bSKevin Wolf } else { 36546eade7bSKevin Wolf g_free(qdev); 36646eade7bSKevin Wolf } 36746eade7bSKevin Wolf 368327032ceSMax Reitz if (blk_dev_has_tray(blk)) { 369f364ec65SWenchao Xia info->has_tray_open = true; 370a7f53e26SMarkus Armbruster info->tray_open = blk_dev_is_tray_open(blk); 371f364ec65SWenchao Xia } 372f364ec65SWenchao Xia 373373340b2SMax Reitz if (blk_iostatus_is_enabled(blk)) { 374f364ec65SWenchao Xia info->has_io_status = true; 375373340b2SMax Reitz info->io_status = blk_iostatus(blk); 376f364ec65SWenchao Xia } 377f364ec65SWenchao Xia 3785433c24fSMax Reitz if (bs && !QLIST_EMPTY(&bs->dirty_bitmaps)) { 37921b56835SFam Zheng info->has_dirty_bitmaps = true; 38021b56835SFam Zheng info->dirty_bitmaps = bdrv_query_dirty_bitmaps(bs); 38121b56835SFam Zheng } 38221b56835SFam Zheng 3835433c24fSMax Reitz if (bs && bs->drv) { 384f364ec65SWenchao Xia info->has_inserted = true; 385c83f9fbaSKevin Wolf info->inserted = bdrv_block_device_info(blk, bs, errp); 386d5a8ee60SAlberto Garcia if (info->inserted == NULL) { 387553a7e87SWenchao Xia goto err; 388f364ec65SWenchao Xia } 389553a7e87SWenchao Xia } 390553a7e87SWenchao Xia 391553a7e87SWenchao Xia *p_info = info; 392553a7e87SWenchao Xia return; 393553a7e87SWenchao Xia 394553a7e87SWenchao Xia err: 395553a7e87SWenchao Xia qapi_free_BlockInfo(info); 396f364ec65SWenchao Xia } 397f364ec65SWenchao Xia 3987e5c776dSVladimir Sementsov-Ogievskiy static uint64List *uint64_list(uint64_t *list, int size) 3997e5c776dSVladimir Sementsov-Ogievskiy { 4007e5c776dSVladimir Sementsov-Ogievskiy int i; 4017e5c776dSVladimir Sementsov-Ogievskiy uint64List *out_list = NULL; 4027e5c776dSVladimir Sementsov-Ogievskiy uint64List **pout_list = &out_list; 4037e5c776dSVladimir Sementsov-Ogievskiy 4047e5c776dSVladimir Sementsov-Ogievskiy for (i = 0; i < size; i++) { 4057e5c776dSVladimir Sementsov-Ogievskiy uint64List *entry = g_new(uint64List, 1); 4067e5c776dSVladimir Sementsov-Ogievskiy entry->value = list[i]; 4077e5c776dSVladimir Sementsov-Ogievskiy *pout_list = entry; 4087e5c776dSVladimir Sementsov-Ogievskiy pout_list = &entry->next; 4097e5c776dSVladimir Sementsov-Ogievskiy } 4107e5c776dSVladimir Sementsov-Ogievskiy 4117e5c776dSVladimir Sementsov-Ogievskiy *pout_list = NULL; 4127e5c776dSVladimir Sementsov-Ogievskiy 4137e5c776dSVladimir Sementsov-Ogievskiy return out_list; 4147e5c776dSVladimir Sementsov-Ogievskiy } 4157e5c776dSVladimir Sementsov-Ogievskiy 4167e5c776dSVladimir Sementsov-Ogievskiy static void bdrv_latency_histogram_stats(BlockLatencyHistogram *hist, 4177e5c776dSVladimir Sementsov-Ogievskiy bool *not_null, 4187e5c776dSVladimir Sementsov-Ogievskiy BlockLatencyHistogramInfo **info) 4197e5c776dSVladimir Sementsov-Ogievskiy { 4207e5c776dSVladimir Sementsov-Ogievskiy *not_null = hist->bins != NULL; 4217e5c776dSVladimir Sementsov-Ogievskiy if (*not_null) { 4227e5c776dSVladimir Sementsov-Ogievskiy *info = g_new0(BlockLatencyHistogramInfo, 1); 4237e5c776dSVladimir Sementsov-Ogievskiy 4247e5c776dSVladimir Sementsov-Ogievskiy (*info)->boundaries = uint64_list(hist->boundaries, hist->nbins - 1); 4257e5c776dSVladimir Sementsov-Ogievskiy (*info)->bins = uint64_list(hist->bins, hist->nbins); 4267e5c776dSVladimir Sementsov-Ogievskiy } 4277e5c776dSVladimir Sementsov-Ogievskiy } 4287e5c776dSVladimir Sementsov-Ogievskiy 42954302156SMax Reitz static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk) 430f364ec65SWenchao Xia { 4312b77e60aSKevin Wolf BlockAcctStats *stats = blk_get_stats(blk); 432979e9b03SAlberto Garcia BlockAcctTimedStats *ts = NULL; 4337f0e9da6SMax Reitz 43454302156SMax Reitz ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ]; 43554302156SMax Reitz ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE]; 43654302156SMax Reitz ds->rd_operations = stats->nr_ops[BLOCK_ACCT_READ]; 43754302156SMax Reitz ds->wr_operations = stats->nr_ops[BLOCK_ACCT_WRITE]; 4387ee12dafSAlberto Garcia 43954302156SMax Reitz ds->failed_rd_operations = stats->failed_ops[BLOCK_ACCT_READ]; 44054302156SMax Reitz ds->failed_wr_operations = stats->failed_ops[BLOCK_ACCT_WRITE]; 44154302156SMax Reitz ds->failed_flush_operations = stats->failed_ops[BLOCK_ACCT_FLUSH]; 4427ee12dafSAlberto Garcia 44354302156SMax Reitz ds->invalid_rd_operations = stats->invalid_ops[BLOCK_ACCT_READ]; 44454302156SMax Reitz ds->invalid_wr_operations = stats->invalid_ops[BLOCK_ACCT_WRITE]; 44554302156SMax Reitz ds->invalid_flush_operations = 4467ee12dafSAlberto Garcia stats->invalid_ops[BLOCK_ACCT_FLUSH]; 4477ee12dafSAlberto Garcia 44854302156SMax Reitz ds->rd_merged = stats->merged[BLOCK_ACCT_READ]; 44954302156SMax Reitz ds->wr_merged = stats->merged[BLOCK_ACCT_WRITE]; 45054302156SMax Reitz ds->flush_operations = stats->nr_ops[BLOCK_ACCT_FLUSH]; 45154302156SMax Reitz ds->wr_total_time_ns = stats->total_time_ns[BLOCK_ACCT_WRITE]; 45254302156SMax Reitz ds->rd_total_time_ns = stats->total_time_ns[BLOCK_ACCT_READ]; 45354302156SMax Reitz ds->flush_total_time_ns = stats->total_time_ns[BLOCK_ACCT_FLUSH]; 454cb38fffbSAlberto Garcia 45554302156SMax Reitz ds->has_idle_time_ns = stats->last_access_time_ns > 0; 45654302156SMax Reitz if (ds->has_idle_time_ns) { 45754302156SMax Reitz ds->idle_time_ns = block_acct_idle_time_ns(stats); 458cb38fffbSAlberto Garcia } 459362e9299SAlberto Garcia 46054302156SMax Reitz ds->account_invalid = stats->account_invalid; 46154302156SMax Reitz ds->account_failed = stats->account_failed; 462979e9b03SAlberto Garcia 463979e9b03SAlberto Garcia while ((ts = block_acct_interval_next(stats, ts))) { 464979e9b03SAlberto Garcia BlockDeviceTimedStatsList *timed_stats = 465979e9b03SAlberto Garcia g_malloc0(sizeof(*timed_stats)); 466979e9b03SAlberto Garcia BlockDeviceTimedStats *dev_stats = g_malloc0(sizeof(*dev_stats)); 46754302156SMax Reitz timed_stats->next = ds->timed_stats; 468979e9b03SAlberto Garcia timed_stats->value = dev_stats; 46954302156SMax Reitz ds->timed_stats = timed_stats; 470979e9b03SAlberto Garcia 471979e9b03SAlberto Garcia TimedAverage *rd = &ts->latency[BLOCK_ACCT_READ]; 472979e9b03SAlberto Garcia TimedAverage *wr = &ts->latency[BLOCK_ACCT_WRITE]; 473979e9b03SAlberto Garcia TimedAverage *fl = &ts->latency[BLOCK_ACCT_FLUSH]; 474979e9b03SAlberto Garcia 475979e9b03SAlberto Garcia dev_stats->interval_length = ts->interval_length; 476979e9b03SAlberto Garcia 477979e9b03SAlberto Garcia dev_stats->min_rd_latency_ns = timed_average_min(rd); 478979e9b03SAlberto Garcia dev_stats->max_rd_latency_ns = timed_average_max(rd); 479979e9b03SAlberto Garcia dev_stats->avg_rd_latency_ns = timed_average_avg(rd); 480979e9b03SAlberto Garcia 481979e9b03SAlberto Garcia dev_stats->min_wr_latency_ns = timed_average_min(wr); 482979e9b03SAlberto Garcia dev_stats->max_wr_latency_ns = timed_average_max(wr); 483979e9b03SAlberto Garcia dev_stats->avg_wr_latency_ns = timed_average_avg(wr); 484979e9b03SAlberto Garcia 485979e9b03SAlberto Garcia dev_stats->min_flush_latency_ns = timed_average_min(fl); 486979e9b03SAlberto Garcia dev_stats->max_flush_latency_ns = timed_average_max(fl); 487979e9b03SAlberto Garcia dev_stats->avg_flush_latency_ns = timed_average_avg(fl); 48896e4dedaSAlberto Garcia 48996e4dedaSAlberto Garcia dev_stats->avg_rd_queue_depth = 49096e4dedaSAlberto Garcia block_acct_queue_depth(ts, BLOCK_ACCT_READ); 49196e4dedaSAlberto Garcia dev_stats->avg_wr_queue_depth = 49296e4dedaSAlberto Garcia block_acct_queue_depth(ts, BLOCK_ACCT_WRITE); 493979e9b03SAlberto Garcia } 4947e5c776dSVladimir Sementsov-Ogievskiy 4957e5c776dSVladimir Sementsov-Ogievskiy bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_READ], 496*cb8aac37SVladimir Sementsov-Ogievskiy &ds->has_rd_latency_histogram, 497*cb8aac37SVladimir Sementsov-Ogievskiy &ds->rd_latency_histogram); 4987e5c776dSVladimir Sementsov-Ogievskiy bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_WRITE], 499*cb8aac37SVladimir Sementsov-Ogievskiy &ds->has_wr_latency_histogram, 500*cb8aac37SVladimir Sementsov-Ogievskiy &ds->wr_latency_histogram); 5017e5c776dSVladimir Sementsov-Ogievskiy bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_FLUSH], 502*cb8aac37SVladimir Sementsov-Ogievskiy &ds->has_flush_latency_histogram, 503*cb8aac37SVladimir Sementsov-Ogievskiy &ds->flush_latency_histogram); 5047f0e9da6SMax Reitz } 505f364ec65SWenchao Xia 506d3c8c674SKevin Wolf static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs, 507d3c8c674SKevin Wolf bool blk_level) 5082b77e60aSKevin Wolf { 50920a6d768SDou Liyang BlockStats *s = NULL; 51020a6d768SDou Liyang 51120a6d768SDou Liyang s = g_malloc0(sizeof(*s)); 51220a6d768SDou Liyang s->stats = g_malloc0(sizeof(*s->stats)); 51320a6d768SDou Liyang 51420a6d768SDou Liyang if (!bs) { 51520a6d768SDou Liyang return s; 51620a6d768SDou Liyang } 51720a6d768SDou Liyang 518d3c8c674SKevin Wolf /* Skip automatically inserted nodes that the user isn't aware of in 519d3c8c674SKevin Wolf * a BlockBackend-level command. Stay at the exact node for a node-level 520d3c8c674SKevin Wolf * command. */ 521d3c8c674SKevin Wolf while (blk_level && bs->drv && bs->implicit) { 522d3c8c674SKevin Wolf bs = backing_bs(bs); 523d3c8c674SKevin Wolf assert(bs); 524d3c8c674SKevin Wolf } 525d3c8c674SKevin Wolf 5262b77e60aSKevin Wolf if (bdrv_get_node_name(bs)[0]) { 5272b77e60aSKevin Wolf s->has_node_name = true; 5282b77e60aSKevin Wolf s->node_name = g_strdup(bdrv_get_node_name(bs)); 5292b77e60aSKevin Wolf } 5302b77e60aSKevin Wolf 531f7946da2SPaolo Bonzini s->stats->wr_highest_offset = stat64_get(&bs->wr_highest_offset); 53253d8f9d8SMax Reitz 533f364ec65SWenchao Xia if (bs->file) { 534f364ec65SWenchao Xia s->has_parent = true; 535d3c8c674SKevin Wolf s->parent = bdrv_query_bds_stats(bs->file->bs, blk_level); 536f364ec65SWenchao Xia } 537f364ec65SWenchao Xia 538d3c8c674SKevin Wolf if (blk_level && bs->backing) { 539c8059b97SFam Zheng s->has_backing = true; 540d3c8c674SKevin Wolf s->backing = bdrv_query_bds_stats(bs->backing->bs, blk_level); 541c8059b97SFam Zheng } 542c8059b97SFam Zheng 54320a6d768SDou Liyang return s; 544b07363a1SKevin Wolf } 545b07363a1SKevin Wolf 546f364ec65SWenchao Xia BlockInfoList *qmp_query_block(Error **errp) 547f364ec65SWenchao Xia { 548f364ec65SWenchao Xia BlockInfoList *head = NULL, **p_next = &head; 549d829a211SMarkus Armbruster BlockBackend *blk; 550553a7e87SWenchao Xia Error *local_err = NULL; 551f364ec65SWenchao Xia 552d5b68844SKevin Wolf for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) { 553d5b68844SKevin Wolf BlockInfoList *info; 554d5b68844SKevin Wolf 555ec18b0a9SKevin Wolf if (!*blk_name(blk) && !blk_get_attached_dev(blk)) { 556d5b68844SKevin Wolf continue; 557d5b68844SKevin Wolf } 558d5b68844SKevin Wolf 559d5b68844SKevin Wolf info = g_malloc0(sizeof(*info)); 560d829a211SMarkus Armbruster bdrv_query_info(blk, &info->value, &local_err); 56184d18f06SMarkus Armbruster if (local_err) { 562553a7e87SWenchao Xia error_propagate(errp, local_err); 563903c341dSMarkus Armbruster g_free(info); 564903c341dSMarkus Armbruster qapi_free_BlockInfoList(head); 565903c341dSMarkus Armbruster return NULL; 566553a7e87SWenchao Xia } 567f364ec65SWenchao Xia 568f364ec65SWenchao Xia *p_next = info; 569f364ec65SWenchao Xia p_next = &info->next; 570f364ec65SWenchao Xia } 571f364ec65SWenchao Xia 572f364ec65SWenchao Xia return head; 573f364ec65SWenchao Xia } 574f364ec65SWenchao Xia 575f71eaa74SFam Zheng BlockStatsList *qmp_query_blockstats(bool has_query_nodes, 576f71eaa74SFam Zheng bool query_nodes, 577f71eaa74SFam Zheng Error **errp) 578f364ec65SWenchao Xia { 579f364ec65SWenchao Xia BlockStatsList *head = NULL, **p_next = &head; 580a6baa608SDou Liyang BlockBackend *blk; 581a6baa608SDou Liyang BlockDriverState *bs; 582f364ec65SWenchao Xia 583f71eaa74SFam Zheng /* Just to be safe if query_nodes is not always initialized */ 584a6baa608SDou Liyang if (has_query_nodes && query_nodes) { 585a6baa608SDou Liyang for (bs = bdrv_next_node(NULL); bs; bs = bdrv_next_node(bs)) { 586f364ec65SWenchao Xia BlockStatsList *info = g_malloc0(sizeof(*info)); 587a6baa608SDou Liyang AioContext *ctx = bdrv_get_aio_context(bs); 58813344f3aSStefan Hajnoczi 58913344f3aSStefan Hajnoczi aio_context_acquire(ctx); 590a6baa608SDou Liyang info->value = bdrv_query_bds_stats(bs, false); 59113344f3aSStefan Hajnoczi aio_context_release(ctx); 592f364ec65SWenchao Xia 593f364ec65SWenchao Xia *p_next = info; 594f364ec65SWenchao Xia p_next = &info->next; 595f364ec65SWenchao Xia } 596a6baa608SDou Liyang } else { 597567dcb31SKevin Wolf for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) { 598f62492bbSKevin Wolf BlockStatsList *info; 599a6baa608SDou Liyang AioContext *ctx = blk_get_aio_context(blk); 600a6baa608SDou Liyang BlockStats *s; 6015a9cb5a9SKevin Wolf char *qdev; 602a6baa608SDou Liyang 603567dcb31SKevin Wolf if (!*blk_name(blk) && !blk_get_attached_dev(blk)) { 604567dcb31SKevin Wolf continue; 605567dcb31SKevin Wolf } 606567dcb31SKevin Wolf 607a6baa608SDou Liyang aio_context_acquire(ctx); 608a6baa608SDou Liyang s = bdrv_query_bds_stats(blk_bs(blk), true); 609a6baa608SDou Liyang s->has_device = true; 610a6baa608SDou Liyang s->device = g_strdup(blk_name(blk)); 6115a9cb5a9SKevin Wolf 6125a9cb5a9SKevin Wolf qdev = blk_get_attached_dev_id(blk); 6135a9cb5a9SKevin Wolf if (qdev && *qdev) { 6145a9cb5a9SKevin Wolf s->has_qdev = true; 6155a9cb5a9SKevin Wolf s->qdev = qdev; 6165a9cb5a9SKevin Wolf } else { 6175a9cb5a9SKevin Wolf g_free(qdev); 6185a9cb5a9SKevin Wolf } 6195a9cb5a9SKevin Wolf 620a6baa608SDou Liyang bdrv_query_blk_stats(s->stats, blk); 621a6baa608SDou Liyang aio_context_release(ctx); 622a6baa608SDou Liyang 623f62492bbSKevin Wolf info = g_malloc0(sizeof(*info)); 624a6baa608SDou Liyang info->value = s; 625a6baa608SDou Liyang *p_next = info; 626a6baa608SDou Liyang p_next = &info->next; 627a6baa608SDou Liyang } 628a6baa608SDou Liyang } 629f364ec65SWenchao Xia 630f364ec65SWenchao Xia return head; 631f364ec65SWenchao Xia } 632f364ec65SWenchao Xia 633f364ec65SWenchao Xia #define NB_SUFFIXES 4 634f364ec65SWenchao Xia 635f364ec65SWenchao Xia static char *get_human_readable_size(char *buf, int buf_size, int64_t size) 636f364ec65SWenchao Xia { 6372c20fa2cSStefan Weil static const char suffixes[NB_SUFFIXES] = {'K', 'M', 'G', 'T'}; 638f364ec65SWenchao Xia int64_t base; 639f364ec65SWenchao Xia int i; 640f364ec65SWenchao Xia 641f364ec65SWenchao Xia if (size <= 999) { 642f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64, size); 643f364ec65SWenchao Xia } else { 644f364ec65SWenchao Xia base = 1024; 645f364ec65SWenchao Xia for (i = 0; i < NB_SUFFIXES; i++) { 646f364ec65SWenchao Xia if (size < (10 * base)) { 647f364ec65SWenchao Xia snprintf(buf, buf_size, "%0.1f%c", 648f364ec65SWenchao Xia (double)size / base, 649f364ec65SWenchao Xia suffixes[i]); 650f364ec65SWenchao Xia break; 651f364ec65SWenchao Xia } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 652f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64 "%c", 653f364ec65SWenchao Xia ((size + (base >> 1)) / base), 654f364ec65SWenchao Xia suffixes[i]); 655f364ec65SWenchao Xia break; 656f364ec65SWenchao Xia } 657f364ec65SWenchao Xia base = base * 1024; 658f364ec65SWenchao Xia } 659f364ec65SWenchao Xia } 660f364ec65SWenchao Xia return buf; 661f364ec65SWenchao Xia } 662f364ec65SWenchao Xia 6635b917044SWenchao Xia void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 6645b917044SWenchao Xia QEMUSnapshotInfo *sn) 665f364ec65SWenchao Xia { 666f364ec65SWenchao Xia char buf1[128], date_buf[128], clock_buf[128]; 667f364ec65SWenchao Xia struct tm tm; 668f364ec65SWenchao Xia time_t ti; 669f364ec65SWenchao Xia int64_t secs; 670f364ec65SWenchao Xia 671f364ec65SWenchao Xia if (!sn) { 6725b917044SWenchao Xia func_fprintf(f, 673f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 674f364ec65SWenchao Xia "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 675f364ec65SWenchao Xia } else { 676f364ec65SWenchao Xia ti = sn->date_sec; 677f364ec65SWenchao Xia localtime_r(&ti, &tm); 678f364ec65SWenchao Xia strftime(date_buf, sizeof(date_buf), 679f364ec65SWenchao Xia "%Y-%m-%d %H:%M:%S", &tm); 680f364ec65SWenchao Xia secs = sn->vm_clock_nsec / 1000000000; 681f364ec65SWenchao Xia snprintf(clock_buf, sizeof(clock_buf), 682f364ec65SWenchao Xia "%02d:%02d:%02d.%03d", 683f364ec65SWenchao Xia (int)(secs / 3600), 684f364ec65SWenchao Xia (int)((secs / 60) % 60), 685f364ec65SWenchao Xia (int)(secs % 60), 686f364ec65SWenchao Xia (int)((sn->vm_clock_nsec / 1000000) % 1000)); 6875b917044SWenchao Xia func_fprintf(f, 688f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 689f364ec65SWenchao Xia sn->id_str, sn->name, 6905b917044SWenchao Xia get_human_readable_size(buf1, sizeof(buf1), 6915b917044SWenchao Xia sn->vm_state_size), 692f364ec65SWenchao Xia date_buf, 693f364ec65SWenchao Xia clock_buf); 694f364ec65SWenchao Xia } 695f364ec65SWenchao Xia } 696f364ec65SWenchao Xia 697a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 698a8d8ecb7SMax Reitz QDict *dict); 699a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 700a8d8ecb7SMax Reitz QList *list); 701a8d8ecb7SMax Reitz 702a8d8ecb7SMax Reitz static void dump_qobject(fprintf_function func_fprintf, void *f, 703a8d8ecb7SMax Reitz int comp_indent, QObject *obj) 704a8d8ecb7SMax Reitz { 705a8d8ecb7SMax Reitz switch (qobject_type(obj)) { 70601b2ffceSMarc-André Lureau case QTYPE_QNUM: { 7077dc847ebSMax Reitz QNum *value = qobject_to(QNum, obj); 70801b2ffceSMarc-André Lureau char *tmp = qnum_to_string(value); 70901b2ffceSMarc-André Lureau func_fprintf(f, "%s", tmp); 71001b2ffceSMarc-André Lureau g_free(tmp); 711a8d8ecb7SMax Reitz break; 712a8d8ecb7SMax Reitz } 713a8d8ecb7SMax Reitz case QTYPE_QSTRING: { 7147dc847ebSMax Reitz QString *value = qobject_to(QString, obj); 715a8d8ecb7SMax Reitz func_fprintf(f, "%s", qstring_get_str(value)); 716a8d8ecb7SMax Reitz break; 717a8d8ecb7SMax Reitz } 718a8d8ecb7SMax Reitz case QTYPE_QDICT: { 7197dc847ebSMax Reitz QDict *value = qobject_to(QDict, obj); 720a8d8ecb7SMax Reitz dump_qdict(func_fprintf, f, comp_indent, value); 721a8d8ecb7SMax Reitz break; 722a8d8ecb7SMax Reitz } 723a8d8ecb7SMax Reitz case QTYPE_QLIST: { 7247dc847ebSMax Reitz QList *value = qobject_to(QList, obj); 725a8d8ecb7SMax Reitz dump_qlist(func_fprintf, f, comp_indent, value); 726a8d8ecb7SMax Reitz break; 727a8d8ecb7SMax Reitz } 728a8d8ecb7SMax Reitz case QTYPE_QBOOL: { 7297dc847ebSMax Reitz QBool *value = qobject_to(QBool, obj); 730fc48ffc3SEric Blake func_fprintf(f, "%s", qbool_get_bool(value) ? "true" : "false"); 731a8d8ecb7SMax Reitz break; 732a8d8ecb7SMax Reitz } 733a8d8ecb7SMax Reitz default: 734a8d8ecb7SMax Reitz abort(); 735a8d8ecb7SMax Reitz } 736a8d8ecb7SMax Reitz } 737a8d8ecb7SMax Reitz 738a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 739a8d8ecb7SMax Reitz QList *list) 740a8d8ecb7SMax Reitz { 741a8d8ecb7SMax Reitz const QListEntry *entry; 742a8d8ecb7SMax Reitz int i = 0; 743a8d8ecb7SMax Reitz 744a8d8ecb7SMax Reitz for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) { 7451310a3d3SEric Blake QType type = qobject_type(entry->value); 746a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 747853ccfedSPeter Xu func_fprintf(f, "%*s[%i]:%c", indentation * 4, "", i, 748853ccfedSPeter Xu composite ? '\n' : ' '); 749a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 750a8d8ecb7SMax Reitz if (!composite) { 751a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 752a8d8ecb7SMax Reitz } 753a8d8ecb7SMax Reitz } 754a8d8ecb7SMax Reitz } 755a8d8ecb7SMax Reitz 756a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 757a8d8ecb7SMax Reitz QDict *dict) 758a8d8ecb7SMax Reitz { 759a8d8ecb7SMax Reitz const QDictEntry *entry; 760a8d8ecb7SMax Reitz 761a8d8ecb7SMax Reitz for (entry = qdict_first(dict); entry; entry = qdict_next(dict, entry)) { 7621310a3d3SEric Blake QType type = qobject_type(entry->value); 763a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 7645eda6227SPeter Xu char *key = g_malloc(strlen(entry->key) + 1); 765a8d8ecb7SMax Reitz int i; 766a8d8ecb7SMax Reitz 767a8d8ecb7SMax Reitz /* replace dashes with spaces in key (variable) names */ 768a8d8ecb7SMax Reitz for (i = 0; entry->key[i]; i++) { 769a8d8ecb7SMax Reitz key[i] = entry->key[i] == '-' ? ' ' : entry->key[i]; 770a8d8ecb7SMax Reitz } 771a8d8ecb7SMax Reitz key[i] = 0; 772853ccfedSPeter Xu func_fprintf(f, "%*s%s:%c", indentation * 4, "", key, 773853ccfedSPeter Xu composite ? '\n' : ' '); 774a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 775a8d8ecb7SMax Reitz if (!composite) { 776a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 777a8d8ecb7SMax Reitz } 7785eda6227SPeter Xu g_free(key); 779a8d8ecb7SMax Reitz } 780a8d8ecb7SMax Reitz } 781a8d8ecb7SMax Reitz 782a8d8ecb7SMax Reitz void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f, 783a8d8ecb7SMax Reitz ImageInfoSpecific *info_spec) 784a8d8ecb7SMax Reitz { 785a8d8ecb7SMax Reitz QObject *obj, *data; 7867d5e199aSDaniel P. Berrange Visitor *v = qobject_output_visitor_new(&obj); 787a8d8ecb7SMax Reitz 7883b098d56SEric Blake visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort); 7893b098d56SEric Blake visit_complete(v, &obj); 7907dc847ebSMax Reitz data = qdict_get(qobject_to(QDict, obj), "data"); 791a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, 1, data); 792cb3e7f08SMarc-André Lureau qobject_unref(obj); 7933b098d56SEric Blake visit_free(v); 794a8d8ecb7SMax Reitz } 795a8d8ecb7SMax Reitz 7965b917044SWenchao Xia void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 7975b917044SWenchao Xia ImageInfo *info) 798f364ec65SWenchao Xia { 799f364ec65SWenchao Xia char size_buf[128], dsize_buf[128]; 800f364ec65SWenchao Xia if (!info->has_actual_size) { 801f364ec65SWenchao Xia snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 802f364ec65SWenchao Xia } else { 803f364ec65SWenchao Xia get_human_readable_size(dsize_buf, sizeof(dsize_buf), 804f364ec65SWenchao Xia info->actual_size); 805f364ec65SWenchao Xia } 806f364ec65SWenchao Xia get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size); 8075b917044SWenchao Xia func_fprintf(f, 8085b917044SWenchao Xia "image: %s\n" 809f364ec65SWenchao Xia "file format: %s\n" 810f364ec65SWenchao Xia "virtual size: %s (%" PRId64 " bytes)\n" 811f364ec65SWenchao Xia "disk size: %s\n", 812f364ec65SWenchao Xia info->filename, info->format, size_buf, 813f364ec65SWenchao Xia info->virtual_size, 814f364ec65SWenchao Xia dsize_buf); 815f364ec65SWenchao Xia 816f364ec65SWenchao Xia if (info->has_encrypted && info->encrypted) { 8175b917044SWenchao Xia func_fprintf(f, "encrypted: yes\n"); 818f364ec65SWenchao Xia } 819f364ec65SWenchao Xia 820f364ec65SWenchao Xia if (info->has_cluster_size) { 8215b917044SWenchao Xia func_fprintf(f, "cluster_size: %" PRId64 "\n", 8225b917044SWenchao Xia info->cluster_size); 823f364ec65SWenchao Xia } 824f364ec65SWenchao Xia 825f364ec65SWenchao Xia if (info->has_dirty_flag && info->dirty_flag) { 8265b917044SWenchao Xia func_fprintf(f, "cleanly shut down: no\n"); 827f364ec65SWenchao Xia } 828f364ec65SWenchao Xia 829f364ec65SWenchao Xia if (info->has_backing_filename) { 8305b917044SWenchao Xia func_fprintf(f, "backing file: %s", info->backing_filename); 8315c9d9ca5SJohn Snow if (!info->has_full_backing_filename) { 8325c9d9ca5SJohn Snow func_fprintf(f, " (cannot determine actual path)"); 8335c9d9ca5SJohn Snow } else if (strcmp(info->backing_filename, 8345c9d9ca5SJohn Snow info->full_backing_filename) != 0) { 8355b917044SWenchao Xia func_fprintf(f, " (actual path: %s)", info->full_backing_filename); 836f364ec65SWenchao Xia } 8375b917044SWenchao Xia func_fprintf(f, "\n"); 838f364ec65SWenchao Xia if (info->has_backing_filename_format) { 8395b917044SWenchao Xia func_fprintf(f, "backing file format: %s\n", 8405b917044SWenchao Xia info->backing_filename_format); 841f364ec65SWenchao Xia } 842f364ec65SWenchao Xia } 843f364ec65SWenchao Xia 844f364ec65SWenchao Xia if (info->has_snapshots) { 845f364ec65SWenchao Xia SnapshotInfoList *elem; 846f364ec65SWenchao Xia 8475b917044SWenchao Xia func_fprintf(f, "Snapshot list:\n"); 8485b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, NULL); 8495b917044SWenchao Xia func_fprintf(f, "\n"); 850f364ec65SWenchao Xia 851f364ec65SWenchao Xia /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but 852f364ec65SWenchao Xia * we convert to the block layer's native QEMUSnapshotInfo for now. 853f364ec65SWenchao Xia */ 854f364ec65SWenchao Xia for (elem = info->snapshots; elem; elem = elem->next) { 855f364ec65SWenchao Xia QEMUSnapshotInfo sn = { 856f364ec65SWenchao Xia .vm_state_size = elem->value->vm_state_size, 857f364ec65SWenchao Xia .date_sec = elem->value->date_sec, 858f364ec65SWenchao Xia .date_nsec = elem->value->date_nsec, 859f364ec65SWenchao Xia .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL + 860f364ec65SWenchao Xia elem->value->vm_clock_nsec, 861f364ec65SWenchao Xia }; 862f364ec65SWenchao Xia 863f364ec65SWenchao Xia pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id); 864f364ec65SWenchao Xia pstrcpy(sn.name, sizeof(sn.name), elem->value->name); 8655b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, &sn); 8665b917044SWenchao Xia func_fprintf(f, "\n"); 867f364ec65SWenchao Xia } 868f364ec65SWenchao Xia } 869a8d8ecb7SMax Reitz 870a8d8ecb7SMax Reitz if (info->has_format_specific) { 871a8d8ecb7SMax Reitz func_fprintf(f, "Format specific information:\n"); 872a8d8ecb7SMax Reitz bdrv_image_info_specific_dump(func_fprintf, f, info->format_specific); 873a8d8ecb7SMax Reitz } 874f364ec65SWenchao Xia } 875