xref: /openbmc/qemu/stats/stats-hmp-cmds.c (revision f2b90109)
1 /*
2  * HMP commands related to stats
3  *
4  * This work is licensed under the terms of the GNU GPL, version 2 or
5  * (at your option) any later version.
6  */
7 
8 #include "qemu/osdep.h"
9 #include "qapi/qapi-commands-stats.h"
10 #include "monitor/hmp.h"
11 #include "monitor/monitor.h"
12 #include "qemu/cutils.h"
13 #include "hw/core/cpu.h"
14 #include "qapi/qmp/qdict.h"
15 #include "qapi/error.h"
16 
print_stats_schema_value(Monitor * mon,StatsSchemaValue * value)17 static void print_stats_schema_value(Monitor *mon, StatsSchemaValue *value)
18 {
19     const char *unit = NULL;
20     monitor_printf(mon, "    %s (%s%s", value->name, StatsType_str(value->type),
21                    value->has_unit || value->exponent ? ", " : "");
22 
23     if (value->has_unit) {
24         if (value->unit == STATS_UNIT_SECONDS) {
25             unit = "s";
26         } else if (value->unit == STATS_UNIT_BYTES) {
27             unit = "B";
28         }
29     }
30 
31     if (unit && value->base == 10 &&
32         value->exponent >= -18 && value->exponent <= 18 &&
33         value->exponent % 3 == 0) {
34         monitor_puts(mon, si_prefix(value->exponent));
35     } else if (unit && value->base == 2 &&
36                value->exponent >= 0 && value->exponent <= 60 &&
37                value->exponent % 10 == 0) {
38 
39         monitor_puts(mon, iec_binary_prefix(value->exponent));
40     } else if (value->exponent) {
41         /* Use exponential notation and write the unit's English name */
42         monitor_printf(mon, "* %d^%d%s",
43                        value->base, value->exponent,
44                        value->has_unit ? " " : "");
45         unit = NULL;
46     }
47 
48     if (value->has_unit) {
49         monitor_puts(mon, unit ? unit : StatsUnit_str(value->unit));
50     }
51 
52     /* Print bucket size for linear histograms */
53     if (value->type == STATS_TYPE_LINEAR_HISTOGRAM && value->has_bucket_size) {
54         monitor_printf(mon, ", bucket size=%d", value->bucket_size);
55     }
56     monitor_printf(mon, ")");
57 }
58 
find_schema_value_list(StatsSchemaList * list,StatsProvider provider,StatsTarget target)59 static StatsSchemaValueList *find_schema_value_list(
60     StatsSchemaList *list, StatsProvider provider,
61     StatsTarget target)
62 {
63     StatsSchemaList *node;
64 
65     for (node = list; node; node = node->next) {
66         if (node->value->provider == provider &&
67             node->value->target == target) {
68             return node->value->stats;
69         }
70     }
71     return NULL;
72 }
73 
print_stats_results(Monitor * mon,StatsTarget target,bool show_provider,StatsResult * result,StatsSchemaList * schema)74 static void print_stats_results(Monitor *mon, StatsTarget target,
75                                 bool show_provider,
76                                 StatsResult *result,
77                                 StatsSchemaList *schema)
78 {
79     /* Find provider schema */
80     StatsSchemaValueList *schema_value_list =
81         find_schema_value_list(schema, result->provider, target);
82     StatsList *stats_list;
83 
84     if (!schema_value_list) {
85         monitor_printf(mon, "failed to find schema list for %s\n",
86                        StatsProvider_str(result->provider));
87         return;
88     }
89 
90     if (show_provider) {
91         monitor_printf(mon, "provider: %s\n",
92                        StatsProvider_str(result->provider));
93     }
94 
95     for (stats_list = result->stats; stats_list;
96              stats_list = stats_list->next,
97              schema_value_list = schema_value_list->next) {
98 
99         Stats *stats = stats_list->value;
100         StatsValue *stats_value = stats->value;
101         StatsSchemaValue *schema_value = schema_value_list->value;
102 
103         /* Find schema entry */
104         while (!g_str_equal(stats->name, schema_value->name)) {
105             if (!schema_value_list->next) {
106                 monitor_printf(mon, "failed to find schema entry for %s\n",
107                                stats->name);
108                 return;
109             }
110             schema_value_list = schema_value_list->next;
111             schema_value = schema_value_list->value;
112         }
113 
114         print_stats_schema_value(mon, schema_value);
115 
116         if (stats_value->type == QTYPE_QNUM) {
117             monitor_printf(mon, ": %" PRId64 "\n", stats_value->u.scalar);
118         } else if (stats_value->type == QTYPE_QBOOL) {
119             monitor_printf(mon, ": %s\n", stats_value->u.boolean ? "yes" : "no");
120         } else if (stats_value->type == QTYPE_QLIST) {
121             uint64List *list;
122             int i;
123 
124             monitor_printf(mon, ": ");
125             for (list = stats_value->u.list, i = 1;
126                  list;
127                  list = list->next, i++) {
128                 monitor_printf(mon, "[%d]=%" PRId64 " ", i, list->value);
129             }
130             monitor_printf(mon, "\n");
131         }
132     }
133 }
134 
135 /* Create the StatsFilter that is needed for an "info stats" invocation.  */
stats_filter(StatsTarget target,const char * names,int cpu_index,StatsProvider provider)136 static StatsFilter *stats_filter(StatsTarget target, const char *names,
137                                  int cpu_index, StatsProvider provider)
138 {
139     StatsFilter *filter = g_malloc0(sizeof(*filter));
140     StatsProvider provider_idx;
141     StatsRequestList *request_list = NULL;
142 
143     filter->target = target;
144     switch (target) {
145     case STATS_TARGET_VM:
146         break;
147     case STATS_TARGET_VCPU:
148     {
149         strList *vcpu_list = NULL;
150         CPUState *cpu = qemu_get_cpu(cpu_index);
151         char *canonical_path = object_get_canonical_path(OBJECT(cpu));
152 
153         QAPI_LIST_PREPEND(vcpu_list, canonical_path);
154         filter->u.vcpu.has_vcpus = true;
155         filter->u.vcpu.vcpus = vcpu_list;
156         break;
157     }
158     case STATS_TARGET_CRYPTODEV:
159         break;
160     default:
161         break;
162     }
163 
164     if (!names && provider == STATS_PROVIDER__MAX) {
165         return filter;
166     }
167 
168     /*
169      * "info stats" can only query either one or all the providers.  Querying
170      * by name, but not by provider, requires the creation of one filter per
171      * provider.
172      */
173     for (provider_idx = 0; provider_idx < STATS_PROVIDER__MAX; provider_idx++) {
174         if (provider == STATS_PROVIDER__MAX || provider == provider_idx) {
175             StatsRequest *request = g_new0(StatsRequest, 1);
176             request->provider = provider_idx;
177             if (names && !g_str_equal(names, "*")) {
178                 request->has_names = true;
179                 request->names = hmp_split_at_comma(names);
180             }
181             QAPI_LIST_PREPEND(request_list, request);
182         }
183     }
184 
185     filter->has_providers = true;
186     filter->providers = request_list;
187     return filter;
188 }
189 
hmp_info_stats(Monitor * mon,const QDict * qdict)190 void hmp_info_stats(Monitor *mon, const QDict *qdict)
191 {
192     const char *target_str = qdict_get_str(qdict, "target");
193     const char *provider_str = qdict_get_try_str(qdict, "provider");
194     const char *names = qdict_get_try_str(qdict, "names");
195 
196     StatsProvider provider = STATS_PROVIDER__MAX;
197     StatsTarget target;
198     Error *err = NULL;
199     g_autoptr(StatsSchemaList) schema = NULL;
200     g_autoptr(StatsResultList) stats = NULL;
201     g_autoptr(StatsFilter) filter = NULL;
202     StatsResultList *entry;
203 
204     target = qapi_enum_parse(&StatsTarget_lookup, target_str, -1, &err);
205     if (err) {
206         monitor_printf(mon, "invalid stats target %s\n", target_str);
207         goto exit_no_print;
208     }
209     if (provider_str) {
210         provider = qapi_enum_parse(&StatsProvider_lookup, provider_str, -1, &err);
211         if (err) {
212             monitor_printf(mon, "invalid stats provider %s\n", provider_str);
213             goto exit_no_print;
214         }
215     }
216 
217     schema = qmp_query_stats_schemas(provider_str ? true : false,
218                                      provider, &err);
219     if (err) {
220         goto exit;
221     }
222 
223     switch (target) {
224     case STATS_TARGET_VM:
225         filter = stats_filter(target, names, -1, provider);
226         break;
227     case STATS_TARGET_VCPU: {}
228         int cpu_index = monitor_get_cpu_index(mon);
229         filter = stats_filter(target, names, cpu_index, provider);
230         break;
231     case STATS_TARGET_CRYPTODEV:
232         filter = stats_filter(target, names, -1, provider);
233         break;
234     default:
235         abort();
236     }
237 
238     stats = qmp_query_stats(filter, &err);
239     if (err) {
240         goto exit;
241     }
242     for (entry = stats; entry; entry = entry->next) {
243         print_stats_results(mon, target, provider_str == NULL, entry->value, schema);
244     }
245 
246 exit:
247     if (err) {
248         monitor_printf(mon, "%s\n", error_get_pretty(err));
249     }
250 exit_no_print:
251     error_free(err);
252 }
253