xref: /aosp_15_r20/external/bcc/tools/virtiostat.py (revision 387f9dfdfa2baef462e92476d413c7bc2470293e) 
1#!/usr/bin/env python
2# @lint-avoid-python-3-compatibility-imports
3#
4# virtiostat    Show virtio devices input/output statistics.
5#               For Linux, uses BCC, eBPF.
6#
7# USAGE: virtiostat [-h] [-T] [-D] [-d DRIVER] [-n DEVNAME] [INTERVAL] [COUNT]
8#
9# Copyright (c) 2021 zhenwei pi
10# Licensed under the Apache License, Version 2.0 (the "License")
11#
12# 13-Feb-2021  zhenwei pi  Created this.
13
14from __future__ import print_function
15from bcc import BPF
16from time import sleep, strftime
17import argparse
18
19# arguments
20examples = """examples:
21    ./virtiostat                 # print 3(default) second summaries
22    ./virtiostat  1  10          # print 1 second summaries, 10 times
23    ./virtiostat -T              # show timestamps
24    ./virtiostat -d virtio_blk   # only show virtio block devices
25    ./virtiostat -n virtio0      # only show virtio0 device
26    ./virtiostat -D              # show debug bpf text
27"""
28parser = argparse.ArgumentParser(
29    description="Show virtio devices input/output statistics",
30    formatter_class=argparse.RawDescriptionHelpFormatter,
31    epilog=examples)
32parser.add_argument("interval", nargs="?", default=3,
33    help="output interval, in seconds")
34parser.add_argument("count", nargs="?", default=99999999,
35    help="number of outputs")
36parser.add_argument("-T", "--timestamp", action="store_true",
37    help="show timestamp on output")
38parser.add_argument("-d", "--driver",
39    help="filter for driver name")
40parser.add_argument("-n", "--devname",
41    help="filter for device name")
42parser.add_argument("-D", "--debug", action="store_true",
43    help="print BPF program before starting (for debugging purposes)")
44parser.add_argument("--ebpf", action="store_true",
45    help=argparse.SUPPRESS)
46args = parser.parse_args()
47
48# define BPF program
49bpf_text = """
50#include <linux/virtio.h>
51#include <bcc/proto.h>
52
53/* typically virtio scsi has max SGs of 6 */
54#define VIRTIO_MAX_SGS  6
55/* typically virtio blk has max SEG of 128 */
56#define SG_MAX          128
57
58/* local strcmp function, max length 16 to protect instruction loops */
59#define CMPMAX	16
60
61static int local_strcmp(const char *cs, const char *ct)
62{
63    int len = 0;
64    unsigned char c1, c2;
65
66    while (len++ < CMPMAX) {
67        c1 = *cs++;
68        c2 = *ct++;
69        if (c1 != c2)
70            return c1 < c2 ? -1 : 1;
71        if (!c1)
72            break;
73    }
74    return 0;
75}
76
77typedef struct virtio_stat {
78    char driver[16];
79    char dev[12];
80    char vqname[12];
81    u32 in_sgs;
82    u32 out_sgs;
83    u64 in_bw;
84    u64 out_bw;
85} virtio_stat_t;
86
87BPF_HASH(stats, u64, virtio_stat_t);
88
89static struct scatterlist *__sg_next(struct scatterlist *sgp)
90{
91    struct scatterlist sg;
92
93    bpf_probe_read_kernel(&sg, sizeof(sg), sgp);
94    if (sg_is_last(&sg))
95        return NULL;
96
97    sgp++;
98
99    bpf_probe_read_kernel(&sg, sizeof(sg), sgp);
100    if (unlikely(sg_is_chain(&sg)))
101        sgp = sg_chain_ptr(&sg);
102
103    return sgp;
104}
105
106static u64 count_len(struct scatterlist **sgs, unsigned int num)
107{
108    u64 length = 0;
109    unsigned int i, n;
110    struct scatterlist *sgp = NULL;
111
112    for (i = 0; (i < VIRTIO_MAX_SGS) && (i < num); i++) {
113        for (n = 0, sgp = sgs[i]; sgp && (n < SG_MAX); sgp = __sg_next(sgp)) {
114            length += sgp->length;
115            n++;
116        }
117
118        /* Suggested by Yonghong Song:
119         * IndVarSimplifyPass with clang 12 may cause verifier failure:
120         *   ; for (i = 0; (i < VIRTIO_MAX_SGS) && (i < num); i++) { // Line  60
121         *   90:   15 08 15 00 00 00 00 00 if r8 == 0 goto +21
122         *   91:   bf 81 00 00 00 00 00 00 r1 = r8
123         *   92:   07 01 00 00 ff ff ff ff r1 += -1
124         *   93:   67 01 00 00 20 00 00 00 r1 <<= 32
125         *   94:   77 01 00 00 20 00 00 00 r1 >>= 32
126         *   95:   b7 02 00 00 05 00 00 00 r2 = 5
127         *   96:   2d 12 01 00 00 00 00 00 if r2 > r1 goto +1
128         *   97:   b7 08 00 00 06 00 00 00 r8 = 6
129         *   98:   b7 02 00 00 00 00 00 00 r2 = 0
130         *   99:   b7 09 00 00 00 00 00 00 r9 = 0
131         *  100:   7b 8a 68 ff 00 00 00 00 *(u64 *)(r10 - 152) = r8
132         *  101:   05 00 35 00 00 00 00 00 goto +53
133         * Note that r1 is refined by r8 is saved to stack for later use.
134         * This will give verifier u64_max loop bound and eventually cause
135         * verification failure. Workaround with the below asm code.
136         */
137#if __clang_major__ >= 7
138        asm volatile("" : "=r"(i) : "0"(i));
139#endif
140    }
141
142    return length;
143}
144
145static void record(struct virtqueue *vq, struct scatterlist **sgs,
146                   unsigned int out_sgs, unsigned int in_sgs)
147{
148    virtio_stat_t newvs = {0};
149    virtio_stat_t *vs;
150    u64 key = (u64)vq;
151    u64 in_bw = 0;
152
153    DRIVERFILTER
154    DEVNAMEFILTER
155
156    /* Workaround: separate two count_len() calls, one here and the
157     * other below. Otherwise, compiler may generate some spills which
158     * harms verifier pruning. This happens in llvm12, but not llvm4.
159     * Below code works on both cases.
160     */
161    if (in_sgs)
162        in_bw = count_len(sgs + out_sgs, in_sgs);
163
164    vs = stats.lookup(&key);
165    if (!vs) {
166        bpf_probe_read_kernel_str(newvs.driver, sizeof(newvs.driver), vq->vdev->dev.driver->name);
167        bpf_probe_read_kernel_str(newvs.dev, sizeof(newvs.dev), vq->vdev->dev.kobj.name);
168        bpf_probe_read_kernel_str(newvs.vqname, sizeof(newvs.vqname), vq->name);
169        newvs.out_sgs = out_sgs;
170        newvs.in_sgs = in_sgs;
171        if (out_sgs)
172            newvs.out_bw = count_len(sgs, out_sgs);
173        newvs.in_bw = in_bw;
174        stats.update(&key, &newvs);
175    } else {
176        vs->out_sgs += out_sgs;
177        vs->in_sgs += in_sgs;
178        if (out_sgs)
179            vs->out_bw += count_len(sgs, out_sgs);
180        vs->in_bw += in_bw;
181    }
182}
183
184int trace_virtqueue_add_sgs(struct pt_regs *ctx, struct virtqueue *vq,
185                            struct scatterlist **sgs, unsigned int out_sgs,
186                            unsigned int in_sgs, void *data, gfp_t gfp)
187
188{
189    record(vq, sgs, out_sgs, in_sgs);
190
191    return 0;
192}
193
194int trace_virtqueue_add_outbuf(struct pt_regs *ctx, struct virtqueue *vq,
195                              struct scatterlist *sg, unsigned int num,
196                              void *data, gfp_t gfp)
197{
198    record(vq, &sg, 1, 0);
199
200    return 0;
201}
202
203int trace_virtqueue_add_inbuf(struct pt_regs *ctx, struct virtqueue *vq,
204                             struct scatterlist *sg, unsigned int num,
205                             void *data, gfp_t gfp)
206{
207    record(vq, &sg, 0, 1);
208
209    return 0;
210}
211
212int trace_virtqueue_add_inbuf_ctx(struct pt_regs *ctx, struct virtqueue *vq,
213                                  struct scatterlist *sg, unsigned int num,
214                                  void *data, void *_ctx, gfp_t gfp)
215{
216    record(vq, &sg, 0, 1);
217
218    return 0;
219}
220"""
221
222# filter for driver name
223if args.driver:
224    bpf_text = bpf_text.replace('DRIVERFILTER',
225        """char filter_driver[] = \"%s\";
226        char driver[16];
227        bpf_probe_read_kernel_str(driver, sizeof(driver), vq->vdev->dev.driver->name);
228        if (local_strcmp(filter_driver, driver))
229        return;""" % (args.driver))
230else:
231    bpf_text = bpf_text.replace('DRIVERFILTER', '')
232
233# filter for dev name
234if args.devname:
235    bpf_text = bpf_text.replace('DEVNAMEFILTER',
236        """char filter_devname[] = \"%s\";
237        char devname[16];
238        bpf_probe_read_kernel_str(devname, sizeof(devname), vq->vdev->dev.kobj.name);
239        if (local_strcmp(filter_devname, devname))
240        return;""" % (args.devname))
241else:
242    bpf_text = bpf_text.replace('DEVNAMEFILTER', '')
243
244
245# debug mode: print bpf text
246if args.debug:
247    print(bpf_text)
248
249# dump mode: print bpf text and exit
250if args.ebpf:
251    print(bpf_text)
252    exit()
253
254# load BPF program
255b = BPF(text=bpf_text)
256b.attach_kprobe(event="virtqueue_add_sgs", fn_name="trace_virtqueue_add_sgs")
257b.attach_kprobe(event="virtqueue_add_outbuf", fn_name="trace_virtqueue_add_outbuf")
258b.attach_kprobe(event="virtqueue_add_inbuf", fn_name="trace_virtqueue_add_inbuf")
259b.attach_kprobe(event="virtqueue_add_inbuf_ctx", fn_name="trace_virtqueue_add_inbuf_ctx")
260
261print("Tracing virtio devices statistics ... Hit Ctrl-C to end.")
262
263# start main loop
264exiting = 0 if args.interval else 1
265seconds = 0
266while (1):
267    try:
268        sleep(int(args.interval))
269        seconds = seconds + int(args.interval)
270    except KeyboardInterrupt:
271        exiting = 1
272
273    if args.timestamp:
274        print("%-8s\n" % strftime("%H:%M:%S"), end="")
275    else:
276        print("--------", end="\n")
277
278    print("%14s %8s %10s %7s %7s %14s %14s" % ("Driver", "Device", "VQ Name", "In SGs", "Out SGs", "In BW", "Out BW"))
279    stats = b.get_table("stats")
280    for k, v in sorted(stats.items(), key=lambda vs: vs[1].dev):
281        print("%14s %8s %10s %7d %7d %14d %14d" % (v.driver, v.dev, v.vqname, v.in_sgs, v.out_sgs, v.in_bw, v.out_bw))
282
283    stats.clear()
284
285    if exiting or seconds >= int(args.count):
286        exit()
287