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 25f364ec65SWenchao Xia #include "block/qapi.h" 26f364ec65SWenchao Xia #include "block/block_int.h" 27f364ec65SWenchao Xia #include "qmp-commands.h" 28a8d8ecb7SMax Reitz #include "qapi-visit.h" 29a8d8ecb7SMax Reitz #include "qapi/qmp-output-visitor.h" 30a8d8ecb7SMax Reitz #include "qapi/qmp/types.h" 31f364ec65SWenchao Xia 32c13163fbSBenoît Canet BlockDeviceInfo *bdrv_block_device_info(BlockDriverState *bs) 33c13163fbSBenoît Canet { 34c13163fbSBenoît Canet BlockDeviceInfo *info = g_malloc0(sizeof(*info)); 35c13163fbSBenoît Canet 36c13163fbSBenoît Canet info->file = g_strdup(bs->filename); 37c13163fbSBenoît Canet info->ro = bs->read_only; 38c13163fbSBenoît Canet info->drv = g_strdup(bs->drv->format_name); 39c13163fbSBenoît Canet info->encrypted = bs->encrypted; 40c13163fbSBenoît Canet info->encryption_key_missing = bdrv_key_required(bs); 41c13163fbSBenoît Canet 42c13163fbSBenoît Canet if (bs->node_name[0]) { 43c13163fbSBenoît Canet info->has_node_name = true; 44c13163fbSBenoît Canet info->node_name = g_strdup(bs->node_name); 45c13163fbSBenoît Canet } 46c13163fbSBenoît Canet 47c13163fbSBenoît Canet if (bs->backing_file[0]) { 48c13163fbSBenoît Canet info->has_backing_file = true; 49c13163fbSBenoît Canet info->backing_file = g_strdup(bs->backing_file); 50c13163fbSBenoît Canet } 51c13163fbSBenoît Canet 52c13163fbSBenoît Canet info->backing_file_depth = bdrv_get_backing_file_depth(bs); 53c13163fbSBenoît Canet 54c13163fbSBenoît Canet if (bs->io_limits_enabled) { 55c13163fbSBenoît Canet ThrottleConfig cfg; 56c13163fbSBenoît Canet throttle_get_config(&bs->throttle_state, &cfg); 57c13163fbSBenoît Canet info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg; 58c13163fbSBenoît Canet info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg; 59c13163fbSBenoît Canet info->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE].avg; 60c13163fbSBenoît Canet 61c13163fbSBenoît Canet info->iops = cfg.buckets[THROTTLE_OPS_TOTAL].avg; 62c13163fbSBenoît Canet info->iops_rd = cfg.buckets[THROTTLE_OPS_READ].avg; 63c13163fbSBenoît Canet info->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE].avg; 64c13163fbSBenoît Canet 65c13163fbSBenoît Canet info->has_bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 66c13163fbSBenoît Canet info->bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max; 67c13163fbSBenoît Canet info->has_bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 68c13163fbSBenoît Canet info->bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max; 69c13163fbSBenoît Canet info->has_bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 70c13163fbSBenoît Canet info->bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max; 71c13163fbSBenoît Canet 72c13163fbSBenoît Canet info->has_iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 73c13163fbSBenoît Canet info->iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max; 74c13163fbSBenoît Canet info->has_iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 75c13163fbSBenoît Canet info->iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max; 76c13163fbSBenoît Canet info->has_iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 77c13163fbSBenoît Canet info->iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max; 78c13163fbSBenoît Canet 79c13163fbSBenoît Canet info->has_iops_size = cfg.op_size; 80c13163fbSBenoît Canet info->iops_size = cfg.op_size; 81c13163fbSBenoît Canet } 82c13163fbSBenoît Canet 83c13163fbSBenoît Canet return info; 84c13163fbSBenoît Canet } 85c13163fbSBenoît Canet 86fb0ed453SWenchao Xia /* 87fb0ed453SWenchao Xia * Returns 0 on success, with *p_list either set to describe snapshot 88fb0ed453SWenchao Xia * information, or NULL because there are no snapshots. Returns -errno on 89fb0ed453SWenchao Xia * error, with *p_list untouched. 90fb0ed453SWenchao Xia */ 91fb0ed453SWenchao Xia int bdrv_query_snapshot_info_list(BlockDriverState *bs, 92fb0ed453SWenchao Xia SnapshotInfoList **p_list, 93fb0ed453SWenchao Xia Error **errp) 94f364ec65SWenchao Xia { 95f364ec65SWenchao Xia int i, sn_count; 96f364ec65SWenchao Xia QEMUSnapshotInfo *sn_tab = NULL; 97fb0ed453SWenchao Xia SnapshotInfoList *info_list, *cur_item = NULL, *head = NULL; 98fb0ed453SWenchao Xia SnapshotInfo *info; 99fb0ed453SWenchao Xia 100f364ec65SWenchao Xia sn_count = bdrv_snapshot_list(bs, &sn_tab); 101fb0ed453SWenchao Xia if (sn_count < 0) { 102fb0ed453SWenchao Xia const char *dev = bdrv_get_device_name(bs); 103fb0ed453SWenchao Xia switch (sn_count) { 104fb0ed453SWenchao Xia case -ENOMEDIUM: 105fb0ed453SWenchao Xia error_setg(errp, "Device '%s' is not inserted", dev); 106fb0ed453SWenchao Xia break; 107fb0ed453SWenchao Xia case -ENOTSUP: 108fb0ed453SWenchao Xia error_setg(errp, 109fb0ed453SWenchao Xia "Device '%s' does not support internal snapshots", 110fb0ed453SWenchao Xia dev); 111fb0ed453SWenchao Xia break; 112fb0ed453SWenchao Xia default: 113fb0ed453SWenchao Xia error_setg_errno(errp, -sn_count, 114fb0ed453SWenchao Xia "Can't list snapshots of device '%s'", dev); 115fb0ed453SWenchao Xia break; 116fb0ed453SWenchao Xia } 117fb0ed453SWenchao Xia return sn_count; 118fb0ed453SWenchao Xia } 119f364ec65SWenchao Xia 120f364ec65SWenchao Xia for (i = 0; i < sn_count; i++) { 121fb0ed453SWenchao Xia info = g_new0(SnapshotInfo, 1); 122fb0ed453SWenchao Xia info->id = g_strdup(sn_tab[i].id_str); 123fb0ed453SWenchao Xia info->name = g_strdup(sn_tab[i].name); 124fb0ed453SWenchao Xia info->vm_state_size = sn_tab[i].vm_state_size; 125fb0ed453SWenchao Xia info->date_sec = sn_tab[i].date_sec; 126fb0ed453SWenchao Xia info->date_nsec = sn_tab[i].date_nsec; 127fb0ed453SWenchao Xia info->vm_clock_sec = sn_tab[i].vm_clock_nsec / 1000000000; 128fb0ed453SWenchao Xia info->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000; 129f364ec65SWenchao Xia 130fb0ed453SWenchao Xia info_list = g_new0(SnapshotInfoList, 1); 131fb0ed453SWenchao Xia info_list->value = info; 132f364ec65SWenchao Xia 133f364ec65SWenchao Xia /* XXX: waiting for the qapi to support qemu-queue.h types */ 134f364ec65SWenchao Xia if (!cur_item) { 135fb0ed453SWenchao Xia head = cur_item = info_list; 136f364ec65SWenchao Xia } else { 137f364ec65SWenchao Xia cur_item->next = info_list; 138f364ec65SWenchao Xia cur_item = info_list; 139f364ec65SWenchao Xia } 140f364ec65SWenchao Xia 141f364ec65SWenchao Xia } 142f364ec65SWenchao Xia 143f364ec65SWenchao Xia g_free(sn_tab); 144fb0ed453SWenchao Xia *p_list = head; 145fb0ed453SWenchao Xia return 0; 146f364ec65SWenchao Xia } 147f364ec65SWenchao Xia 14843526ec8SWenchao Xia /** 14943526ec8SWenchao Xia * bdrv_query_image_info: 15043526ec8SWenchao Xia * @bs: block device to examine 15143526ec8SWenchao Xia * @p_info: location to store image information 15243526ec8SWenchao Xia * @errp: location to store error information 15343526ec8SWenchao Xia * 154553a7e87SWenchao Xia * Store "flat" image information in @p_info. 155553a7e87SWenchao Xia * 156553a7e87SWenchao Xia * "Flat" means it does *not* query backing image information, 157553a7e87SWenchao Xia * i.e. (*pinfo)->has_backing_image will be set to false and 158553a7e87SWenchao Xia * (*pinfo)->backing_image to NULL even when the image does in fact have 159553a7e87SWenchao Xia * a backing image. 160553a7e87SWenchao Xia * 16143526ec8SWenchao Xia * @p_info will be set only on success. On error, store error in @errp. 16243526ec8SWenchao Xia */ 16343526ec8SWenchao Xia void bdrv_query_image_info(BlockDriverState *bs, 16443526ec8SWenchao Xia ImageInfo **p_info, 16543526ec8SWenchao Xia Error **errp) 166f364ec65SWenchao Xia { 167f364ec65SWenchao Xia uint64_t total_sectors; 16843526ec8SWenchao Xia const char *backing_filename; 169f364ec65SWenchao Xia char backing_filename2[1024]; 170f364ec65SWenchao Xia BlockDriverInfo bdi; 17143526ec8SWenchao Xia int ret; 17243526ec8SWenchao Xia Error *err = NULL; 17343526ec8SWenchao Xia ImageInfo *info = g_new0(ImageInfo, 1); 174f364ec65SWenchao Xia 175f364ec65SWenchao Xia bdrv_get_geometry(bs, &total_sectors); 176f364ec65SWenchao Xia 17743526ec8SWenchao Xia info->filename = g_strdup(bs->filename); 178f364ec65SWenchao Xia info->format = g_strdup(bdrv_get_format_name(bs)); 179f364ec65SWenchao Xia info->virtual_size = total_sectors * 512; 180f364ec65SWenchao Xia info->actual_size = bdrv_get_allocated_file_size(bs); 181f364ec65SWenchao Xia info->has_actual_size = info->actual_size >= 0; 182f364ec65SWenchao Xia if (bdrv_is_encrypted(bs)) { 183f364ec65SWenchao Xia info->encrypted = true; 184f364ec65SWenchao Xia info->has_encrypted = true; 185f364ec65SWenchao Xia } 186f364ec65SWenchao Xia if (bdrv_get_info(bs, &bdi) >= 0) { 187f364ec65SWenchao Xia if (bdi.cluster_size != 0) { 188f364ec65SWenchao Xia info->cluster_size = bdi.cluster_size; 189f364ec65SWenchao Xia info->has_cluster_size = true; 190f364ec65SWenchao Xia } 191f364ec65SWenchao Xia info->dirty_flag = bdi.is_dirty; 192f364ec65SWenchao Xia info->has_dirty_flag = true; 193f364ec65SWenchao Xia } 194eae041feSMax Reitz info->format_specific = bdrv_get_specific_info(bs); 195eae041feSMax Reitz info->has_format_specific = info->format_specific != NULL; 196eae041feSMax Reitz 19743526ec8SWenchao Xia backing_filename = bs->backing_file; 198f364ec65SWenchao Xia if (backing_filename[0] != '\0') { 199f364ec65SWenchao Xia info->backing_filename = g_strdup(backing_filename); 200f364ec65SWenchao Xia info->has_backing_filename = true; 201f364ec65SWenchao Xia bdrv_get_full_backing_filename(bs, backing_filename2, 202f364ec65SWenchao Xia sizeof(backing_filename2)); 203f364ec65SWenchao Xia 204f364ec65SWenchao Xia if (strcmp(backing_filename, backing_filename2) != 0) { 205f364ec65SWenchao Xia info->full_backing_filename = 206f364ec65SWenchao Xia g_strdup(backing_filename2); 207f364ec65SWenchao Xia info->has_full_backing_filename = true; 208f364ec65SWenchao Xia } 209f364ec65SWenchao Xia 210f364ec65SWenchao Xia if (bs->backing_format[0]) { 211f364ec65SWenchao Xia info->backing_filename_format = g_strdup(bs->backing_format); 212f364ec65SWenchao Xia info->has_backing_filename_format = true; 213f364ec65SWenchao Xia } 214f364ec65SWenchao Xia } 21543526ec8SWenchao Xia 21643526ec8SWenchao Xia ret = bdrv_query_snapshot_info_list(bs, &info->snapshots, &err); 21743526ec8SWenchao Xia switch (ret) { 21843526ec8SWenchao Xia case 0: 21943526ec8SWenchao Xia if (info->snapshots) { 22043526ec8SWenchao Xia info->has_snapshots = true; 22143526ec8SWenchao Xia } 22243526ec8SWenchao Xia break; 22343526ec8SWenchao Xia /* recoverable error */ 22443526ec8SWenchao Xia case -ENOMEDIUM: 22543526ec8SWenchao Xia case -ENOTSUP: 22643526ec8SWenchao Xia error_free(err); 22743526ec8SWenchao Xia break; 22843526ec8SWenchao Xia default: 22943526ec8SWenchao Xia error_propagate(errp, err); 23043526ec8SWenchao Xia qapi_free_ImageInfo(info); 23143526ec8SWenchao Xia return; 23243526ec8SWenchao Xia } 23343526ec8SWenchao Xia 23443526ec8SWenchao Xia *p_info = info; 235f364ec65SWenchao Xia } 236f364ec65SWenchao Xia 237553a7e87SWenchao Xia /* @p_info will be set only on success. */ 238553a7e87SWenchao Xia void bdrv_query_info(BlockDriverState *bs, 239553a7e87SWenchao Xia BlockInfo **p_info, 240553a7e87SWenchao Xia Error **errp) 241f364ec65SWenchao Xia { 242f364ec65SWenchao Xia BlockInfo *info = g_malloc0(sizeof(*info)); 243553a7e87SWenchao Xia BlockDriverState *bs0; 244553a7e87SWenchao Xia ImageInfo **p_image_info; 245553a7e87SWenchao Xia Error *local_err = NULL; 246f364ec65SWenchao Xia info->device = g_strdup(bs->device_name); 247f364ec65SWenchao Xia info->type = g_strdup("unknown"); 248f364ec65SWenchao Xia info->locked = bdrv_dev_is_medium_locked(bs); 249f364ec65SWenchao Xia info->removable = bdrv_dev_has_removable_media(bs); 250f364ec65SWenchao Xia 251f364ec65SWenchao Xia if (bdrv_dev_has_removable_media(bs)) { 252f364ec65SWenchao Xia info->has_tray_open = true; 253f364ec65SWenchao Xia info->tray_open = bdrv_dev_is_tray_open(bs); 254f364ec65SWenchao Xia } 255f364ec65SWenchao Xia 256f364ec65SWenchao Xia if (bdrv_iostatus_is_enabled(bs)) { 257f364ec65SWenchao Xia info->has_io_status = true; 258f364ec65SWenchao Xia info->io_status = bs->iostatus; 259f364ec65SWenchao Xia } 260f364ec65SWenchao Xia 26121b56835SFam Zheng if (!QLIST_EMPTY(&bs->dirty_bitmaps)) { 26221b56835SFam Zheng info->has_dirty_bitmaps = true; 26321b56835SFam Zheng info->dirty_bitmaps = bdrv_query_dirty_bitmaps(bs); 26421b56835SFam Zheng } 26521b56835SFam Zheng 266f364ec65SWenchao Xia if (bs->drv) { 267f364ec65SWenchao Xia info->has_inserted = true; 268c13163fbSBenoît Canet info->inserted = bdrv_block_device_info(bs); 269553a7e87SWenchao Xia 270553a7e87SWenchao Xia bs0 = bs; 271553a7e87SWenchao Xia p_image_info = &info->inserted->image; 272553a7e87SWenchao Xia while (1) { 273553a7e87SWenchao Xia bdrv_query_image_info(bs0, p_image_info, &local_err); 274*84d18f06SMarkus Armbruster if (local_err) { 275553a7e87SWenchao Xia error_propagate(errp, local_err); 276553a7e87SWenchao Xia goto err; 277f364ec65SWenchao Xia } 278553a7e87SWenchao Xia if (bs0->drv && bs0->backing_hd) { 279553a7e87SWenchao Xia bs0 = bs0->backing_hd; 280553a7e87SWenchao Xia (*p_image_info)->has_backing_image = true; 281553a7e87SWenchao Xia p_image_info = &((*p_image_info)->backing_image); 282553a7e87SWenchao Xia } else { 283553a7e87SWenchao Xia break; 284553a7e87SWenchao Xia } 285553a7e87SWenchao Xia } 286553a7e87SWenchao Xia } 287553a7e87SWenchao Xia 288553a7e87SWenchao Xia *p_info = info; 289553a7e87SWenchao Xia return; 290553a7e87SWenchao Xia 291553a7e87SWenchao Xia err: 292553a7e87SWenchao Xia qapi_free_BlockInfo(info); 293f364ec65SWenchao Xia } 294f364ec65SWenchao Xia 295f364ec65SWenchao Xia BlockStats *bdrv_query_stats(const BlockDriverState *bs) 296f364ec65SWenchao Xia { 297f364ec65SWenchao Xia BlockStats *s; 298f364ec65SWenchao Xia 299f364ec65SWenchao Xia s = g_malloc0(sizeof(*s)); 300f364ec65SWenchao Xia 301f364ec65SWenchao Xia if (bs->device_name[0]) { 302f364ec65SWenchao Xia s->has_device = true; 303f364ec65SWenchao Xia s->device = g_strdup(bs->device_name); 304f364ec65SWenchao Xia } 305f364ec65SWenchao Xia 306f364ec65SWenchao Xia s->stats = g_malloc0(sizeof(*s->stats)); 307f364ec65SWenchao Xia s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ]; 308f364ec65SWenchao Xia s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE]; 309f364ec65SWenchao Xia s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ]; 310f364ec65SWenchao Xia s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE]; 311f364ec65SWenchao Xia s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE; 312f364ec65SWenchao Xia s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH]; 313f364ec65SWenchao Xia s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE]; 314f364ec65SWenchao Xia s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ]; 315f364ec65SWenchao Xia s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH]; 316f364ec65SWenchao Xia 317f364ec65SWenchao Xia if (bs->file) { 318f364ec65SWenchao Xia s->has_parent = true; 319f364ec65SWenchao Xia s->parent = bdrv_query_stats(bs->file); 320f364ec65SWenchao Xia } 321f364ec65SWenchao Xia 322c8059b97SFam Zheng if (bs->backing_hd) { 323c8059b97SFam Zheng s->has_backing = true; 324c8059b97SFam Zheng s->backing = bdrv_query_stats(bs->backing_hd); 325c8059b97SFam Zheng } 326c8059b97SFam Zheng 327f364ec65SWenchao Xia return s; 328f364ec65SWenchao Xia } 329f364ec65SWenchao Xia 330f364ec65SWenchao Xia BlockInfoList *qmp_query_block(Error **errp) 331f364ec65SWenchao Xia { 332f364ec65SWenchao Xia BlockInfoList *head = NULL, **p_next = &head; 333f364ec65SWenchao Xia BlockDriverState *bs = NULL; 334553a7e87SWenchao Xia Error *local_err = NULL; 335f364ec65SWenchao Xia 336f364ec65SWenchao Xia while ((bs = bdrv_next(bs))) { 337f364ec65SWenchao Xia BlockInfoList *info = g_malloc0(sizeof(*info)); 338553a7e87SWenchao Xia bdrv_query_info(bs, &info->value, &local_err); 339*84d18f06SMarkus Armbruster if (local_err) { 340553a7e87SWenchao Xia error_propagate(errp, local_err); 341553a7e87SWenchao Xia goto err; 342553a7e87SWenchao Xia } 343f364ec65SWenchao Xia 344f364ec65SWenchao Xia *p_next = info; 345f364ec65SWenchao Xia p_next = &info->next; 346f364ec65SWenchao Xia } 347f364ec65SWenchao Xia 348f364ec65SWenchao Xia return head; 349553a7e87SWenchao Xia 350553a7e87SWenchao Xia err: 351553a7e87SWenchao Xia qapi_free_BlockInfoList(head); 352553a7e87SWenchao Xia return NULL; 353f364ec65SWenchao Xia } 354f364ec65SWenchao Xia 355f364ec65SWenchao Xia BlockStatsList *qmp_query_blockstats(Error **errp) 356f364ec65SWenchao Xia { 357f364ec65SWenchao Xia BlockStatsList *head = NULL, **p_next = &head; 358f364ec65SWenchao Xia BlockDriverState *bs = NULL; 359f364ec65SWenchao Xia 360f364ec65SWenchao Xia while ((bs = bdrv_next(bs))) { 361f364ec65SWenchao Xia BlockStatsList *info = g_malloc0(sizeof(*info)); 362f364ec65SWenchao Xia info->value = bdrv_query_stats(bs); 363f364ec65SWenchao Xia 364f364ec65SWenchao Xia *p_next = info; 365f364ec65SWenchao Xia p_next = &info->next; 366f364ec65SWenchao Xia } 367f364ec65SWenchao Xia 368f364ec65SWenchao Xia return head; 369f364ec65SWenchao Xia } 370f364ec65SWenchao Xia 371f364ec65SWenchao Xia #define NB_SUFFIXES 4 372f364ec65SWenchao Xia 373f364ec65SWenchao Xia static char *get_human_readable_size(char *buf, int buf_size, int64_t size) 374f364ec65SWenchao Xia { 375f364ec65SWenchao Xia static const char suffixes[NB_SUFFIXES] = "KMGT"; 376f364ec65SWenchao Xia int64_t base; 377f364ec65SWenchao Xia int i; 378f364ec65SWenchao Xia 379f364ec65SWenchao Xia if (size <= 999) { 380f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64, size); 381f364ec65SWenchao Xia } else { 382f364ec65SWenchao Xia base = 1024; 383f364ec65SWenchao Xia for (i = 0; i < NB_SUFFIXES; i++) { 384f364ec65SWenchao Xia if (size < (10 * base)) { 385f364ec65SWenchao Xia snprintf(buf, buf_size, "%0.1f%c", 386f364ec65SWenchao Xia (double)size / base, 387f364ec65SWenchao Xia suffixes[i]); 388f364ec65SWenchao Xia break; 389f364ec65SWenchao Xia } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 390f364ec65SWenchao Xia snprintf(buf, buf_size, "%" PRId64 "%c", 391f364ec65SWenchao Xia ((size + (base >> 1)) / base), 392f364ec65SWenchao Xia suffixes[i]); 393f364ec65SWenchao Xia break; 394f364ec65SWenchao Xia } 395f364ec65SWenchao Xia base = base * 1024; 396f364ec65SWenchao Xia } 397f364ec65SWenchao Xia } 398f364ec65SWenchao Xia return buf; 399f364ec65SWenchao Xia } 400f364ec65SWenchao Xia 4015b917044SWenchao Xia void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, 4025b917044SWenchao Xia QEMUSnapshotInfo *sn) 403f364ec65SWenchao Xia { 404f364ec65SWenchao Xia char buf1[128], date_buf[128], clock_buf[128]; 405f364ec65SWenchao Xia struct tm tm; 406f364ec65SWenchao Xia time_t ti; 407f364ec65SWenchao Xia int64_t secs; 408f364ec65SWenchao Xia 409f364ec65SWenchao Xia if (!sn) { 4105b917044SWenchao Xia func_fprintf(f, 411f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 412f364ec65SWenchao Xia "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 413f364ec65SWenchao Xia } else { 414f364ec65SWenchao Xia ti = sn->date_sec; 415f364ec65SWenchao Xia localtime_r(&ti, &tm); 416f364ec65SWenchao Xia strftime(date_buf, sizeof(date_buf), 417f364ec65SWenchao Xia "%Y-%m-%d %H:%M:%S", &tm); 418f364ec65SWenchao Xia secs = sn->vm_clock_nsec / 1000000000; 419f364ec65SWenchao Xia snprintf(clock_buf, sizeof(clock_buf), 420f364ec65SWenchao Xia "%02d:%02d:%02d.%03d", 421f364ec65SWenchao Xia (int)(secs / 3600), 422f364ec65SWenchao Xia (int)((secs / 60) % 60), 423f364ec65SWenchao Xia (int)(secs % 60), 424f364ec65SWenchao Xia (int)((sn->vm_clock_nsec / 1000000) % 1000)); 4255b917044SWenchao Xia func_fprintf(f, 426f364ec65SWenchao Xia "%-10s%-20s%7s%20s%15s", 427f364ec65SWenchao Xia sn->id_str, sn->name, 4285b917044SWenchao Xia get_human_readable_size(buf1, sizeof(buf1), 4295b917044SWenchao Xia sn->vm_state_size), 430f364ec65SWenchao Xia date_buf, 431f364ec65SWenchao Xia clock_buf); 432f364ec65SWenchao Xia } 433f364ec65SWenchao Xia } 434f364ec65SWenchao Xia 435a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 436a8d8ecb7SMax Reitz QDict *dict); 437a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 438a8d8ecb7SMax Reitz QList *list); 439a8d8ecb7SMax Reitz 440a8d8ecb7SMax Reitz static void dump_qobject(fprintf_function func_fprintf, void *f, 441a8d8ecb7SMax Reitz int comp_indent, QObject *obj) 442a8d8ecb7SMax Reitz { 443a8d8ecb7SMax Reitz switch (qobject_type(obj)) { 444a8d8ecb7SMax Reitz case QTYPE_QINT: { 445a8d8ecb7SMax Reitz QInt *value = qobject_to_qint(obj); 446a8d8ecb7SMax Reitz func_fprintf(f, "%" PRId64, qint_get_int(value)); 447a8d8ecb7SMax Reitz break; 448a8d8ecb7SMax Reitz } 449a8d8ecb7SMax Reitz case QTYPE_QSTRING: { 450a8d8ecb7SMax Reitz QString *value = qobject_to_qstring(obj); 451a8d8ecb7SMax Reitz func_fprintf(f, "%s", qstring_get_str(value)); 452a8d8ecb7SMax Reitz break; 453a8d8ecb7SMax Reitz } 454a8d8ecb7SMax Reitz case QTYPE_QDICT: { 455a8d8ecb7SMax Reitz QDict *value = qobject_to_qdict(obj); 456a8d8ecb7SMax Reitz dump_qdict(func_fprintf, f, comp_indent, value); 457a8d8ecb7SMax Reitz break; 458a8d8ecb7SMax Reitz } 459a8d8ecb7SMax Reitz case QTYPE_QLIST: { 460a8d8ecb7SMax Reitz QList *value = qobject_to_qlist(obj); 461a8d8ecb7SMax Reitz dump_qlist(func_fprintf, f, comp_indent, value); 462a8d8ecb7SMax Reitz break; 463a8d8ecb7SMax Reitz } 464a8d8ecb7SMax Reitz case QTYPE_QFLOAT: { 465a8d8ecb7SMax Reitz QFloat *value = qobject_to_qfloat(obj); 466a8d8ecb7SMax Reitz func_fprintf(f, "%g", qfloat_get_double(value)); 467a8d8ecb7SMax Reitz break; 468a8d8ecb7SMax Reitz } 469a8d8ecb7SMax Reitz case QTYPE_QBOOL: { 470a8d8ecb7SMax Reitz QBool *value = qobject_to_qbool(obj); 471a8d8ecb7SMax Reitz func_fprintf(f, "%s", qbool_get_int(value) ? "true" : "false"); 472a8d8ecb7SMax Reitz break; 473a8d8ecb7SMax Reitz } 474a8d8ecb7SMax Reitz case QTYPE_QERROR: { 475a8d8ecb7SMax Reitz QString *value = qerror_human((QError *)obj); 476a8d8ecb7SMax Reitz func_fprintf(f, "%s", qstring_get_str(value)); 477a8d8ecb7SMax Reitz break; 478a8d8ecb7SMax Reitz } 479a8d8ecb7SMax Reitz case QTYPE_NONE: 480a8d8ecb7SMax Reitz break; 481a8d8ecb7SMax Reitz case QTYPE_MAX: 482a8d8ecb7SMax Reitz default: 483a8d8ecb7SMax Reitz abort(); 484a8d8ecb7SMax Reitz } 485a8d8ecb7SMax Reitz } 486a8d8ecb7SMax Reitz 487a8d8ecb7SMax Reitz static void dump_qlist(fprintf_function func_fprintf, void *f, int indentation, 488a8d8ecb7SMax Reitz QList *list) 489a8d8ecb7SMax Reitz { 490a8d8ecb7SMax Reitz const QListEntry *entry; 491a8d8ecb7SMax Reitz int i = 0; 492a8d8ecb7SMax Reitz 493a8d8ecb7SMax Reitz for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) { 494a8d8ecb7SMax Reitz qtype_code type = qobject_type(entry->value); 495a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 496a8d8ecb7SMax Reitz const char *format = composite ? "%*s[%i]:\n" : "%*s[%i]: "; 497a8d8ecb7SMax Reitz 498a8d8ecb7SMax Reitz func_fprintf(f, format, indentation * 4, "", i); 499a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 500a8d8ecb7SMax Reitz if (!composite) { 501a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 502a8d8ecb7SMax Reitz } 503a8d8ecb7SMax Reitz } 504a8d8ecb7SMax Reitz } 505a8d8ecb7SMax Reitz 506a8d8ecb7SMax Reitz static void dump_qdict(fprintf_function func_fprintf, void *f, int indentation, 507a8d8ecb7SMax Reitz QDict *dict) 508a8d8ecb7SMax Reitz { 509a8d8ecb7SMax Reitz const QDictEntry *entry; 510a8d8ecb7SMax Reitz 511a8d8ecb7SMax Reitz for (entry = qdict_first(dict); entry; entry = qdict_next(dict, entry)) { 512a8d8ecb7SMax Reitz qtype_code type = qobject_type(entry->value); 513a8d8ecb7SMax Reitz bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST); 514a8d8ecb7SMax Reitz const char *format = composite ? "%*s%s:\n" : "%*s%s: "; 515a8d8ecb7SMax Reitz char key[strlen(entry->key) + 1]; 516a8d8ecb7SMax Reitz int i; 517a8d8ecb7SMax Reitz 518a8d8ecb7SMax Reitz /* replace dashes with spaces in key (variable) names */ 519a8d8ecb7SMax Reitz for (i = 0; entry->key[i]; i++) { 520a8d8ecb7SMax Reitz key[i] = entry->key[i] == '-' ? ' ' : entry->key[i]; 521a8d8ecb7SMax Reitz } 522a8d8ecb7SMax Reitz key[i] = 0; 523a8d8ecb7SMax Reitz 524a8d8ecb7SMax Reitz func_fprintf(f, format, indentation * 4, "", key); 525a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, indentation + 1, entry->value); 526a8d8ecb7SMax Reitz if (!composite) { 527a8d8ecb7SMax Reitz func_fprintf(f, "\n"); 528a8d8ecb7SMax Reitz } 529a8d8ecb7SMax Reitz } 530a8d8ecb7SMax Reitz } 531a8d8ecb7SMax Reitz 532a8d8ecb7SMax Reitz void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f, 533a8d8ecb7SMax Reitz ImageInfoSpecific *info_spec) 534a8d8ecb7SMax Reitz { 535a8d8ecb7SMax Reitz Error *local_err = NULL; 536a8d8ecb7SMax Reitz QmpOutputVisitor *ov = qmp_output_visitor_new(); 537a8d8ecb7SMax Reitz QObject *obj, *data; 538a8d8ecb7SMax Reitz 539a8d8ecb7SMax Reitz visit_type_ImageInfoSpecific(qmp_output_get_visitor(ov), &info_spec, NULL, 540a8d8ecb7SMax Reitz &local_err); 541a8d8ecb7SMax Reitz obj = qmp_output_get_qobject(ov); 542a8d8ecb7SMax Reitz assert(qobject_type(obj) == QTYPE_QDICT); 543a8d8ecb7SMax Reitz data = qdict_get(qobject_to_qdict(obj), "data"); 544a8d8ecb7SMax Reitz dump_qobject(func_fprintf, f, 1, data); 545a8d8ecb7SMax Reitz qmp_output_visitor_cleanup(ov); 546a8d8ecb7SMax Reitz } 547a8d8ecb7SMax Reitz 5485b917044SWenchao Xia void bdrv_image_info_dump(fprintf_function func_fprintf, void *f, 5495b917044SWenchao Xia ImageInfo *info) 550f364ec65SWenchao Xia { 551f364ec65SWenchao Xia char size_buf[128], dsize_buf[128]; 552f364ec65SWenchao Xia if (!info->has_actual_size) { 553f364ec65SWenchao Xia snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); 554f364ec65SWenchao Xia } else { 555f364ec65SWenchao Xia get_human_readable_size(dsize_buf, sizeof(dsize_buf), 556f364ec65SWenchao Xia info->actual_size); 557f364ec65SWenchao Xia } 558f364ec65SWenchao Xia get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size); 5595b917044SWenchao Xia func_fprintf(f, 5605b917044SWenchao Xia "image: %s\n" 561f364ec65SWenchao Xia "file format: %s\n" 562f364ec65SWenchao Xia "virtual size: %s (%" PRId64 " bytes)\n" 563f364ec65SWenchao Xia "disk size: %s\n", 564f364ec65SWenchao Xia info->filename, info->format, size_buf, 565f364ec65SWenchao Xia info->virtual_size, 566f364ec65SWenchao Xia dsize_buf); 567f364ec65SWenchao Xia 568f364ec65SWenchao Xia if (info->has_encrypted && info->encrypted) { 5695b917044SWenchao Xia func_fprintf(f, "encrypted: yes\n"); 570f364ec65SWenchao Xia } 571f364ec65SWenchao Xia 572f364ec65SWenchao Xia if (info->has_cluster_size) { 5735b917044SWenchao Xia func_fprintf(f, "cluster_size: %" PRId64 "\n", 5745b917044SWenchao Xia info->cluster_size); 575f364ec65SWenchao Xia } 576f364ec65SWenchao Xia 577f364ec65SWenchao Xia if (info->has_dirty_flag && info->dirty_flag) { 5785b917044SWenchao Xia func_fprintf(f, "cleanly shut down: no\n"); 579f364ec65SWenchao Xia } 580f364ec65SWenchao Xia 581f364ec65SWenchao Xia if (info->has_backing_filename) { 5825b917044SWenchao Xia func_fprintf(f, "backing file: %s", info->backing_filename); 583f364ec65SWenchao Xia if (info->has_full_backing_filename) { 5845b917044SWenchao Xia func_fprintf(f, " (actual path: %s)", info->full_backing_filename); 585f364ec65SWenchao Xia } 5865b917044SWenchao Xia func_fprintf(f, "\n"); 587f364ec65SWenchao Xia if (info->has_backing_filename_format) { 5885b917044SWenchao Xia func_fprintf(f, "backing file format: %s\n", 5895b917044SWenchao Xia info->backing_filename_format); 590f364ec65SWenchao Xia } 591f364ec65SWenchao Xia } 592f364ec65SWenchao Xia 593f364ec65SWenchao Xia if (info->has_snapshots) { 594f364ec65SWenchao Xia SnapshotInfoList *elem; 595f364ec65SWenchao Xia 5965b917044SWenchao Xia func_fprintf(f, "Snapshot list:\n"); 5975b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, NULL); 5985b917044SWenchao Xia func_fprintf(f, "\n"); 599f364ec65SWenchao Xia 600f364ec65SWenchao Xia /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but 601f364ec65SWenchao Xia * we convert to the block layer's native QEMUSnapshotInfo for now. 602f364ec65SWenchao Xia */ 603f364ec65SWenchao Xia for (elem = info->snapshots; elem; elem = elem->next) { 604f364ec65SWenchao Xia QEMUSnapshotInfo sn = { 605f364ec65SWenchao Xia .vm_state_size = elem->value->vm_state_size, 606f364ec65SWenchao Xia .date_sec = elem->value->date_sec, 607f364ec65SWenchao Xia .date_nsec = elem->value->date_nsec, 608f364ec65SWenchao Xia .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL + 609f364ec65SWenchao Xia elem->value->vm_clock_nsec, 610f364ec65SWenchao Xia }; 611f364ec65SWenchao Xia 612f364ec65SWenchao Xia pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id); 613f364ec65SWenchao Xia pstrcpy(sn.name, sizeof(sn.name), elem->value->name); 6145b917044SWenchao Xia bdrv_snapshot_dump(func_fprintf, f, &sn); 6155b917044SWenchao Xia func_fprintf(f, "\n"); 616f364ec65SWenchao Xia } 617f364ec65SWenchao Xia } 618a8d8ecb7SMax Reitz 619a8d8ecb7SMax Reitz if (info->has_format_specific) { 620a8d8ecb7SMax Reitz func_fprintf(f, "Format specific information:\n"); 621a8d8ecb7SMax Reitz bdrv_image_info_specific_dump(func_fprintf, f, info->format_specific); 622a8d8ecb7SMax Reitz } 623f364ec65SWenchao Xia } 624