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