1 // SPDX-License-Identifier: GPL-2.0
2 #include "parse-events.h"
3 #include "evsel.h"
4 #include "evlist.h"
5 #include <api/fs/fs.h>
6 #include "tests.h"
7 #include "debug.h"
8 #include "pmu.h"
9 #include "pmus.h"
10 #include <dirent.h>
11 #include <errno.h>
12 #include "fncache.h"
13 #include <sys/types.h>
14 #include <sys/stat.h>
15 #include <unistd.h>
16 #include <linux/kernel.h>
17 #include <linux/hw_breakpoint.h>
18 #include <api/fs/tracing_path.h>
19
20 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
21 PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
22
num_core_entries(void)23 static int num_core_entries(void)
24 {
25 /*
26 * If the kernel supports extended type, expect events to be
27 * opened once for each core PMU type. Otherwise fall back to the legacy
28 * behavior of opening only one event even though there are multiple
29 * PMUs
30 */
31 if (perf_pmus__supports_extended_type())
32 return perf_pmus__num_core_pmus();
33
34 return 1;
35 }
36
test_config(const struct evsel * evsel,__u64 expected_config)37 static bool test_config(const struct evsel *evsel, __u64 expected_config)
38 {
39 __u32 type = evsel->core.attr.type;
40 __u64 config = evsel->core.attr.config;
41
42 if (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE) {
43 /*
44 * HARDWARE and HW_CACHE events encode the PMU's extended type
45 * in the top 32-bits. Mask in order to ignore.
46 */
47 config &= PERF_HW_EVENT_MASK;
48 }
49 return config == expected_config;
50 }
51
test_perf_config(const struct perf_evsel * evsel,__u64 expected_config)52 static bool test_perf_config(const struct perf_evsel *evsel, __u64 expected_config)
53 {
54 return (evsel->attr.config & PERF_HW_EVENT_MASK) == expected_config;
55 }
56
57 #ifdef HAVE_LIBTRACEEVENT
58
59 #if defined(__s390x__)
60 /* Return true if kvm module is available and loaded. Test this
61 * and return success when trace point kvm_s390_create_vm
62 * exists. Otherwise this test always fails.
63 */
kvm_s390_create_vm_valid(void)64 static bool kvm_s390_create_vm_valid(void)
65 {
66 char *eventfile;
67 bool rc = false;
68
69 eventfile = get_events_file("kvm-s390");
70
71 if (eventfile) {
72 DIR *mydir = opendir(eventfile);
73
74 if (mydir) {
75 rc = true;
76 closedir(mydir);
77 }
78 put_events_file(eventfile);
79 }
80
81 return rc;
82 }
83 #endif
84
test__checkevent_tracepoint(struct evlist * evlist)85 static int test__checkevent_tracepoint(struct evlist *evlist)
86 {
87 struct evsel *evsel = evlist__first(evlist);
88
89 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
90 TEST_ASSERT_VAL("wrong number of groups", 0 == evlist__nr_groups(evlist));
91 TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
92 TEST_ASSERT_VAL("wrong sample_type",
93 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
94 TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
95 return TEST_OK;
96 }
97
test__checkevent_tracepoint_multi(struct evlist * evlist)98 static int test__checkevent_tracepoint_multi(struct evlist *evlist)
99 {
100 struct evsel *evsel;
101
102 TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1);
103 TEST_ASSERT_VAL("wrong number of groups", 0 == evlist__nr_groups(evlist));
104
105 evlist__for_each_entry(evlist, evsel) {
106 TEST_ASSERT_VAL("wrong type",
107 PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
108 TEST_ASSERT_VAL("wrong sample_type",
109 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
110 TEST_ASSERT_VAL("wrong sample_period",
111 1 == evsel->core.attr.sample_period);
112 }
113 return TEST_OK;
114 }
115 #endif /* HAVE_LIBTRACEEVENT */
116
test__checkevent_raw(struct evlist * evlist)117 static int test__checkevent_raw(struct evlist *evlist)
118 {
119 struct perf_evsel *evsel;
120 bool raw_type_match = false;
121
122 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
123
124 perf_evlist__for_each_evsel(&evlist->core, evsel) {
125 struct perf_pmu *pmu __maybe_unused = NULL;
126 bool type_matched = false;
127
128 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, 0x1a));
129 TEST_ASSERT_VAL("event not parsed as raw type",
130 evsel->attr.type == PERF_TYPE_RAW);
131 #if defined(__aarch64__)
132 /*
133 * Arm doesn't have a real raw type PMU in sysfs, so raw events
134 * would never match any PMU. However, RAW events on Arm will
135 * always successfully open on the first available core PMU
136 * so no need to test for a matching type here.
137 */
138 type_matched = raw_type_match = true;
139 #else
140 while ((pmu = perf_pmus__scan(pmu)) != NULL) {
141 if (pmu->type == evsel->attr.type) {
142 TEST_ASSERT_VAL("PMU type expected once", !type_matched);
143 type_matched = true;
144 if (pmu->type == PERF_TYPE_RAW)
145 raw_type_match = true;
146 }
147 }
148 #endif
149 TEST_ASSERT_VAL("No PMU found for type", type_matched);
150 }
151 TEST_ASSERT_VAL("Raw PMU not matched", raw_type_match);
152 return TEST_OK;
153 }
154
test__checkevent_numeric(struct evlist * evlist)155 static int test__checkevent_numeric(struct evlist *evlist)
156 {
157 struct evsel *evsel = evlist__first(evlist);
158
159 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
160 TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
161 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1));
162 return TEST_OK;
163 }
164
test__checkevent_symbolic_name(struct evlist * evlist)165 static int test__checkevent_symbolic_name(struct evlist *evlist)
166 {
167 struct perf_evsel *evsel;
168
169 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
170
171 perf_evlist__for_each_evsel(&evlist->core, evsel) {
172 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
173 TEST_ASSERT_VAL("wrong config",
174 test_perf_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
175 }
176 return TEST_OK;
177 }
178
test__checkevent_symbolic_name_config(struct evlist * evlist)179 static int test__checkevent_symbolic_name_config(struct evlist *evlist)
180 {
181 struct perf_evsel *evsel;
182
183 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
184
185 perf_evlist__for_each_evsel(&evlist->core, evsel) {
186 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
187 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
188 /*
189 * The period value gets configured within evlist__config,
190 * while this test executes only parse events method.
191 */
192 TEST_ASSERT_VAL("wrong period", 0 == evsel->attr.sample_period);
193 TEST_ASSERT_VAL("wrong config1", 0 == evsel->attr.config1);
194 TEST_ASSERT_VAL("wrong config2", 1 == evsel->attr.config2);
195 }
196 return TEST_OK;
197 }
198
test__checkevent_symbolic_alias(struct evlist * evlist)199 static int test__checkevent_symbolic_alias(struct evlist *evlist)
200 {
201 struct evsel *evsel = evlist__first(evlist);
202
203 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
204 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
205 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_SW_PAGE_FAULTS));
206 return TEST_OK;
207 }
208
test__checkevent_genhw(struct evlist * evlist)209 static int test__checkevent_genhw(struct evlist *evlist)
210 {
211 struct perf_evsel *evsel;
212
213 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries);
214
215 perf_evlist__for_each_entry(&evlist->core, evsel) {
216 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->attr.type);
217 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, 1 << 16));
218 }
219 return TEST_OK;
220 }
221
test__checkevent_breakpoint(struct evlist * evlist)222 static int test__checkevent_breakpoint(struct evlist *evlist)
223 {
224 struct evsel *evsel = evlist__first(evlist);
225
226 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
227 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
228 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
229 TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
230 evsel->core.attr.bp_type);
231 TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_4 ==
232 evsel->core.attr.bp_len);
233 return TEST_OK;
234 }
235
test__checkevent_breakpoint_x(struct evlist * evlist)236 static int test__checkevent_breakpoint_x(struct evlist *evlist)
237 {
238 struct evsel *evsel = evlist__first(evlist);
239
240 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
241 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
242 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
243 TEST_ASSERT_VAL("wrong bp_type",
244 HW_BREAKPOINT_X == evsel->core.attr.bp_type);
245 TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->core.attr.bp_len);
246 return TEST_OK;
247 }
248
test__checkevent_breakpoint_r(struct evlist * evlist)249 static int test__checkevent_breakpoint_r(struct evlist *evlist)
250 {
251 struct evsel *evsel = evlist__first(evlist);
252
253 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
254 TEST_ASSERT_VAL("wrong type",
255 PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
256 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
257 TEST_ASSERT_VAL("wrong bp_type",
258 HW_BREAKPOINT_R == evsel->core.attr.bp_type);
259 TEST_ASSERT_VAL("wrong bp_len",
260 HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
261 return TEST_OK;
262 }
263
test__checkevent_breakpoint_w(struct evlist * evlist)264 static int test__checkevent_breakpoint_w(struct evlist *evlist)
265 {
266 struct evsel *evsel = evlist__first(evlist);
267
268 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
269 TEST_ASSERT_VAL("wrong type",
270 PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
271 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
272 TEST_ASSERT_VAL("wrong bp_type",
273 HW_BREAKPOINT_W == evsel->core.attr.bp_type);
274 TEST_ASSERT_VAL("wrong bp_len",
275 HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
276 return TEST_OK;
277 }
278
test__checkevent_breakpoint_rw(struct evlist * evlist)279 static int test__checkevent_breakpoint_rw(struct evlist *evlist)
280 {
281 struct evsel *evsel = evlist__first(evlist);
282
283 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
284 TEST_ASSERT_VAL("wrong type",
285 PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
286 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
287 TEST_ASSERT_VAL("wrong bp_type",
288 (HW_BREAKPOINT_R|HW_BREAKPOINT_W) == evsel->core.attr.bp_type);
289 TEST_ASSERT_VAL("wrong bp_len",
290 HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
291 return TEST_OK;
292 }
293
294 #ifdef HAVE_LIBTRACEEVENT
test__checkevent_tracepoint_modifier(struct evlist * evlist)295 static int test__checkevent_tracepoint_modifier(struct evlist *evlist)
296 {
297 struct evsel *evsel = evlist__first(evlist);
298
299 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
300 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
301 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
302 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
303
304 return test__checkevent_tracepoint(evlist);
305 }
306
307 static int
test__checkevent_tracepoint_multi_modifier(struct evlist * evlist)308 test__checkevent_tracepoint_multi_modifier(struct evlist *evlist)
309 {
310 struct perf_evsel *evsel;
311
312 TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1);
313
314 perf_evlist__for_each_entry(&evlist->core, evsel) {
315 TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
316 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
317 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
318 TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
319 }
320
321 return test__checkevent_tracepoint_multi(evlist);
322 }
323 #endif /* HAVE_LIBTRACEEVENT */
324
test__checkevent_raw_modifier(struct evlist * evlist)325 static int test__checkevent_raw_modifier(struct evlist *evlist)
326 {
327 struct perf_evsel *evsel;
328
329 perf_evlist__for_each_entry(&evlist->core, evsel) {
330 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
331 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
332 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
333 TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
334 }
335 return test__checkevent_raw(evlist);
336 }
337
test__checkevent_numeric_modifier(struct evlist * evlist)338 static int test__checkevent_numeric_modifier(struct evlist *evlist)
339 {
340 struct perf_evsel *evsel;
341
342 perf_evlist__for_each_entry(&evlist->core, evsel) {
343 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
344 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
345 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
346 TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
347 }
348 return test__checkevent_numeric(evlist);
349 }
350
test__checkevent_symbolic_name_modifier(struct evlist * evlist)351 static int test__checkevent_symbolic_name_modifier(struct evlist *evlist)
352 {
353 struct perf_evsel *evsel;
354
355 TEST_ASSERT_VAL("wrong number of entries",
356 evlist->core.nr_entries == num_core_entries());
357
358 perf_evlist__for_each_entry(&evlist->core, evsel) {
359 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
360 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
361 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
362 TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
363 }
364 return test__checkevent_symbolic_name(evlist);
365 }
366
test__checkevent_exclude_host_modifier(struct evlist * evlist)367 static int test__checkevent_exclude_host_modifier(struct evlist *evlist)
368 {
369 struct perf_evsel *evsel;
370
371 perf_evlist__for_each_entry(&evlist->core, evsel) {
372 TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
373 TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
374 }
375 return test__checkevent_symbolic_name(evlist);
376 }
377
test__checkevent_exclude_guest_modifier(struct evlist * evlist)378 static int test__checkevent_exclude_guest_modifier(struct evlist *evlist)
379 {
380 struct perf_evsel *evsel;
381
382 perf_evlist__for_each_entry(&evlist->core, evsel) {
383 TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
384 TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
385 }
386 return test__checkevent_symbolic_name(evlist);
387 }
388
test__checkevent_symbolic_alias_modifier(struct evlist * evlist)389 static int test__checkevent_symbolic_alias_modifier(struct evlist *evlist)
390 {
391 struct evsel *evsel = evlist__first(evlist);
392
393 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
394 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
395 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
396 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
397
398 return test__checkevent_symbolic_alias(evlist);
399 }
400
test__checkevent_genhw_modifier(struct evlist * evlist)401 static int test__checkevent_genhw_modifier(struct evlist *evlist)
402 {
403 struct perf_evsel *evsel;
404
405 perf_evlist__for_each_entry(&evlist->core, evsel) {
406 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
407 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
408 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
409 TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
410 }
411 return test__checkevent_genhw(evlist);
412 }
413
test__checkevent_exclude_idle_modifier(struct evlist * evlist)414 static int test__checkevent_exclude_idle_modifier(struct evlist *evlist)
415 {
416 struct evsel *evsel = evlist__first(evlist);
417
418 TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle);
419 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
420 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
421 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
422 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
423 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
424 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
425
426 return test__checkevent_symbolic_name(evlist);
427 }
428
test__checkevent_exclude_idle_modifier_1(struct evlist * evlist)429 static int test__checkevent_exclude_idle_modifier_1(struct evlist *evlist)
430 {
431 struct evsel *evsel = evlist__first(evlist);
432
433 TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle);
434 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
435 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
436 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
437 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
438 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
439 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
440
441 return test__checkevent_symbolic_name(evlist);
442 }
443
test__checkevent_breakpoint_modifier(struct evlist * evlist)444 static int test__checkevent_breakpoint_modifier(struct evlist *evlist)
445 {
446 struct evsel *evsel = evlist__first(evlist);
447
448
449 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
450 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
451 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
452 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
453 TEST_ASSERT_VAL("wrong name",
454 !strcmp(evsel__name(evsel), "mem:0:u"));
455
456 return test__checkevent_breakpoint(evlist);
457 }
458
test__checkevent_breakpoint_x_modifier(struct evlist * evlist)459 static int test__checkevent_breakpoint_x_modifier(struct evlist *evlist)
460 {
461 struct evsel *evsel = evlist__first(evlist);
462
463 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
464 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
465 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
466 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
467 TEST_ASSERT_VAL("wrong name",
468 !strcmp(evsel__name(evsel), "mem:0:x:k"));
469
470 return test__checkevent_breakpoint_x(evlist);
471 }
472
test__checkevent_breakpoint_r_modifier(struct evlist * evlist)473 static int test__checkevent_breakpoint_r_modifier(struct evlist *evlist)
474 {
475 struct evsel *evsel = evlist__first(evlist);
476
477 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
478 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
479 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
480 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
481 TEST_ASSERT_VAL("wrong name",
482 !strcmp(evsel__name(evsel), "mem:0:r:hp"));
483
484 return test__checkevent_breakpoint_r(evlist);
485 }
486
test__checkevent_breakpoint_w_modifier(struct evlist * evlist)487 static int test__checkevent_breakpoint_w_modifier(struct evlist *evlist)
488 {
489 struct evsel *evsel = evlist__first(evlist);
490
491 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
492 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
493 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
494 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
495 TEST_ASSERT_VAL("wrong name",
496 !strcmp(evsel__name(evsel), "mem:0:w:up"));
497
498 return test__checkevent_breakpoint_w(evlist);
499 }
500
test__checkevent_breakpoint_rw_modifier(struct evlist * evlist)501 static int test__checkevent_breakpoint_rw_modifier(struct evlist *evlist)
502 {
503 struct evsel *evsel = evlist__first(evlist);
504
505 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
506 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
507 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
508 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
509 TEST_ASSERT_VAL("wrong name",
510 !strcmp(evsel__name(evsel), "mem:0:rw:kp"));
511
512 return test__checkevent_breakpoint_rw(evlist);
513 }
514
test__checkevent_breakpoint_modifier_name(struct evlist * evlist)515 static int test__checkevent_breakpoint_modifier_name(struct evlist *evlist)
516 {
517 struct evsel *evsel = evlist__first(evlist);
518
519 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
520 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
521 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
522 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
523 TEST_ASSERT_VAL("wrong name",
524 !strcmp(evsel__name(evsel), "breakpoint"));
525
526 return test__checkevent_breakpoint(evlist);
527 }
528
test__checkevent_breakpoint_x_modifier_name(struct evlist * evlist)529 static int test__checkevent_breakpoint_x_modifier_name(struct evlist *evlist)
530 {
531 struct evsel *evsel = evlist__first(evlist);
532
533 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
534 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
535 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
536 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
537 TEST_ASSERT_VAL("wrong name",
538 !strcmp(evsel__name(evsel), "breakpoint"));
539
540 return test__checkevent_breakpoint_x(evlist);
541 }
542
test__checkevent_breakpoint_r_modifier_name(struct evlist * evlist)543 static int test__checkevent_breakpoint_r_modifier_name(struct evlist *evlist)
544 {
545 struct evsel *evsel = evlist__first(evlist);
546
547 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
548 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
549 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
550 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
551 TEST_ASSERT_VAL("wrong name",
552 !strcmp(evsel__name(evsel), "breakpoint"));
553
554 return test__checkevent_breakpoint_r(evlist);
555 }
556
test__checkevent_breakpoint_w_modifier_name(struct evlist * evlist)557 static int test__checkevent_breakpoint_w_modifier_name(struct evlist *evlist)
558 {
559 struct evsel *evsel = evlist__first(evlist);
560
561 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
562 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
563 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
564 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
565 TEST_ASSERT_VAL("wrong name",
566 !strcmp(evsel__name(evsel), "breakpoint"));
567
568 return test__checkevent_breakpoint_w(evlist);
569 }
570
test__checkevent_breakpoint_rw_modifier_name(struct evlist * evlist)571 static int test__checkevent_breakpoint_rw_modifier_name(struct evlist *evlist)
572 {
573 struct evsel *evsel = evlist__first(evlist);
574
575 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
576 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
577 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
578 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
579 TEST_ASSERT_VAL("wrong name",
580 !strcmp(evsel__name(evsel), "breakpoint"));
581
582 return test__checkevent_breakpoint_rw(evlist);
583 }
584
test__checkevent_breakpoint_2_events(struct evlist * evlist)585 static int test__checkevent_breakpoint_2_events(struct evlist *evlist)
586 {
587 struct evsel *evsel = evlist__first(evlist);
588
589 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
590
591 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
592 TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "breakpoint1"));
593
594 evsel = evsel__next(evsel);
595
596 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
597 TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "breakpoint2"));
598
599 return TEST_OK;
600 }
601
test__checkevent_pmu(struct evlist * evlist)602 static int test__checkevent_pmu(struct evlist *evlist)
603 {
604
605 struct evsel *evsel = evlist__first(evlist);
606
607 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
608 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
609 TEST_ASSERT_VAL("wrong config", test_config(evsel, 10));
610 TEST_ASSERT_VAL("wrong config1", 1 == evsel->core.attr.config1);
611 TEST_ASSERT_VAL("wrong config2", 3 == evsel->core.attr.config2);
612 TEST_ASSERT_VAL("wrong config3", 0 == evsel->core.attr.config3);
613 /*
614 * The period value gets configured within evlist__config,
615 * while this test executes only parse events method.
616 */
617 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period);
618
619 return TEST_OK;
620 }
621
622 #ifdef HAVE_LIBTRACEEVENT
test__checkevent_list(struct evlist * evlist)623 static int test__checkevent_list(struct evlist *evlist)
624 {
625 struct evsel *evsel = evlist__first(evlist);
626
627 TEST_ASSERT_VAL("wrong number of entries", 3 <= evlist->core.nr_entries);
628
629 /* r1 */
630 TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT != evsel->core.attr.type);
631 while (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
632 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1));
633 TEST_ASSERT_VAL("wrong config1", 0 == evsel->core.attr.config1);
634 TEST_ASSERT_VAL("wrong config2", 0 == evsel->core.attr.config2);
635 TEST_ASSERT_VAL("wrong config3", 0 == evsel->core.attr.config3);
636 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
637 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
638 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
639 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
640 evsel = evsel__next(evsel);
641 }
642
643 /* syscalls:sys_enter_openat:k */
644 TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
645 TEST_ASSERT_VAL("wrong sample_type",
646 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
647 TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
648 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
649 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
650 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
651 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
652
653 /* 1:1:hp */
654 evsel = evsel__next(evsel);
655 TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
656 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1));
657 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
658 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
659 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
660 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
661
662 return TEST_OK;
663 }
664 #endif
665
test__checkevent_pmu_name(struct evlist * evlist)666 static int test__checkevent_pmu_name(struct evlist *evlist)
667 {
668 struct evsel *evsel = evlist__first(evlist);
669
670 /* cpu/config=1,name=krava/u */
671 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
672 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
673 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1));
674 TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "krava"));
675
676 /* cpu/config=2/u" */
677 evsel = evsel__next(evsel);
678 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
679 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
680 TEST_ASSERT_VAL("wrong config", test_config(evsel, 2));
681 TEST_ASSERT_VAL("wrong name",
682 !strcmp(evsel__name(evsel), "cpu/config=2/u"));
683
684 return TEST_OK;
685 }
686
test__checkevent_pmu_partial_time_callgraph(struct evlist * evlist)687 static int test__checkevent_pmu_partial_time_callgraph(struct evlist *evlist)
688 {
689 struct evsel *evsel = evlist__first(evlist);
690
691 /* cpu/config=1,call-graph=fp,time,period=100000/ */
692 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
693 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
694 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1));
695 /*
696 * The period, time and callgraph value gets configured within evlist__config,
697 * while this test executes only parse events method.
698 */
699 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period);
700 TEST_ASSERT_VAL("wrong callgraph", !evsel__has_callchain(evsel));
701 TEST_ASSERT_VAL("wrong time", !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type));
702
703 /* cpu/config=2,call-graph=no,time=0,period=2000/ */
704 evsel = evsel__next(evsel);
705 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
706 TEST_ASSERT_VAL("wrong config", test_config(evsel, 2));
707 /*
708 * The period, time and callgraph value gets configured within evlist__config,
709 * while this test executes only parse events method.
710 */
711 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period);
712 TEST_ASSERT_VAL("wrong callgraph", !evsel__has_callchain(evsel));
713 TEST_ASSERT_VAL("wrong time", !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type));
714
715 return TEST_OK;
716 }
717
test__checkevent_pmu_events(struct evlist * evlist)718 static int test__checkevent_pmu_events(struct evlist *evlist)
719 {
720 struct evsel *evsel = evlist__first(evlist);
721
722 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
723 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type ||
724 strcmp(evsel->pmu_name, "cpu"));
725 TEST_ASSERT_VAL("wrong exclude_user",
726 !evsel->core.attr.exclude_user);
727 TEST_ASSERT_VAL("wrong exclude_kernel",
728 evsel->core.attr.exclude_kernel);
729 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
730 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
731 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
732 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
733
734 return TEST_OK;
735 }
736
737
test__checkevent_pmu_events_mix(struct evlist * evlist)738 static int test__checkevent_pmu_events_mix(struct evlist *evlist)
739 {
740 struct evsel *evsel = NULL;
741
742 /*
743 * The wild card event will be opened at least once, but it may be
744 * opened on each core PMU.
745 */
746 TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries >= 2);
747 for (int i = 0; i < evlist->core.nr_entries - 1; i++) {
748 evsel = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
749 /* pmu-event:u */
750 TEST_ASSERT_VAL("wrong exclude_user",
751 !evsel->core.attr.exclude_user);
752 TEST_ASSERT_VAL("wrong exclude_kernel",
753 evsel->core.attr.exclude_kernel);
754 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
755 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
756 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
757 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
758 }
759 /* cpu/pmu-event/u*/
760 evsel = evsel__next(evsel);
761 TEST_ASSERT_VAL("wrong type", evsel__find_pmu(evsel)->is_core);
762 TEST_ASSERT_VAL("wrong exclude_user",
763 !evsel->core.attr.exclude_user);
764 TEST_ASSERT_VAL("wrong exclude_kernel",
765 evsel->core.attr.exclude_kernel);
766 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
767 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
768 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
769 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.pinned);
770
771 return TEST_OK;
772 }
773
test__checkterms_simple(struct list_head * terms)774 static int test__checkterms_simple(struct list_head *terms)
775 {
776 struct parse_events_term *term;
777
778 /* config=10 */
779 term = list_entry(terms->next, struct parse_events_term, list);
780 TEST_ASSERT_VAL("wrong type term",
781 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
782 TEST_ASSERT_VAL("wrong type val",
783 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
784 TEST_ASSERT_VAL("wrong val", term->val.num == 10);
785 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config"));
786
787 /* config1 */
788 term = list_entry(term->list.next, struct parse_events_term, list);
789 TEST_ASSERT_VAL("wrong type term",
790 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1);
791 TEST_ASSERT_VAL("wrong type val",
792 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
793 TEST_ASSERT_VAL("wrong val", term->val.num == 1);
794 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config1"));
795
796 /* config2=3 */
797 term = list_entry(term->list.next, struct parse_events_term, list);
798 TEST_ASSERT_VAL("wrong type term",
799 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2);
800 TEST_ASSERT_VAL("wrong type val",
801 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
802 TEST_ASSERT_VAL("wrong val", term->val.num == 3);
803 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config2"));
804
805 /* config3=4 */
806 term = list_entry(term->list.next, struct parse_events_term, list);
807 TEST_ASSERT_VAL("wrong type term",
808 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG3);
809 TEST_ASSERT_VAL("wrong type val",
810 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
811 TEST_ASSERT_VAL("wrong val", term->val.num == 4);
812 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config3"));
813
814 /* umask=1*/
815 term = list_entry(term->list.next, struct parse_events_term, list);
816 TEST_ASSERT_VAL("wrong type term",
817 term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
818 TEST_ASSERT_VAL("wrong type val",
819 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
820 TEST_ASSERT_VAL("wrong val", term->val.num == 1);
821 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "umask"));
822
823 /*
824 * read
825 *
826 * The perf_pmu__test_parse_init injects 'read' term into
827 * perf_pmu_events_list, so 'read' is evaluated as read term
828 * and not as raw event with 'ead' hex value.
829 */
830 term = list_entry(term->list.next, struct parse_events_term, list);
831 TEST_ASSERT_VAL("wrong type term",
832 term->type_term == PARSE_EVENTS__TERM_TYPE_RAW);
833 TEST_ASSERT_VAL("wrong type val",
834 term->type_val == PARSE_EVENTS__TERM_TYPE_STR);
835 TEST_ASSERT_VAL("wrong val", !strcmp(term->val.str, "read"));
836 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "raw"));
837
838 /*
839 * r0xead
840 *
841 * To be still able to pass 'ead' value with 'r' syntax,
842 * we added support to parse 'r0xHEX' event.
843 */
844 term = list_entry(term->list.next, struct parse_events_term, list);
845 TEST_ASSERT_VAL("wrong type term",
846 term->type_term == PARSE_EVENTS__TERM_TYPE_RAW);
847 TEST_ASSERT_VAL("wrong type val",
848 term->type_val == PARSE_EVENTS__TERM_TYPE_STR);
849 TEST_ASSERT_VAL("wrong val", !strcmp(term->val.str, "r0xead"));
850 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "raw"));
851 return TEST_OK;
852 }
853
test__group1(struct evlist * evlist)854 static int test__group1(struct evlist *evlist)
855 {
856 struct evsel *evsel, *leader;
857
858 TEST_ASSERT_VAL("wrong number of entries",
859 evlist->core.nr_entries == (num_core_entries() * 2));
860 TEST_ASSERT_VAL("wrong number of groups",
861 evlist__nr_groups(evlist) == num_core_entries());
862
863 for (int i = 0; i < num_core_entries(); i++) {
864 /* instructions:k */
865 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
866 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
867 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
868 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
869 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
870 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
871 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
872 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
873 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
874 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
875 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
876 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
877 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
878
879 /* cycles:upp */
880 evsel = evsel__next(evsel);
881 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
882 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
883 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
884 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
885 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
886 /* use of precise requires exclude_guest */
887 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
888 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
889 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
890 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
891 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
892 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
893 }
894 return TEST_OK;
895 }
896
test__group2(struct evlist * evlist)897 static int test__group2(struct evlist *evlist)
898 {
899 struct evsel *evsel, *leader = NULL;
900
901 TEST_ASSERT_VAL("wrong number of entries",
902 evlist->core.nr_entries == (2 * num_core_entries() + 1));
903 /*
904 * TODO: Currently the software event won't be grouped with the hardware
905 * event except for 1 PMU.
906 */
907 TEST_ASSERT_VAL("wrong number of groups", 1 == evlist__nr_groups(evlist));
908
909 evlist__for_each_entry(evlist, evsel) {
910 if (evsel->core.attr.type == PERF_TYPE_SOFTWARE) {
911 /* faults + :ku modifier */
912 leader = evsel;
913 TEST_ASSERT_VAL("wrong config",
914 test_config(evsel, PERF_COUNT_SW_PAGE_FAULTS));
915 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
916 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
917 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
918 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
919 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
920 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
921 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
922 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
923 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
924 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
925 continue;
926 }
927 if (evsel->core.attr.type == PERF_TYPE_HARDWARE &&
928 test_config(evsel, PERF_COUNT_HW_CACHE_REFERENCES)) {
929 /* cache-references + :u modifier */
930 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
931 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
932 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
933 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
934 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
935 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
936 if (evsel__has_leader(evsel, leader))
937 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
938 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
939 continue;
940 }
941 /* cycles:k */
942 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
943 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
944 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
945 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
946 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
947 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
948 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
949 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
950 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
951 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
952 }
953 return TEST_OK;
954 }
955
956 #ifdef HAVE_LIBTRACEEVENT
test__group3(struct evlist * evlist __maybe_unused)957 static int test__group3(struct evlist *evlist __maybe_unused)
958 {
959 struct evsel *evsel, *group1_leader = NULL, *group2_leader = NULL;
960
961 TEST_ASSERT_VAL("wrong number of entries",
962 evlist->core.nr_entries == (3 * perf_pmus__num_core_pmus() + 2));
963 /*
964 * Currently the software event won't be grouped with the hardware event
965 * except for 1 PMU. This means there are always just 2 groups
966 * regardless of the number of core PMUs.
967 */
968 TEST_ASSERT_VAL("wrong number of groups", 2 == evlist__nr_groups(evlist));
969
970 evlist__for_each_entry(evlist, evsel) {
971 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
972 /* group1 syscalls:sys_enter_openat:H */
973 group1_leader = evsel;
974 TEST_ASSERT_VAL("wrong sample_type",
975 evsel->core.attr.sample_type == PERF_TP_SAMPLE_TYPE);
976 TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
977 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
978 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
979 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
980 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
981 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
982 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
983 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
984 TEST_ASSERT_VAL("wrong group name", !strcmp(evsel->group_name, "group1"));
985 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
986 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
987 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
988 continue;
989 }
990 if (evsel->core.attr.type == PERF_TYPE_HARDWARE &&
991 test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)) {
992 if (evsel->core.attr.exclude_user) {
993 /* group1 cycles:kppp */
994 TEST_ASSERT_VAL("wrong exclude_user",
995 evsel->core.attr.exclude_user);
996 TEST_ASSERT_VAL("wrong exclude_kernel",
997 !evsel->core.attr.exclude_kernel);
998 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
999 /* use of precise requires exclude_guest */
1000 TEST_ASSERT_VAL("wrong exclude guest",
1001 evsel->core.attr.exclude_guest);
1002 TEST_ASSERT_VAL("wrong exclude host",
1003 !evsel->core.attr.exclude_host);
1004 TEST_ASSERT_VAL("wrong precise_ip",
1005 evsel->core.attr.precise_ip == 3);
1006 if (evsel__has_leader(evsel, group1_leader)) {
1007 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1008 TEST_ASSERT_VAL("wrong group_idx",
1009 evsel__group_idx(evsel) == 1);
1010 }
1011 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1012 } else {
1013 /* group2 cycles + G modifier */
1014 group2_leader = evsel;
1015 TEST_ASSERT_VAL("wrong exclude_kernel",
1016 !evsel->core.attr.exclude_kernel);
1017 TEST_ASSERT_VAL("wrong exclude_hv",
1018 !evsel->core.attr.exclude_hv);
1019 TEST_ASSERT_VAL("wrong exclude guest",
1020 !evsel->core.attr.exclude_guest);
1021 TEST_ASSERT_VAL("wrong exclude host",
1022 evsel->core.attr.exclude_host);
1023 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1024 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1025 if (evsel->core.nr_members == 2) {
1026 TEST_ASSERT_VAL("wrong group_idx",
1027 evsel__group_idx(evsel) == 0);
1028 }
1029 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1030 }
1031 continue;
1032 }
1033 if (evsel->core.attr.type == 1) {
1034 /* group2 1:3 + G modifier */
1035 TEST_ASSERT_VAL("wrong config", test_config(evsel, 3));
1036 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1037 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1038 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1039 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1040 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1041 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1042 if (evsel__has_leader(evsel, group2_leader))
1043 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1044 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1045 continue;
1046 }
1047 /* instructions:u */
1048 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1049 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
1050 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1051 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1052 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1053 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1054 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1055 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1056 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1057 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1058 }
1059 return TEST_OK;
1060 }
1061 #endif
1062
test__group4(struct evlist * evlist __maybe_unused)1063 static int test__group4(struct evlist *evlist __maybe_unused)
1064 {
1065 struct evsel *evsel, *leader;
1066
1067 TEST_ASSERT_VAL("wrong number of entries",
1068 evlist->core.nr_entries == (num_core_entries() * 2));
1069 TEST_ASSERT_VAL("wrong number of groups",
1070 num_core_entries() == evlist__nr_groups(evlist));
1071
1072 for (int i = 0; i < num_core_entries(); i++) {
1073 /* cycles:u + p */
1074 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1075 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1076 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1077 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1078 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1079 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1080 /* use of precise requires exclude_guest */
1081 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1082 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1083 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 1);
1084 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1085 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1086 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1087 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1088 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1089
1090 /* instructions:kp + p */
1091 evsel = evsel__next(evsel);
1092 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1093 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
1094 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1095 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1096 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1097 /* use of precise requires exclude_guest */
1098 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1099 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1100 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
1101 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1102 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1103 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1104 }
1105 return TEST_OK;
1106 }
1107
test__group5(struct evlist * evlist __maybe_unused)1108 static int test__group5(struct evlist *evlist __maybe_unused)
1109 {
1110 struct evsel *evsel = NULL, *leader;
1111
1112 TEST_ASSERT_VAL("wrong number of entries",
1113 evlist->core.nr_entries == (5 * num_core_entries()));
1114 TEST_ASSERT_VAL("wrong number of groups",
1115 evlist__nr_groups(evlist) == (2 * num_core_entries()));
1116
1117 for (int i = 0; i < num_core_entries(); i++) {
1118 /* cycles + G */
1119 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1120 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1121 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1122 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1123 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1124 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1125 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1126 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1127 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1128 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1129 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1130 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1131 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1132 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1133
1134 /* instructions + G */
1135 evsel = evsel__next(evsel);
1136 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1137 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
1138 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1139 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1140 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1141 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1142 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1143 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1144 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1145 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1146 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1147 }
1148 for (int i = 0; i < num_core_entries(); i++) {
1149 /* cycles:G */
1150 evsel = leader = evsel__next(evsel);
1151 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1152 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1153 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1154 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1155 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1156 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1157 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1158 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1159 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1160 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1161 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1162 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1163 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
1164
1165 /* instructions:G */
1166 evsel = evsel__next(evsel);
1167 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1168 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
1169 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1170 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1171 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1172 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1173 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1174 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1175 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1176 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1177 }
1178 for (int i = 0; i < num_core_entries(); i++) {
1179 /* cycles */
1180 evsel = evsel__next(evsel);
1181 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1182 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1183 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1184 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1185 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1186 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1187 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1188 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1189 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1190 }
1191 return TEST_OK;
1192 }
1193
test__group_gh1(struct evlist * evlist)1194 static int test__group_gh1(struct evlist *evlist)
1195 {
1196 struct evsel *evsel = NULL, *leader;
1197
1198 TEST_ASSERT_VAL("wrong number of entries",
1199 evlist->core.nr_entries == (2 * num_core_entries()));
1200 TEST_ASSERT_VAL("wrong number of groups",
1201 evlist__nr_groups(evlist) == num_core_entries());
1202
1203 for (int i = 0; i < num_core_entries(); i++) {
1204 /* cycles + :H group modifier */
1205 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1206 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1207 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1208 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1209 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1210 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1211 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1212 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1213 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1214 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1215 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1216 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1217 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1218
1219 /* cache-misses:G + :H group modifier */
1220 evsel = evsel__next(evsel);
1221 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1222 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1223 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1224 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1225 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1226 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1227 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1228 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1229 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1230 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1231 }
1232 return TEST_OK;
1233 }
1234
test__group_gh2(struct evlist * evlist)1235 static int test__group_gh2(struct evlist *evlist)
1236 {
1237 struct evsel *evsel = NULL, *leader;
1238
1239 TEST_ASSERT_VAL("wrong number of entries",
1240 evlist->core.nr_entries == (2 * num_core_entries()));
1241 TEST_ASSERT_VAL("wrong number of groups",
1242 evlist__nr_groups(evlist) == num_core_entries());
1243
1244 for (int i = 0; i < num_core_entries(); i++) {
1245 /* cycles + :G group modifier */
1246 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1247 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1248 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1249 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1250 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1251 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1252 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1253 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1254 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1255 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1256 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1257 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1258 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1259
1260 /* cache-misses:H + :G group modifier */
1261 evsel = evsel__next(evsel);
1262 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1263 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1264 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1265 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1266 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1267 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1268 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1269 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1270 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1271 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1272 }
1273 return TEST_OK;
1274 }
1275
test__group_gh3(struct evlist * evlist)1276 static int test__group_gh3(struct evlist *evlist)
1277 {
1278 struct evsel *evsel = NULL, *leader;
1279
1280 TEST_ASSERT_VAL("wrong number of entries",
1281 evlist->core.nr_entries == (2 * num_core_entries()));
1282 TEST_ASSERT_VAL("wrong number of groups",
1283 evlist__nr_groups(evlist) == num_core_entries());
1284
1285 for (int i = 0; i < num_core_entries(); i++) {
1286 /* cycles:G + :u group modifier */
1287 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1288 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1289 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1290 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1291 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1292 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1293 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1294 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1295 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1296 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1297 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1298 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1299 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1300
1301 /* cache-misses:H + :u group modifier */
1302 evsel = evsel__next(evsel);
1303 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1304 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1305 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1306 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1307 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1308 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1309 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1310 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1311 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1312 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1313 }
1314 return TEST_OK;
1315 }
1316
test__group_gh4(struct evlist * evlist)1317 static int test__group_gh4(struct evlist *evlist)
1318 {
1319 struct evsel *evsel = NULL, *leader;
1320
1321 TEST_ASSERT_VAL("wrong number of entries",
1322 evlist->core.nr_entries == (2 * num_core_entries()));
1323 TEST_ASSERT_VAL("wrong number of groups",
1324 evlist__nr_groups(evlist) == num_core_entries());
1325
1326 for (int i = 0; i < num_core_entries(); i++) {
1327 /* cycles:G + :uG group modifier */
1328 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1329 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1330 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1331 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1332 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1333 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1334 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1335 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1336 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1337 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1338 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1339 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1340 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1341
1342 /* cache-misses:H + :uG group modifier */
1343 evsel = evsel__next(evsel);
1344 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1345 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1346 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1347 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1348 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1349 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1350 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1351 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1352 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1353 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1354 }
1355 return TEST_OK;
1356 }
1357
test__leader_sample1(struct evlist * evlist)1358 static int test__leader_sample1(struct evlist *evlist)
1359 {
1360 struct evsel *evsel = NULL, *leader;
1361
1362 TEST_ASSERT_VAL("wrong number of entries",
1363 evlist->core.nr_entries == (3 * num_core_entries()));
1364
1365 for (int i = 0; i < num_core_entries(); i++) {
1366 /* cycles - sampling group leader */
1367 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1368 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1369 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1370 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1371 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1372 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1373 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1374 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1375 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1376 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1377 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1378 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1379
1380 /* cache-misses - not sampling */
1381 evsel = evsel__next(evsel);
1382 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1383 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1384 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1385 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1386 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1387 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1388 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1389 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1390 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1391 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1392
1393 /* branch-misses - not sampling */
1394 evsel = evsel__next(evsel);
1395 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1396 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
1397 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1398 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1399 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1400 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1401 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1402 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1403 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1404 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1405 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1406 }
1407 return TEST_OK;
1408 }
1409
test__leader_sample2(struct evlist * evlist __maybe_unused)1410 static int test__leader_sample2(struct evlist *evlist __maybe_unused)
1411 {
1412 struct evsel *evsel = NULL, *leader;
1413
1414 TEST_ASSERT_VAL("wrong number of entries",
1415 evlist->core.nr_entries == (2 * num_core_entries()));
1416
1417 for (int i = 0; i < num_core_entries(); i++) {
1418 /* instructions - sampling group leader */
1419 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1420 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1421 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_INSTRUCTIONS));
1422 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1423 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1424 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1425 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1426 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1427 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1428 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1429 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1430 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1431
1432 /* branch-misses - not sampling */
1433 evsel = evsel__next(evsel);
1434 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1435 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
1436 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1437 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1438 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1439 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1440 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1441 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1442 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1443 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1444 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1445 }
1446 return TEST_OK;
1447 }
1448
test__checkevent_pinned_modifier(struct evlist * evlist)1449 static int test__checkevent_pinned_modifier(struct evlist *evlist)
1450 {
1451 struct evsel *evsel = NULL;
1452
1453 TEST_ASSERT_VAL("wrong number of entries",
1454 evlist->core.nr_entries == num_core_entries());
1455
1456 for (int i = 0; i < num_core_entries(); i++) {
1457 evsel = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1458 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1459 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1460 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1461 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1462 TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1463 }
1464 return test__checkevent_symbolic_name(evlist);
1465 }
1466
test__pinned_group(struct evlist * evlist)1467 static int test__pinned_group(struct evlist *evlist)
1468 {
1469 struct evsel *evsel = NULL, *leader;
1470
1471 TEST_ASSERT_VAL("wrong number of entries",
1472 evlist->core.nr_entries == (3 * num_core_entries()));
1473
1474 for (int i = 0; i < num_core_entries(); i++) {
1475 /* cycles - group leader */
1476 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1477 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1478 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1479 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1480 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1481 /* TODO: The group modifier is not copied to the split group leader. */
1482 if (perf_pmus__num_core_pmus() == 1)
1483 TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1484
1485 /* cache-misses - can not be pinned, but will go on with the leader */
1486 evsel = evsel__next(evsel);
1487 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1488 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1489 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1490
1491 /* branch-misses - ditto */
1492 evsel = evsel__next(evsel);
1493 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
1494 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1495 }
1496 return TEST_OK;
1497 }
1498
test__checkevent_exclusive_modifier(struct evlist * evlist)1499 static int test__checkevent_exclusive_modifier(struct evlist *evlist)
1500 {
1501 struct evsel *evsel = evlist__first(evlist);
1502
1503 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1504 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1505 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1506 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1507 TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive);
1508
1509 return test__checkevent_symbolic_name(evlist);
1510 }
1511
test__exclusive_group(struct evlist * evlist)1512 static int test__exclusive_group(struct evlist *evlist)
1513 {
1514 struct evsel *evsel = NULL, *leader;
1515
1516 TEST_ASSERT_VAL("wrong number of entries",
1517 evlist->core.nr_entries == 3 * num_core_entries());
1518
1519 for (int i = 0; i < num_core_entries(); i++) {
1520 /* cycles - group leader */
1521 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1522 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1523 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1524 TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1525 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1526 /* TODO: The group modifier is not copied to the split group leader. */
1527 if (perf_pmus__num_core_pmus() == 1)
1528 TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive);
1529
1530 /* cache-misses - can not be pinned, but will go on with the leader */
1531 evsel = evsel__next(evsel);
1532 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1533 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CACHE_MISSES));
1534 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1535
1536 /* branch-misses - ditto */
1537 evsel = evsel__next(evsel);
1538 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_BRANCH_MISSES));
1539 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1540 }
1541 return TEST_OK;
1542 }
test__checkevent_breakpoint_len(struct evlist * evlist)1543 static int test__checkevent_breakpoint_len(struct evlist *evlist)
1544 {
1545 struct evsel *evsel = evlist__first(evlist);
1546
1547 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1548 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1549 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
1550 TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
1551 evsel->core.attr.bp_type);
1552 TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_1 ==
1553 evsel->core.attr.bp_len);
1554
1555 return TEST_OK;
1556 }
1557
test__checkevent_breakpoint_len_w(struct evlist * evlist)1558 static int test__checkevent_breakpoint_len_w(struct evlist *evlist)
1559 {
1560 struct evsel *evsel = evlist__first(evlist);
1561
1562 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1563 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1564 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0));
1565 TEST_ASSERT_VAL("wrong bp_type", HW_BREAKPOINT_W ==
1566 evsel->core.attr.bp_type);
1567 TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_2 ==
1568 evsel->core.attr.bp_len);
1569
1570 return TEST_OK;
1571 }
1572
1573 static int
test__checkevent_breakpoint_len_rw_modifier(struct evlist * evlist)1574 test__checkevent_breakpoint_len_rw_modifier(struct evlist *evlist)
1575 {
1576 struct evsel *evsel = evlist__first(evlist);
1577
1578 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1579 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1580 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1581 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1582
1583 return test__checkevent_breakpoint_rw(evlist);
1584 }
1585
test__checkevent_precise_max_modifier(struct evlist * evlist)1586 static int test__checkevent_precise_max_modifier(struct evlist *evlist)
1587 {
1588 struct evsel *evsel = evlist__first(evlist);
1589
1590 TEST_ASSERT_VAL("wrong number of entries",
1591 evlist->core.nr_entries == 1 + num_core_entries());
1592 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1593 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_SW_TASK_CLOCK));
1594 return TEST_OK;
1595 }
1596
test__checkevent_config_symbol(struct evlist * evlist)1597 static int test__checkevent_config_symbol(struct evlist *evlist)
1598 {
1599 struct evsel *evsel = evlist__first(evlist);
1600
1601 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "insn"));
1602 return TEST_OK;
1603 }
1604
test__checkevent_config_raw(struct evlist * evlist)1605 static int test__checkevent_config_raw(struct evlist *evlist)
1606 {
1607 struct evsel *evsel = evlist__first(evlist);
1608
1609 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "rawpmu"));
1610 return TEST_OK;
1611 }
1612
test__checkevent_config_num(struct evlist * evlist)1613 static int test__checkevent_config_num(struct evlist *evlist)
1614 {
1615 struct evsel *evsel = evlist__first(evlist);
1616
1617 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "numpmu"));
1618 return TEST_OK;
1619 }
1620
test__checkevent_config_cache(struct evlist * evlist)1621 static int test__checkevent_config_cache(struct evlist *evlist)
1622 {
1623 struct evsel *evsel = evlist__first(evlist);
1624
1625 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "cachepmu"));
1626 return test__checkevent_genhw(evlist);
1627 }
1628
test__pmu_cpu_valid(void)1629 static bool test__pmu_cpu_valid(void)
1630 {
1631 return !!perf_pmus__find("cpu");
1632 }
1633
test__pmu_cpu_event_valid(void)1634 static bool test__pmu_cpu_event_valid(void)
1635 {
1636 struct perf_pmu *pmu = perf_pmus__find("cpu");
1637
1638 if (!pmu)
1639 return false;
1640
1641 return perf_pmu__has_format(pmu, "event");
1642 }
1643
test__intel_pt_valid(void)1644 static bool test__intel_pt_valid(void)
1645 {
1646 return !!perf_pmus__find("intel_pt");
1647 }
1648
test__intel_pt(struct evlist * evlist)1649 static int test__intel_pt(struct evlist *evlist)
1650 {
1651 struct evsel *evsel = evlist__first(evlist);
1652
1653 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "intel_pt//u"));
1654 return TEST_OK;
1655 }
1656
test__checkevent_complex_name(struct evlist * evlist)1657 static int test__checkevent_complex_name(struct evlist *evlist)
1658 {
1659 struct evsel *evsel = evlist__first(evlist);
1660
1661 TEST_ASSERT_VAL("wrong complex name parsing",
1662 evsel__name_is(evsel,
1663 "COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks"));
1664 return TEST_OK;
1665 }
1666
test__checkevent_raw_pmu(struct evlist * evlist)1667 static int test__checkevent_raw_pmu(struct evlist *evlist)
1668 {
1669 struct evsel *evsel = evlist__first(evlist);
1670
1671 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1672 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1673 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));
1674 return TEST_OK;
1675 }
1676
test__sym_event_slash(struct evlist * evlist)1677 static int test__sym_event_slash(struct evlist *evlist)
1678 {
1679 struct evsel *evsel = evlist__first(evlist);
1680
1681 TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1682 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1683 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1684 return TEST_OK;
1685 }
1686
test__sym_event_dc(struct evlist * evlist)1687 static int test__sym_event_dc(struct evlist *evlist)
1688 {
1689 struct evsel *evsel = evlist__first(evlist);
1690
1691 TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1692 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1693 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1694 return TEST_OK;
1695 }
1696
test__term_equal_term(struct evlist * evlist)1697 static int test__term_equal_term(struct evlist *evlist)
1698 {
1699 struct evsel *evsel = evlist__first(evlist);
1700
1701 TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1702 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1703 TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "name") == 0);
1704 return TEST_OK;
1705 }
1706
test__term_equal_legacy(struct evlist * evlist)1707 static int test__term_equal_legacy(struct evlist *evlist)
1708 {
1709 struct evsel *evsel = evlist__first(evlist);
1710
1711 TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1712 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_HW_CPU_CYCLES));
1713 TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "l1d") == 0);
1714 return TEST_OK;
1715 }
1716
1717 #ifdef HAVE_LIBTRACEEVENT
count_tracepoints(void)1718 static int count_tracepoints(void)
1719 {
1720 struct dirent *events_ent;
1721 DIR *events_dir;
1722 int cnt = 0;
1723
1724 events_dir = tracing_events__opendir();
1725
1726 TEST_ASSERT_VAL("Can't open events dir", events_dir);
1727
1728 while ((events_ent = readdir(events_dir))) {
1729 char *sys_path;
1730 struct dirent *sys_ent;
1731 DIR *sys_dir;
1732
1733 if (!strcmp(events_ent->d_name, ".")
1734 || !strcmp(events_ent->d_name, "..")
1735 || !strcmp(events_ent->d_name, "enable")
1736 || !strcmp(events_ent->d_name, "header_event")
1737 || !strcmp(events_ent->d_name, "header_page"))
1738 continue;
1739
1740 sys_path = get_events_file(events_ent->d_name);
1741 TEST_ASSERT_VAL("Can't get sys path", sys_path);
1742
1743 sys_dir = opendir(sys_path);
1744 TEST_ASSERT_VAL("Can't open sys dir", sys_dir);
1745
1746 while ((sys_ent = readdir(sys_dir))) {
1747 if (!strcmp(sys_ent->d_name, ".")
1748 || !strcmp(sys_ent->d_name, "..")
1749 || !strcmp(sys_ent->d_name, "enable")
1750 || !strcmp(sys_ent->d_name, "filter"))
1751 continue;
1752
1753 cnt++;
1754 }
1755
1756 closedir(sys_dir);
1757 put_events_file(sys_path);
1758 }
1759
1760 closedir(events_dir);
1761 return cnt;
1762 }
1763
test__all_tracepoints(struct evlist * evlist)1764 static int test__all_tracepoints(struct evlist *evlist)
1765 {
1766 TEST_ASSERT_VAL("wrong events count",
1767 count_tracepoints() == evlist->core.nr_entries);
1768
1769 return test__checkevent_tracepoint_multi(evlist);
1770 }
1771 #endif /* HAVE_LIBTRACEVENT */
1772
1773 struct evlist_test {
1774 const char *name;
1775 bool (*valid)(void);
1776 int (*check)(struct evlist *evlist);
1777 };
1778
1779 static const struct evlist_test test__events[] = {
1780 #ifdef HAVE_LIBTRACEEVENT
1781 {
1782 .name = "syscalls:sys_enter_openat",
1783 .check = test__checkevent_tracepoint,
1784 /* 0 */
1785 },
1786 {
1787 .name = "syscalls:*",
1788 .check = test__checkevent_tracepoint_multi,
1789 /* 1 */
1790 },
1791 #endif
1792 {
1793 .name = "r1a",
1794 .check = test__checkevent_raw,
1795 /* 2 */
1796 },
1797 {
1798 .name = "1:1",
1799 .check = test__checkevent_numeric,
1800 /* 3 */
1801 },
1802 {
1803 .name = "instructions",
1804 .check = test__checkevent_symbolic_name,
1805 /* 4 */
1806 },
1807 {
1808 .name = "cycles/period=100000,config2/",
1809 .check = test__checkevent_symbolic_name_config,
1810 /* 5 */
1811 },
1812 {
1813 .name = "faults",
1814 .check = test__checkevent_symbolic_alias,
1815 /* 6 */
1816 },
1817 {
1818 .name = "L1-dcache-load-miss",
1819 .check = test__checkevent_genhw,
1820 /* 7 */
1821 },
1822 {
1823 .name = "mem:0",
1824 .check = test__checkevent_breakpoint,
1825 /* 8 */
1826 },
1827 {
1828 .name = "mem:0:x",
1829 .check = test__checkevent_breakpoint_x,
1830 /* 9 */
1831 },
1832 {
1833 .name = "mem:0:r",
1834 .check = test__checkevent_breakpoint_r,
1835 /* 0 */
1836 },
1837 {
1838 .name = "mem:0:w",
1839 .check = test__checkevent_breakpoint_w,
1840 /* 1 */
1841 },
1842 #ifdef HAVE_LIBTRACEEVENT
1843 {
1844 .name = "syscalls:sys_enter_openat:k",
1845 .check = test__checkevent_tracepoint_modifier,
1846 /* 2 */
1847 },
1848 {
1849 .name = "syscalls:*:u",
1850 .check = test__checkevent_tracepoint_multi_modifier,
1851 /* 3 */
1852 },
1853 #endif
1854 {
1855 .name = "r1a:kp",
1856 .check = test__checkevent_raw_modifier,
1857 /* 4 */
1858 },
1859 {
1860 .name = "1:1:hp",
1861 .check = test__checkevent_numeric_modifier,
1862 /* 5 */
1863 },
1864 {
1865 .name = "instructions:h",
1866 .check = test__checkevent_symbolic_name_modifier,
1867 /* 6 */
1868 },
1869 {
1870 .name = "faults:u",
1871 .check = test__checkevent_symbolic_alias_modifier,
1872 /* 7 */
1873 },
1874 {
1875 .name = "L1-dcache-load-miss:kp",
1876 .check = test__checkevent_genhw_modifier,
1877 /* 8 */
1878 },
1879 {
1880 .name = "mem:0:u",
1881 .check = test__checkevent_breakpoint_modifier,
1882 /* 9 */
1883 },
1884 {
1885 .name = "mem:0:x:k",
1886 .check = test__checkevent_breakpoint_x_modifier,
1887 /* 0 */
1888 },
1889 {
1890 .name = "mem:0:r:hp",
1891 .check = test__checkevent_breakpoint_r_modifier,
1892 /* 1 */
1893 },
1894 {
1895 .name = "mem:0:w:up",
1896 .check = test__checkevent_breakpoint_w_modifier,
1897 /* 2 */
1898 },
1899 #ifdef HAVE_LIBTRACEEVENT
1900 {
1901 .name = "r1,syscalls:sys_enter_openat:k,1:1:hp",
1902 .check = test__checkevent_list,
1903 /* 3 */
1904 },
1905 #endif
1906 {
1907 .name = "instructions:G",
1908 .check = test__checkevent_exclude_host_modifier,
1909 /* 4 */
1910 },
1911 {
1912 .name = "instructions:H",
1913 .check = test__checkevent_exclude_guest_modifier,
1914 /* 5 */
1915 },
1916 {
1917 .name = "mem:0:rw",
1918 .check = test__checkevent_breakpoint_rw,
1919 /* 6 */
1920 },
1921 {
1922 .name = "mem:0:rw:kp",
1923 .check = test__checkevent_breakpoint_rw_modifier,
1924 /* 7 */
1925 },
1926 {
1927 .name = "{instructions:k,cycles:upp}",
1928 .check = test__group1,
1929 /* 8 */
1930 },
1931 {
1932 .name = "{faults:k,cache-references}:u,cycles:k",
1933 .check = test__group2,
1934 /* 9 */
1935 },
1936 #ifdef HAVE_LIBTRACEEVENT
1937 {
1938 .name = "group1{syscalls:sys_enter_openat:H,cycles:kppp},group2{cycles,1:3}:G,instructions:u",
1939 .check = test__group3,
1940 /* 0 */
1941 },
1942 #endif
1943 {
1944 .name = "{cycles:u,instructions:kp}:p",
1945 .check = test__group4,
1946 /* 1 */
1947 },
1948 {
1949 .name = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles",
1950 .check = test__group5,
1951 /* 2 */
1952 },
1953 #ifdef HAVE_LIBTRACEEVENT
1954 {
1955 .name = "*:*",
1956 .check = test__all_tracepoints,
1957 /* 3 */
1958 },
1959 #endif
1960 {
1961 .name = "{cycles,cache-misses:G}:H",
1962 .check = test__group_gh1,
1963 /* 4 */
1964 },
1965 {
1966 .name = "{cycles,cache-misses:H}:G",
1967 .check = test__group_gh2,
1968 /* 5 */
1969 },
1970 {
1971 .name = "{cycles:G,cache-misses:H}:u",
1972 .check = test__group_gh3,
1973 /* 6 */
1974 },
1975 {
1976 .name = "{cycles:G,cache-misses:H}:uG",
1977 .check = test__group_gh4,
1978 /* 7 */
1979 },
1980 {
1981 .name = "{cycles,cache-misses,branch-misses}:S",
1982 .check = test__leader_sample1,
1983 /* 8 */
1984 },
1985 {
1986 .name = "{instructions,branch-misses}:Su",
1987 .check = test__leader_sample2,
1988 /* 9 */
1989 },
1990 {
1991 .name = "instructions:uDp",
1992 .check = test__checkevent_pinned_modifier,
1993 /* 0 */
1994 },
1995 {
1996 .name = "{cycles,cache-misses,branch-misses}:D",
1997 .check = test__pinned_group,
1998 /* 1 */
1999 },
2000 {
2001 .name = "mem:0/1",
2002 .check = test__checkevent_breakpoint_len,
2003 /* 2 */
2004 },
2005 {
2006 .name = "mem:0/2:w",
2007 .check = test__checkevent_breakpoint_len_w,
2008 /* 3 */
2009 },
2010 {
2011 .name = "mem:0/4:rw:u",
2012 .check = test__checkevent_breakpoint_len_rw_modifier,
2013 /* 4 */
2014 },
2015 #if defined(__s390x__) && defined(HAVE_LIBTRACEEVENT)
2016 {
2017 .name = "kvm-s390:kvm_s390_create_vm",
2018 .check = test__checkevent_tracepoint,
2019 .valid = kvm_s390_create_vm_valid,
2020 /* 0 */
2021 },
2022 #endif
2023 {
2024 .name = "instructions:I",
2025 .check = test__checkevent_exclude_idle_modifier,
2026 /* 5 */
2027 },
2028 {
2029 .name = "instructions:kIG",
2030 .check = test__checkevent_exclude_idle_modifier_1,
2031 /* 6 */
2032 },
2033 {
2034 .name = "task-clock:P,cycles",
2035 .check = test__checkevent_precise_max_modifier,
2036 /* 7 */
2037 },
2038 {
2039 .name = "instructions/name=insn/",
2040 .check = test__checkevent_config_symbol,
2041 /* 8 */
2042 },
2043 {
2044 .name = "r1234/name=rawpmu/",
2045 .check = test__checkevent_config_raw,
2046 /* 9 */
2047 },
2048 {
2049 .name = "4:0x6530160/name=numpmu/",
2050 .check = test__checkevent_config_num,
2051 /* 0 */
2052 },
2053 {
2054 .name = "L1-dcache-misses/name=cachepmu/",
2055 .check = test__checkevent_config_cache,
2056 /* 1 */
2057 },
2058 {
2059 .name = "intel_pt//u",
2060 .valid = test__intel_pt_valid,
2061 .check = test__intel_pt,
2062 /* 2 */
2063 },
2064 {
2065 .name = "cycles/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks'/Duk",
2066 .check = test__checkevent_complex_name,
2067 /* 3 */
2068 },
2069 {
2070 .name = "cycles//u",
2071 .check = test__sym_event_slash,
2072 /* 4 */
2073 },
2074 {
2075 .name = "cycles:k",
2076 .check = test__sym_event_dc,
2077 /* 5 */
2078 },
2079 {
2080 .name = "instructions:uep",
2081 .check = test__checkevent_exclusive_modifier,
2082 /* 6 */
2083 },
2084 {
2085 .name = "{cycles,cache-misses,branch-misses}:e",
2086 .check = test__exclusive_group,
2087 /* 7 */
2088 },
2089 {
2090 .name = "cycles/name=name/",
2091 .check = test__term_equal_term,
2092 /* 8 */
2093 },
2094 {
2095 .name = "cycles/name=l1d/",
2096 .check = test__term_equal_legacy,
2097 /* 9 */
2098 },
2099 {
2100 .name = "mem:0/name=breakpoint/",
2101 .check = test__checkevent_breakpoint,
2102 /* 0 */
2103 },
2104 {
2105 .name = "mem:0:x/name=breakpoint/",
2106 .check = test__checkevent_breakpoint_x,
2107 /* 1 */
2108 },
2109 {
2110 .name = "mem:0:r/name=breakpoint/",
2111 .check = test__checkevent_breakpoint_r,
2112 /* 2 */
2113 },
2114 {
2115 .name = "mem:0:w/name=breakpoint/",
2116 .check = test__checkevent_breakpoint_w,
2117 /* 3 */
2118 },
2119 {
2120 .name = "mem:0/name=breakpoint/u",
2121 .check = test__checkevent_breakpoint_modifier_name,
2122 /* 4 */
2123 },
2124 {
2125 .name = "mem:0:x/name=breakpoint/k",
2126 .check = test__checkevent_breakpoint_x_modifier_name,
2127 /* 5 */
2128 },
2129 {
2130 .name = "mem:0:r/name=breakpoint/hp",
2131 .check = test__checkevent_breakpoint_r_modifier_name,
2132 /* 6 */
2133 },
2134 {
2135 .name = "mem:0:w/name=breakpoint/up",
2136 .check = test__checkevent_breakpoint_w_modifier_name,
2137 /* 7 */
2138 },
2139 {
2140 .name = "mem:0:rw/name=breakpoint/",
2141 .check = test__checkevent_breakpoint_rw,
2142 /* 8 */
2143 },
2144 {
2145 .name = "mem:0:rw/name=breakpoint/kp",
2146 .check = test__checkevent_breakpoint_rw_modifier_name,
2147 /* 9 */
2148 },
2149 {
2150 .name = "mem:0/1/name=breakpoint/",
2151 .check = test__checkevent_breakpoint_len,
2152 /* 0 */
2153 },
2154 {
2155 .name = "mem:0/2:w/name=breakpoint/",
2156 .check = test__checkevent_breakpoint_len_w,
2157 /* 1 */
2158 },
2159 {
2160 .name = "mem:0/4:rw/name=breakpoint/u",
2161 .check = test__checkevent_breakpoint_len_rw_modifier,
2162 /* 2 */
2163 },
2164 {
2165 .name = "mem:0/1/name=breakpoint1/,mem:0/4:rw/name=breakpoint2/",
2166 .check = test__checkevent_breakpoint_2_events,
2167 /* 3 */
2168 },
2169 };
2170
2171 static const struct evlist_test test__events_pmu[] = {
2172 {
2173 .name = "cpu/config=10,config1=1,config2=3,period=1000/u",
2174 .valid = test__pmu_cpu_valid,
2175 .check = test__checkevent_pmu,
2176 /* 0 */
2177 },
2178 {
2179 .name = "cpu/config=1,name=krava/u,cpu/config=2/u",
2180 .valid = test__pmu_cpu_valid,
2181 .check = test__checkevent_pmu_name,
2182 /* 1 */
2183 },
2184 {
2185 .name = "cpu/config=1,call-graph=fp,time,period=100000/,cpu/config=2,call-graph=no,time=0,period=2000/",
2186 .valid = test__pmu_cpu_valid,
2187 .check = test__checkevent_pmu_partial_time_callgraph,
2188 /* 2 */
2189 },
2190 {
2191 .name = "cpu/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks',period=0x1,event=0x2/ukp",
2192 .valid = test__pmu_cpu_event_valid,
2193 .check = test__checkevent_complex_name,
2194 /* 3 */
2195 },
2196 {
2197 .name = "software/r1a/",
2198 .check = test__checkevent_raw_pmu,
2199 /* 4 */
2200 },
2201 {
2202 .name = "software/r0x1a/",
2203 .check = test__checkevent_raw_pmu,
2204 /* 5 */
2205 },
2206 {
2207 .name = "cpu/L1-dcache-load-miss/",
2208 .valid = test__pmu_cpu_valid,
2209 .check = test__checkevent_genhw,
2210 /* 6 */
2211 },
2212 {
2213 .name = "cpu/L1-dcache-load-miss/kp",
2214 .valid = test__pmu_cpu_valid,
2215 .check = test__checkevent_genhw_modifier,
2216 /* 7 */
2217 },
2218 {
2219 .name = "cpu/L1-dcache-misses,name=cachepmu/",
2220 .valid = test__pmu_cpu_valid,
2221 .check = test__checkevent_config_cache,
2222 /* 8 */
2223 },
2224 {
2225 .name = "cpu/instructions/",
2226 .valid = test__pmu_cpu_valid,
2227 .check = test__checkevent_symbolic_name,
2228 /* 9 */
2229 },
2230 {
2231 .name = "cpu/cycles,period=100000,config2/",
2232 .valid = test__pmu_cpu_valid,
2233 .check = test__checkevent_symbolic_name_config,
2234 /* 0 */
2235 },
2236 {
2237 .name = "cpu/instructions/h",
2238 .valid = test__pmu_cpu_valid,
2239 .check = test__checkevent_symbolic_name_modifier,
2240 /* 1 */
2241 },
2242 {
2243 .name = "cpu/instructions/G",
2244 .valid = test__pmu_cpu_valid,
2245 .check = test__checkevent_exclude_host_modifier,
2246 /* 2 */
2247 },
2248 {
2249 .name = "cpu/instructions/H",
2250 .valid = test__pmu_cpu_valid,
2251 .check = test__checkevent_exclude_guest_modifier,
2252 /* 3 */
2253 },
2254 {
2255 .name = "{cpu/instructions/k,cpu/cycles/upp}",
2256 .valid = test__pmu_cpu_valid,
2257 .check = test__group1,
2258 /* 4 */
2259 },
2260 {
2261 .name = "{cpu/cycles/u,cpu/instructions/kp}:p",
2262 .valid = test__pmu_cpu_valid,
2263 .check = test__group4,
2264 /* 5 */
2265 },
2266 {
2267 .name = "{cpu/cycles/,cpu/cache-misses/G}:H",
2268 .valid = test__pmu_cpu_valid,
2269 .check = test__group_gh1,
2270 /* 6 */
2271 },
2272 {
2273 .name = "{cpu/cycles/,cpu/cache-misses/H}:G",
2274 .valid = test__pmu_cpu_valid,
2275 .check = test__group_gh2,
2276 /* 7 */
2277 },
2278 {
2279 .name = "{cpu/cycles/G,cpu/cache-misses/H}:u",
2280 .valid = test__pmu_cpu_valid,
2281 .check = test__group_gh3,
2282 /* 8 */
2283 },
2284 {
2285 .name = "{cpu/cycles/G,cpu/cache-misses/H}:uG",
2286 .valid = test__pmu_cpu_valid,
2287 .check = test__group_gh4,
2288 /* 9 */
2289 },
2290 {
2291 .name = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:S",
2292 .valid = test__pmu_cpu_valid,
2293 .check = test__leader_sample1,
2294 /* 0 */
2295 },
2296 {
2297 .name = "{cpu/instructions/,cpu/branch-misses/}:Su",
2298 .valid = test__pmu_cpu_valid,
2299 .check = test__leader_sample2,
2300 /* 1 */
2301 },
2302 {
2303 .name = "cpu/instructions/uDp",
2304 .valid = test__pmu_cpu_valid,
2305 .check = test__checkevent_pinned_modifier,
2306 /* 2 */
2307 },
2308 {
2309 .name = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:D",
2310 .valid = test__pmu_cpu_valid,
2311 .check = test__pinned_group,
2312 /* 3 */
2313 },
2314 {
2315 .name = "cpu/instructions/I",
2316 .valid = test__pmu_cpu_valid,
2317 .check = test__checkevent_exclude_idle_modifier,
2318 /* 4 */
2319 },
2320 {
2321 .name = "cpu/instructions/kIG",
2322 .valid = test__pmu_cpu_valid,
2323 .check = test__checkevent_exclude_idle_modifier_1,
2324 /* 5 */
2325 },
2326 {
2327 .name = "cpu/cycles/u",
2328 .valid = test__pmu_cpu_valid,
2329 .check = test__sym_event_slash,
2330 /* 6 */
2331 },
2332 {
2333 .name = "cpu/cycles/k",
2334 .valid = test__pmu_cpu_valid,
2335 .check = test__sym_event_dc,
2336 /* 7 */
2337 },
2338 {
2339 .name = "cpu/instructions/uep",
2340 .valid = test__pmu_cpu_valid,
2341 .check = test__checkevent_exclusive_modifier,
2342 /* 8 */
2343 },
2344 {
2345 .name = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:e",
2346 .valid = test__pmu_cpu_valid,
2347 .check = test__exclusive_group,
2348 /* 9 */
2349 },
2350 {
2351 .name = "cpu/cycles,name=name/",
2352 .valid = test__pmu_cpu_valid,
2353 .check = test__term_equal_term,
2354 /* 0 */
2355 },
2356 {
2357 .name = "cpu/cycles,name=l1d/",
2358 .valid = test__pmu_cpu_valid,
2359 .check = test__term_equal_legacy,
2360 /* 1 */
2361 },
2362 };
2363
2364 struct terms_test {
2365 const char *str;
2366 int (*check)(struct list_head *terms);
2367 };
2368
2369 static const struct terms_test test__terms[] = {
2370 [0] = {
2371 .str = "config=10,config1,config2=3,config3=4,umask=1,read,r0xead",
2372 .check = test__checkterms_simple,
2373 },
2374 };
2375
test_event(const struct evlist_test * e)2376 static int test_event(const struct evlist_test *e)
2377 {
2378 struct parse_events_error err;
2379 struct evlist *evlist;
2380 int ret;
2381
2382 if (e->valid && !e->valid()) {
2383 pr_debug("... SKIP\n");
2384 return TEST_OK;
2385 }
2386
2387 evlist = evlist__new();
2388 if (evlist == NULL) {
2389 pr_err("Failed allocation");
2390 return TEST_FAIL;
2391 }
2392 parse_events_error__init(&err);
2393 ret = parse_events(evlist, e->name, &err);
2394 if (ret) {
2395 pr_debug("failed to parse event '%s', err %d, str '%s'\n",
2396 e->name, ret, err.str);
2397 parse_events_error__print(&err, e->name);
2398 ret = TEST_FAIL;
2399 if (err.str && strstr(err.str, "can't access trace events"))
2400 ret = TEST_SKIP;
2401 } else {
2402 ret = e->check(evlist);
2403 }
2404 parse_events_error__exit(&err);
2405 evlist__delete(evlist);
2406
2407 return ret;
2408 }
2409
test_event_fake_pmu(const char * str)2410 static int test_event_fake_pmu(const char *str)
2411 {
2412 struct parse_events_error err;
2413 struct evlist *evlist;
2414 int ret;
2415
2416 evlist = evlist__new();
2417 if (!evlist)
2418 return -ENOMEM;
2419
2420 parse_events_error__init(&err);
2421 ret = __parse_events(evlist, str, /*pmu_filter=*/NULL, &err,
2422 &perf_pmu__fake, /*warn_if_reordered=*/true);
2423 if (ret) {
2424 pr_debug("failed to parse event '%s', err %d, str '%s'\n",
2425 str, ret, err.str);
2426 parse_events_error__print(&err, str);
2427 }
2428
2429 parse_events_error__exit(&err);
2430 evlist__delete(evlist);
2431
2432 return ret;
2433 }
2434
combine_test_results(int existing,int latest)2435 static int combine_test_results(int existing, int latest)
2436 {
2437 if (existing == TEST_FAIL)
2438 return TEST_FAIL;
2439 if (existing == TEST_SKIP)
2440 return latest == TEST_OK ? TEST_SKIP : latest;
2441 return latest;
2442 }
2443
test_events(const struct evlist_test * events,int cnt)2444 static int test_events(const struct evlist_test *events, int cnt)
2445 {
2446 int ret = TEST_OK;
2447
2448 for (int i = 0; i < cnt; i++) {
2449 const struct evlist_test *e = &events[i];
2450 int test_ret;
2451
2452 pr_debug("running test %d '%s'\n", i, e->name);
2453 test_ret = test_event(e);
2454 if (test_ret != TEST_OK) {
2455 pr_debug("Event test failure: test %d '%s'", i, e->name);
2456 ret = combine_test_results(ret, test_ret);
2457 }
2458 }
2459
2460 return ret;
2461 }
2462
test__events2(struct test_suite * test __maybe_unused,int subtest __maybe_unused)2463 static int test__events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2464 {
2465 return test_events(test__events, ARRAY_SIZE(test__events));
2466 }
2467
test_term(const struct terms_test * t)2468 static int test_term(const struct terms_test *t)
2469 {
2470 struct list_head terms;
2471 int ret;
2472
2473 INIT_LIST_HEAD(&terms);
2474
2475 ret = parse_events_terms(&terms, t->str, /*input=*/ NULL);
2476 if (ret) {
2477 pr_debug("failed to parse terms '%s', err %d\n",
2478 t->str , ret);
2479 return ret;
2480 }
2481
2482 ret = t->check(&terms);
2483 parse_events_terms__purge(&terms);
2484
2485 return ret;
2486 }
2487
test_terms(const struct terms_test * terms,int cnt)2488 static int test_terms(const struct terms_test *terms, int cnt)
2489 {
2490 int ret = 0;
2491
2492 for (int i = 0; i < cnt; i++) {
2493 const struct terms_test *t = &terms[i];
2494
2495 pr_debug("running test %d '%s'\n", i, t->str);
2496 ret = test_term(t);
2497 if (ret)
2498 break;
2499 }
2500
2501 return ret;
2502 }
2503
test__terms2(struct test_suite * test __maybe_unused,int subtest __maybe_unused)2504 static int test__terms2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2505 {
2506 return test_terms(test__terms, ARRAY_SIZE(test__terms));
2507 }
2508
test__pmu_events(struct test_suite * test __maybe_unused,int subtest __maybe_unused)2509 static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2510 {
2511 struct perf_pmu *pmu = NULL;
2512 int ret = TEST_OK;
2513
2514 while ((pmu = perf_pmus__scan(pmu)) != NULL) {
2515 struct stat st;
2516 char path[PATH_MAX];
2517 struct dirent *ent;
2518 DIR *dir;
2519 int err;
2520
2521 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/events/",
2522 sysfs__mountpoint(), pmu->name);
2523
2524 err = stat(path, &st);
2525 if (err) {
2526 pr_debug("skipping PMU %s events tests: %s\n", pmu->name, path);
2527 continue;
2528 }
2529
2530 dir = opendir(path);
2531 if (!dir) {
2532 pr_debug("can't open pmu event dir: %s\n", path);
2533 ret = combine_test_results(ret, TEST_SKIP);
2534 continue;
2535 }
2536
2537 while ((ent = readdir(dir))) {
2538 struct evlist_test e = { .name = NULL, };
2539 char name[2 * NAME_MAX + 1 + 12 + 3];
2540 int test_ret;
2541
2542 /* Names containing . are special and cannot be used directly */
2543 if (strchr(ent->d_name, '.'))
2544 continue;
2545
2546 snprintf(name, sizeof(name), "%s/event=%s/u", pmu->name, ent->d_name);
2547
2548 e.name = name;
2549 e.check = test__checkevent_pmu_events;
2550
2551 test_ret = test_event(&e);
2552 if (test_ret != TEST_OK) {
2553 pr_debug("Test PMU event failed for '%s'", name);
2554 ret = combine_test_results(ret, test_ret);
2555 }
2556
2557 if (!is_pmu_core(pmu->name))
2558 continue;
2559
2560 /*
2561 * Names containing '-' are recognized as prefixes and suffixes
2562 * due to '-' being a legacy PMU separator. This fails when the
2563 * prefix or suffix collides with an existing legacy token. For
2564 * example, branch-brs has a prefix (branch) that collides with
2565 * a PE_NAME_CACHE_TYPE token causing a parse error as a suffix
2566 * isn't expected after this. As event names in the config
2567 * slashes are allowed a '-' in the name we check this works
2568 * above.
2569 */
2570 if (strchr(ent->d_name, '-'))
2571 continue;
2572
2573 snprintf(name, sizeof(name), "%s:u,%s/event=%s/u",
2574 ent->d_name, pmu->name, ent->d_name);
2575 e.name = name;
2576 e.check = test__checkevent_pmu_events_mix;
2577 test_ret = test_event(&e);
2578 if (test_ret != TEST_OK) {
2579 pr_debug("Test PMU event failed for '%s'", name);
2580 ret = combine_test_results(ret, test_ret);
2581 }
2582 }
2583
2584 closedir(dir);
2585 }
2586 return ret;
2587 }
2588
test__pmu_events2(struct test_suite * test __maybe_unused,int subtest __maybe_unused)2589 static int test__pmu_events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2590 {
2591 return test_events(test__events_pmu, ARRAY_SIZE(test__events_pmu));
2592 }
2593
test_alias(char ** event,char ** alias)2594 static bool test_alias(char **event, char **alias)
2595 {
2596 char path[PATH_MAX];
2597 DIR *dir;
2598 struct dirent *dent;
2599 const char *sysfs = sysfs__mountpoint();
2600 char buf[128];
2601 FILE *file;
2602
2603 if (!sysfs)
2604 return false;
2605
2606 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/", sysfs);
2607 dir = opendir(path);
2608 if (!dir)
2609 return false;
2610
2611 while ((dent = readdir(dir))) {
2612 if (!strcmp(dent->d_name, ".") ||
2613 !strcmp(dent->d_name, ".."))
2614 continue;
2615
2616 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/alias",
2617 sysfs, dent->d_name);
2618
2619 if (!file_available(path))
2620 continue;
2621
2622 file = fopen(path, "r");
2623 if (!file)
2624 continue;
2625
2626 if (!fgets(buf, sizeof(buf), file)) {
2627 fclose(file);
2628 continue;
2629 }
2630
2631 /* Remove the last '\n' */
2632 buf[strlen(buf) - 1] = 0;
2633
2634 fclose(file);
2635 *event = strdup(dent->d_name);
2636 *alias = strdup(buf);
2637 closedir(dir);
2638
2639 if (*event == NULL || *alias == NULL) {
2640 free(*event);
2641 free(*alias);
2642 return false;
2643 }
2644
2645 return true;
2646 }
2647
2648 closedir(dir);
2649 return false;
2650 }
2651
test__checkevent_pmu_events_alias(struct evlist * evlist)2652 static int test__checkevent_pmu_events_alias(struct evlist *evlist)
2653 {
2654 struct evsel *evsel1 = evlist__first(evlist);
2655 struct evsel *evsel2 = evlist__last(evlist);
2656
2657 TEST_ASSERT_VAL("wrong type", evsel1->core.attr.type == evsel2->core.attr.type);
2658 TEST_ASSERT_VAL("wrong config", evsel1->core.attr.config == evsel2->core.attr.config);
2659 return TEST_OK;
2660 }
2661
test__pmu_events_alias(char * event,char * alias)2662 static int test__pmu_events_alias(char *event, char *alias)
2663 {
2664 struct evlist_test e = { .name = NULL, };
2665 char name[2 * NAME_MAX + 20];
2666
2667 snprintf(name, sizeof(name), "%s/event=1/,%s/event=1/",
2668 event, alias);
2669
2670 e.name = name;
2671 e.check = test__checkevent_pmu_events_alias;
2672 return test_event(&e);
2673 }
2674
test__alias(struct test_suite * test __maybe_unused,int subtest __maybe_unused)2675 static int test__alias(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2676 {
2677 char *event, *alias;
2678 int ret;
2679
2680 if (!test_alias(&event, &alias))
2681 return TEST_SKIP;
2682
2683 ret = test__pmu_events_alias(event, alias);
2684
2685 free(event);
2686 free(alias);
2687 return ret;
2688 }
2689
test__pmu_events_alias2(struct test_suite * test __maybe_unused,int subtest __maybe_unused)2690 static int test__pmu_events_alias2(struct test_suite *test __maybe_unused,
2691 int subtest __maybe_unused)
2692 {
2693 static const char events[][30] = {
2694 "event-hyphen",
2695 "event-two-hyph",
2696 };
2697 int ret = TEST_OK;
2698
2699 for (unsigned int i = 0; i < ARRAY_SIZE(events); i++) {
2700 int test_ret = test_event_fake_pmu(&events[i][0]);
2701
2702 if (test_ret != TEST_OK) {
2703 pr_debug("check_parse_fake %s failed\n", &events[i][0]);
2704 ret = combine_test_results(ret, test_ret);
2705 }
2706 }
2707
2708 return ret;
2709 }
2710
2711 static struct test_case tests__parse_events[] = {
2712 TEST_CASE_REASON("Test event parsing",
2713 events2,
2714 "permissions"),
2715 TEST_CASE_REASON("Parsing of all PMU events from sysfs",
2716 pmu_events,
2717 "permissions"),
2718 TEST_CASE_REASON("Parsing of given PMU events from sysfs",
2719 pmu_events2,
2720 "permissions"),
2721 TEST_CASE_REASON("Parsing of aliased events from sysfs", alias,
2722 "no aliases in sysfs"),
2723 TEST_CASE("Parsing of aliased events", pmu_events_alias2),
2724 TEST_CASE("Parsing of terms (event modifiers)", terms2),
2725 { .name = NULL, }
2726 };
2727
2728 struct test_suite suite__parse_events = {
2729 .desc = "Parse event definition strings",
2730 .test_cases = tests__parse_events,
2731 };
2732