tools/perf/tests/parse-events.c

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