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 25*80c71a24SPeter 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" 32a8d8ecb7SMax Reitz #include "qapi/qmp-output-visitor.h" 33a8d8ecb7SMax Reitz #include "qapi/qmp/types.h" 34d829a211SMarkus Armbruster #include "sysemu/block-backend.h" 35f364ec65SWenchao Xia 36d5a8ee60SAlberto Garcia BlockDeviceInfo *bdrv_block_device_info(BlockDriverState *bs, Error **errp) 37c13163fbSBenoît Canet { 38d5a8ee60SAlberto Garcia ImageInfo **p_image_info; 39d5a8ee60SAlberto Garcia BlockDriverState *bs0; 40c13163fbSBenoît Canet BlockDeviceInfo *info = g_malloc0(sizeof(*info)); 41c13163fbSBenoît Canet 42c13163fbSBenoît Canet info->file = g_strdup(bs->filename); 43c13163fbSBenoît Canet info->ro = bs->read_only; 44c13163fbSBenoît Canet info->drv = g_strdup(bs->drv->format_name); 45c13163fbSBenoît Canet info->encrypted = bs->encrypted; 46c13163fbSBenoît Canet info->encryption_key_missing = bdrv_key_required(bs); 47c13163fbSBenoît Canet 489e193c5aSKevin Wolf info->cache = g_new(BlockdevCacheInfo, 1); 499e193c5aSKevin Wolf *info->cache = (BlockdevCacheInfo) { 509e193c5aSKevin Wolf .writeback = bdrv_enable_write_cache(bs), 519e193c5aSKevin Wolf .direct = !!(bs->open_flags & BDRV_O_NOCACHE), 529e193c5aSKevin Wolf .no_flush = !!(bs->open_flags & BDRV_O_NO_FLUSH), 539e193c5aSKevin Wolf }; 549e193c5aSKevin Wolf 55c13163fbSBenoît Canet if (bs->node_name[0]) { 56c13163fbSBenoît Canet info->has_node_name = true; 57c13163fbSBenoît Canet info->node_name = g_strdup(bs->node_name); 58c13163fbSBenoît Canet } 59c13163fbSBenoît Canet 60c13163fbSBenoît Canet if (bs->backing_file[0]) { 61c13163fbSBenoît Canet info->has_backing_file = true; 62c13163fbSBenoît Canet info->backing_file = g_strdup(bs->backing_file); 63c13163fbSBenoît Canet } 64c13163fbSBenoît Canet 65c13163fbSBenoît Canet info->backing_file_depth = bdrv_get_backing_file_depth(bs); 66465bee1dSPeter Lieven info->detect_zeroes = bs->detect_zeroes; 67c13163fbSBenoît Canet 68a0d64a61SAlberto Garcia if (bs->throttle_state) { 69c13163fbSBenoît Canet ThrottleConfig cfg; 7076f4afb4SAlberto Garcia 7176f4afb4SAlberto Garcia throttle_group_get_config(bs, &cfg); 7276f4afb4SAlberto Garcia 73c13163fbSBenoît Canet info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg; 74c13163fbSBenoît Canet info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg; 75c13163fbSBenoît Canet info->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE].avg; 76c13163fbSBenoît Canet 77c13163fbSBenoît Canet info->iops = cfg.buckets[THROTTLE_OPS_TOTAL].avg; 78c13163fbSBenoît Canet info->iops_rd = cfg.buckets[THROTTLE_OPS_READ].avg; 79c13163fbSBenoît Canet info->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE].avg; 80c13163fbSBenoît Canet 81c13163fbSBenoît Canet info->has_bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 82c13163fbSBenoît Canet info->bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 83c13163fbSBenoît Canet info->has_bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 84c13163fbSBenoît Canet info->bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 85c13163fbSBenoît Canet info->has_bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 86c13163fbSBenoît Canet info->bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 87c13163fbSBenoît Canet 88c13163fbSBenoît Canet info->has_iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 89c13163fbSBenoît Canet info->iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 90c13163fbSBenoît Canet info->has_iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 91c13163fbSBenoît Canet info->iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 92c13163fbSBenoît Canet info->has_iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 93c13163fbSBenoît Canet info->iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 94c13163fbSBenoît Canet 95c13163fbSBenoît Canet info->has_iops_size = cfg.op_size; 96c13163fbSBenoît Canet info->iops_size = cfg.op_size; 97b8fe1694SAlberto Garcia 98b8fe1694SAlberto Garcia info->has_group = true; 99b8fe1694SAlberto Garcia info->group = g_strdup(throttle_group_get_name(bs)); 100c13163fbSBenoît Canet } 101c13163fbSBenoît Canet 102e2462113SFrancesco Romani info->write_threshold = bdrv_write_threshold_get(bs); 103e2462113SFrancesco Romani 104d5a8ee60SAlberto Garcia bs0 = bs; 105d5a8ee60SAlberto Garcia p_image_info = &info->image; 106d5a8ee60SAlberto Garcia while (1) { 107d5a8ee60SAlberto Garcia Error *local_err = NULL; 108d5a8ee60SAlberto Garcia bdrv_query_image_info(bs0, p_image_info, &local_err); 109d5a8ee60SAlberto Garcia if (local_err) { 110d5a8ee60SAlberto Garcia error_propagate(errp, local_err); 111d5a8ee60SAlberto Garcia qapi_free_BlockDeviceInfo(info); 112d5a8ee60SAlberto Garcia return NULL; 113d5a8ee60SAlberto Garcia } 114760e0063SKevin Wolf if (bs0->drv && bs0->backing) { 115760e0063SKevin Wolf bs0 = bs0->backing->bs; 116d5a8ee60SAlberto Garcia (*p_image_info)->has_backing_image = true; 117d5a8ee60SAlberto Garcia p_image_info = &((*p_image_info)->backing_image); 118d5a8ee60SAlberto Garcia } else { 119d5a8ee60SAlberto Garcia break; 120d5a8ee60SAlberto Garcia } 121d5a8ee60SAlberto Garcia } 122d5a8ee60SAlberto Garcia 123c13163fbSBenoît Canet return info; 124c13163fbSBenoît Canet } 125c13163fbSBenoît Canet 126fb0ed453SWenchao Xia /* 127fb0ed453SWenchao Xia * Returns 0 on success, with *p_list either set to describe snapshot 128fb0ed453SWenchao Xia * information, or NULL because there are no snapshots. Returns -errno on 129fb0ed453SWenchao Xia * error, with *p_list untouched. 130fb0ed453SWenchao Xia */ 131fb0ed453SWenchao Xia int bdrv_query_snapshot_info_list(BlockDriverState *bs, 132fb0ed453SWenchao Xia SnapshotInfoList **p_list, 133fb0ed453SWenchao Xia Error **errp) 134f364ec65SWenchao Xia { 135f364ec65SWenchao Xia int i, sn_count; 136f364ec65SWenchao Xia QEMUSnapshotInfo *sn_tab = NULL; 137fb0ed453SWenchao Xia SnapshotInfoList *info_list, *cur_item = NULL, *head = NULL; 138fb0ed453SWenchao Xia SnapshotInfo *info; 139fb0ed453SWenchao Xia 140f364ec65SWenchao Xia sn_count = bdrv_snapshot_list(bs, &sn_tab); 141fb0ed453SWenchao Xia if (sn_count < 0) { 142fb0ed453SWenchao Xia const char *dev = bdrv_get_device_name(bs); 143fb0ed453SWenchao Xia switch (sn_count) { 144fb0ed453SWenchao Xia case -ENOMEDIUM: 145fb0ed453SWenchao Xia error_setg(errp, "Device '%s' is not inserted", dev); 146fb0ed453SWenchao Xia break; 147fb0ed453SWenchao Xia case -ENOTSUP: 148fb0ed453SWenchao Xia error_setg(errp, 149fb0ed453SWenchao Xia "Device '%s' does not support internal snapshots", 150fb0ed453SWenchao Xia dev); 151fb0ed453SWenchao Xia break; 152fb0ed453SWenchao Xia default: 153fb0ed453SWenchao Xia error_setg_errno(errp, -sn_count, 154fb0ed453SWenchao Xia "Can't list snapshots of device '%s'", dev); 155fb0ed453SWenchao Xia break; 156fb0ed453SWenchao Xia } 157fb0ed453SWenchao Xia return sn_count; 158fb0ed453SWenchao Xia } 159f364ec65SWenchao Xia 160f364ec65SWenchao Xia for (i = 0; i < sn_count; i++) { 161fb0ed453SWenchao Xia info = g_new0(SnapshotInfo, 1); 162fb0ed453SWenchao Xia info->id = g_strdup(sn_tab[i].id_str); 163fb0ed453SWenchao Xia info->name = g_strdup(sn_tab[i].name); 164fb0ed453SWenchao Xia info->vm_state_size = sn_tab[i].vm_state_size; 165fb0ed453SWenchao Xia info->date_sec = sn_tab[i].date_sec; 166fb0ed453SWenchao Xia info->date_nsec = sn_tab[i].date_nsec; 167fb0ed453SWenchao Xia info->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000; 168fb0ed453SWenchao Xia info->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000; 169f364ec65SWenchao Xia 170fb0ed453SWenchao Xia info_list = g_new0(SnapshotInfoList, 1); 171fb0ed453SWenchao Xia info_list->value = info; 172f364ec65SWenchao Xia 173f364ec65SWenchao Xia /* XXX: waiting for the qapi to support qemu-queue.h types */ 174f364ec65SWenchao Xia if (!cur_item) { 175fb0ed453SWenchao Xia head = cur_item = info_list; 176f364ec65SWenchao Xia } else { 177f364ec65SWenchao Xia cur_item->next = info_list; 178f364ec65SWenchao Xia cur_item = info_list; 179f364ec65SWenchao Xia } 180f364ec65SWenchao Xia 181f364ec65SWenchao Xia } 182f364ec65SWenchao Xia 183f364ec65SWenchao Xia g_free(sn_tab); 184fb0ed453SWenchao Xia *p_list = head; 185fb0ed453SWenchao Xia return 0; 186f364ec65SWenchao Xia } 187f364ec65SWenchao Xia 18843526ec8SWenchao Xia /** 18943526ec8SWenchao Xia * bdrv_query_image_info: 19043526ec8SWenchao Xia * @bs: block device to examine 19143526ec8SWenchao Xia * @p_info: location to store image information 19243526ec8SWenchao Xia * @errp: location to store error information 19343526ec8SWenchao Xia * 194553a7e87SWenchao Xia * Store "flat" image information in @p_info. 195553a7e87SWenchao Xia * 196553a7e87SWenchao Xia * "Flat" means it does *not* query backing image information, 197553a7e87SWenchao Xia * i.e. (*pinfo)->has_backing_image will be set to false and 198553a7e87SWenchao Xia * (*pinfo)->backing_image to NULL even when the image does in fact have 199553a7e87SWenchao Xia * a backing image. 200553a7e87SWenchao Xia * 20143526ec8SWenchao Xia * @p_info will be set only on success. On error, store error in @errp. 20243526ec8SWenchao Xia */ 20343526ec8SWenchao Xia void bdrv_query_image_info(BlockDriverState *bs, 20443526ec8SWenchao Xia ImageInfo **p_info, 20543526ec8SWenchao Xia Error **errp) 206f364ec65SWenchao Xia { 20752bf1e72SMarkus Armbruster int64_t size; 20843526ec8SWenchao Xia const char *backing_filename; 209f364ec65SWenchao Xia BlockDriverInfo bdi; 21043526ec8SWenchao Xia int ret; 21143526ec8SWenchao Xia Error *err = NULL; 21252bf1e72SMarkus Armbruster ImageInfo *info; 213f364ec65SWenchao Xia 21452bf1e72SMarkus Armbruster size = bdrv_getlength(bs); 21552bf1e72SMarkus Armbruster if (size < 0) { 21652bf1e72SMarkus Armbruster error_setg_errno(errp, -size, "Can't get size of device '%s'", 21752bf1e72SMarkus Armbruster bdrv_get_device_name(bs)); 21852bf1e72SMarkus Armbruster return; 21952bf1e72SMarkus Armbruster } 220f364ec65SWenchao Xia 22152bf1e72SMarkus Armbruster info = g_new0(ImageInfo, 1); 22243526ec8SWenchao Xia info->filename = g_strdup(bs->filename); 223f364ec65SWenchao Xia info->format = g_strdup(bdrv_get_format_name(bs)); 22452bf1e72SMarkus Armbruster info->virtual_size = size; 225f364ec65SWenchao Xia info->actual_size = bdrv_get_allocated_file_size(bs); 226f364ec65SWenchao Xia info->has_actual_size = info->actual_size >= 0; 227f364ec65SWenchao Xia if (bdrv_is_encrypted(bs)) { 228f364ec65SWenchao Xia info->encrypted = true; 229f364ec65SWenchao Xia info->has_encrypted = true; 230f364ec65SWenchao Xia } 231f364ec65SWenchao Xia if (bdrv_get_info(bs, &bdi) >= 0) { 232f364ec65SWenchao Xia if (bdi.cluster_size != 0) { 233f364ec65SWenchao Xia info->cluster_size = bdi.cluster_size; 234f364ec65SWenchao Xia info->has_cluster_size = true; 235f364ec65SWenchao Xia } 236f364ec65SWenchao Xia info->dirty_flag = bdi.is_dirty; 237f364ec65SWenchao Xia info->has_dirty_flag = true; 238f364ec65SWenchao Xia } 239eae041feSMax Reitz info->format_specific = bdrv_get_specific_info(bs); 240eae041feSMax Reitz info->has_format_specific = info->format_specific != NULL; 241eae041feSMax Reitz 24243526ec8SWenchao Xia backing_filename = bs->backing_file; 243f364ec65SWenchao Xia if (backing_filename[0] != '\0') { 2449a29e18fSJeff Cody char *backing_filename2 = g_malloc0(PATH_MAX); 245f364ec65SWenchao Xia info->backing_filename = g_strdup(backing_filename); 246f364ec65SWenchao Xia info->has_backing_filename = true; 2479a29e18fSJeff Cody bdrv_get_full_backing_filename(bs, backing_filename2, PATH_MAX, &err); 2489f07429eSMax Reitz if (err) { 249a5002d53SJohn Snow /* Can't reconstruct the full backing filename, so we must omit 250a5002d53SJohn Snow * this field and apply a Best Effort to this query. */ 251564d64bdSJeff Cody g_free(backing_filename2); 252a5002d53SJohn Snow backing_filename2 = NULL; 253a5002d53SJohn Snow error_free(err); 2540fa296ebSFam Zheng err = NULL; 2559f07429eSMax Reitz } 256f364ec65SWenchao Xia 25712dcb1c0SJohn Snow /* Always report the full_backing_filename if present, even if it's the 25812dcb1c0SJohn Snow * same as backing_filename. That they are same is useful info. */ 25912dcb1c0SJohn Snow if (backing_filename2) { 26012dcb1c0SJohn Snow info->full_backing_filename = g_strdup(backing_filename2); 261f364ec65SWenchao Xia info->has_full_backing_filename = true; 262f364ec65SWenchao Xia } 263f364ec65SWenchao Xia 264f364ec65SWenchao Xia if (bs->backing_format[0]) { 265f364ec65SWenchao Xia info->backing_filename_format = g_strdup(bs->backing_format); 266f364ec65SWenchao Xia info->has_backing_filename_format = true; 267f364ec65SWenchao Xia } 268564d64bdSJeff Cody g_free(backing_filename2); 269f364ec65SWenchao Xia } 27043526ec8SWenchao Xia 27143526ec8SWenchao Xia ret = bdrv_query_snapshot_info_list(bs, &info->snapshots, &err); 27243526ec8SWenchao Xia switch (ret) { 27343526ec8SWenchao Xia case 0: 27443526ec8SWenchao Xia if (info->snapshots) { 27543526ec8SWenchao Xia info->has_snapshots = true; 27643526ec8SWenchao Xia } 27743526ec8SWenchao Xia break; 27843526ec8SWenchao Xia /* recoverable error */ 27943526ec8SWenchao Xia case -ENOMEDIUM: 28043526ec8SWenchao Xia case -ENOTSUP: 28143526ec8SWenchao Xia error_free(err); 28243526ec8SWenchao Xia break; 28343526ec8SWenchao Xia default: 28443526ec8SWenchao Xia error_propagate(errp, err); 28543526ec8SWenchao Xia qapi_free_ImageInfo(info); 28643526ec8SWenchao Xia return; 28743526ec8SWenchao Xia } 28843526ec8SWenchao Xia 28943526ec8SWenchao Xia *p_info = info; 290f364ec65SWenchao Xia } 291f364ec65SWenchao Xia 292553a7e87SWenchao Xia /* @p_info will be set only on success. */ 293d829a211SMarkus Armbruster static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info, 294553a7e87SWenchao Xia Error **errp) 295f364ec65SWenchao Xia { 296f364ec65SWenchao Xia BlockInfo *info = g_malloc0(sizeof(*info)); 297d829a211SMarkus Armbruster BlockDriverState *bs = blk_bs(blk); 298d829a211SMarkus Armbruster info->device = g_strdup(blk_name(blk)); 299f364ec65SWenchao Xia info->type = g_strdup("unknown"); 300a7f53e26SMarkus Armbruster info->locked = blk_dev_is_medium_locked(blk); 301a7f53e26SMarkus Armbruster info->removable = blk_dev_has_removable_media(blk); 302f364ec65SWenchao Xia 303a7f53e26SMarkus Armbruster if (blk_dev_has_removable_media(blk)) { 304f364ec65SWenchao Xia info->has_tray_open = true; 305a7f53e26SMarkus Armbruster info->tray_open = blk_dev_is_tray_open(blk); 306f364ec65SWenchao Xia } 307f364ec65SWenchao Xia 308373340b2SMax Reitz if (blk_iostatus_is_enabled(blk)) { 309f364ec65SWenchao Xia info->has_io_status = true; 310373340b2SMax Reitz info->io_status = blk_iostatus(blk); 311f364ec65SWenchao Xia } 312f364ec65SWenchao Xia 3135433c24fSMax Reitz if (bs && !QLIST_EMPTY(&bs->dirty_bitmaps)) { 31421b56835SFam Zheng info->has_dirty_bitmaps = true; 31521b56835SFam Zheng info->dirty_bitmaps = bdrv_query_dirty_bitmaps(bs); 31621b56835SFam Zheng } 31721b56835SFam Zheng 3185433c24fSMax Reitz if (bs && bs->drv) { 319f364ec65SWenchao Xia info->has_inserted = true; 320d5a8ee60SAlberto Garcia info->inserted = bdrv_block_device_info(bs, errp); 321d5a8ee60SAlberto Garcia if (info->inserted == NULL) { 322553a7e87SWenchao Xia goto err; 323f364ec65SWenchao Xia } 324553a7e87SWenchao Xia } 325553a7e87SWenchao Xia 326553a7e87SWenchao Xia *p_info = info; 327553a7e87SWenchao Xia return; 328553a7e87SWenchao Xia 329553a7e87SWenchao Xia err: 330553a7e87SWenchao Xia qapi_free_BlockInfo(info); 331f364ec65SWenchao Xia } 332f364ec65SWenchao Xia 333f71eaa74SFam Zheng static BlockStats *bdrv_query_stats(const BlockDriverState *bs, 334f71eaa74SFam Zheng bool query_backing) 335f364ec65SWenchao Xia { 336f364ec65SWenchao Xia BlockStats *s; 337f364ec65SWenchao Xia 338f364ec65SWenchao Xia s = g_malloc0(sizeof(*s)); 339f364ec65SWenchao Xia 340bfb197e0SMarkus Armbruster if (bdrv_get_device_name(bs)[0]) { 341f364ec65SWenchao Xia s->has_device = true; 342bfb197e0SMarkus Armbruster s->device = g_strdup(bdrv_get_device_name(bs)); 343f364ec65SWenchao Xia } 344f364ec65SWenchao Xia 3454875a779SFam Zheng if (bdrv_get_node_name(bs)[0]) { 3464875a779SFam Zheng s->has_node_name = true; 3474875a779SFam Zheng s->node_name = g_strdup(bdrv_get_node_name(bs)); 3484875a779SFam Zheng } 3494875a779SFam Zheng 350f364ec65SWenchao Xia s->stats = g_malloc0(sizeof(*s->stats)); 3517f0e9da6SMax Reitz if (bs->blk) { 3527f0e9da6SMax Reitz BlockAcctStats *stats = blk_get_stats(bs->blk); 353979e9b03SAlberto Garcia BlockAcctTimedStats *ts = NULL; 3547f0e9da6SMax Reitz 3557f0e9da6SMax Reitz s->stats->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ]; 3567f0e9da6SMax Reitz s->stats->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE]; 3577f0e9da6SMax Reitz s->stats->rd_operations = stats->nr_ops[BLOCK_ACCT_READ]; 3587f0e9da6SMax Reitz s->stats->wr_operations = stats->nr_ops[BLOCK_ACCT_WRITE]; 3597ee12dafSAlberto Garcia 3607ee12dafSAlberto Garcia s->stats->failed_rd_operations = stats->failed_ops[BLOCK_ACCT_READ]; 3617ee12dafSAlberto Garcia s->stats->failed_wr_operations = stats->failed_ops[BLOCK_ACCT_WRITE]; 3627ee12dafSAlberto Garcia s->stats->failed_flush_operations = stats->failed_ops[BLOCK_ACCT_FLUSH]; 3637ee12dafSAlberto Garcia 3647ee12dafSAlberto Garcia s->stats->invalid_rd_operations = stats->invalid_ops[BLOCK_ACCT_READ]; 3657ee12dafSAlberto Garcia s->stats->invalid_wr_operations = stats->invalid_ops[BLOCK_ACCT_WRITE]; 3667ee12dafSAlberto Garcia s->stats->invalid_flush_operations = 3677ee12dafSAlberto Garcia stats->invalid_ops[BLOCK_ACCT_FLUSH]; 3687ee12dafSAlberto Garcia 3697f0e9da6SMax Reitz s->stats->rd_merged = stats->merged[BLOCK_ACCT_READ]; 3707f0e9da6SMax Reitz s->stats->wr_merged = stats->merged[BLOCK_ACCT_WRITE]; 3717f0e9da6SMax Reitz s->stats->flush_operations = stats->nr_ops[BLOCK_ACCT_FLUSH]; 3727f0e9da6SMax Reitz s->stats->wr_total_time_ns = stats->total_time_ns[BLOCK_ACCT_WRITE]; 3737f0e9da6SMax Reitz s->stats->rd_total_time_ns = stats->total_time_ns[BLOCK_ACCT_READ]; 3747f0e9da6SMax Reitz s->stats->flush_total_time_ns = stats->total_time_ns[BLOCK_ACCT_FLUSH]; 375cb38fffbSAlberto Garcia 376cb38fffbSAlberto Garcia s->stats->has_idle_time_ns = stats->last_access_time_ns > 0; 377cb38fffbSAlberto Garcia if (s->stats->has_idle_time_ns) { 378cb38fffbSAlberto Garcia s->stats->idle_time_ns = block_acct_idle_time_ns(stats); 379cb38fffbSAlberto Garcia } 380362e9299SAlberto Garcia 381362e9299SAlberto Garcia s->stats->account_invalid = stats->account_invalid; 382362e9299SAlberto Garcia s->stats->account_failed = stats->account_failed; 383979e9b03SAlberto Garcia 384979e9b03SAlberto Garcia while ((ts = block_acct_interval_next(stats, ts))) { 385979e9b03SAlberto Garcia BlockDeviceTimedStatsList *timed_stats = 386979e9b03SAlberto Garcia g_malloc0(sizeof(*timed_stats)); 387979e9b03SAlberto Garcia BlockDeviceTimedStats *dev_stats = g_malloc0(sizeof(*dev_stats)); 388979e9b03SAlberto Garcia timed_stats->next = s->stats->timed_stats; 389979e9b03SAlberto Garcia timed_stats->value = dev_stats; 390979e9b03SAlberto Garcia s->stats->timed_stats = timed_stats; 391979e9b03SAlberto Garcia 392979e9b03SAlberto Garcia TimedAverage *rd = &ts->latency[BLOCK_ACCT_READ]; 393979e9b03SAlberto Garcia TimedAverage *wr = &ts->latency[BLOCK_ACCT_WRITE]; 394979e9b03SAlberto Garcia TimedAverage *fl = &ts->latency[BLOCK_ACCT_FLUSH]; 395979e9b03SAlberto Garcia 396979e9b03SAlberto Garcia dev_stats->interval_length = ts->interval_length; 397979e9b03SAlberto Garcia 398979e9b03SAlberto Garcia dev_stats->min_rd_latency_ns = timed_average_min(rd); 399979e9b03SAlberto Garcia dev_stats->max_rd_latency_ns = timed_average_max(rd); 400979e9b03SAlberto Garcia dev_stats->avg_rd_latency_ns = timed_average_avg(rd); 401979e9b03SAlberto Garcia 402979e9b03SAlberto Garcia dev_stats->min_wr_latency_ns = timed_average_min(wr); 403979e9b03SAlberto Garcia dev_stats->max_wr_latency_ns = timed_average_max(wr); 404979e9b03SAlberto Garcia dev_stats->avg_wr_latency_ns = timed_average_avg(wr); 405979e9b03SAlberto Garcia 406979e9b03SAlberto Garcia dev_stats->min_flush_latency_ns = timed_average_min(fl); 407979e9b03SAlberto Garcia dev_stats->max_flush_latency_ns = timed_average_max(fl); 408979e9b03SAlberto Garcia dev_stats->avg_flush_latency_ns = timed_average_avg(fl); 40996e4dedaSAlberto Garcia 41096e4dedaSAlberto Garcia dev_stats->avg_rd_queue_depth = 41196e4dedaSAlberto Garcia block_acct_queue_depth(ts, BLOCK_ACCT_READ); 41296e4dedaSAlberto Garcia dev_stats->avg_wr_queue_depth = 41396e4dedaSAlberto Garcia block_acct_queue_depth(ts, BLOCK_ACCT_WRITE); 414979e9b03SAlberto Garcia } 4157f0e9da6SMax Reitz } 416f364ec65SWenchao Xia 41753d8f9d8SMax Reitz s->stats->wr_highest_offset = bs->wr_highest_offset; 41853d8f9d8SMax Reitz 419f364ec65SWenchao Xia if (bs->file) { 420f364ec65SWenchao Xia s->has_parent = true; 4219a4f4c31SKevin Wolf s->parent = bdrv_query_stats(bs->file->bs, query_backing); 422f364ec65SWenchao Xia } 423f364ec65SWenchao Xia 424760e0063SKevin Wolf if (query_backing && bs->backing) { 425c8059b97SFam Zheng s->has_backing = true; 426760e0063SKevin Wolf s->backing = bdrv_query_stats(bs->backing->bs, query_backing); 427c8059b97SFam Zheng } 428c8059b97SFam Zheng 429f364ec65SWenchao Xia return s; 430f364ec65SWenchao Xia } 431f364ec65SWenchao Xia 432f364ec65SWenchao Xia BlockInfoList *qmp_query_block(Error **errp) 433f364ec65SWenchao Xia { 434f364ec65SWenchao Xia BlockInfoList *head = NULL, **p_next = &head; 435d829a211SMarkus Armbruster BlockBackend *blk; 436553a7e87SWenchao Xia Error *local_err = NULL; 437f364ec65SWenchao Xia 438d829a211SMarkus Armbruster for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 439f364ec65SWenchao Xia BlockInfoList *info = g_malloc0(sizeof(*info)); 440d829a211SMarkus Armbruster bdrv_query_info(blk, &info->value, &local_err); 44184d18f06SMarkus Armbruster if (local_err) { 442553a7e87SWenchao Xia error_propagate(errp, local_err); 443903c341dSMarkus Armbruster g_free(info); 444903c341dSMarkus Armbruster qapi_free_BlockInfoList(head); 445903c341dSMarkus Armbruster return NULL; 446553a7e87SWenchao Xia } 447f364ec65SWenchao Xia 448f364ec65SWenchao Xia *p_next = info; 449f364ec65SWenchao Xia p_next = &info->next; 450f364ec65SWenchao Xia } 451f364ec65SWenchao Xia 452f364ec65SWenchao Xia return head; 453f364ec65SWenchao Xia } 454f364ec65SWenchao Xia 455f71eaa74SFam Zheng BlockStatsList *qmp_query_blockstats(bool has_query_nodes, 456f71eaa74SFam Zheng bool query_nodes, 457f71eaa74SFam Zheng Error **errp) 458f364ec65SWenchao Xia { 459f364ec65SWenchao Xia BlockStatsList *head = NULL, **p_next = &head; 460f364ec65SWenchao Xia BlockDriverState *bs = NULL; 461f364ec65SWenchao Xia 462f71eaa74SFam Zheng /* Just to be safe if query_nodes is not always initialized */ 463f71eaa74SFam Zheng query_nodes = has_query_nodes && query_nodes; 464f71eaa74SFam Zheng 465f71eaa74SFam Zheng while ((bs = query_nodes ? bdrv_next_node(bs) : bdrv_next(bs))) { 466f364ec65SWenchao Xia BlockStatsList *info = g_malloc0(sizeof(*info)); 46713344f3aSStefan Hajnoczi AioContext *ctx = bdrv_get_aio_context(bs); 46813344f3aSStefan Hajnoczi 46913344f3aSStefan Hajnoczi aio_context_acquire(ctx); 470f71eaa74SFam Zheng info->value = bdrv_query_stats(bs, !query_nodes); 47113344f3aSStefan Hajnoczi aio_context_release(ctx); 472f364ec65SWenchao Xia 473f364ec65SWenchao Xia *p_next = info; 474f364ec65SWenchao Xia p_next = &info->next; 475f364ec65SWenchao Xia } 476f364ec65SWenchao Xia 477f364ec65SWenchao Xia return head; 478f364ec65SWenchao Xia } 479f364ec65SWenchao Xia 480f364ec65SWenchao Xia #define NB_SUFFIXES 4 481f364ec65SWenchao Xia 482f364ec65SWenchao Xia static char *get_human_readable_size(char *buf, int buf_size, int64_t size) 483f364ec65SWenchao Xia { 4842c20fa2cSStefan Weil static const char suffixes[NB_SUFFIXES] = {'K', 'M', 'G', 'T'}; 485f364ec65SWenchao Xia int64_t base; 486f364ec65SWenchao Xia int i; 487f364ec65SWenchao Xia 488f364ec65SWenchao Xia if (size <= 999) { 489f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64, size); 490f364ec65SWenchao Xia } else { 491f364ec65SWenchao Xia base = 1024; 492f364ec65SWenchao Xia for (i = 0; i < NB_SUFFIXES; i++) { 493f364ec65SWenchao Xia if (size < (10 * base)) { 494f364ec65SWenchao Xia snprintf(buf, buf_size, "%0.1f%c", 495f364ec65SWenchao Xia (double)size / base, 496f364ec65SWenchao Xia suffixes[i]); 497f364ec65SWenchao Xia break; 498f364ec65SWenchao Xia } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 499f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64 "%c", 500f364ec65SWenchao Xia ((size + (base >> 1)) / base), 501f364ec65SWenchao Xia suffixes[i]); 502f364ec65SWenchao Xia break; 503f364ec65SWenchao Xia } 504f364ec65SWenchao Xia base = base * 1024; 505f364ec65SWenchao Xia } 506f364ec65SWenchao Xia } 507f364ec65SWenchao Xia return buf; 508f364ec65SWenchao Xia } 509f364ec65SWenchao Xia 5105b917044SWenchao Xia void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 5115b917044SWenchao Xia QEMUSnapshotInfo *sn) 512f364ec65SWenchao Xia { 513f364ec65SWenchao Xia char buf1[128], date_buf[128], clock_buf[128]; 514f364ec65SWenchao Xia struct tm tm; 515f364ec65SWenchao Xia time_t ti; 516f364ec65SWenchao Xia int64_t secs; 517f364ec65SWenchao Xia 518f364ec65SWenchao Xia if (!sn) { 5195b917044SWenchao Xia func_fprintf(f, 520f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 521f364ec65SWenchao Xia "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 522f364ec65SWenchao Xia } else { 523f364ec65SWenchao Xia ti = sn->date_sec; 524f364ec65SWenchao Xia localtime_r(&ti, &tm); 525f364ec65SWenchao Xia strftime(date_buf, sizeof(date_buf), 526f364ec65SWenchao Xia "%Y-%m-%d %H:%M:%S", &tm); 527f364ec65SWenchao Xia secs = sn->vm_clock_nsec / 1000000000; 528f364ec65SWenchao Xia snprintf(clock_buf, sizeof(clock_buf), 529f364ec65SWenchao Xia "%02d:%02d:%02d.%03d", 530f364ec65SWenchao Xia (int)(secs / 3600), 531f364ec65SWenchao Xia (int)((secs / 60) % 60), 532f364ec65SWenchao Xia (int)(secs % 60), 533f364ec65SWenchao Xia (int)((sn->vm_clock_nsec / 1000000) % 1000)); 5345b917044SWenchao Xia func_fprintf(f, 535f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 536f364ec65SWenchao Xia sn->id_str, sn->name, 5375b917044SWenchao Xia get_human_readable_size(buf1, sizeof(buf1), 5385b917044SWenchao Xia sn->vm_state_size), 539f364ec65SWenchao Xia date_buf, 540f364ec65SWenchao Xia clock_buf); 541f364ec65SWenchao Xia } 542f364ec65SWenchao Xia } 543f364ec65SWenchao Xia 544a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 545a8d8ecb7SMax Reitz QDict *dict); 546a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 547a8d8ecb7SMax Reitz QList *list); 548a8d8ecb7SMax Reitz 549a8d8ecb7SMax Reitz static void dump_qobject(fprintf_function func_fprintf, void *f, 550a8d8ecb7SMax Reitz int comp_indent, QObject *obj) 551a8d8ecb7SMax Reitz { 552a8d8ecb7SMax Reitz switch (qobject_type(obj)) { 553a8d8ecb7SMax Reitz case QTYPE_QINT: { 554a8d8ecb7SMax Reitz QInt *value = qobject_to_qint(obj); 555a8d8ecb7SMax Reitz func_fprintf(f, "%" PRId64, qint_get_int(value)); 556a8d8ecb7SMax Reitz break; 557a8d8ecb7SMax Reitz } 558a8d8ecb7SMax Reitz case QTYPE_QSTRING: { 559a8d8ecb7SMax Reitz QString *value = qobject_to_qstring(obj); 560a8d8ecb7SMax Reitz func_fprintf(f, "%s", qstring_get_str(value)); 561a8d8ecb7SMax Reitz break; 562a8d8ecb7SMax Reitz } 563a8d8ecb7SMax Reitz case QTYPE_QDICT: { 564a8d8ecb7SMax Reitz QDict *value = qobject_to_qdict(obj); 565a8d8ecb7SMax Reitz dump_qdict(func_fprintf, f, comp_indent, value); 566a8d8ecb7SMax Reitz break; 567a8d8ecb7SMax Reitz } 568a8d8ecb7SMax Reitz case QTYPE_QLIST: { 569a8d8ecb7SMax Reitz QList *value = qobject_to_qlist(obj); 570a8d8ecb7SMax Reitz dump_qlist(func_fprintf, f, comp_indent, value); 571a8d8ecb7SMax Reitz break; 572a8d8ecb7SMax Reitz } 573a8d8ecb7SMax Reitz case QTYPE_QFLOAT: { 574a8d8ecb7SMax Reitz QFloat *value = qobject_to_qfloat(obj); 575a8d8ecb7SMax Reitz func_fprintf(f, "%g", qfloat_get_double(value)); 576a8d8ecb7SMax Reitz break; 577a8d8ecb7SMax Reitz } 578a8d8ecb7SMax Reitz case QTYPE_QBOOL: { 579a8d8ecb7SMax Reitz QBool *value = qobject_to_qbool(obj); 580fc48ffc3SEric Blake func_fprintf(f, "%s", qbool_get_bool(value) ? "true" : "false"); 581a8d8ecb7SMax Reitz break; 582a8d8ecb7SMax Reitz } 583a8d8ecb7SMax Reitz default: 584a8d8ecb7SMax Reitz abort(); 585a8d8ecb7SMax Reitz } 586a8d8ecb7SMax Reitz } 587a8d8ecb7SMax Reitz 588a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 589a8d8ecb7SMax Reitz QList *list) 590a8d8ecb7SMax Reitz { 591a8d8ecb7SMax Reitz const QListEntry *entry; 592a8d8ecb7SMax Reitz int i = 0; 593a8d8ecb7SMax Reitz 594a8d8ecb7SMax Reitz for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) { 5951310a3d3SEric Blake QType type = qobject_type(entry->value); 596a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 597a8d8ecb7SMax Reitz const char *format = composite ? "%*s[%i]:\n" : "%*s[%i]: "; 598a8d8ecb7SMax Reitz 599a8d8ecb7SMax Reitz func_fprintf(f, format, indentation * 4, "", i); 600a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 601a8d8ecb7SMax Reitz if (!composite) { 602a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 603a8d8ecb7SMax Reitz } 604a8d8ecb7SMax Reitz } 605a8d8ecb7SMax Reitz } 606a8d8ecb7SMax Reitz 607a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 608a8d8ecb7SMax Reitz QDict *dict) 609a8d8ecb7SMax Reitz { 610a8d8ecb7SMax Reitz const QDictEntry *entry; 611a8d8ecb7SMax Reitz 612a8d8ecb7SMax Reitz for (entry = qdict_first(dict); entry; entry = qdict_next(dict, entry)) { 6131310a3d3SEric Blake QType type = qobject_type(entry->value); 614a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 615a8d8ecb7SMax Reitz const char *format = composite ? "%*s%s:\n" : "%*s%s: "; 616a8d8ecb7SMax Reitz char key[strlen(entry->key) + 1]; 617a8d8ecb7SMax Reitz int i; 618a8d8ecb7SMax Reitz 619a8d8ecb7SMax Reitz /* replace dashes with spaces in key (variable) names */ 620a8d8ecb7SMax Reitz for (i = 0; entry->key[i]; i++) { 621a8d8ecb7SMax Reitz key[i] = entry->key[i] == '-' ? ' ' : entry->key[i]; 622a8d8ecb7SMax Reitz } 623a8d8ecb7SMax Reitz key[i] = 0; 624a8d8ecb7SMax Reitz 625a8d8ecb7SMax Reitz func_fprintf(f, format, indentation * 4, "", key); 626a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 627a8d8ecb7SMax Reitz if (!composite) { 628a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 629a8d8ecb7SMax Reitz } 630a8d8ecb7SMax Reitz } 631a8d8ecb7SMax Reitz } 632a8d8ecb7SMax Reitz 633a8d8ecb7SMax Reitz void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f, 634a8d8ecb7SMax Reitz ImageInfoSpecific *info_spec) 635a8d8ecb7SMax Reitz { 636a8d8ecb7SMax Reitz QmpOutputVisitor *ov = qmp_output_visitor_new(); 637a8d8ecb7SMax Reitz QObject *obj, *data; 638a8d8ecb7SMax Reitz 639a8d8ecb7SMax Reitz visit_type_ImageInfoSpecific(qmp_output_get_visitor(ov), &info_spec, NULL, 64035d0d40aSMax Reitz &error_abort); 641a8d8ecb7SMax Reitz obj = qmp_output_get_qobject(ov); 642a8d8ecb7SMax Reitz assert(qobject_type(obj) == QTYPE_QDICT); 643a8d8ecb7SMax Reitz data = qdict_get(qobject_to_qdict(obj), "data"); 644a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, 1, data); 645a8d8ecb7SMax Reitz qmp_output_visitor_cleanup(ov); 646a8d8ecb7SMax Reitz } 647a8d8ecb7SMax Reitz 6485b917044SWenchao Xia void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 6495b917044SWenchao Xia ImageInfo *info) 650f364ec65SWenchao Xia { 651f364ec65SWenchao Xia char size_buf[128], dsize_buf[128]; 652f364ec65SWenchao Xia if (!info->has_actual_size) { 653f364ec65SWenchao Xia snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 654f364ec65SWenchao Xia } else { 655f364ec65SWenchao Xia get_human_readable_size(dsize_buf, sizeof(dsize_buf), 656f364ec65SWenchao Xia info->actual_size); 657f364ec65SWenchao Xia } 658f364ec65SWenchao Xia get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size); 6595b917044SWenchao Xia func_fprintf(f, 6605b917044SWenchao Xia "image: %s\n" 661f364ec65SWenchao Xia "file format: %s\n" 662f364ec65SWenchao Xia "virtual size: %s (%" PRId64 " bytes)\n" 663f364ec65SWenchao Xia "disk size: %s\n", 664f364ec65SWenchao Xia info->filename, info->format, size_buf, 665f364ec65SWenchao Xia info->virtual_size, 666f364ec65SWenchao Xia dsize_buf); 667f364ec65SWenchao Xia 668f364ec65SWenchao Xia if (info->has_encrypted && info->encrypted) { 6695b917044SWenchao Xia func_fprintf(f, "encrypted: yes\n"); 670f364ec65SWenchao Xia } 671f364ec65SWenchao Xia 672f364ec65SWenchao Xia if (info->has_cluster_size) { 6735b917044SWenchao Xia func_fprintf(f, "cluster_size: %" PRId64 "\n", 6745b917044SWenchao Xia info->cluster_size); 675f364ec65SWenchao Xia } 676f364ec65SWenchao Xia 677f364ec65SWenchao Xia if (info->has_dirty_flag && info->dirty_flag) { 6785b917044SWenchao Xia func_fprintf(f, "cleanly shut down: no\n"); 679f364ec65SWenchao Xia } 680f364ec65SWenchao Xia 681f364ec65SWenchao Xia if (info->has_backing_filename) { 6825b917044SWenchao Xia func_fprintf(f, "backing file: %s", info->backing_filename); 6835c9d9ca5SJohn Snow if (!info->has_full_backing_filename) { 6845c9d9ca5SJohn Snow func_fprintf(f, " (cannot determine actual path)"); 6855c9d9ca5SJohn Snow } else if (strcmp(info->backing_filename, 6865c9d9ca5SJohn Snow info->full_backing_filename) != 0) { 6875b917044SWenchao Xia func_fprintf(f, " (actual path: %s)", info->full_backing_filename); 688f364ec65SWenchao Xia } 6895b917044SWenchao Xia func_fprintf(f, "\n"); 690f364ec65SWenchao Xia if (info->has_backing_filename_format) { 6915b917044SWenchao Xia func_fprintf(f, "backing file format: %s\n", 6925b917044SWenchao Xia info->backing_filename_format); 693f364ec65SWenchao Xia } 694f364ec65SWenchao Xia } 695f364ec65SWenchao Xia 696f364ec65SWenchao Xia if (info->has_snapshots) { 697f364ec65SWenchao Xia SnapshotInfoList *elem; 698f364ec65SWenchao Xia 6995b917044SWenchao Xia func_fprintf(f, "Snapshot list:\n"); 7005b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, NULL); 7015b917044SWenchao Xia func_fprintf(f, "\n"); 702f364ec65SWenchao Xia 703f364ec65SWenchao Xia /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but 704f364ec65SWenchao Xia * we convert to the block layer's native QEMUSnapshotInfo for now. 705f364ec65SWenchao Xia */ 706f364ec65SWenchao Xia for (elem = info->snapshots; elem; elem = elem->next) { 707f364ec65SWenchao Xia QEMUSnapshotInfo sn = { 708f364ec65SWenchao Xia .vm_state_size = elem->value->vm_state_size, 709f364ec65SWenchao Xia .date_sec = elem->value->date_sec, 710f364ec65SWenchao Xia .date_nsec = elem->value->date_nsec, 711f364ec65SWenchao Xia .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL + 712f364ec65SWenchao Xia elem->value->vm_clock_nsec, 713f364ec65SWenchao Xia }; 714f364ec65SWenchao Xia 715f364ec65SWenchao Xia pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id); 716f364ec65SWenchao Xia pstrcpy(sn.name, sizeof(sn.name), elem->value->name); 7175b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, &sn); 7185b917044SWenchao Xia func_fprintf(f, "\n"); 719f364ec65SWenchao Xia } 720f364ec65SWenchao Xia } 721a8d8ecb7SMax Reitz 722a8d8ecb7SMax Reitz if (info->has_format_specific) { 723a8d8ecb7SMax Reitz func_fprintf(f, "Format specific information:\n"); 724a8d8ecb7SMax Reitz bdrv_image_info_specific_dump(func_fprintf, f, info->format_specific); 725a8d8ecb7SMax Reitz } 726f364ec65SWenchao Xia } 727