perf tool_pmu: Rename enum perf_tool_event to tool_pmu_event

To better reflect the events listed are from the tool PMU. Rename the
enum values from PERF_TOOL_* to TOOL_PMU__EVENT_*.

Signed-off-by: Ian Rogers <irogers@google.com>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Link: https://lore.kernel.org/r/20241002032016.333748-6-irogers@google.com
Signed-off-by: Namhyung Kim <namhyung@kernel.org>

diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index bc12975efad561e8560afc39b5135e7f2217bd2a..b5e18853982cdb0f5a7186bef19eac56e5f10319 100644 (file)
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -295,14 +295,14 @@ static int read_single_counter(struct evsel *counter, int cpu_map_idx, int threa
         * terminates. Use the wait4 values in that case.
         */
        if (err && cpu_map_idx == 0 &&
-           (evsel__tool_event(counter) == PERF_TOOL_USER_TIME ||
-            evsel__tool_event(counter) == PERF_TOOL_SYSTEM_TIME)) {
+           (evsel__tool_event(counter) == TOOL_PMU__EVENT_USER_TIME ||
+            evsel__tool_event(counter) == TOOL_PMU__EVENT_SYSTEM_TIME)) {
                u64 val, *start_time;
                struct perf_counts_values *count =
                        perf_counts(counter->counts, cpu_map_idx, thread);
 
                start_time = xyarray__entry(counter->start_times, cpu_map_idx, thread);
-               if (evsel__tool_event(counter) == PERF_TOOL_USER_TIME)
+               if (evsel__tool_event(counter) == TOOL_PMU__EVENT_USER_TIME)
                        val = ru_stats.ru_utime_usec_stat.mean;
                else
                        val = ru_stats.ru_stime_usec_stat.mean;

diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 14a17f768f4263f4a98f213f32d63ce38697852f..320310e333e647b0f02cd9ba13b734de1717c962 100644 (file)
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -1476,8 +1476,8 @@ void evsel__exit(struct evsel *evsel)
        evsel->per_pkg_mask = NULL;
        zfree(&evsel->metric_events);
        perf_evsel__object.fini(evsel);
-       if (evsel__tool_event(evsel) == PERF_TOOL_SYSTEM_TIME ||
-           evsel__tool_event(evsel) == PERF_TOOL_USER_TIME)
+       if (evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
+           evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME)
                xyarray__delete(evsel->start_times);
 }
 

diff --git a/tools/perf/util/metricgroup.c b/tools/perf/util/metricgroup.c
index 827bab455d5bc8438186e36f56c22be3f1ff5c26..1250bf5050b09e6d492ac1907ae953cc2197d5a5 100644 (file)
--- a/tools/perf/util/metricgroup.c
+++ b/tools/perf/util/metricgroup.c
@@ -674,20 +674,20 @@ static int metricgroup__build_event_string(struct strbuf *events,
        struct hashmap_entry *cur;
        size_t bkt;
        bool no_group = true, has_tool_events = false;
-       bool tool_events[PERF_TOOL_MAX] = {false};
+       bool tool_events[TOOL_PMU__EVENT_MAX] = {false};
        int ret = 0;
 
 #define RETURN_IF_NON_ZERO(x) do { if (x) return x; } while (0)
 
        hashmap__for_each_entry(ctx->ids, cur, bkt) {
                const char *sep, *rsep, *id = cur->pkey;
-               enum perf_tool_event ev;
+               enum tool_pmu_event ev;
 
                pr_debug("found event %s\n", id);
 
                /* Always move tool events outside of the group. */
                ev = perf_tool_event__from_str(id);
-               if (ev != PERF_TOOL_NONE) {
+               if (ev != TOOL_PMU__EVENT_NONE) {
                        has_tool_events = true;
                        tool_events[ev] = true;
                        continue;
@@ -1375,7 +1375,7 @@ static void metricgroup__free_metrics(struct list_head *metric_list)
  *               to true if tool event is found.
  */
 static void find_tool_events(const struct list_head *metric_list,
-                            bool tool_events[PERF_TOOL_MAX])
+                            bool tool_events[TOOL_PMU__EVENT_MAX])
 {
        struct metric *m;
 
@@ -1447,7 +1447,7 @@ err_out:
  */
 static int parse_ids(bool metric_no_merge, bool fake_pmu,
                     struct expr_parse_ctx *ids, const char *modifier,
-                    bool group_events, const bool tool_events[PERF_TOOL_MAX],
+                    bool group_events, const bool tool_events[TOOL_PMU__EVENT_MAX],
                     struct evlist **out_evlist)
 {
        struct parse_events_error parse_error;
@@ -1536,7 +1536,7 @@ static int parse_groups(struct evlist *perf_evlist,
        struct evlist *combined_evlist = NULL;
        LIST_HEAD(metric_list);
        struct metric *m;
-       bool tool_events[PERF_TOOL_MAX] = {false};
+       bool tool_events[TOOL_PMU__EVENT_MAX] = {false};
        bool is_default = !strcmp(str, "Default");
        int ret;
 

diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 762942853351d6c85c88aa7792b350017a970456..77e848ac5841b770bc474c1832208bead21ee6dd 100644 (file)
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -1836,7 +1836,7 @@ bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)
        if (!name)
                return false;
        if (perf_pmu__is_tool(pmu))
-               return perf_tool_event__from_str(name) != PERF_TOOL_NONE;
+               return perf_tool_event__from_str(name) != TOOL_PMU__EVENT_NONE;
        if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL)
                return true;
        if (pmu->cpu_aliases_added || !pmu->events_table)

diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index 50f347217d84c923ee6cf265ba87953938639203..b54afb56e3d67fc600372e582a77567975ae0590 100644 (file)
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -382,22 +382,22 @@ static int prepare_metric(const struct metric_expr *mexp,
                        double scale;
 
                        switch (evsel__tool_event(metric_events[i])) {
-                       case PERF_TOOL_DURATION_TIME:
+                       case TOOL_PMU__EVENT_DURATION_TIME:
                                stats = &walltime_nsecs_stats;
                                scale = 1e-9;
                                break;
-                       case PERF_TOOL_USER_TIME:
+                       case TOOL_PMU__EVENT_USER_TIME:
                                stats = &ru_stats.ru_utime_usec_stat;
                                scale = 1e-6;
                                break;
-                       case PERF_TOOL_SYSTEM_TIME:
+                       case TOOL_PMU__EVENT_SYSTEM_TIME:
                                stats = &ru_stats.ru_stime_usec_stat;
                                scale = 1e-6;
                                break;
-                       case PERF_TOOL_NONE:
+                       case TOOL_PMU__EVENT_NONE:
                                pr_err("Invalid tool event 'none'");
                                abort();
-                       case PERF_TOOL_MAX:
+                       case TOOL_PMU__EVENT_MAX:
                                pr_err("Invalid tool event 'max'");
                                abort();
                        default:

diff --git a/tools/perf/util/tool_pmu.c b/tools/perf/util/tool_pmu.c
index f41fed39d70d8a319c3a061c45a0d562a7c41821..ae0ca023f5ed5f2793070d8f227d7bfab0e81f61 100644 (file)
--- a/tools/perf/util/tool_pmu.c
+++ b/tools/perf/util/tool_pmu.c
@@ -12,7 +12,7 @@
 #include <fcntl.h>
 #include <strings.h>
 
-static const char *const tool_pmu__event_names[PERF_TOOL_MAX] = {
+static const char *const tool_pmu__event_names[TOOL_PMU__EVENT_MAX] = {
        NULL,
        "duration_time",
        "user_time",
@@ -20,15 +20,15 @@ static const char *const tool_pmu__event_names[PERF_TOOL_MAX] = {
 };
 
 
-const char *perf_tool_event__to_str(enum perf_tool_event ev)
+const char *perf_tool_event__to_str(enum tool_pmu_event ev)
 {
-       if (ev > PERF_TOOL_NONE && ev < PERF_TOOL_MAX)
+       if (ev > TOOL_PMU__EVENT_NONE && ev < TOOL_PMU__EVENT_MAX)
                return tool_pmu__event_names[ev];
 
        return NULL;
 }
 
-enum perf_tool_event perf_tool_event__from_str(const char *str)
+enum tool_pmu_event perf_tool_event__from_str(const char *str)
 {
        int i;
 
@@ -36,7 +36,7 @@ enum perf_tool_event perf_tool_event__from_str(const char *str)
                if (!strcasecmp(str, tool_pmu__event_names[i]))
                        return i;
        }
-       return PERF_TOOL_NONE;
+       return TOOL_PMU__EVENT_NONE;
 }
 
 static int tool_pmu__config_term(struct perf_event_attr *attr,
@@ -44,9 +44,9 @@ static int tool_pmu__config_term(struct perf_event_attr *attr,
                                 struct parse_events_error *err)
 {
        if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
-               enum perf_tool_event ev = perf_tool_event__from_str(term->config);
+               enum tool_pmu_event ev = perf_tool_event__from_str(term->config);
 
-               if (ev == PERF_TOOL_NONE)
+               if (ev == TOOL_PMU__EVENT_NONE)
                        goto err_out;
 
                attr->config = ev;
@@ -120,12 +120,12 @@ bool evsel__is_tool(const struct evsel *evsel)
        return perf_pmu__is_tool(evsel->pmu);
 }
 
-enum perf_tool_event evsel__tool_event(const struct evsel *evsel)
+enum tool_pmu_event evsel__tool_event(const struct evsel *evsel)
 {
        if (!evsel__is_tool(evsel))
-               return PERF_TOOL_NONE;
+               return TOOL_PMU__EVENT_NONE;
 
-       return (enum perf_tool_event)evsel->core.attr.config;
+       return (enum tool_pmu_event)evsel->core.attr.config;
 }
 
 const char *evsel__tool_pmu_event_name(const struct evsel *evsel)
@@ -229,8 +229,8 @@ int evsel__tool_pmu_prepare_open(struct evsel *evsel,
                                 struct perf_cpu_map *cpus,
                                 int nthreads)
 {
-       if ((evsel__tool_event(evsel) == PERF_TOOL_SYSTEM_TIME ||
-            evsel__tool_event(evsel) == PERF_TOOL_USER_TIME) &&
+       if ((evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
+            evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME) &&
            !evsel->start_times) {
                evsel->start_times = xyarray__new(perf_cpu_map__nr(cpus),
                                                  nthreads,
@@ -247,10 +247,10 @@ int evsel__tool_pmu_open(struct evsel *evsel,
                         struct perf_thread_map *threads,
                         int start_cpu_map_idx, int end_cpu_map_idx)
 {
-       enum perf_tool_event ev = evsel__tool_event(evsel);
+       enum tool_pmu_event ev = evsel__tool_event(evsel);
        int pid = -1, idx = 0, thread = 0, nthreads, err = 0, old_errno;
 
-       if (ev == PERF_TOOL_DURATION_TIME) {
+       if (ev == TOOL_PMU__EVENT_DURATION_TIME) {
                if (evsel->core.attr.sample_period) /* no sampling */
                        return -EINVAL;
                evsel->start_time = rdclock();
@@ -269,8 +269,8 @@ int evsel__tool_pmu_open(struct evsel *evsel,
                        if (!evsel->cgrp && !evsel->core.system_wide)
                                pid = perf_thread_map__pid(threads, thread);
 
-                       if (ev == PERF_TOOL_USER_TIME || ev == PERF_TOOL_SYSTEM_TIME) {
-                               bool system = ev == PERF_TOOL_SYSTEM_TIME;
+                       if (ev == TOOL_PMU__EVENT_USER_TIME || ev == TOOL_PMU__EVENT_SYSTEM_TIME) {
+                               bool system = ev == TOOL_PMU__EVENT_SYSTEM_TIME;
                                __u64 *start_time = NULL;
                                int fd;
 
@@ -338,7 +338,7 @@ int evsel__read_tool(struct evsel *evsel, int cpu_map_idx, int thread)
        count = perf_counts(evsel->counts, cpu_map_idx, thread);
 
        switch (evsel__tool_event(evsel)) {
-       case PERF_TOOL_DURATION_TIME:
+       case TOOL_PMU__EVENT_DURATION_TIME:
                /*
                 * Pretend duration_time is only on the first CPU and thread, or
                 * else aggregation will scale duration_time by the number of
@@ -350,9 +350,9 @@ int evsel__read_tool(struct evsel *evsel, int cpu_map_idx, int thread)
                else
                        cur_time = *start_time;
                break;
-       case PERF_TOOL_USER_TIME:
-       case PERF_TOOL_SYSTEM_TIME: {
-               bool system = evsel__tool_event(evsel) == PERF_TOOL_SYSTEM_TIME;
+       case TOOL_PMU__EVENT_USER_TIME:
+       case TOOL_PMU__EVENT_SYSTEM_TIME: {
+               bool system = evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME;
 
                start_time = xyarray__entry(evsel->start_times, cpu_map_idx, thread);
                fd = FD(evsel, cpu_map_idx, thread);
@@ -377,8 +377,8 @@ int evsel__read_tool(struct evsel *evsel, int cpu_map_idx, int thread)
                adjust = true;
                break;
        }
-       case PERF_TOOL_NONE:
-       case PERF_TOOL_MAX:
+       case TOOL_PMU__EVENT_NONE:
+       case TOOL_PMU__EVENT_MAX:
        default:
                err = -EINVAL;
        }

diff --git a/tools/perf/util/tool_pmu.h b/tools/perf/util/tool_pmu.h
index 05a4052c8b9d859605b179855d35b7bab1b57e13..b27a26133927bcaad84e37fd89b96fc5436dce4f 100644 (file)
--- a/tools/perf/util/tool_pmu.h
+++ b/tools/perf/util/tool_pmu.h
@@ -8,25 +8,25 @@ struct evsel;
 struct perf_thread_map;
 struct print_callbacks;
 
-enum perf_tool_event {
-       PERF_TOOL_NONE = 0,
-       PERF_TOOL_DURATION_TIME = 1,
-       PERF_TOOL_USER_TIME = 2,
-       PERF_TOOL_SYSTEM_TIME = 3,
+enum tool_pmu_event {
+       TOOL_PMU__EVENT_NONE = 0,
+       TOOL_PMU__EVENT_DURATION_TIME = 1,
+       TOOL_PMU__EVENT_USER_TIME = 2,
+       TOOL_PMU__EVENT_SYSTEM_TIME = 3,
 
-       PERF_TOOL_MAX,
+       TOOL_PMU__EVENT_MAX,
 };
 
 #define perf_tool_event__for_each_event(ev)                            \
-       for ((ev) = PERF_TOOL_DURATION_TIME; (ev) < PERF_TOOL_MAX; ev++)
+       for ((ev) = TOOL_PMU__EVENT_DURATION_TIME; (ev) < TOOL_PMU__EVENT_MAX; ev++)
 
 static inline size_t tool_pmu__num_events(void)
 {
-       return PERF_TOOL_MAX - 1;
+       return TOOL_PMU__EVENT_MAX - 1;
 }
 
-const char *perf_tool_event__to_str(enum perf_tool_event ev);
-enum perf_tool_event perf_tool_event__from_str(const char *str);
+const char *perf_tool_event__to_str(enum tool_pmu_event ev);
+enum tool_pmu_event perf_tool_event__from_str(const char *str);
 int tool_pmu__config_terms(struct perf_event_attr *attr,
                           struct parse_events_terms *terms,
                           struct parse_events_error *err);
@@ -36,7 +36,7 @@ bool perf_pmu__is_tool(const struct perf_pmu *pmu);
 
 
 bool evsel__is_tool(const struct evsel *evsel);
-enum perf_tool_event evsel__tool_event(const struct evsel *evsel);
+enum tool_pmu_event evsel__tool_event(const struct evsel *evsel);
 const char *evsel__tool_pmu_event_name(const struct evsel *evsel);
 int evsel__tool_pmu_prepare_open(struct evsel *evsel,
                                 struct perf_cpu_map *cpus,