perf pmus: Fake PMU clean up · tjh.dev/kernel@9253207

+2 -2

tools/perf/tests/parse-events.c

··· 2500 2500 return TEST_FAIL; 2501 2501 } 2502 2502 parse_events_error__init(&err); 2503 - ret = __parse_events(evlist, e->name, /*pmu_filter=*/NULL, &err, /*fake_pmu=*/NULL, 2503 + ret = __parse_events(evlist, e->name, /*pmu_filter=*/NULL, &err, /*fake_pmu=*/false, 2504 2504 /*warn_if_reordered=*/true, /*fake_tp=*/true); 2505 2505 if (ret) { 2506 2506 pr_debug("failed to parse event '%s', err %d\n", e->name, ret); ··· 2529 2529 2530 2530 parse_events_error__init(&err); 2531 2531 ret = __parse_events(evlist, str, /*pmu_filter=*/NULL, &err, 2532 - &perf_pmu__fake, /*warn_if_reordered=*/true, 2532 + /*fake_pmu=*/true, /*warn_if_reordered=*/true, 2533 2533 /*fake_tp=*/true); 2534 2534 if (ret) { 2535 2535 pr_debug("failed to parse event '%s', err %d\n",

+5 -7

tools/perf/tests/pmu-events.c

··· 819 819 return errno == 0 && end_ptr != str; 820 820 } 821 821 822 - static int check_parse_id(const char *id, struct parse_events_error *error, 823 - struct perf_pmu *fake_pmu) 822 + static int check_parse_id(const char *id, struct parse_events_error *error) 824 823 { 825 824 struct evlist *evlist; 826 825 int ret; ··· 840 841 for (cur = strchr(dup, '@') ; cur; cur = strchr(++cur, '@')) 841 842 *cur = '/'; 842 843 843 - ret = __parse_events(evlist, dup, /*pmu_filter=*/NULL, error, fake_pmu, 844 + ret = __parse_events(evlist, dup, /*pmu_filter=*/NULL, error, /*fake_pmu=*/true, 844 845 /*warn_if_reordered=*/true, /*fake_tp=*/false); 845 846 free(dup); 846 847 ··· 854 855 int ret; 855 856 856 857 parse_events_error__init(&error); 857 - ret = check_parse_id(id, &error, &perf_pmu__fake); 858 + ret = check_parse_id(id, &error); 858 859 parse_events_error__exit(&error); 859 860 return ret; 860 861 } ··· 1050 1051 } 1051 1052 1052 1053 /* 1053 - * Parse all the metrics for current architecture, 1054 - * or all defined cpus via the 'fake_pmu' 1055 - * in parse_events. 1054 + * Parse all the metrics for current architecture, or all defined cpus via the 1055 + * 'fake_pmu' in parse_events. 1056 1056 */ 1057 1057 static int test__parsing_fake(struct test_suite *test __maybe_unused, 1058 1058 int subtest __maybe_unused)

+5 -5

tools/perf/util/metricgroup.c

··· 1436 1436 * parse_ids - Build the event string for the ids and parse them creating an 1437 1437 * evlist. The encoded metric_ids are decoded. 1438 1438 * @metric_no_merge: is metric sharing explicitly disabled. 1439 - * @fake_pmu: used when testing metrics not supported by the current CPU. 1439 + * @fake_pmu: use a fake PMU when testing metrics not supported by the current CPU. 1440 1440 * @ids: the event identifiers parsed from a metric. 1441 1441 * @modifier: any modifiers added to the events. 1442 1442 * @group_events: should events be placed in a weak group. ··· 1444 1444 * the overall list of metrics. 1445 1445 * @out_evlist: the created list of events. 1446 1446 */ 1447 - static int parse_ids(bool metric_no_merge, struct perf_pmu *fake_pmu, 1447 + static int parse_ids(bool metric_no_merge, bool fake_pmu, 1448 1448 struct expr_parse_ctx *ids, const char *modifier, 1449 1449 bool group_events, const bool tool_events[PERF_TOOL_MAX], 1450 1450 struct evlist **out_evlist) ··· 1528 1528 bool metric_no_threshold, 1529 1529 const char *user_requested_cpu_list, 1530 1530 bool system_wide, 1531 - struct perf_pmu *fake_pmu, 1531 + bool fake_pmu, 1532 1532 struct rblist *metric_events_list, 1533 1533 const struct pmu_metrics_table *table) 1534 1534 { ··· 1703 1703 1704 1704 return parse_groups(perf_evlist, pmu, str, metric_no_group, metric_no_merge, 1705 1705 metric_no_threshold, user_requested_cpu_list, system_wide, 1706 - /*fake_pmu=*/NULL, metric_events, table); 1706 + /*fake_pmu=*/false, metric_events, table); 1707 1707 } 1708 1708 1709 1709 int metricgroup__parse_groups_test(struct evlist *evlist, ··· 1717 1717 /*metric_no_threshold=*/false, 1718 1718 /*user_requested_cpu_list=*/NULL, 1719 1719 /*system_wide=*/false, 1720 - &perf_pmu__fake, metric_events, table); 1720 + /*fake_pmu=*/true, metric_events, table); 1721 1721 } 1722 1722 1723 1723 struct metricgroup__has_metric_data {

+17 -16

tools/perf/util/parse-events.c

··· 1500 1500 } 1501 1501 1502 1502 /* Look for event names in the terms and rewrite into format based terms. */ 1503 - if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, &parsed_terms, 1504 - &info, &alias_rewrote_terms, err)) { 1503 + if (perf_pmu__check_alias(pmu, &parsed_terms, 1504 + &info, &alias_rewrote_terms, err)) { 1505 1505 parse_events_terms__exit(&parsed_terms); 1506 1506 return -EINVAL; 1507 1507 } ··· 1537 1537 return -ENOMEM; 1538 1538 } 1539 1539 1540 - if (!parse_state->fake_pmu && 1541 - perf_pmu__config(pmu, &attr, &parsed_terms, parse_state->error)) { 1540 + if (perf_pmu__config(pmu, &attr, &parsed_terms, parse_state->error)) { 1542 1541 free_config_terms(&config_terms); 1543 1542 parse_events_terms__exit(&parsed_terms); 1544 1543 return -EINVAL; ··· 1556 1557 evsel->use_config_name = true; 1557 1558 1558 1559 evsel->percore = config_term_percore(&evsel->config_terms); 1559 - 1560 - if (parse_state->fake_pmu) { 1561 - parse_events_terms__exit(&parsed_terms); 1562 - return 0; 1563 - } 1564 1560 1565 1561 parse_events_terms__exit(&parsed_terms); 1566 1562 free((char *)evsel->unit); ··· 1632 1638 } 1633 1639 1634 1640 if (parse_state->fake_pmu) { 1635 - if (!parse_events_add_pmu(parse_state, list, parse_state->fake_pmu, &parsed_terms, 1641 + if (!parse_events_add_pmu(parse_state, list, perf_pmus__fake_pmu(), &parsed_terms, 1636 1642 /*auto_merge_stats=*/true)) { 1637 1643 struct strbuf sb; 1638 1644 1639 1645 strbuf_init(&sb, /*hint=*/ 0); 1640 1646 parse_events_terms__to_strbuf(&parsed_terms, &sb); 1641 - pr_debug("%s -> %s/%s/\n", event_name, "fake_pmu", sb.buf); 1647 + pr_debug("%s -> fake/%s/\n", event_name, sb.buf); 1642 1648 strbuf_release(&sb); 1643 1649 ok++; 1644 1650 } ··· 1672 1678 INIT_LIST_HEAD(*listp); 1673 1679 1674 1680 /* Attempt to add to list assuming event_or_pmu is a PMU name. */ 1675 - pmu = parse_state->fake_pmu ?: perf_pmus__find(event_or_pmu); 1681 + pmu = perf_pmus__find(event_or_pmu); 1676 1682 if (pmu && !parse_events_add_pmu(parse_state, *listp, pmu, const_parsed_terms, 1677 1683 /*auto_merge_stats=*/false)) 1678 1684 return 0; 1685 + 1686 + if (parse_state->fake_pmu) { 1687 + if (!parse_events_add_pmu(parse_state, *listp, perf_pmus__fake_pmu(), 1688 + const_parsed_terms, 1689 + /*auto_merge_stats=*/false)) 1690 + return 0; 1691 + } 1679 1692 1680 1693 pmu = NULL; 1681 1694 /* Failed to add, try wildcard expansion of event_or_pmu as a PMU name. */ ··· 1984 1983 } 1985 1984 } 1986 1985 } 1987 - /* Assign the actual name taking care that the fake PMU lacks a name. */ 1988 - evsel->group_pmu_name = strdup(group_pmu_name ?: "fake"); 1986 + /* Record computed name. */ 1987 + evsel->group_pmu_name = strdup(group_pmu_name); 1989 1988 return evsel->group_pmu_name ? 0 : -ENOMEM; 1990 1989 } 1991 1990 ··· 2147 2146 } 2148 2147 2149 2148 int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter, 2150 - struct parse_events_error *err, struct perf_pmu *fake_pmu, 2149 + struct parse_events_error *err, bool fake_pmu, 2151 2150 bool warn_if_reordered, bool fake_tp) 2152 2151 { 2153 2152 struct parse_events_state parse_state = { ··· 2366 2365 2367 2366 parse_events_error__init(&err); 2368 2367 ret = __parse_events(*args->evlistp, str, args->pmu_filter, &err, 2369 - /*fake_pmu=*/NULL, /*warn_if_reordered=*/true, 2368 + /*fake_pmu=*/false, /*warn_if_reordered=*/true, 2370 2369 /*fake_tp=*/false); 2371 2370 2372 2371 if (ret) {

+4 -4

tools/perf/util/parse-events.h

··· 31 31 int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset); 32 32 __attribute__((nonnull(1, 2, 4))) 33 33 int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter, 34 - struct parse_events_error *error, struct perf_pmu *fake_pmu, 34 + struct parse_events_error *error, bool fake_pmu, 35 35 bool warn_if_reordered, bool fake_tp); 36 36 37 37 __attribute__((nonnull(1, 2, 3))) 38 38 static inline int parse_events(struct evlist *evlist, const char *str, 39 39 struct parse_events_error *err) 40 40 { 41 - return __parse_events(evlist, str, /*pmu_filter=*/NULL, err, /*fake_pmu=*/NULL, 41 + return __parse_events(evlist, str, /*pmu_filter=*/NULL, err, /*fake_pmu=*/false, 42 42 /*warn_if_reordered=*/true, /*fake_tp=*/false); 43 43 } 44 44 ··· 150 150 struct parse_events_terms *terms; 151 151 /* Start token. */ 152 152 int stoken; 153 - /* Special fake PMU marker for testing. */ 154 - struct perf_pmu *fake_pmu; 153 + /* Use the fake PMU marker for testing. */ 154 + bool fake_pmu; 155 155 /* Skip actual tracepoint processing for testing. */ 156 156 bool fake_tp; 157 157 /* If non-null, when wildcard matching only match the given PMU. */

+15 -6

tools/perf/util/pmu.c

··· 30 30 #include "util/evsel_config.h" 31 31 #include <regex.h> 32 32 33 - struct perf_pmu perf_pmu__fake = { 34 - .name = "fake", 35 - }; 36 - 37 33 #define UNIT_MAX_LEN 31 /* max length for event unit name */ 38 34 39 35 enum event_source { ··· 1168 1172 return pmu; 1169 1173 } 1170 1174 1175 + static bool perf_pmu__is_fake(const struct perf_pmu *pmu) 1176 + { 1177 + return pmu->type == PERF_PMU_TYPE_FAKE; 1178 + } 1179 + 1171 1180 void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) 1172 1181 { 1173 1182 struct perf_pmu_format *format; ··· 1183 1182 pmu->formats_checked = true; 1184 1183 1185 1184 /* fake pmu doesn't have format list */ 1186 - if (pmu == &perf_pmu__fake) 1185 + if (perf_pmu__is_fake(pmu)) 1187 1186 return; 1188 1187 1189 1188 list_for_each_entry(format, &pmu->format, list) { ··· 1511 1510 { 1512 1511 bool zero = !!pmu->perf_event_attr_init_default; 1513 1512 1513 + /* Fake PMU doesn't have proper terms so nothing to configure in attr. */ 1514 + if (perf_pmu__is_fake(pmu)) 1515 + return 0; 1516 + 1514 1517 return perf_pmu__config_terms(pmu, attr, head_terms, zero, err); 1515 1518 } 1516 1519 ··· 1623 1618 info->scale = 0.0; 1624 1619 info->snapshot = false; 1625 1620 1621 + /* Fake PMU doesn't rewrite terms. */ 1622 + if (perf_pmu__is_fake(pmu)) 1623 + goto out; 1624 + 1626 1625 list_for_each_entry_safe(term, h, &head_terms->terms, list) { 1627 1626 alias = pmu_find_alias(pmu, term); 1628 1627 if (!alias) ··· 1649 1640 list_del_init(&term->list); 1650 1641 parse_events_term__delete(term); 1651 1642 } 1652 - 1643 + out: 1653 1644 /* 1654 1645 * if no unit or scale found in aliases, then 1655 1646 * set defaults as for evsel

+4 -3

tools/perf/util/pmu.h

··· 36 36 struct list_head list; 37 37 }; 38 38 39 + enum { 40 + PERF_PMU_TYPE_FAKE = 0xFFFFFFFF, 41 + }; 42 + 39 43 /** 40 44 * struct perf_pmu 41 45 */ ··· 176 172 */ 177 173 struct perf_mem_event *mem_events; 178 174 }; 179 - 180 - /** @perf_pmu__fake: A special global PMU used for testing. */ 181 - extern struct perf_pmu perf_pmu__fake; 182 175 183 176 struct perf_pmu_info { 184 177 const char *unit;

+11

tools/perf/util/pmus.c

··· 720 720 */ 721 721 return perf_pmu__lookup(&other_pmus, test_sysfs_dirfd, name, /*eager_load=*/true); 722 722 } 723 + 724 + struct perf_pmu *perf_pmus__fake_pmu(void) 725 + { 726 + static struct perf_pmu fake = { 727 + .name = "fake", 728 + .type = PERF_PMU_TYPE_FAKE, 729 + .format = LIST_HEAD_INIT(fake.format), 730 + }; 731 + 732 + return &fake; 733 + }

+1

tools/perf/util/pmus.h

··· 30 30 char *perf_pmus__default_pmu_name(void); 31 31 32 32 struct perf_pmu *perf_pmus__add_test_pmu(int test_sysfs_dirfd, const char *name); 33 + struct perf_pmu *perf_pmus__fake_pmu(void); 33 34 34 35 #endif /* __PMUS_H */

Configure Feed

Configure Feed