perf parse-events: Make legacy events lower priority than sysfs/JSON

The perf tool has previously made legacy events the priority so with
or without a PMU the legacy event would be opened:

  $ perf stat -e cpu-cycles,cpu/cpu-cycles/ true
  Using CPUID GenuineIntel-6-8D-1
  intel_pt default config: tsc,mtc,mtc_period=3,psb_period=3,pt,branch
  Attempting to add event pmu 'cpu' with 'cpu-cycles,' that may result in non-fatal errors
  After aliases, add event pmu 'cpu' with 'cpu-cycles,' that may result in non-fatal errors
  Control descriptor is not initialized
  ------------------------------------------------------------
  perf_event_attr:
    type                             0 (PERF_TYPE_HARDWARE)
    size                             136
    config                           0 (PERF_COUNT_HW_CPU_CYCLES)
    sample_type                      IDENTIFIER
    read_format                      TOTAL_TIME_ENABLED|TOTAL_TIME_RUNNING
    disabled                         1
    inherit                          1
    enable_on_exec                   1
    exclude_guest                    1
  ------------------------------------------------------------
  sys_perf_event_open: pid 833967  cpu -1  group_fd -1  flags 0x8 = 3
  ------------------------------------------------------------
  perf_event_attr:
    type                             0 (PERF_TYPE_HARDWARE)
    size                             136
    config                           0 (PERF_COUNT_HW_CPU_CYCLES)
    sample_type                      IDENTIFIER
    read_format                      TOTAL_TIME_ENABLED|TOTAL_TIME_RUNNING
    disabled                         1
    inherit                          1
    enable_on_exec                   1
    exclude_guest                    1
  ------------------------------------------------------------
  ...

Fixes to make hybrid/BIG.little PMUs behave correctly, ie as core PMUs
capable of opening legacy events on each, removing hard coded "cpu_core"
and "cpu_atom" Intel PMU names, etc. caused a behavioral difference on
Apple/ARM due to latent issues in the PMU driver reported in:
https://lore.kernel.org/lkml/08f1f185-e259-4014-9ca4-6411d5c1bc65@marcan.st/

As part of that report Mark Rutland <mark.rutland@arm.com> requested
that legacy events not be higher in priority when a PMU is specified
reversing what has until this change been perf's default behavior. With
this change the above becomes:

  $ perf stat -e cpu-cycles,cpu/cpu-cycles/ true
  Using CPUID GenuineIntel-6-8D-1
  Attempt to add: cpu/cpu-cycles=0/
  ..after resolving event: cpu/event=0x3c/
  Control descriptor is not initialized
  ------------------------------------------------------------
  perf_event_attr:
    type                             0 (PERF_TYPE_HARDWARE)
    size                             136
    config                           0 (PERF_COUNT_HW_CPU_CYCLES)
    sample_type                      IDENTIFIER
    read_format                      TOTAL_TIME_ENABLED|TOTAL_TIME_RUNNING
    disabled                         1
    inherit                          1
    enable_on_exec                   1
    exclude_guest                    1
  ------------------------------------------------------------
  sys_perf_event_open: pid 827628  cpu -1  group_fd -1  flags 0x8 = 3
  ------------------------------------------------------------
  perf_event_attr:
    type                             4 (PERF_TYPE_RAW)
    size                             136
    config                           0x3c
    sample_type                      IDENTIFIER
    read_format                      TOTAL_TIME_ENABLED|TOTAL_TIME_RUNNING
    disabled                         1
    inherit                          1
    enable_on_exec                   1
    exclude_guest                    1
  ------------------------------------------------------------
  ...

So the second event has become a raw event as
/sys/devices/cpu/events/cpu-cycles exists.

A fix was necessary to config_term_pmu in parse-events.c as check_alias
expansion needs to happen after config_term_pmu, and config_term_pmu may
need calling a second time because of this.

config_term_pmu is updated to not use the legacy event when the PMU has
such a named event (either from JSON or sysfs).

The bulk of this change is updating all of the parse-events test
expectations so that if a sysfs/JSON event exists for a PMU the test
doesn't fail - a further sign, if it were needed, that the legacy event
priority was a known and tested behavior of the perf tool.

Reported-by: Hector Martin <marcan@marcan.st>
Signed-off-by: Ian Rogers <irogers@google.com>
Tested-by: Hector Martin <marcan@marcan.st>
Tested-by: Marc Zyngier <maz@kernel.org>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: https://lore.kernel.org/r/20231123042922.834425-1-irogers@google.com
[ Initialize the 'alias_rewrote_terms' variable to false to address a clang warning ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index e52f45c7c3d1aaa3935a6c8f5d951dd3f43443ca..fbdf710d5eea06047784aef245438b87442451d9 100644 (file)
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -162,6 +162,22 @@ static int test__checkevent_numeric(struct evlist *evlist)
        return TEST_OK;
 }
 
+
+static int assert_hw(struct perf_evsel *evsel, enum perf_hw_id id, const char *name)
+{
+       struct perf_pmu *pmu;
+
+       if (evsel->attr.type == PERF_TYPE_HARDWARE) {
+               TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, id));
+               return 0;
+       }
+       pmu = perf_pmus__find_by_type(evsel->attr.type);
+
+       TEST_ASSERT_VAL("unexpected PMU type", pmu);
+       TEST_ASSERT_VAL("PMU missing event", perf_pmu__have_event(pmu, name));
+       return 0;
+}
+
 static int test__checkevent_symbolic_name(struct evlist *evlist)
 {
        struct perf_evsel *evsel;
@@ -169,10 +185,12 @@ static int test__checkevent_symbolic_name(struct evlist *evlist)
        TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
 
        perf_evlist__for_each_evsel(&evlist->core, evsel) {
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
-               TEST_ASSERT_VAL("wrong config",
-                               test_perf_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               int ret = assert_hw(evsel, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+
+               if (ret)
+                       return ret;
        }
+
        return TEST_OK;
 }
 
@@ -183,8 +201,10 @@ static int test__checkevent_symbolic_name_config(struct evlist *evlist)
        TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
 
        perf_evlist__for_each_evsel(&evlist->core, evsel) {
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
-               TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               int ret = assert_hw(evsel, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+
+               if (ret)
+                       return ret;
                /*
                 * The period value gets configured within evlist__config,
                 * while this test executes only parse events method.
@@ -861,10 +881,14 @@ static int test__group1(struct evlist *evlist)
                        evlist__nr_groups(evlist) == num_core_entries());
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* instructions:k */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -878,8 +902,10 @@ static int test__group1(struct evlist *evlist)
 
                /* cycles:upp */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -907,6 +933,8 @@ static int test__group2(struct evlist *evlist)
        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist__nr_groups(evlist));
 
        evlist__for_each_entry(evlist, evsel) {
+               int ret;
+
                if (evsel->core.attr.type == PERF_TYPE_SOFTWARE) {
                        /* faults + :ku modifier */
                        leader = evsel;
@@ -939,8 +967,10 @@ static int test__group2(struct evlist *evlist)
                        continue;
                }
                /* cycles:k */
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -957,6 +987,7 @@ static int test__group2(struct evlist *evlist)
 static int test__group3(struct evlist *evlist __maybe_unused)
 {
        struct evsel *evsel, *group1_leader = NULL, *group2_leader = NULL;
+       int ret;
 
        TEST_ASSERT_VAL("wrong number of entries",
                        evlist->core.nr_entries == (3 * perf_pmus__num_core_pmus() + 2));
@@ -1045,8 +1076,10 @@ static int test__group3(struct evlist *evlist __maybe_unused)
                        continue;
                }
                /* instructions:u */
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1070,10 +1103,14 @@ static int test__group4(struct evlist *evlist __maybe_unused)
                        num_core_entries() == evlist__nr_groups(evlist));
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles:u + p */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1089,8 +1126,10 @@ static int test__group4(struct evlist *evlist __maybe_unused)
 
                /* instructions:kp + p */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1108,6 +1147,7 @@ static int test__group4(struct evlist *evlist __maybe_unused)
 static int test__group5(struct evlist *evlist __maybe_unused)
 {
        struct evsel *evsel = NULL, *leader;
+       int ret;
 
        TEST_ASSERT_VAL("wrong number of entries",
                        evlist->core.nr_entries == (5 * num_core_entries()));
@@ -1117,8 +1157,10 @@ static int test__group5(struct evlist *evlist __maybe_unused)
        for (int i = 0; i < num_core_entries(); i++) {
                /* cycles + G */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1133,8 +1175,10 @@ static int test__group5(struct evlist *evlist __maybe_unused)
 
                /* instructions + G */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1148,8 +1192,10 @@ static int test__group5(struct evlist *evlist __maybe_unused)
        for (int i = 0; i < num_core_entries(); i++) {
                /* cycles:G */
                evsel = leader = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1164,8 +1210,10 @@ static int test__group5(struct evlist *evlist __maybe_unused)
 
                /* instructions:G */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1178,8 +1226,10 @@ static int test__group5(struct evlist *evlist __maybe_unused)
        for (int i = 0; i < num_core_entries(); i++) {
                /* cycles */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1201,10 +1251,14 @@ static int test__group_gh1(struct evlist *evlist)
                        evlist__nr_groups(evlist) == num_core_entries());
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles + :H group modifier */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1218,8 +1272,10 @@ static int test__group_gh1(struct evlist *evlist)
 
                /* cache-misses:G + :H group modifier */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1242,10 +1298,14 @@ static int test__group_gh2(struct evlist *evlist)
                        evlist__nr_groups(evlist) == num_core_entries());
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles + :G group modifier */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1259,8 +1319,10 @@ static int test__group_gh2(struct evlist *evlist)
 
                /* cache-misses:H + :G group modifier */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1283,10 +1345,14 @@ static int test__group_gh3(struct evlist *evlist)
                        evlist__nr_groups(evlist) == num_core_entries());
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles:G + :u group modifier */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1300,8 +1366,10 @@ static int test__group_gh3(struct evlist *evlist)
 
                /* cache-misses:H + :u group modifier */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1324,10 +1392,14 @@ static int test__group_gh4(struct evlist *evlist)
                        evlist__nr_groups(evlist) == num_core_entries());
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles:G + :uG group modifier */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1341,8 +1413,10 @@ static int test__group_gh4(struct evlist *evlist)
 
                /* cache-misses:H + :uG group modifier */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1363,10 +1437,14 @@ static int test__leader_sample1(struct evlist *evlist)
                        evlist->core.nr_entries == (3 * num_core_entries()));
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles - sampling group leader */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1379,8 +1457,10 @@ static int test__leader_sample1(struct evlist *evlist)
 
                /* cache-misses - not sampling */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1392,8 +1472,10 @@ static int test__leader_sample1(struct evlist *evlist)
 
                /* branch-misses - not sampling */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
@@ -1415,10 +1497,14 @@ static int test__leader_sample2(struct evlist *evlist __maybe_unused)
                        evlist->core.nr_entries == (2 * num_core_entries()));
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* instructions - sampling group leader */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1431,8 +1517,10 @@ static int test__leader_sample2(struct evlist *evlist __maybe_unused)
 
                /* branch-misses - not sampling */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
                TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
                TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
@@ -1472,10 +1560,14 @@ static int test__pinned_group(struct evlist *evlist)
                        evlist->core.nr_entries == (3 * num_core_entries()));
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles - group leader */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
                TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
                /* TODO: The group modifier is not copied to the split group leader. */
@@ -1484,13 +1576,18 @@ static int test__pinned_group(struct evlist *evlist)
 
                /* cache-misses - can not be pinned, but will go on with the leader */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 
                /* branch-misses - ditto */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
        }
        return TEST_OK;
@@ -1517,10 +1614,14 @@ static int test__exclusive_group(struct evlist *evlist)
                        evlist->core.nr_entries == 3 * num_core_entries());
 
        for (int i = 0; i < num_core_entries(); i++) {
+               int ret;
+
                /* cycles - group leader */
                evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
                TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
                /* TODO: The group modifier is not copied to the split group leader. */
@@ -1529,13 +1630,18 @@ static int test__exclusive_group(struct evlist *evlist)
 
                /* cache-misses - can not be pinned, but will go on with the leader */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
 
                /* branch-misses - ditto */
                evsel = evsel__next(evsel);
-               TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
+               ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses");
+               if (ret)
+                       return ret;
+
                TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
        }
        return TEST_OK;
@@ -1677,9 +1783,11 @@ static int test__checkevent_raw_pmu(struct evlist *evlist)
 static int test__sym_event_slash(struct evlist *evlist)
 {
        struct evsel *evsel = evlist__first(evlist);
+       int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+
+       if (ret)
+               return ret;
 
-       TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
-       TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
        TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
        return TEST_OK;
 }
@@ -1687,9 +1795,11 @@ static int test__sym_event_slash(struct evlist *evlist)
 static int test__sym_event_dc(struct evlist *evlist)
 {
        struct evsel *evsel = evlist__first(evlist);
+       int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+
+       if (ret)
+               return ret;
 
-       TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
-       TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
        TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
        return TEST_OK;
 }
@@ -1697,9 +1807,11 @@ static int test__sym_event_dc(struct evlist *evlist)
 static int test__term_equal_term(struct evlist *evlist)
 {
        struct evsel *evsel = evlist__first(evlist);
+       int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+
+       if (ret)
+               return ret;
 
-       TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
-       TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
        TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "name") == 0);
        return TEST_OK;
 }
@@ -1707,9 +1819,11 @@ static int test__term_equal_term(struct evlist *evlist)
 static int test__term_equal_legacy(struct evlist *evlist)
 {
        struct evsel *evsel = evlist__first(evlist);
+       int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles");
+
+       if (ret)
+               return ret;
 
-       TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
-       TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
        TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "l1d") == 0);
        return TEST_OK;
 }

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index aa2f5c6fc7fc24f205b9c88012dfd8016fdf9b3e..66eabcea424274580abe69fd5226b16931a67dec 100644 (file)
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -976,7 +976,7 @@ static int config_term_pmu(struct perf_event_attr *attr,
                           struct parse_events_error *err)
 {
        if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE) {
-               const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
+               struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
 
                if (!pmu) {
                        char *err_str;
@@ -986,15 +986,23 @@ static int config_term_pmu(struct perf_event_attr *attr,
                                                           err_str, /*help=*/NULL);
                        return -EINVAL;
                }
-               if (perf_pmu__supports_legacy_cache(pmu)) {
+               /*
+                * Rewrite the PMU event to a legacy cache one unless the PMU
+                * doesn't support legacy cache events or the event is present
+                * within the PMU.
+                */
+               if (perf_pmu__supports_legacy_cache(pmu) &&
+                   !perf_pmu__have_event(pmu, term->config)) {
                        attr->type = PERF_TYPE_HW_CACHE;
                        return parse_events__decode_legacy_cache(term->config, pmu->type,
                                                                 &attr->config);
-               } else
+               } else {
                        term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
+                       term->no_value = true;
+               }
        }
        if (term->type_term == PARSE_EVENTS__TERM_TYPE_HARDWARE) {
-               const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
+               struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
 
                if (!pmu) {
                        char *err_str;
@@ -1004,10 +1012,19 @@ static int config_term_pmu(struct perf_event_attr *attr,
                                                           err_str, /*help=*/NULL);
                        return -EINVAL;
                }
-               attr->type = PERF_TYPE_HARDWARE;
-               attr->config = term->val.num;
-               if (perf_pmus__supports_extended_type())
-                       attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;
+               /*
+                * If the PMU has a sysfs or json event prefer it over
+                * legacy. ARM requires this.
+                */
+               if (perf_pmu__have_event(pmu, term->config)) {
+                       term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
+                       term->no_value = true;
+               } else {
+                       attr->type = PERF_TYPE_HARDWARE;
+                       attr->config = term->val.num;
+                       if (perf_pmus__supports_extended_type())
+                               attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;
+               }
                return 0;
        }
        if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
@@ -1381,6 +1398,7 @@ int parse_events_add_pmu(struct parse_events_state *parse_state,
        YYLTYPE *loc = loc_;
        LIST_HEAD(config_terms);
        struct parse_events_terms parsed_terms;
+       bool alias_rewrote_terms = false;
 
        pmu = parse_state->fake_pmu ?: perf_pmus__find(name);
 
@@ -1433,7 +1451,15 @@ int parse_events_add_pmu(struct parse_events_state *parse_state,
                return evsel ? 0 : -ENOMEM;
        }
 
-       if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, &parsed_terms, &info, err)) {
+       /* Configure attr/terms with a known PMU, this will set hardcoded terms. */
+       if (config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
+               parse_events_terms__exit(&parsed_terms);
+               return -EINVAL;
+       }
+
+       /* Look for event names in the terms and rewrite into format based terms. */
+       if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, &parsed_terms,
+                                                           &info, &alias_rewrote_terms, err)) {
                parse_events_terms__exit(&parsed_terms);
                return -EINVAL;
        }
@@ -1447,11 +1473,9 @@ int parse_events_add_pmu(struct parse_events_state *parse_state,
                strbuf_release(&sb);
        }
 
-       /*
-        * Configure hardcoded terms first, no need to check
-        * return value when called with fail == 0 ;)
-        */
-       if (config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
+       /* Configure attr/terms again if an alias was expanded. */
+       if (alias_rewrote_terms &&
+           config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
                parse_events_terms__exit(&parsed_terms);
                return -EINVAL;
        }

diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index d3c9aa4326bee4ba3d3b6594349d4e0426c2aae3..3c9609944a2f312e7cac681f8a19dd037d6eb01e 100644 (file)
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -1494,12 +1494,14 @@ static int check_info_data(struct perf_pmu *pmu,
  * defined for the alias
  */
 int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms,
-                         struct perf_pmu_info *info, struct parse_events_error *err)
+                         struct perf_pmu_info *info, bool *rewrote_terms,
+                         struct parse_events_error *err)
 {
        struct parse_events_term *term, *h;
        struct perf_pmu_alias *alias;
        int ret;
 
+       *rewrote_terms = false;
        info->per_pkg = false;
 
        /*
@@ -1521,7 +1523,7 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_
                                                NULL);
                        return ret;
                }
-
+               *rewrote_terms = true;
                ret = check_info_data(pmu, alias, info, err, term->err_term);
                if (ret)
                        return ret;
@@ -1615,6 +1617,8 @@ bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu)
 
 bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)
 {
+       if (!name)
+               return false;
        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/pmu.h b/tools/perf/util/pmu.h
index d2895d415f08fbf941bfd1bfa52f371307228e09..424c3fee09496248d6168ba5361d4fa9f66e28a2 100644 (file)
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -201,7 +201,8 @@ int perf_pmu__config_terms(const struct perf_pmu *pmu,
 __u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name);
 int perf_pmu__format_type(struct perf_pmu *pmu, const char *name);
 int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms,
-                         struct perf_pmu_info *info, struct parse_events_error *err);
+                         struct perf_pmu_info *info, bool *rewrote_terms,
+                         struct parse_events_error *err);
 int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb);
 
 int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load);