]>
Commit | Line | Data |
---|---|---|
2025cf9e | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b18f3e36 AK |
2 | /* |
3 | * Copyright (c) 2017, Intel Corporation. | |
b18f3e36 AK |
4 | */ |
5 | ||
6 | /* Manage metrics and groups of metrics from JSON files */ | |
7 | ||
8 | #include "metricgroup.h" | |
b4209025 | 9 | #include "debug.h" |
b18f3e36 | 10 | #include "evlist.h" |
0b8026e8 | 11 | #include "evsel.h" |
b18f3e36 AK |
12 | #include "strbuf.h" |
13 | #include "pmu.h" | |
14 | #include "expr.h" | |
15 | #include "rblist.h" | |
b18f3e36 | 16 | #include <string.h> |
b18f3e36 AK |
17 | #include <errno.h> |
18 | #include "pmu-events/pmu-events.h" | |
b18f3e36 AK |
19 | #include "strlist.h" |
20 | #include <assert.h> | |
bd9860bf | 21 | #include <linux/ctype.h> |
b4209025 | 22 | #include <linux/string.h> |
d8f9da24 | 23 | #include <linux/zalloc.h> |
0b8026e8 | 24 | #include <subcmd/parse-options.h> |
b18f3e36 AK |
25 | |
26 | struct metric_event *metricgroup__lookup(struct rblist *metric_events, | |
32dcd021 | 27 | struct evsel *evsel, |
b18f3e36 AK |
28 | bool create) |
29 | { | |
30 | struct rb_node *nd; | |
31 | struct metric_event me = { | |
32 | .evsel = evsel | |
33 | }; | |
4bd1bef8 AK |
34 | |
35 | if (!metric_events) | |
36 | return NULL; | |
37 | ||
b18f3e36 AK |
38 | nd = rblist__find(metric_events, &me); |
39 | if (nd) | |
40 | return container_of(nd, struct metric_event, nd); | |
41 | if (create) { | |
42 | rblist__add_node(metric_events, &me); | |
43 | nd = rblist__find(metric_events, &me); | |
44 | if (nd) | |
45 | return container_of(nd, struct metric_event, nd); | |
46 | } | |
47 | return NULL; | |
48 | } | |
49 | ||
50 | static int metric_event_cmp(struct rb_node *rb_node, const void *entry) | |
51 | { | |
52 | struct metric_event *a = container_of(rb_node, | |
53 | struct metric_event, | |
54 | nd); | |
55 | const struct metric_event *b = entry; | |
56 | ||
57 | if (a->evsel == b->evsel) | |
58 | return 0; | |
59 | if ((char *)a->evsel < (char *)b->evsel) | |
60 | return -1; | |
61 | return +1; | |
62 | } | |
63 | ||
64 | static struct rb_node *metric_event_new(struct rblist *rblist __maybe_unused, | |
65 | const void *entry) | |
66 | { | |
67 | struct metric_event *me = malloc(sizeof(struct metric_event)); | |
68 | ||
69 | if (!me) | |
70 | return NULL; | |
71 | memcpy(me, entry, sizeof(struct metric_event)); | |
72 | me->evsel = ((struct metric_event *)entry)->evsel; | |
73 | INIT_LIST_HEAD(&me->head); | |
74 | return &me->nd; | |
75 | } | |
76 | ||
77 | static void metricgroup__rblist_init(struct rblist *metric_events) | |
78 | { | |
79 | rblist__init(metric_events); | |
80 | metric_events->node_cmp = metric_event_cmp; | |
81 | metric_events->node_new = metric_event_new; | |
82 | } | |
83 | ||
84 | struct egroup { | |
85 | struct list_head nd; | |
86 | int idnum; | |
87 | const char **ids; | |
88 | const char *metric_name; | |
89 | const char *metric_expr; | |
287f2649 | 90 | const char *metric_unit; |
b18f3e36 AK |
91 | }; |
92 | ||
63503dba | 93 | static struct evsel *find_evsel_group(struct evlist *perf_evlist, |
32dcd021 JO |
94 | const char **ids, |
95 | int idnum, | |
96 | struct evsel **metric_events) | |
b18f3e36 | 97 | { |
f01642e4 JY |
98 | struct evsel *ev; |
99 | int i = 0; | |
100 | bool leader_found; | |
b18f3e36 AK |
101 | |
102 | evlist__for_each_entry (perf_evlist, ev) { | |
f01642e4 JY |
103 | if (!strcmp(ev->name, ids[i])) { |
104 | if (!metric_events[i]) | |
105 | metric_events[i] = ev; | |
b18f3e36 | 106 | } else { |
f01642e4 JY |
107 | if (++i == idnum) { |
108 | /* Discard the whole match and start again */ | |
109 | i = 0; | |
110 | memset(metric_events, 0, | |
111 | sizeof(struct evsel *) * idnum); | |
112 | continue; | |
113 | } | |
114 | ||
115 | if (!strcmp(ev->name, ids[i])) | |
116 | metric_events[i] = ev; | |
117 | else { | |
118 | /* Discard the whole match and start again */ | |
119 | i = 0; | |
120 | memset(metric_events, 0, | |
121 | sizeof(struct evsel *) * idnum); | |
122 | continue; | |
2f87f33f | 123 | } |
b18f3e36 AK |
124 | } |
125 | } | |
f01642e4 JY |
126 | |
127 | if (i != idnum - 1) { | |
128 | /* Not whole match */ | |
129 | return NULL; | |
130 | } | |
131 | ||
132 | metric_events[idnum] = NULL; | |
133 | ||
134 | for (i = 0; i < idnum; i++) { | |
135 | leader_found = false; | |
136 | evlist__for_each_entry(perf_evlist, ev) { | |
137 | if (!leader_found && (ev == metric_events[i])) | |
138 | leader_found = true; | |
139 | ||
140 | if (leader_found && | |
141 | !strcmp(ev->name, metric_events[i]->name)) { | |
142 | ev->metric_leader = metric_events[i]; | |
143 | } | |
144 | } | |
145 | } | |
146 | ||
147 | return metric_events[0]; | |
b18f3e36 AK |
148 | } |
149 | ||
150 | static int metricgroup__setup_events(struct list_head *groups, | |
63503dba | 151 | struct evlist *perf_evlist, |
b18f3e36 AK |
152 | struct rblist *metric_events_list) |
153 | { | |
154 | struct metric_event *me; | |
155 | struct metric_expr *expr; | |
156 | int i = 0; | |
157 | int ret = 0; | |
158 | struct egroup *eg; | |
32dcd021 | 159 | struct evsel *evsel; |
b18f3e36 AK |
160 | |
161 | list_for_each_entry (eg, groups, nd) { | |
32dcd021 | 162 | struct evsel **metric_events; |
b18f3e36 AK |
163 | |
164 | metric_events = calloc(sizeof(void *), eg->idnum + 1); | |
165 | if (!metric_events) { | |
166 | ret = -ENOMEM; | |
167 | break; | |
168 | } | |
2f87f33f AK |
169 | evsel = find_evsel_group(perf_evlist, eg->ids, eg->idnum, |
170 | metric_events); | |
b18f3e36 AK |
171 | if (!evsel) { |
172 | pr_debug("Cannot resolve %s: %s\n", | |
173 | eg->metric_name, eg->metric_expr); | |
174 | continue; | |
175 | } | |
176 | for (i = 0; i < eg->idnum; i++) | |
177 | metric_events[i]->collect_stat = true; | |
178 | me = metricgroup__lookup(metric_events_list, evsel, true); | |
179 | if (!me) { | |
180 | ret = -ENOMEM; | |
181 | break; | |
182 | } | |
183 | expr = malloc(sizeof(struct metric_expr)); | |
184 | if (!expr) { | |
185 | ret = -ENOMEM; | |
186 | break; | |
187 | } | |
188 | expr->metric_expr = eg->metric_expr; | |
189 | expr->metric_name = eg->metric_name; | |
287f2649 | 190 | expr->metric_unit = eg->metric_unit; |
b18f3e36 AK |
191 | expr->metric_events = metric_events; |
192 | list_add(&expr->nd, &me->head); | |
193 | } | |
194 | return ret; | |
195 | } | |
196 | ||
197 | static bool match_metric(const char *n, const char *list) | |
198 | { | |
199 | int len; | |
200 | char *m; | |
201 | ||
202 | if (!list) | |
203 | return false; | |
204 | if (!strcmp(list, "all")) | |
205 | return true; | |
206 | if (!n) | |
207 | return !strcasecmp(list, "No_group"); | |
208 | len = strlen(list); | |
209 | m = strcasestr(n, list); | |
210 | if (!m) | |
211 | return false; | |
212 | if ((m == n || m[-1] == ';' || m[-1] == ' ') && | |
213 | (m[len] == 0 || m[len] == ';')) | |
214 | return true; | |
215 | return false; | |
216 | } | |
217 | ||
71b0acce AK |
218 | struct mep { |
219 | struct rb_node nd; | |
220 | const char *name; | |
221 | struct strlist *metrics; | |
222 | }; | |
223 | ||
224 | static int mep_cmp(struct rb_node *rb_node, const void *entry) | |
225 | { | |
226 | struct mep *a = container_of(rb_node, struct mep, nd); | |
227 | struct mep *b = (struct mep *)entry; | |
228 | ||
229 | return strcmp(a->name, b->name); | |
230 | } | |
231 | ||
232 | static struct rb_node *mep_new(struct rblist *rl __maybe_unused, | |
233 | const void *entry) | |
234 | { | |
235 | struct mep *me = malloc(sizeof(struct mep)); | |
236 | ||
237 | if (!me) | |
238 | return NULL; | |
239 | memcpy(me, entry, sizeof(struct mep)); | |
240 | me->name = strdup(me->name); | |
241 | if (!me->name) | |
242 | goto out_me; | |
243 | me->metrics = strlist__new(NULL, NULL); | |
244 | if (!me->metrics) | |
245 | goto out_name; | |
246 | return &me->nd; | |
247 | out_name: | |
d8f9da24 | 248 | zfree(&me->name); |
71b0acce AK |
249 | out_me: |
250 | free(me); | |
251 | return NULL; | |
252 | } | |
253 | ||
254 | static struct mep *mep_lookup(struct rblist *groups, const char *name) | |
255 | { | |
256 | struct rb_node *nd; | |
257 | struct mep me = { | |
258 | .name = name | |
259 | }; | |
260 | nd = rblist__find(groups, &me); | |
261 | if (nd) | |
262 | return container_of(nd, struct mep, nd); | |
263 | rblist__add_node(groups, &me); | |
264 | nd = rblist__find(groups, &me); | |
265 | if (nd) | |
266 | return container_of(nd, struct mep, nd); | |
267 | return NULL; | |
268 | } | |
269 | ||
270 | static void mep_delete(struct rblist *rl __maybe_unused, | |
271 | struct rb_node *nd) | |
272 | { | |
273 | struct mep *me = container_of(nd, struct mep, nd); | |
274 | ||
275 | strlist__delete(me->metrics); | |
d8f9da24 | 276 | zfree(&me->name); |
71b0acce AK |
277 | free(me); |
278 | } | |
279 | ||
280 | static void metricgroup__print_strlist(struct strlist *metrics, bool raw) | |
281 | { | |
282 | struct str_node *sn; | |
283 | int n = 0; | |
284 | ||
285 | strlist__for_each_entry (sn, metrics) { | |
286 | if (raw) | |
287 | printf("%s%s", n > 0 ? " " : "", sn->s); | |
288 | else | |
289 | printf(" %s\n", sn->s); | |
290 | n++; | |
291 | } | |
292 | if (raw) | |
293 | putchar('\n'); | |
294 | } | |
295 | ||
296 | void metricgroup__print(bool metrics, bool metricgroups, char *filter, | |
33bbc571 | 297 | bool raw, bool details) |
71b0acce | 298 | { |
54e32dc0 | 299 | struct pmu_events_map *map = perf_pmu__find_map(NULL); |
71b0acce AK |
300 | struct pmu_event *pe; |
301 | int i; | |
302 | struct rblist groups; | |
303 | struct rb_node *node, *next; | |
304 | struct strlist *metriclist = NULL; | |
305 | ||
306 | if (!map) | |
307 | return; | |
308 | ||
309 | if (!metricgroups) { | |
310 | metriclist = strlist__new(NULL, NULL); | |
311 | if (!metriclist) | |
312 | return; | |
313 | } | |
314 | ||
315 | rblist__init(&groups); | |
316 | groups.node_new = mep_new; | |
317 | groups.node_cmp = mep_cmp; | |
318 | groups.node_delete = mep_delete; | |
319 | for (i = 0; ; i++) { | |
320 | const char *g; | |
321 | pe = &map->table[i]; | |
322 | ||
323 | if (!pe->name && !pe->metric_group && !pe->metric_name) | |
324 | break; | |
325 | if (!pe->metric_expr) | |
326 | continue; | |
327 | g = pe->metric_group; | |
328 | if (!g && pe->metric_name) { | |
329 | if (pe->name) | |
330 | continue; | |
331 | g = "No_group"; | |
332 | } | |
333 | if (g) { | |
334 | char *omg; | |
335 | char *mg = strdup(g); | |
336 | ||
337 | if (!mg) | |
338 | return; | |
339 | omg = mg; | |
340 | while ((g = strsep(&mg, ";")) != NULL) { | |
341 | struct mep *me; | |
342 | char *s; | |
343 | ||
80e9073f | 344 | g = skip_spaces(g); |
71b0acce AK |
345 | if (*g == 0) |
346 | g = "No_group"; | |
71b0acce AK |
347 | if (filter && !strstr(g, filter)) |
348 | continue; | |
349 | if (raw) | |
350 | s = (char *)pe->metric_name; | |
351 | else { | |
95f04328 MP |
352 | if (asprintf(&s, "%s\n%*s%s]", |
353 | pe->metric_name, 8, "[", pe->desc) < 0) | |
71b0acce | 354 | return; |
33bbc571 JO |
355 | |
356 | if (details) { | |
357 | if (asprintf(&s, "%s\n%*s%s]", | |
358 | s, 8, "[", pe->metric_expr) < 0) | |
359 | return; | |
360 | } | |
71b0acce AK |
361 | } |
362 | ||
363 | if (!s) | |
364 | continue; | |
365 | ||
366 | if (!metricgroups) { | |
367 | strlist__add(metriclist, s); | |
368 | } else { | |
369 | me = mep_lookup(&groups, g); | |
370 | if (!me) | |
371 | continue; | |
372 | strlist__add(me->metrics, s); | |
373 | } | |
374 | } | |
375 | free(omg); | |
376 | } | |
377 | } | |
378 | ||
379 | if (metricgroups && !raw) | |
380 | printf("\nMetric Groups:\n\n"); | |
381 | else if (metrics && !raw) | |
382 | printf("\nMetrics:\n\n"); | |
383 | ||
ca227029 | 384 | for (node = rb_first_cached(&groups.entries); node; node = next) { |
71b0acce AK |
385 | struct mep *me = container_of(node, struct mep, nd); |
386 | ||
387 | if (metricgroups) | |
9c344d15 | 388 | printf("%s%s%s", me->name, metrics && !raw ? ":" : "", raw ? " " : "\n"); |
71b0acce AK |
389 | if (metrics) |
390 | metricgroup__print_strlist(me->metrics, raw); | |
391 | next = rb_next(node); | |
392 | rblist__remove_node(&groups, node); | |
393 | } | |
394 | if (!metricgroups) | |
395 | metricgroup__print_strlist(metriclist, raw); | |
396 | strlist__delete(metriclist); | |
397 | } | |
398 | ||
b18f3e36 AK |
399 | static int metricgroup__add_metric(const char *metric, struct strbuf *events, |
400 | struct list_head *group_list) | |
401 | { | |
54e32dc0 | 402 | struct pmu_events_map *map = perf_pmu__find_map(NULL); |
b18f3e36 AK |
403 | struct pmu_event *pe; |
404 | int ret = -EINVAL; | |
405 | int i, j; | |
406 | ||
b18f3e36 AK |
407 | if (!map) |
408 | return 0; | |
409 | ||
410 | for (i = 0; ; i++) { | |
411 | pe = &map->table[i]; | |
412 | ||
413 | if (!pe->name && !pe->metric_group && !pe->metric_name) | |
414 | break; | |
415 | if (!pe->metric_expr) | |
416 | continue; | |
417 | if (match_metric(pe->metric_group, metric) || | |
418 | match_metric(pe->metric_name, metric)) { | |
419 | const char **ids; | |
420 | int idnum; | |
421 | struct egroup *eg; | |
488c3bf7 | 422 | bool no_group = false; |
b18f3e36 AK |
423 | |
424 | pr_debug("metric expr %s for %s\n", pe->metric_expr, pe->metric_name); | |
425 | ||
426 | if (expr__find_other(pe->metric_expr, | |
427 | NULL, &ids, &idnum) < 0) | |
428 | continue; | |
429 | if (events->len > 0) | |
430 | strbuf_addf(events, ","); | |
431 | for (j = 0; j < idnum; j++) { | |
432 | pr_debug("found event %s\n", ids[j]); | |
488c3bf7 AK |
433 | /* |
434 | * Duration time maps to a software event and can make | |
435 | * groups not count. Always use it outside a | |
436 | * group. | |
437 | */ | |
438 | if (!strcmp(ids[j], "duration_time")) { | |
439 | if (j > 0) | |
440 | strbuf_addf(events, "}:W,"); | |
441 | strbuf_addf(events, "duration_time"); | |
442 | no_group = true; | |
443 | continue; | |
444 | } | |
b18f3e36 | 445 | strbuf_addf(events, "%s%s", |
488c3bf7 | 446 | j == 0 || no_group ? "{" : ",", |
b18f3e36 | 447 | ids[j]); |
488c3bf7 | 448 | no_group = false; |
b18f3e36 | 449 | } |
488c3bf7 AK |
450 | if (!no_group) |
451 | strbuf_addf(events, "}:W"); | |
b18f3e36 AK |
452 | |
453 | eg = malloc(sizeof(struct egroup)); | |
454 | if (!eg) { | |
455 | ret = -ENOMEM; | |
456 | break; | |
457 | } | |
458 | eg->ids = ids; | |
459 | eg->idnum = idnum; | |
460 | eg->metric_name = pe->metric_name; | |
461 | eg->metric_expr = pe->metric_expr; | |
287f2649 | 462 | eg->metric_unit = pe->unit; |
b18f3e36 AK |
463 | list_add_tail(&eg->nd, group_list); |
464 | ret = 0; | |
465 | } | |
466 | } | |
467 | return ret; | |
468 | } | |
469 | ||
470 | static int metricgroup__add_metric_list(const char *list, struct strbuf *events, | |
471 | struct list_head *group_list) | |
472 | { | |
473 | char *llist, *nlist, *p; | |
474 | int ret = -EINVAL; | |
475 | ||
476 | nlist = strdup(list); | |
477 | if (!nlist) | |
478 | return -ENOMEM; | |
479 | llist = nlist; | |
411bc316 AK |
480 | |
481 | strbuf_init(events, 100); | |
482 | strbuf_addf(events, "%s", ""); | |
483 | ||
b18f3e36 AK |
484 | while ((p = strsep(&llist, ",")) != NULL) { |
485 | ret = metricgroup__add_metric(p, events, group_list); | |
486 | if (ret == -EINVAL) { | |
487 | fprintf(stderr, "Cannot find metric or group `%s'\n", | |
488 | p); | |
489 | break; | |
490 | } | |
491 | } | |
492 | free(nlist); | |
493 | return ret; | |
494 | } | |
495 | ||
496 | static void metricgroup__free_egroups(struct list_head *group_list) | |
497 | { | |
498 | struct egroup *eg, *egtmp; | |
499 | int i; | |
500 | ||
501 | list_for_each_entry_safe (eg, egtmp, group_list, nd) { | |
502 | for (i = 0; i < eg->idnum; i++) | |
d8f9da24 ACM |
503 | zfree(&eg->ids[i]); |
504 | zfree(&eg->ids); | |
acc7bfb3 | 505 | list_del_init(&eg->nd); |
b18f3e36 AK |
506 | free(eg); |
507 | } | |
508 | } | |
509 | ||
510 | int metricgroup__parse_groups(const struct option *opt, | |
511 | const char *str, | |
512 | struct rblist *metric_events) | |
513 | { | |
514 | struct parse_events_error parse_error; | |
63503dba | 515 | struct evlist *perf_evlist = *(struct evlist **)opt->value; |
b18f3e36 AK |
516 | struct strbuf extra_events; |
517 | LIST_HEAD(group_list); | |
518 | int ret; | |
519 | ||
520 | if (metric_events->nr_entries == 0) | |
521 | metricgroup__rblist_init(metric_events); | |
522 | ret = metricgroup__add_metric_list(str, &extra_events, &group_list); | |
523 | if (ret) | |
524 | return ret; | |
525 | pr_debug("adding %s\n", extra_events.buf); | |
a910e466 | 526 | bzero(&parse_error, sizeof(parse_error)); |
b18f3e36 AK |
527 | ret = parse_events(perf_evlist, extra_events.buf, &parse_error); |
528 | if (ret) { | |
333b5665 | 529 | parse_events_print_error(&parse_error, extra_events.buf); |
b18f3e36 AK |
530 | goto out; |
531 | } | |
532 | strbuf_release(&extra_events); | |
533 | ret = metricgroup__setup_events(&group_list, perf_evlist, | |
534 | metric_events); | |
535 | out: | |
536 | metricgroup__free_egroups(&group_list); | |
537 | return ret; | |
538 | } | |
742d92ff TR |
539 | |
540 | bool metricgroup__has_metric(const char *metric) | |
541 | { | |
542 | struct pmu_events_map *map = perf_pmu__find_map(NULL); | |
543 | struct pmu_event *pe; | |
544 | int i; | |
545 | ||
546 | if (!map) | |
547 | return false; | |
548 | ||
549 | for (i = 0; ; i++) { | |
550 | pe = &map->table[i]; | |
551 | ||
552 | if (!pe->name && !pe->metric_group && !pe->metric_name) | |
553 | break; | |
554 | if (!pe->metric_expr) | |
555 | continue; | |
556 | if (match_metric(pe->metric_name, metric)) | |
557 | return true; | |
558 | } | |
559 | return false; | |
560 | } |