1// SPDX-License-Identifier: GPL-2.0 2#include "arch-tests.h" 3#include "debug.h" 4#include "evlist.h" 5#include "evsel.h" 6#include "pmu.h" 7#include "pmus.h" 8#include "tests/tests.h" 9 10static bool test_config(const struct evsel *evsel, __u64 expected_config) 11{ 12 return (evsel->core.attr.config & PERF_HW_EVENT_MASK) == expected_config; 13} 14 15static bool test_perf_config(const struct perf_evsel *evsel, __u64 expected_config) 16{ 17 return (evsel->attr.config & PERF_HW_EVENT_MASK) == expected_config; 18} 19 20static bool test_hybrid_type(const struct evsel *evsel, __u64 expected_config) 21{ 22 return (evsel->core.attr.config >> PERF_PMU_TYPE_SHIFT) == expected_config; 23} 24 25static int test__hybrid_hw_event_with_pmu(struct evlist *evlist) 26{ 27 struct evsel *evsel = evlist__first(evlist); 28 29 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 30 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 31 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 32 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)); 33 return TEST_OK; 34} 35 36static int test__hybrid_hw_group_event(struct evlist *evlist) 37{ 38 struct evsel *evsel, *leader; 39 40 evsel = leader = evlist__first(evlist); 41 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 42 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 43 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 44 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)); 45 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 46 47 evsel = evsel__next(evsel); 48 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 49 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 50 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS)); 51 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 52 return TEST_OK; 53} 54 55static int test__hybrid_sw_hw_group_event(struct evlist *evlist) 56{ 57 struct evsel *evsel, *leader; 58 59 evsel = leader = evlist__first(evlist); 60 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 61 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type); 62 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 63 64 evsel = evsel__next(evsel); 65 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 66 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 67 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)); 68 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 69 return TEST_OK; 70} 71 72static int test__hybrid_hw_sw_group_event(struct evlist *evlist) 73{ 74 struct evsel *evsel, *leader; 75 76 evsel = leader = evlist__first(evlist); 77 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 78 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 79 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 80 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)); 81 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 82 83 evsel = evsel__next(evsel); 84 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type); 85 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 86 return TEST_OK; 87} 88 89static int test__hybrid_group_modifier1(struct evlist *evlist) 90{ 91 struct evsel *evsel, *leader; 92 93 evsel = leader = evlist__first(evlist); 94 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 95 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 96 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 97 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)); 98 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 99 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 100 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 101 102 evsel = evsel__next(evsel); 103 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type); 104 TEST_ASSERT_VAL("wrong hybrid type", test_hybrid_type(evsel, PERF_TYPE_RAW)); 105 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS)); 106 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 107 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 108 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 109 return TEST_OK; 110} 111 112static int test__hybrid_raw1(struct evlist *evlist) 113{ 114 struct perf_evsel *evsel; 115 116 perf_evlist__for_each_evsel(&evlist->core, evsel) { 117 struct perf_pmu *pmu = perf_pmus__find_by_type(evsel->attr.type); 118 119 TEST_ASSERT_VAL("missing pmu", pmu); 120 TEST_ASSERT_VAL("unexpected pmu", !strncmp(pmu->name, "cpu_", 4)); 121 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, 0x1a)); 122 } 123 return TEST_OK; 124} 125 126static int test__hybrid_raw2(struct evlist *evlist) 127{ 128 struct evsel *evsel = evlist__first(evlist); 129 130 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 131 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 132 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a)); 133 return TEST_OK; 134} 135 136static int test__hybrid_cache_event(struct evlist *evlist) 137{ 138 struct evsel *evsel = evlist__first(evlist); 139 140 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 141 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type); 142 TEST_ASSERT_VAL("wrong config", 0x2 == (evsel->core.attr.config & 0xffffffff)); 143 return TEST_OK; 144} 145 146static int test__checkevent_pmu(struct evlist *evlist) 147{ 148 149 struct evsel *evsel = evlist__first(evlist); 150 151 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 152 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 153 TEST_ASSERT_VAL("wrong config", 10 == evsel->core.attr.config); 154 TEST_ASSERT_VAL("wrong config1", 1 == evsel->core.attr.config1); 155 TEST_ASSERT_VAL("wrong config2", 3 == evsel->core.attr.config2); 156 TEST_ASSERT_VAL("wrong config3", 0 == evsel->core.attr.config3); 157 /* 158 * The period value gets configured within evlist__config, 159 * while this test executes only parse events method. 160 */ 161 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period); 162 163 return TEST_OK; 164} 165 166struct evlist_test { 167 const char *name; 168 bool (*valid)(void); 169 int (*check)(struct evlist *evlist); 170}; 171 172static const struct evlist_test test__hybrid_events[] = { 173 { 174 .name = "cpu_core/cpu-cycles/", 175 .check = test__hybrid_hw_event_with_pmu, 176 /* 0 */ 177 }, 178 { 179 .name = "{cpu_core/cpu-cycles/,cpu_core/instructions/}", 180 .check = test__hybrid_hw_group_event, 181 /* 1 */ 182 }, 183 { 184 .name = "{cpu-clock,cpu_core/cpu-cycles/}", 185 .check = test__hybrid_sw_hw_group_event, 186 /* 2 */ 187 }, 188 { 189 .name = "{cpu_core/cpu-cycles/,cpu-clock}", 190 .check = test__hybrid_hw_sw_group_event, 191 /* 3 */ 192 }, 193 { 194 .name = "{cpu_core/cpu-cycles/k,cpu_core/instructions/u}", 195 .check = test__hybrid_group_modifier1, 196 /* 4 */ 197 }, 198 { 199 .name = "r1a", 200 .check = test__hybrid_raw1, 201 /* 5 */ 202 }, 203 { 204 .name = "cpu_core/r1a/", 205 .check = test__hybrid_raw2, 206 /* 6 */ 207 }, 208 { 209 .name = "cpu_core/config=10,config1,config2=3,period=1000/u", 210 .check = test__checkevent_pmu, 211 /* 7 */ 212 }, 213 { 214 .name = "cpu_core/LLC-loads/", 215 .check = test__hybrid_cache_event, 216 /* 8 */ 217 }, 218}; 219 220static int test_event(const struct evlist_test *e) 221{ 222 struct parse_events_error err; 223 struct evlist *evlist; 224 int ret; 225 226 if (e->valid && !e->valid()) { 227 pr_debug("... SKIP\n"); 228 return TEST_OK; 229 } 230 231 evlist = evlist__new(); 232 if (evlist == NULL) { 233 pr_err("Failed allocation"); 234 return TEST_FAIL; 235 } 236 parse_events_error__init(&err); 237 ret = parse_events(evlist, e->name, &err); 238 if (ret) { 239 pr_debug("failed to parse event '%s', err %d, str '%s'\n", 240 e->name, ret, err.str); 241 parse_events_error__print(&err, e->name); 242 ret = TEST_FAIL; 243 if (strstr(err.str, "can't access trace events")) 244 ret = TEST_SKIP; 245 } else { 246 ret = e->check(evlist); 247 } 248 parse_events_error__exit(&err); 249 evlist__delete(evlist); 250 251 return ret; 252} 253 254static int combine_test_results(int existing, int latest) 255{ 256 if (existing == TEST_FAIL) 257 return TEST_FAIL; 258 if (existing == TEST_SKIP) 259 return latest == TEST_OK ? TEST_SKIP : latest; 260 return latest; 261} 262 263static int test_events(const struct evlist_test *events, int cnt) 264{ 265 int ret = TEST_OK; 266 267 for (int i = 0; i < cnt; i++) { 268 const struct evlist_test *e = &events[i]; 269 int test_ret; 270 271 pr_debug("running test %d '%s'\n", i, e->name); 272 test_ret = test_event(e); 273 if (test_ret != TEST_OK) { 274 pr_debug("Event test failure: test %d '%s'", i, e->name); 275 ret = combine_test_results(ret, test_ret); 276 } 277 } 278 279 return ret; 280} 281 282int test__hybrid(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 283{ 284 if (perf_pmus__num_core_pmus() == 1) 285 return TEST_SKIP; 286 287 return test_events(test__hybrid_events, ARRAY_SIZE(test__hybrid_events)); 288} 289