qemu

1
/*
2
 * Block layer qmp and info dump related functions
3
 *
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24

25
#include "qemu/osdep.h"
26
#include "qemu/cutils.h"
27
#include "block/qapi.h"
28
#include "block/block_int.h"
29
#include "block/dirty-bitmap.h"
30
#include "block/throttle-groups.h"
31
#include "block/write-threshold.h"
32
#include "qapi/error.h"
33
#include "qapi/qapi-commands-block-core.h"
34
#include "qapi/qobject-output-visitor.h"
35
#include "qapi/qapi-visit-block-core.h"
36
#include "qapi/qmp/qbool.h"
37
#include "qapi/qmp/qdict.h"
38
#include "qapi/qmp/qlist.h"
39
#include "qapi/qmp/qnum.h"
40
#include "qapi/qmp/qstring.h"
41
#include "qemu/qemu-print.h"
42
#include "sysemu/block-backend.h"
43

44
BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
45
                                        BlockDriverState *bs,
46
                                        bool flat,
47
                                        Error **errp)
48
{
49
    ERRP_GUARD();
50
    ImageInfo **p_image_info;
51
    ImageInfo *backing_info;
52
    BlockDriverState *backing;
53
    BlockDeviceInfo *info;
54

55
    if (!bs->drv) {
56
        error_setg(errp, "Block device %s is ejected", bs->node_name);
57
        return NULL;
58
    }
59

60
    bdrv_refresh_filename(bs);
61

62
    info = g_malloc0(sizeof(*info));
63
    info->file                   = g_strdup(bs->filename);
64
    info->ro                     = bdrv_is_read_only(bs);
65
    info->drv                    = g_strdup(bs->drv->format_name);
66
    info->encrypted              = bs->encrypted;
67

68
    info->cache = g_new(BlockdevCacheInfo, 1);
69
    *info->cache = (BlockdevCacheInfo) {
70
        .writeback      = blk ? blk_enable_write_cache(blk) : true,
71
        .direct         = !!(bs->open_flags & BDRV_O_NOCACHE),
72
        .no_flush       = !!(bs->open_flags & BDRV_O_NO_FLUSH),
73
    };
74

75
    if (bs->node_name[0]) {
76
        info->node_name = g_strdup(bs->node_name);
77
    }
78

79
    backing = bdrv_cow_bs(bs);
80
    if (backing) {
81
        info->backing_file = g_strdup(backing->filename);
82
    }
83

84
    if (!QLIST_EMPTY(&bs->dirty_bitmaps)) {
85
        info->has_dirty_bitmaps = true;
86
        info->dirty_bitmaps = bdrv_query_dirty_bitmaps(bs);
87
    }
88

89
    info->detect_zeroes = bs->detect_zeroes;
90

91
    if (blk && blk_get_public(blk)->throttle_group_member.throttle_state) {
92
        ThrottleConfig cfg;
93
        BlockBackendPublic *blkp = blk_get_public(blk);
94

95
        throttle_group_get_config(&blkp->throttle_group_member, &cfg);
96

97
        info->bps     = cfg.buckets[THROTTLE_BPS_TOTAL].avg;
98
        info->bps_rd  = cfg.buckets[THROTTLE_BPS_READ].avg;
99
        info->bps_wr  = cfg.buckets[THROTTLE_BPS_WRITE].avg;
100

101
        info->iops    = cfg.buckets[THROTTLE_OPS_TOTAL].avg;
102
        info->iops_rd = cfg.buckets[THROTTLE_OPS_READ].avg;
103
        info->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE].avg;
104

105
        info->has_bps_max     = cfg.buckets[THROTTLE_BPS_TOTAL].max;
106
        info->bps_max         = cfg.buckets[THROTTLE_BPS_TOTAL].max;
107
        info->has_bps_rd_max  = cfg.buckets[THROTTLE_BPS_READ].max;
108
        info->bps_rd_max      = cfg.buckets[THROTTLE_BPS_READ].max;
109
        info->has_bps_wr_max  = cfg.buckets[THROTTLE_BPS_WRITE].max;
110
        info->bps_wr_max      = cfg.buckets[THROTTLE_BPS_WRITE].max;
111

112
        info->has_iops_max    = cfg.buckets[THROTTLE_OPS_TOTAL].max;
113
        info->iops_max        = cfg.buckets[THROTTLE_OPS_TOTAL].max;
114
        info->has_iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max;
115
        info->iops_rd_max     = cfg.buckets[THROTTLE_OPS_READ].max;
116
        info->has_iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max;
117
        info->iops_wr_max     = cfg.buckets[THROTTLE_OPS_WRITE].max;
118

119
        info->has_bps_max_length     = info->has_bps_max;
120
        info->bps_max_length         =
121
            cfg.buckets[THROTTLE_BPS_TOTAL].burst_length;
122
        info->has_bps_rd_max_length  = info->has_bps_rd_max;
123
        info->bps_rd_max_length      =
124
            cfg.buckets[THROTTLE_BPS_READ].burst_length;
125
        info->has_bps_wr_max_length  = info->has_bps_wr_max;
126
        info->bps_wr_max_length      =
127
            cfg.buckets[THROTTLE_BPS_WRITE].burst_length;
128

129
        info->has_iops_max_length    = info->has_iops_max;
130
        info->iops_max_length        =
131
            cfg.buckets[THROTTLE_OPS_TOTAL].burst_length;
132
        info->has_iops_rd_max_length = info->has_iops_rd_max;
133
        info->iops_rd_max_length     =
134
            cfg.buckets[THROTTLE_OPS_READ].burst_length;
135
        info->has_iops_wr_max_length = info->has_iops_wr_max;
136
        info->iops_wr_max_length     =
137
            cfg.buckets[THROTTLE_OPS_WRITE].burst_length;
138

139
        info->has_iops_size = cfg.op_size;
140
        info->iops_size = cfg.op_size;
141

142
        info->group =
143
            g_strdup(throttle_group_get_name(&blkp->throttle_group_member));
144
    }
145

146
    info->write_threshold = bdrv_write_threshold_get(bs);
147

148
    p_image_info = &info->image;
149
    info->backing_file_depth = 0;
150

151
    /*
152
     * Skip automatically inserted nodes that the user isn't aware of for
153
     * query-block (blk != NULL), but not for query-named-block-nodes
154
     */
155
    bdrv_query_image_info(bs, p_image_info, flat, blk != NULL, errp);
156
    if (*errp) {
157
        qapi_free_BlockDeviceInfo(info);
158
        return NULL;
159
    }
160

161
    backing_info = info->image->backing_image;
162
    while (backing_info) {
163
        info->backing_file_depth++;
164
        backing_info = backing_info->backing_image;
165
    }
166

167
    return info;
168
}
169

170
/*
171
 * Returns 0 on success, with *p_list either set to describe snapshot
172
 * information, or NULL because there are no snapshots.  Returns -errno on
173
 * error, with *p_list untouched.
174
 */
175
int bdrv_query_snapshot_info_list(BlockDriverState *bs,
176
                                  SnapshotInfoList **p_list,
177
                                  Error **errp)
178
{
179
    int i, sn_count;
180
    QEMUSnapshotInfo *sn_tab = NULL;
181
    SnapshotInfoList *head = NULL, **tail = &head;
182
    SnapshotInfo *info;
183

184
    sn_count = bdrv_snapshot_list(bs, &sn_tab);
185
    if (sn_count < 0) {
186
        const char *dev = bdrv_get_device_name(bs);
187
        switch (sn_count) {
188
        case -ENOMEDIUM:
189
            error_setg(errp, "Device '%s' is not inserted", dev);
190
            break;
191
        case -ENOTSUP:
192
            error_setg(errp,
193
                       "Device '%s' does not support internal snapshots",
194
                       dev);
195
            break;
196
        default:
197
            error_setg_errno(errp, -sn_count,
198
                             "Can't list snapshots of device '%s'", dev);
199
            break;
200
        }
201
        return sn_count;
202
    }
203

204
    for (i = 0; i < sn_count; i++) {
205
        info = g_new0(SnapshotInfo, 1);
206
        info->id            = g_strdup(sn_tab[i].id_str);
207
        info->name          = g_strdup(sn_tab[i].name);
208
        info->vm_state_size = sn_tab[i].vm_state_size;
209
        info->date_sec      = sn_tab[i].date_sec;
210
        info->date_nsec     = sn_tab[i].date_nsec;
211
        info->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
212
        info->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;
213
        info->icount        = sn_tab[i].icount;
214
        info->has_icount    = sn_tab[i].icount != -1ULL;
215

216
        QAPI_LIST_APPEND(tail, info);
217
    }
218

219
    g_free(sn_tab);
220
    *p_list = head;
221
    return 0;
222
}
223

224
/**
225
 * Helper function for other query info functions.  Store information about @bs
226
 * in @info, setting @errp on error.
227
 */
228
static void GRAPH_RDLOCK
229
bdrv_do_query_node_info(BlockDriverState *bs, BlockNodeInfo *info, Error **errp)
230
{
231
    int64_t size;
232
    const char *backing_filename;
233
    BlockDriverInfo bdi;
234
    int ret;
235
    Error *err = NULL;
236

237
    size = bdrv_getlength(bs);
238
    if (size < 0) {
239
        error_setg_errno(errp, -size, "Can't get image size '%s'",
240
                         bs->exact_filename);
241
        return;
242
    }
243

244
    bdrv_refresh_filename(bs);
245

246
    info->filename        = g_strdup(bs->filename);
247
    info->format          = g_strdup(bdrv_get_format_name(bs));
248
    info->virtual_size    = size;
249
    info->actual_size     = bdrv_get_allocated_file_size(bs);
250
    info->has_actual_size = info->actual_size >= 0;
251
    if (bs->encrypted) {
252
        info->encrypted = true;
253
        info->has_encrypted = true;
254
    }
255
    if (bdrv_get_info(bs, &bdi) >= 0) {
256
        if (bdi.cluster_size != 0) {
257
            info->cluster_size = bdi.cluster_size;
258
            info->has_cluster_size = true;
259
        }
260
        info->dirty_flag = bdi.is_dirty;
261
        info->has_dirty_flag = true;
262
    }
263
    info->format_specific = bdrv_get_specific_info(bs, &err);
264
    if (err) {
265
        error_propagate(errp, err);
266
        return;
267
    }
268
    backing_filename = bs->backing_file;
269
    if (backing_filename[0] != '\0') {
270
        char *backing_filename2;
271

272
        info->backing_filename = g_strdup(backing_filename);
273
        backing_filename2 = bdrv_get_full_backing_filename(bs, NULL);
274

275
        /* Always report the full_backing_filename if present, even if it's the
276
         * same as backing_filename. That they are same is useful info. */
277
        if (backing_filename2) {
278
            info->full_backing_filename = g_strdup(backing_filename2);
279
        }
280

281
        if (bs->backing_format[0]) {
282
            info->backing_filename_format = g_strdup(bs->backing_format);
283
        }
284
        g_free(backing_filename2);
285
    }
286

287
    ret = bdrv_query_snapshot_info_list(bs, &info->snapshots, &err);
288
    switch (ret) {
289
    case 0:
290
        if (info->snapshots) {
291
            info->has_snapshots = true;
292
        }
293
        break;
294
    /* recoverable error */
295
    case -ENOMEDIUM:
296
    case -ENOTSUP:
297
        error_free(err);
298
        break;
299
    default:
300
        error_propagate(errp, err);
301
        return;
302
    }
303
}
304

305
/**
306
 * bdrv_query_image_info:
307
 * @bs: block node to examine
308
 * @p_info: location to store image information
309
 * @flat: skip backing node information
310
 * @skip_implicit_filters: skip implicit filters in the backing chain
311
 * @errp: location to store error information
312
 *
313
 * Store image information in @p_info, potentially recursively covering the
314
 * backing chain.
315
 *
316
 * If @flat is true, do not query backing image information, i.e.
317
 * (*p_info)->has_backing_image will be set to false and
318
 * (*p_info)->backing_image to NULL even when the image does in fact have a
319
 * backing image.
320
 *
321
 * If @skip_implicit_filters is true, implicit filter nodes in the backing chain
322
 * will be skipped when querying backing image information.
323
 * (@skip_implicit_filters is ignored when @flat is true.)
324
 *
325
 * @p_info will be set only on success. On error, store error in @errp.
326
 */
327
void bdrv_query_image_info(BlockDriverState *bs,
328
                           ImageInfo **p_info,
329
                           bool flat,
330
                           bool skip_implicit_filters,
331
                           Error **errp)
332
{
333
    ERRP_GUARD();
334
    ImageInfo *info;
335

336
    info = g_new0(ImageInfo, 1);
337
    bdrv_do_query_node_info(bs, qapi_ImageInfo_base(info), errp);
338
    if (*errp) {
339
        goto fail;
340
    }
341

342
    if (!flat) {
343
        BlockDriverState *backing;
344

345
        /*
346
         * Use any filtered child here (for backwards compatibility to when
347
         * we always took bs->backing, which might be any filtered child).
348
         */
349
        backing = bdrv_filter_or_cow_bs(bs);
350
        if (skip_implicit_filters) {
351
            backing = bdrv_skip_implicit_filters(backing);
352
        }
353

354
        if (backing) {
355
            bdrv_query_image_info(backing, &info->backing_image, false,
356
                                  skip_implicit_filters, errp);
357
            if (*errp) {
358
                goto fail;
359
            }
360
        }
361
    }
362

363
    *p_info = info;
364
    return;
365

366
fail:
367
    assert(*errp);
368
    qapi_free_ImageInfo(info);
369
}
370

371
/**
372
 * bdrv_query_block_graph_info:
373
 * @bs: root node to start from
374
 * @p_info: location to store image information
375
 * @errp: location to store error information
376
 *
377
 * Store image information about the graph starting from @bs in @p_info.
378
 *
379
 * @p_info will be set only on success. On error, store error in @errp.
380
 */
381
void bdrv_query_block_graph_info(BlockDriverState *bs,
382
                                 BlockGraphInfo **p_info,
383
                                 Error **errp)
384
{
385
    ERRP_GUARD();
386
    BlockGraphInfo *info;
387
    BlockChildInfoList **children_list_tail;
388
    BdrvChild *c;
389

390
    info = g_new0(BlockGraphInfo, 1);
391
    bdrv_do_query_node_info(bs, qapi_BlockGraphInfo_base(info), errp);
392
    if (*errp) {
393
        goto fail;
394
    }
395

396
    children_list_tail = &info->children;
397

398
    QLIST_FOREACH(c, &bs->children, next) {
399
        BlockChildInfo *c_info;
400

401
        c_info = g_new0(BlockChildInfo, 1);
402
        QAPI_LIST_APPEND(children_list_tail, c_info);
403

404
        c_info->name = g_strdup(c->name);
405
        bdrv_query_block_graph_info(c->bs, &c_info->info, errp);
406
        if (*errp) {
407
            goto fail;
408
        }
409
    }
410

411
    *p_info = info;
412
    return;
413

414
fail:
415
    assert(*errp != NULL);
416
    qapi_free_BlockGraphInfo(info);
417
}
418

419
/* @p_info will be set only on success. */
420
static void GRAPH_RDLOCK
421
bdrv_query_info(BlockBackend *blk, BlockInfo **p_info, Error **errp)
422
{
423
    BlockInfo *info = g_malloc0(sizeof(*info));
424
    BlockDriverState *bs = blk_bs(blk);
425
    char *qdev;
426

427
    /* Skip automatically inserted nodes that the user isn't aware of */
428
    bs = bdrv_skip_implicit_filters(bs);
429

430
    info->device = g_strdup(blk_name(blk));
431
    info->type = g_strdup("unknown");
432
    info->locked = blk_dev_is_medium_locked(blk);
433
    info->removable = blk_dev_has_removable_media(blk);
434

435
    qdev = blk_get_attached_dev_id(blk);
436
    if (qdev && *qdev) {
437
        info->qdev = qdev;
438
    } else {
439
        g_free(qdev);
440
    }
441

442
    if (blk_dev_has_tray(blk)) {
443
        info->has_tray_open = true;
444
        info->tray_open = blk_dev_is_tray_open(blk);
445
    }
446

447
    if (blk_iostatus_is_enabled(blk)) {
448
        info->has_io_status = true;
449
        info->io_status = blk_iostatus(blk);
450
    }
451

452
    if (bs && bs->drv) {
453
        info->inserted = bdrv_block_device_info(blk, bs, false, errp);
454
        if (info->inserted == NULL) {
455
            goto err;
456
        }
457
    }
458

459
    *p_info = info;
460
    return;
461

462
 err:
463
    qapi_free_BlockInfo(info);
464
}
465

466
static uint64List *uint64_list(uint64_t *list, int size)
467
{
468
    int i;
469
    uint64List *out_list = NULL;
470
    uint64List **tail = &out_list;
471

472
    for (i = 0; i < size; i++) {
473
        QAPI_LIST_APPEND(tail, list[i]);
474
    }
475

476
    return out_list;
477
}
478

479
static BlockLatencyHistogramInfo *
480
bdrv_latency_histogram_stats(BlockLatencyHistogram *hist)
481
{
482
    BlockLatencyHistogramInfo *info;
483

484
    if (!hist->bins) {
485
        return NULL;
486
    }
487

488
    info = g_new0(BlockLatencyHistogramInfo, 1);
489
    info->boundaries = uint64_list(hist->boundaries, hist->nbins - 1);
490
    info->bins = uint64_list(hist->bins, hist->nbins);
491
    return info;
492
}
493

494
static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
495
{
496
    BlockAcctStats *stats = blk_get_stats(blk);
497
    BlockAcctTimedStats *ts = NULL;
498
    BlockLatencyHistogram *hgram;
499

500
    ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ];
501
    ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE];
502
    ds->zone_append_bytes = stats->nr_bytes[BLOCK_ACCT_ZONE_APPEND];
503
    ds->unmap_bytes = stats->nr_bytes[BLOCK_ACCT_UNMAP];
504
    ds->rd_operations = stats->nr_ops[BLOCK_ACCT_READ];
505
    ds->wr_operations = stats->nr_ops[BLOCK_ACCT_WRITE];
506
    ds->zone_append_operations = stats->nr_ops[BLOCK_ACCT_ZONE_APPEND];
507
    ds->unmap_operations = stats->nr_ops[BLOCK_ACCT_UNMAP];
508

509
    ds->failed_rd_operations = stats->failed_ops[BLOCK_ACCT_READ];
510
    ds->failed_wr_operations = stats->failed_ops[BLOCK_ACCT_WRITE];
511
    ds->failed_zone_append_operations =
512
        stats->failed_ops[BLOCK_ACCT_ZONE_APPEND];
513
    ds->failed_flush_operations = stats->failed_ops[BLOCK_ACCT_FLUSH];
514
    ds->failed_unmap_operations = stats->failed_ops[BLOCK_ACCT_UNMAP];
515

516
    ds->invalid_rd_operations = stats->invalid_ops[BLOCK_ACCT_READ];
517
    ds->invalid_wr_operations = stats->invalid_ops[BLOCK_ACCT_WRITE];
518
    ds->invalid_zone_append_operations =
519
        stats->invalid_ops[BLOCK_ACCT_ZONE_APPEND];
520
    ds->invalid_flush_operations =
521
        stats->invalid_ops[BLOCK_ACCT_FLUSH];
522
    ds->invalid_unmap_operations = stats->invalid_ops[BLOCK_ACCT_UNMAP];
523

524
    ds->rd_merged = stats->merged[BLOCK_ACCT_READ];
525
    ds->wr_merged = stats->merged[BLOCK_ACCT_WRITE];
526
    ds->zone_append_merged = stats->merged[BLOCK_ACCT_ZONE_APPEND];
527
    ds->unmap_merged = stats->merged[BLOCK_ACCT_UNMAP];
528
    ds->flush_operations = stats->nr_ops[BLOCK_ACCT_FLUSH];
529
    ds->wr_total_time_ns = stats->total_time_ns[BLOCK_ACCT_WRITE];
530
    ds->zone_append_total_time_ns =
531
        stats->total_time_ns[BLOCK_ACCT_ZONE_APPEND];
532
    ds->rd_total_time_ns = stats->total_time_ns[BLOCK_ACCT_READ];
533
    ds->flush_total_time_ns = stats->total_time_ns[BLOCK_ACCT_FLUSH];
534
    ds->unmap_total_time_ns = stats->total_time_ns[BLOCK_ACCT_UNMAP];
535

536
    ds->has_idle_time_ns = stats->last_access_time_ns > 0;
537
    if (ds->has_idle_time_ns) {
538
        ds->idle_time_ns = block_acct_idle_time_ns(stats);
539
    }
540

541
    ds->account_invalid = stats->account_invalid;
542
    ds->account_failed = stats->account_failed;
543

544
    while ((ts = block_acct_interval_next(stats, ts))) {
545
        BlockDeviceTimedStats *dev_stats = g_malloc0(sizeof(*dev_stats));
546

547
        TimedAverage *rd = &ts->latency[BLOCK_ACCT_READ];
548
        TimedAverage *wr = &ts->latency[BLOCK_ACCT_WRITE];
549
        TimedAverage *zap = &ts->latency[BLOCK_ACCT_ZONE_APPEND];
550
        TimedAverage *fl = &ts->latency[BLOCK_ACCT_FLUSH];
551

552
        dev_stats->interval_length = ts->interval_length;
553

554
        dev_stats->min_rd_latency_ns = timed_average_min(rd);
555
        dev_stats->max_rd_latency_ns = timed_average_max(rd);
556
        dev_stats->avg_rd_latency_ns = timed_average_avg(rd);
557

558
        dev_stats->min_wr_latency_ns = timed_average_min(wr);
559
        dev_stats->max_wr_latency_ns = timed_average_max(wr);
560
        dev_stats->avg_wr_latency_ns = timed_average_avg(wr);
561

562
        dev_stats->min_zone_append_latency_ns = timed_average_min(zap);
563
        dev_stats->max_zone_append_latency_ns = timed_average_max(zap);
564
        dev_stats->avg_zone_append_latency_ns = timed_average_avg(zap);
565

566
        dev_stats->min_flush_latency_ns = timed_average_min(fl);
567
        dev_stats->max_flush_latency_ns = timed_average_max(fl);
568
        dev_stats->avg_flush_latency_ns = timed_average_avg(fl);
569

570
        dev_stats->avg_rd_queue_depth =
571
            block_acct_queue_depth(ts, BLOCK_ACCT_READ);
572
        dev_stats->avg_wr_queue_depth =
573
            block_acct_queue_depth(ts, BLOCK_ACCT_WRITE);
574
        dev_stats->avg_zone_append_queue_depth =
575
            block_acct_queue_depth(ts, BLOCK_ACCT_ZONE_APPEND);
576

577
        QAPI_LIST_PREPEND(ds->timed_stats, dev_stats);
578
    }
579

580
    hgram = stats->latency_histogram;
581
    ds->rd_latency_histogram
582
        = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_READ]);
583
    ds->wr_latency_histogram
584
        = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_WRITE]);
585
    ds->zone_append_latency_histogram
586
        = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_ZONE_APPEND]);
587
    ds->flush_latency_histogram
588
        = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_FLUSH]);
589
}
590

591
static BlockStats * GRAPH_RDLOCK
592
bdrv_query_bds_stats(BlockDriverState *bs, bool blk_level)
593
{
594
    BdrvChild *parent_child;
595
    BlockDriverState *filter_or_cow_bs;
596
    BlockStats *s = NULL;
597

598
    s = g_malloc0(sizeof(*s));
599
    s->stats = g_malloc0(sizeof(*s->stats));
600

601
    if (!bs) {
602
        return s;
603
    }
604

605
    /* Skip automatically inserted nodes that the user isn't aware of in
606
     * a BlockBackend-level command. Stay at the exact node for a node-level
607
     * command. */
608
    if (blk_level) {
609
        bs = bdrv_skip_implicit_filters(bs);
610
    }
611

612
    if (bdrv_get_node_name(bs)[0]) {
613
        s->node_name = g_strdup(bdrv_get_node_name(bs));
614
    }
615

616
    s->stats->wr_highest_offset = stat64_get(&bs->wr_highest_offset);
617

618
    s->driver_specific = bdrv_get_specific_stats(bs);
619

620
    parent_child = bdrv_primary_child(bs);
621
    if (!parent_child ||
622
        !(parent_child->role & (BDRV_CHILD_DATA | BDRV_CHILD_FILTERED)))
623
    {
624
        BdrvChild *c;
625

626
        /*
627
         * Look for a unique data-storing child.  We do not need to look for
628
         * filtered children, as there would be only one and it would have been
629
         * the primary child.
630
         */
631
        parent_child = NULL;
632
        QLIST_FOREACH(c, &bs->children, next) {
633
            if (c->role & BDRV_CHILD_DATA) {
634
                if (parent_child) {
635
                    /*
636
                     * There are multiple data-storing children and we cannot
637
                     * choose between them.
638
                     */
639
                    parent_child = NULL;
640
                    break;
641
                }
642
                parent_child = c;
643
            }
644
        }
645
    }
646
    if (parent_child) {
647
        s->parent = bdrv_query_bds_stats(parent_child->bs, blk_level);
648
    }
649

650
    filter_or_cow_bs = bdrv_filter_or_cow_bs(bs);
651
    if (blk_level && filter_or_cow_bs) {
652
        /*
653
         * Put any filtered or COW child here (for backwards
654
         * compatibility to when we put bs0->backing here, which might
655
         * be either)
656
         */
657
        s->backing = bdrv_query_bds_stats(filter_or_cow_bs, blk_level);
658
    }
659

660
    return s;
661
}
662

663
BlockInfoList *qmp_query_block(Error **errp)
664
{
665
    BlockInfoList *head = NULL, **p_next = &head;
666
    BlockBackend *blk;
667
    Error *local_err = NULL;
668

669
    GRAPH_RDLOCK_GUARD_MAINLOOP();
670

671
    for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
672
        BlockInfoList *info;
673

674
        if (!*blk_name(blk) && !blk_get_attached_dev(blk)) {
675
            continue;
676
        }
677

678
        info = g_malloc0(sizeof(*info));
679
        bdrv_query_info(blk, &info->value, &local_err);
680
        if (local_err) {
681
            error_propagate(errp, local_err);
682
            g_free(info);
683
            qapi_free_BlockInfoList(head);
684
            return NULL;
685
        }
686

687
        *p_next = info;
688
        p_next = &info->next;
689
    }
690

691
    return head;
692
}
693

694
BlockStatsList *qmp_query_blockstats(bool has_query_nodes,
695
                                     bool query_nodes,
696
                                     Error **errp)
697
{
698
    BlockStatsList *head = NULL, **tail = &head;
699
    BlockBackend *blk;
700
    BlockDriverState *bs;
701

702
    GRAPH_RDLOCK_GUARD_MAINLOOP();
703

704
    /* Just to be safe if query_nodes is not always initialized */
705
    if (has_query_nodes && query_nodes) {
706
        for (bs = bdrv_next_node(NULL); bs; bs = bdrv_next_node(bs)) {
707
            QAPI_LIST_APPEND(tail, bdrv_query_bds_stats(bs, false));
708
        }
709
    } else {
710
        for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
711
            BlockStats *s;
712
            char *qdev;
713

714
            if (!*blk_name(blk) && !blk_get_attached_dev(blk)) {
715
                continue;
716
            }
717

718
            s = bdrv_query_bds_stats(blk_bs(blk), true);
719
            s->device = g_strdup(blk_name(blk));
720

721
            qdev = blk_get_attached_dev_id(blk);
722
            if (qdev && *qdev) {
723
                s->qdev = qdev;
724
            } else {
725
                g_free(qdev);
726
            }
727

728
            bdrv_query_blk_stats(s->stats, blk);
729

730
            QAPI_LIST_APPEND(tail, s);
731
        }
732
    }
733

734
    return head;
735
}
736

737
void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
738
{
739
    char clock_buf[128];
740
    char icount_buf[128] = {0};
741
    int64_t secs;
742
    char *sizing = NULL;
743

744
    if (!sn) {
745
        qemu_printf("%-7s %-16s %8s %19s %15s %10s",
746
                    "ID", "TAG", "VM_SIZE", "DATE", "VM_CLOCK", "ICOUNT");
747
    } else {
748
        g_autoptr(GDateTime) date = g_date_time_new_from_unix_local(sn->date_sec);
749
        g_autofree char *date_buf = g_date_time_format(date, "%Y-%m-%d %H:%M:%S");
750

751
        secs = sn->vm_clock_nsec / 1000000000;
752
        snprintf(clock_buf, sizeof(clock_buf),
753
                 "%04d:%02d:%02d.%03d",
754
                 (int)(secs / 3600),
755
                 (int)((secs / 60) % 60),
756
                 (int)(secs % 60),
757
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
758
        sizing = size_to_str(sn->vm_state_size);
759
        if (sn->icount != -1ULL) {
760
            snprintf(icount_buf, sizeof(icount_buf),
761
                "%"PRId64, sn->icount);
762
        } else {
763
            snprintf(icount_buf, sizeof(icount_buf), "--");
764
        }
765
        qemu_printf("%-7s %-16s %8s %19s %15s %10s",
766
                    sn->id_str, sn->name,
767
                    sizing,
768
                    date_buf,
769
                    clock_buf,
770
                    icount_buf);
771
    }
772
    g_free(sizing);
773
}
774

775
static void dump_qdict(int indentation, QDict *dict);
776
static void dump_qlist(int indentation, QList *list);
777

778
static void dump_qobject(int comp_indent, QObject *obj)
779
{
780
    switch (qobject_type(obj)) {
781
        case QTYPE_QNUM: {
782
            QNum *value = qobject_to(QNum, obj);
783
            char *tmp = qnum_to_string(value);
784
            qemu_printf("%s", tmp);
785
            g_free(tmp);
786
            break;
787
        }
788
        case QTYPE_QSTRING: {
789
            QString *value = qobject_to(QString, obj);
790
            qemu_printf("%s", qstring_get_str(value));
791
            break;
792
        }
793
        case QTYPE_QDICT: {
794
            QDict *value = qobject_to(QDict, obj);
795
            dump_qdict(comp_indent, value);
796
            break;
797
        }
798
        case QTYPE_QLIST: {
799
            QList *value = qobject_to(QList, obj);
800
            dump_qlist(comp_indent, value);
801
            break;
802
        }
803
        case QTYPE_QBOOL: {
804
            QBool *value = qobject_to(QBool, obj);
805
            qemu_printf("%s", qbool_get_bool(value) ? "true" : "false");
806
            break;
807
        }
808
        default:
809
            abort();
810
    }
811
}
812

813
static void dump_qlist(int indentation, QList *list)
814
{
815
    const QListEntry *entry;
816
    int i = 0;
817

818
    for (entry = qlist_first(list); entry; entry = qlist_next(entry), i++) {
819
        QType type = qobject_type(entry->value);
820
        bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST);
821
        qemu_printf("%*s[%i]:%c", indentation * 4, "", i,
822
                    composite ? '\n' : ' ');
823
        dump_qobject(indentation + 1, entry->value);
824
        if (!composite) {
825
            qemu_printf("\n");
826
        }
827
    }
828
}
829

830
static void dump_qdict(int indentation, QDict *dict)
831
{
832
    const QDictEntry *entry;
833

834
    for (entry = qdict_first(dict); entry; entry = qdict_next(dict, entry)) {
835
        QType type = qobject_type(entry->value);
836
        bool composite = (type == QTYPE_QDICT || type == QTYPE_QLIST);
837
        char *key = g_malloc(strlen(entry->key) + 1);
838
        int i;
839

840
        /* replace dashes with spaces in key (variable) names */
841
        for (i = 0; entry->key[i]; i++) {
842
            key[i] = entry->key[i] == '-' ? ' ' : entry->key[i];
843
        }
844
        key[i] = 0;
845
        qemu_printf("%*s%s:%c", indentation * 4, "", key,
846
                    composite ? '\n' : ' ');
847
        dump_qobject(indentation + 1, entry->value);
848
        if (!composite) {
849
            qemu_printf("\n");
850
        }
851
        g_free(key);
852
    }
853
}
854

855
/*
856
 * Return whether dumping the given QObject with dump_qobject() would
857
 * yield an empty dump, i.e. not print anything.
858
 */
859
static bool qobject_is_empty_dump(const QObject *obj)
860
{
861
    switch (qobject_type(obj)) {
862
    case QTYPE_QNUM:
863
    case QTYPE_QSTRING:
864
    case QTYPE_QBOOL:
865
        return false;
866

867
    case QTYPE_QDICT:
868
        return qdict_size(qobject_to(QDict, obj)) == 0;
869

870
    case QTYPE_QLIST:
871
        return qlist_empty(qobject_to(QList, obj));
872

873
    default:
874
        abort();
875
    }
876
}
877

878
/**
879
 * Dumps the given ImageInfoSpecific object in a human-readable form,
880
 * prepending an optional prefix if the dump is not empty.
881
 */
882
void bdrv_image_info_specific_dump(ImageInfoSpecific *info_spec,
883
                                   const char *prefix,
884
                                   int indentation)
885
{
886
    QObject *obj, *data;
887
    Visitor *v = qobject_output_visitor_new(&obj);
888

889
    visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort);
890
    visit_complete(v, &obj);
891
    data = qdict_get(qobject_to(QDict, obj), "data");
892
    if (!qobject_is_empty_dump(data)) {
893
        if (prefix) {
894
            qemu_printf("%*s%s", indentation * 4, "", prefix);
895
        }
896
        dump_qobject(indentation + 1, data);
897
    }
898
    qobject_unref(obj);
899
    visit_free(v);
900
}
901

902
/**
903
 * Print the given @info object in human-readable form.  Every field is indented
904
 * using the given @indentation (four spaces per indentation level).
905
 *
906
 * When using this to print a whole block graph, @protocol can be set to true to
907
 * signify that the given information is associated with a protocol node, i.e.
908
 * just data storage for an image, such that the data it presents is not really
909
 * a full VM disk.  If so, several fields change name: For example, "virtual
910
 * size" is printed as "file length".
911
 * (Consider a qcow2 image, which is represented by a qcow2 node and a file
912
 * node.  Printing a "virtual size" for the file node does not make sense,
913
 * because without the qcow2 node, it is not really a guest disk, so it does not
914
 * have a "virtual size".  Therefore, we call it "file length" instead.)
915
 *
916
 * @protocol is ignored when @indentation is 0, because we take that to mean
917
 * that the associated node is the root node in the queried block graph, and
918
 * thus is always to be interpreted as a standalone guest disk.
919
 */
920
void bdrv_node_info_dump(BlockNodeInfo *info, int indentation, bool protocol)
921
{
922
    char *size_buf, *dsize_buf;
923
    g_autofree char *ind_s = g_strdup_printf("%*s", indentation * 4, "");
924

925
    if (indentation == 0) {
926
        /* Top level, consider this a normal image */
927
        protocol = false;
928
    }
929

930
    if (!info->has_actual_size) {
931
        dsize_buf = g_strdup("unavailable");
932
    } else {
933
        dsize_buf = size_to_str(info->actual_size);
934
    }
935
    size_buf = size_to_str(info->virtual_size);
936
    qemu_printf("%s%s: %s\n"
937
                "%s%s: %s\n"
938
                "%s%s: %s (%" PRId64 " bytes)\n"
939
                "%sdisk size: %s\n",
940
                ind_s, protocol ? "filename" : "image", info->filename,
941
                ind_s, protocol ? "protocol type" : "file format",
942
                info->format,
943
                ind_s, protocol ? "file length" : "virtual size",
944
                size_buf, info->virtual_size,
945
                ind_s, dsize_buf);
946
    g_free(size_buf);
947
    g_free(dsize_buf);
948

949
    if (info->has_encrypted && info->encrypted) {
950
        qemu_printf("%sencrypted: yes\n", ind_s);
951
    }
952

953
    if (info->has_cluster_size) {
954
        qemu_printf("%scluster_size: %" PRId64 "\n",
955
                    ind_s, info->cluster_size);
956
    }
957

958
    if (info->has_dirty_flag && info->dirty_flag) {
959
        qemu_printf("%scleanly shut down: no\n", ind_s);
960
    }
961

962
    if (info->backing_filename) {
963
        qemu_printf("%sbacking file: %s", ind_s, info->backing_filename);
964
        if (!info->full_backing_filename) {
965
            qemu_printf(" (cannot determine actual path)");
966
        } else if (strcmp(info->backing_filename,
967
                          info->full_backing_filename) != 0) {
968
            qemu_printf(" (actual path: %s)", info->full_backing_filename);
969
        }
970
        qemu_printf("\n");
971
        if (info->backing_filename_format) {
972
            qemu_printf("%sbacking file format: %s\n",
973
                        ind_s, info->backing_filename_format);
974
        }
975
    }
976

977
    if (info->has_snapshots) {
978
        SnapshotInfoList *elem;
979

980
        qemu_printf("%sSnapshot list:\n", ind_s);
981
        qemu_printf("%s", ind_s);
982
        bdrv_snapshot_dump(NULL);
983
        qemu_printf("\n");
984

985
        /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
986
         * we convert to the block layer's native QEMUSnapshotInfo for now.
987
         */
988
        for (elem = info->snapshots; elem; elem = elem->next) {
989
            QEMUSnapshotInfo sn = {
990
                .vm_state_size = elem->value->vm_state_size,
991
                .date_sec = elem->value->date_sec,
992
                .date_nsec = elem->value->date_nsec,
993
                .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
994
                                 elem->value->vm_clock_nsec,
995
                .icount = elem->value->has_icount ?
996
                          elem->value->icount : -1ULL,
997
            };
998

999
            pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
1000
            pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
1001
            qemu_printf("%s", ind_s);
1002
            bdrv_snapshot_dump(&sn);
1003
            qemu_printf("\n");
1004
        }
1005
    }
1006

1007
    if (info->format_specific) {
1008
        bdrv_image_info_specific_dump(info->format_specific,
1009
                                      "Format specific information:\n",
1010
                                      indentation);
1011
    }
1012
}
1013