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 "pmu-hybrid.h"
  10 #include <dirent.h>
  11 #include <errno.h>
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <unistd.h>
  15 #include <linux/kernel.h>
  16 #include <linux/hw_breakpoint.h>
  17 #include <api/fs/tracing_path.h>
  18
  19 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
  20                              PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
  21
  22 #if defined(__s390x__)
  23 /* Return true if kvm module is available and loaded. Test this
  24  * and return success when trace point kvm_s390_create_vm
  25  * exists. Otherwise this test always fails.
  26  */
  27 static bool kvm_s390_create_vm_valid(void)
  28 {
  29         char *eventfile;
  30         bool rc = false;
  31
  32         eventfile = get_events_file("kvm-s390");
  33
  34         if (eventfile) {
  35                 DIR *mydir = opendir(eventfile);
  36
  37                 if (mydir) {
  38                         rc = true;
  39                         closedir(mydir);
  40                 }
  41                 put_events_file(eventfile);
  42         }
  43
  44         return rc;
  45 }
  46 #endif
  47
  48 static int test__checkevent_tracepoint(struct evlist *evlist)
  49 {
  50         struct evsel *evsel = evlist__first(evlist);
  51
  52         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
  53         TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->core.nr_groups);
  54         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
  55         TEST_ASSERT_VAL("wrong sample_type",
  56                 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
  57         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
  58         return 0;
  59 }
  60
  61 static int test__checkevent_tracepoint_multi(struct evlist *evlist)
  62 {
  63         struct evsel *evsel;
  64
  65         TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1);
  66         TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->core.nr_groups);
  67
  68         evlist__for_each_entry(evlist, evsel) {
  69                 TEST_ASSERT_VAL("wrong type",
  70                         PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
  71                 TEST_ASSERT_VAL("wrong sample_type",
  72                         PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
  73                 TEST_ASSERT_VAL("wrong sample_period",
  74                         1 == evsel->core.attr.sample_period);
  75         }
  76         return 0;
  77 }
  78
  79 static int test__checkevent_raw(struct evlist *evlist)
  80 {
  81         struct evsel *evsel = evlist__first(evlist);
  82
  83         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
  84         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
  85         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
  86         return 0;
  87 }
  88
  89 static int test__checkevent_numeric(struct evlist *evlist)
  90 {
  91         struct evsel *evsel = evlist__first(evlist);
  92
  93         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
  94         TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
  95         TEST_ASSERT_VAL("wrong config", 1 == evsel->core.attr.config);
  96         return 0;
  97 }
  98
  99 static int test__checkevent_symbolic_name(struct evlist *evlist)
 100 {
 101         struct evsel *evsel = evlist__first(evlist);
 102
 103         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 104         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 105         TEST_ASSERT_VAL("wrong config",
 106                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 107         return 0;
 108 }
 109
 110 static int test__checkevent_symbolic_name_config(struct evlist *evlist)
 111 {
 112         struct evsel *evsel = evlist__first(evlist);
 113
 114         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 115         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 116         TEST_ASSERT_VAL("wrong config",
 117                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 118         /*
 119          * The period value gets configured within evlist__config,
 120          * while this test executes only parse events method.
 121          */
 122         TEST_ASSERT_VAL("wrong period",
 123                         0 == evsel->core.attr.sample_period);
 124         TEST_ASSERT_VAL("wrong config1",
 125                         0 == evsel->core.attr.config1);
 126         TEST_ASSERT_VAL("wrong config2",
 127                         1 == evsel->core.attr.config2);
 128         return 0;
 129 }
 130
 131 static int test__checkevent_symbolic_alias(struct evlist *evlist)
 132 {
 133         struct evsel *evsel = evlist__first(evlist);
 134
 135         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 136         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
 137         TEST_ASSERT_VAL("wrong config",
 138                         PERF_COUNT_SW_PAGE_FAULTS == evsel->core.attr.config);
 139         return 0;
 140 }
 141
 142 static int test__checkevent_genhw(struct evlist *evlist)
 143 {
 144         struct evsel *evsel = evlist__first(evlist);
 145
 146         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 147         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type);
 148         TEST_ASSERT_VAL("wrong config", (1 << 16) == evsel->core.attr.config);
 149         return 0;
 150 }
 151
 152 static int test__checkevent_breakpoint(struct evlist *evlist)
 153 {
 154         struct evsel *evsel = evlist__first(evlist);
 155
 156         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 157         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 158         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 159         TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
 160                                          evsel->core.attr.bp_type);
 161         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_4 ==
 162                                         evsel->core.attr.bp_len);
 163         return 0;
 164 }
 165
 166 static int test__checkevent_breakpoint_x(struct evlist *evlist)
 167 {
 168         struct evsel *evsel = evlist__first(evlist);
 169
 170         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 171         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 172         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 173         TEST_ASSERT_VAL("wrong bp_type",
 174                         HW_BREAKPOINT_X == evsel->core.attr.bp_type);
 175         TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->core.attr.bp_len);
 176         return 0;
 177 }
 178
 179 static int test__checkevent_breakpoint_r(struct evlist *evlist)
 180 {
 181         struct evsel *evsel = evlist__first(evlist);
 182
 183         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 184         TEST_ASSERT_VAL("wrong type",
 185                         PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 186         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 187         TEST_ASSERT_VAL("wrong bp_type",
 188                         HW_BREAKPOINT_R == evsel->core.attr.bp_type);
 189         TEST_ASSERT_VAL("wrong bp_len",
 190                         HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
 191         return 0;
 192 }
 193
 194 static int test__checkevent_breakpoint_w(struct evlist *evlist)
 195 {
 196         struct evsel *evsel = evlist__first(evlist);
 197
 198         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 199         TEST_ASSERT_VAL("wrong type",
 200                         PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 201         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 202         TEST_ASSERT_VAL("wrong bp_type",
 203                         HW_BREAKPOINT_W == evsel->core.attr.bp_type);
 204         TEST_ASSERT_VAL("wrong bp_len",
 205                         HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
 206         return 0;
 207 }
 208
 209 static int test__checkevent_breakpoint_rw(struct evlist *evlist)
 210 {
 211         struct evsel *evsel = evlist__first(evlist);
 212
 213         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 214         TEST_ASSERT_VAL("wrong type",
 215                         PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 216         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 217         TEST_ASSERT_VAL("wrong bp_type",
 218                 (HW_BREAKPOINT_R|HW_BREAKPOINT_W) == evsel->core.attr.bp_type);
 219         TEST_ASSERT_VAL("wrong bp_len",
 220                         HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
 221         return 0;
 222 }
 223
 224 static int test__checkevent_tracepoint_modifier(struct evlist *evlist)
 225 {
 226         struct evsel *evsel = evlist__first(evlist);
 227
 228         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 229         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 230         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 231         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 232
 233         return test__checkevent_tracepoint(evlist);
 234 }
 235
 236 static int
 237 test__checkevent_tracepoint_multi_modifier(struct evlist *evlist)
 238 {
 239         struct evsel *evsel;
 240
 241         TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1);
 242
 243         evlist__for_each_entry(evlist, evsel) {
 244                 TEST_ASSERT_VAL("wrong exclude_user",
 245                                 !evsel->core.attr.exclude_user);
 246                 TEST_ASSERT_VAL("wrong exclude_kernel",
 247                                 evsel->core.attr.exclude_kernel);
 248                 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 249                 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 250         }
 251
 252         return test__checkevent_tracepoint_multi(evlist);
 253 }
 254
 255 static int test__checkevent_raw_modifier(struct evlist *evlist)
 256 {
 257         struct evsel *evsel = evlist__first(evlist);
 258
 259         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 260         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 261         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 262         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 263
 264         return test__checkevent_raw(evlist);
 265 }
 266
 267 static int test__checkevent_numeric_modifier(struct evlist *evlist)
 268 {
 269         struct evsel *evsel = evlist__first(evlist);
 270
 271         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 272         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 273         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 274         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 275
 276         return test__checkevent_numeric(evlist);
 277 }
 278
 279 static int test__checkevent_symbolic_name_modifier(struct evlist *evlist)
 280 {
 281         struct evsel *evsel = evlist__first(evlist);
 282
 283         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 284         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 285         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 286         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 287
 288         return test__checkevent_symbolic_name(evlist);
 289 }
 290
 291 static int test__checkevent_exclude_host_modifier(struct evlist *evlist)
 292 {
 293         struct evsel *evsel = evlist__first(evlist);
 294
 295         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 296         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 297
 298         return test__checkevent_symbolic_name(evlist);
 299 }
 300
 301 static int test__checkevent_exclude_guest_modifier(struct evlist *evlist)
 302 {
 303         struct evsel *evsel = evlist__first(evlist);
 304
 305         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 306         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 307
 308         return test__checkevent_symbolic_name(evlist);
 309 }
 310
 311 static int test__checkevent_symbolic_alias_modifier(struct evlist *evlist)
 312 {
 313         struct evsel *evsel = evlist__first(evlist);
 314
 315         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 316         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 317         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 318         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 319
 320         return test__checkevent_symbolic_alias(evlist);
 321 }
 322
 323 static int test__checkevent_genhw_modifier(struct evlist *evlist)
 324 {
 325         struct evsel *evsel = evlist__first(evlist);
 326
 327         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 328         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 329         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 330         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 331
 332         return test__checkevent_genhw(evlist);
 333 }
 334
 335 static int test__checkevent_exclude_idle_modifier(struct evlist *evlist)
 336 {
 337         struct evsel *evsel = evlist__first(evlist);
 338
 339         TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle);
 340         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 341         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 342         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 343         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 344         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 345         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 346
 347         return test__checkevent_symbolic_name(evlist);
 348 }
 349
 350 static int test__checkevent_exclude_idle_modifier_1(struct evlist *evlist)
 351 {
 352         struct evsel *evsel = evlist__first(evlist);
 353
 354         TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle);
 355         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 356         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 357         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 358         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 359         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 360         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 361
 362         return test__checkevent_symbolic_name(evlist);
 363 }
 364
 365 static int test__checkevent_breakpoint_modifier(struct evlist *evlist)
 366 {
 367         struct evsel *evsel = evlist__first(evlist);
 368
 369
 370         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 371         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 372         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 373         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 374         TEST_ASSERT_VAL("wrong name",
 375                         !strcmp(evsel__name(evsel), "mem:0:u"));
 376
 377         return test__checkevent_breakpoint(evlist);
 378 }
 379
 380 static int test__checkevent_breakpoint_x_modifier(struct evlist *evlist)
 381 {
 382         struct evsel *evsel = evlist__first(evlist);
 383
 384         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 385         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 386         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 387         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 388         TEST_ASSERT_VAL("wrong name",
 389                         !strcmp(evsel__name(evsel), "mem:0:x:k"));
 390
 391         return test__checkevent_breakpoint_x(evlist);
 392 }
 393
 394 static int test__checkevent_breakpoint_r_modifier(struct evlist *evlist)
 395 {
 396         struct evsel *evsel = evlist__first(evlist);
 397
 398         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 399         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 400         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 401         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 402         TEST_ASSERT_VAL("wrong name",
 403                         !strcmp(evsel__name(evsel), "mem:0:r:hp"));
 404
 405         return test__checkevent_breakpoint_r(evlist);
 406 }
 407
 408 static int test__checkevent_breakpoint_w_modifier(struct evlist *evlist)
 409 {
 410         struct evsel *evsel = evlist__first(evlist);
 411
 412         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 413         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 414         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 415         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 416         TEST_ASSERT_VAL("wrong name",
 417                         !strcmp(evsel__name(evsel), "mem:0:w:up"));
 418
 419         return test__checkevent_breakpoint_w(evlist);
 420 }
 421
 422 static int test__checkevent_breakpoint_rw_modifier(struct evlist *evlist)
 423 {
 424         struct evsel *evsel = evlist__first(evlist);
 425
 426         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 427         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 428         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 429         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 430         TEST_ASSERT_VAL("wrong name",
 431                         !strcmp(evsel__name(evsel), "mem:0:rw:kp"));
 432
 433         return test__checkevent_breakpoint_rw(evlist);
 434 }
 435
 436 static int test__checkevent_pmu(struct evlist *evlist)
 437 {
 438
 439         struct evsel *evsel = evlist__first(evlist);
 440
 441         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 442         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 443         TEST_ASSERT_VAL("wrong config",    10 == evsel->core.attr.config);
 444         TEST_ASSERT_VAL("wrong config1",    1 == evsel->core.attr.config1);
 445         TEST_ASSERT_VAL("wrong config2",    3 == evsel->core.attr.config2);
 446         /*
 447          * The period value gets configured within evlist__config,
 448          * while this test executes only parse events method.
 449          */
 450         TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);
 451
 452         return 0;
 453 }
 454
 455 static int test__checkevent_list(struct evlist *evlist)
 456 {
 457         struct evsel *evsel = evlist__first(evlist);
 458
 459         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 460
 461         /* r1 */
 462         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 463         TEST_ASSERT_VAL("wrong config", 1 == evsel->core.attr.config);
 464         TEST_ASSERT_VAL("wrong config1", 0 == evsel->core.attr.config1);
 465         TEST_ASSERT_VAL("wrong config2", 0 == evsel->core.attr.config2);
 466         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 467         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 468         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 469         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 470
 471         /* syscalls:sys_enter_openat:k */
 472         evsel = evsel__next(evsel);
 473         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
 474         TEST_ASSERT_VAL("wrong sample_type",
 475                 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
 476         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
 477         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 478         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 479         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 480         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 481
 482         /* 1:1:hp */
 483         evsel = evsel__next(evsel);
 484         TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
 485         TEST_ASSERT_VAL("wrong config", 1 == evsel->core.attr.config);
 486         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 487         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 488         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 489         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 490
 491         return 0;
 492 }
 493
 494 static int test__checkevent_pmu_name(struct evlist *evlist)
 495 {
 496         struct evsel *evsel = evlist__first(evlist);
 497
 498         /* cpu/config=1,name=krava/u */
 499         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 500         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 501         TEST_ASSERT_VAL("wrong config",  1 == evsel->core.attr.config);
 502         TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "krava"));
 503
 504         /* cpu/config=2/u" */
 505         evsel = evsel__next(evsel);
 506         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 507         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 508         TEST_ASSERT_VAL("wrong config",  2 == evsel->core.attr.config);
 509         TEST_ASSERT_VAL("wrong name",
 510                         !strcmp(evsel__name(evsel), "cpu/config=2/u"));
 511
 512         return 0;
 513 }
 514
 515 static int test__checkevent_pmu_partial_time_callgraph(struct evlist *evlist)
 516 {
 517         struct evsel *evsel = evlist__first(evlist);
 518
 519         /* cpu/config=1,call-graph=fp,time,period=100000/ */
 520         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 521         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 522         TEST_ASSERT_VAL("wrong config",  1 == evsel->core.attr.config);
 523         /*
 524          * The period, time and callgraph value gets configured within evlist__config,
 525          * while this test executes only parse events method.
 526          */
 527         TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);
 528         TEST_ASSERT_VAL("wrong callgraph",  !evsel__has_callchain(evsel));
 529         TEST_ASSERT_VAL("wrong time",  !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type));
 530
 531         /* cpu/config=2,call-graph=no,time=0,period=2000/ */
 532         evsel = evsel__next(evsel);
 533         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 534         TEST_ASSERT_VAL("wrong config",  2 == evsel->core.attr.config);
 535         /*
 536          * The period, time and callgraph value gets configured within evlist__config,
 537          * while this test executes only parse events method.
 538          */
 539         TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);
 540         TEST_ASSERT_VAL("wrong callgraph",  !evsel__has_callchain(evsel));
 541         TEST_ASSERT_VAL("wrong time",  !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type));
 542
 543         return 0;
 544 }
 545
 546 static int test__checkevent_pmu_events(struct evlist *evlist)
 547 {
 548         struct evsel *evsel = evlist__first(evlist);
 549
 550         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 551         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 552         TEST_ASSERT_VAL("wrong exclude_user",
 553                         !evsel->core.attr.exclude_user);
 554         TEST_ASSERT_VAL("wrong exclude_kernel",
 555                         evsel->core.attr.exclude_kernel);
 556         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 557         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 558         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 559         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
 560
 561         return 0;
 562 }
 563
 564
 565 static int test__checkevent_pmu_events_mix(struct evlist *evlist)
 566 {
 567         struct evsel *evsel = evlist__first(evlist);
 568
 569         /* pmu-event:u */
 570         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 571         TEST_ASSERT_VAL("wrong exclude_user",
 572                         !evsel->core.attr.exclude_user);
 573         TEST_ASSERT_VAL("wrong exclude_kernel",
 574                         evsel->core.attr.exclude_kernel);
 575         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 576         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 577         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 578         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
 579
 580         /* cpu/pmu-event/u*/
 581         evsel = evsel__next(evsel);
 582         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 583         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 584         TEST_ASSERT_VAL("wrong exclude_user",
 585                         !evsel->core.attr.exclude_user);
 586         TEST_ASSERT_VAL("wrong exclude_kernel",
 587                         evsel->core.attr.exclude_kernel);
 588         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 589         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 590         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 591         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.pinned);
 592
 593         return 0;
 594 }
 595
 596 static int test__checkterms_simple(struct list_head *terms)
 597 {
 598         struct parse_events_term *term;
 599
 600         /* config=10 */
 601         term = list_entry(terms->next, struct parse_events_term, list);
 602         TEST_ASSERT_VAL("wrong type term",
 603                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
 604         TEST_ASSERT_VAL("wrong type val",
 605                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 606         TEST_ASSERT_VAL("wrong val", term->val.num == 10);
 607         TEST_ASSERT_VAL("wrong config", !term->config);
 608
 609         /* config1 */
 610         term = list_entry(term->list.next, struct parse_events_term, list);
 611         TEST_ASSERT_VAL("wrong type term",
 612                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1);
 613         TEST_ASSERT_VAL("wrong type val",
 614                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 615         TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 616         TEST_ASSERT_VAL("wrong config", !term->config);
 617
 618         /* config2=3 */
 619         term = list_entry(term->list.next, struct parse_events_term, list);
 620         TEST_ASSERT_VAL("wrong type term",
 621                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2);
 622         TEST_ASSERT_VAL("wrong type val",
 623                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 624         TEST_ASSERT_VAL("wrong val", term->val.num == 3);
 625         TEST_ASSERT_VAL("wrong config", !term->config);
 626
 627         /* umask=1*/
 628         term = list_entry(term->list.next, struct parse_events_term, list);
 629         TEST_ASSERT_VAL("wrong type term",
 630                         term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
 631         TEST_ASSERT_VAL("wrong type val",
 632                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 633         TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 634         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "umask"));
 635
 636         /*
 637          * read
 638          *
 639          * The perf_pmu__test_parse_init injects 'read' term into
 640          * perf_pmu_events_list, so 'read' is evaluated as read term
 641          * and not as raw event with 'ead' hex value.
 642          */
 643         term = list_entry(term->list.next, struct parse_events_term, list);
 644         TEST_ASSERT_VAL("wrong type term",
 645                         term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
 646         TEST_ASSERT_VAL("wrong type val",
 647                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 648         TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 649         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "read"));
 650
 651         /*
 652          * r0xead
 653          *
 654          * To be still able to pass 'ead' value with 'r' syntax,
 655          * we added support to parse 'r0xHEX' event.
 656          */
 657         term = list_entry(term->list.next, struct parse_events_term, list);
 658         TEST_ASSERT_VAL("wrong type term",
 659                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
 660         TEST_ASSERT_VAL("wrong type val",
 661                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 662         TEST_ASSERT_VAL("wrong val", term->val.num == 0xead);
 663         TEST_ASSERT_VAL("wrong config", !term->config);
 664         return 0;
 665 }
 666
 667 static int test__group1(struct evlist *evlist)
 668 {
 669         struct evsel *evsel, *leader;
 670
 671         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 672         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 673
 674         /* instructions:k */
 675         evsel = leader = evlist__first(evlist);
 676         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 677         TEST_ASSERT_VAL("wrong config",
 678                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 679         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 680         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 681         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 682         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 683         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 684         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 685         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 686         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 687         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 688         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 689
 690         /* cycles:upp */
 691         evsel = evsel__next(evsel);
 692         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 693         TEST_ASSERT_VAL("wrong config",
 694                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 695         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 696         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 697         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 698         /* use of precise requires exclude_guest */
 699         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 700         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 701         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
 702         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 703         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 704         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 705
 706         return 0;
 707 }
 708
 709 static int test__group2(struct evlist *evlist)
 710 {
 711         struct evsel *evsel, *leader;
 712
 713         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 714         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 715
 716         /* faults + :ku modifier */
 717         evsel = leader = evlist__first(evlist);
 718         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
 719         TEST_ASSERT_VAL("wrong config",
 720                         PERF_COUNT_SW_PAGE_FAULTS == evsel->core.attr.config);
 721         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 722         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 723         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 724         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 725         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 726         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 727         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 728         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 729         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 730         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 731
 732         /* cache-references + :u modifier */
 733         evsel = evsel__next(evsel);
 734         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 735         TEST_ASSERT_VAL("wrong config",
 736                         PERF_COUNT_HW_CACHE_REFERENCES == evsel->core.attr.config);
 737         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 738         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 739         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 740         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 741         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 742         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 743         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 744         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 745         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 746
 747         /* cycles:k */
 748         evsel = evsel__next(evsel);
 749         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 750         TEST_ASSERT_VAL("wrong config",
 751                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 752         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 753         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 754         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 755         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 756         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 757         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 758         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 759         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 760
 761         return 0;
 762 }
 763
 764 static int test__group3(struct evlist *evlist __maybe_unused)
 765 {
 766         struct evsel *evsel, *leader;
 767
 768         TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->core.nr_entries);
 769         TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->core.nr_groups);
 770
 771         /* group1 syscalls:sys_enter_openat:H */
 772         evsel = leader = evlist__first(evlist);
 773         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
 774         TEST_ASSERT_VAL("wrong sample_type",
 775                 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
 776         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
 777         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 778         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 779         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 780         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 781         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 782         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 783         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 784         TEST_ASSERT_VAL("wrong group name",
 785                 !strcmp(leader->group_name, "group1"));
 786         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 787         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 788         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 789
 790         /* group1 cycles:kppp */
 791         evsel = evsel__next(evsel);
 792         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 793         TEST_ASSERT_VAL("wrong config",
 794                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 795         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 796         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 797         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 798         /* use of precise requires exclude_guest */
 799         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 800         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 801         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 3);
 802         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 803         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 804         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 805         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 806
 807         /* group2 cycles + G modifier */
 808         evsel = leader = evsel__next(evsel);
 809         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 810         TEST_ASSERT_VAL("wrong config",
 811                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 812         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 813         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 814         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 815         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 816         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 817         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 818         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 819         TEST_ASSERT_VAL("wrong group name",
 820                 !strcmp(leader->group_name, "group2"));
 821         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 822         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 823         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 824
 825         /* group2 1:3 + G modifier */
 826         evsel = evsel__next(evsel);
 827         TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
 828         TEST_ASSERT_VAL("wrong config", 3 == evsel->core.attr.config);
 829         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 830         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 831         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 832         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 833         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 834         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 835         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 836         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 837         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 838
 839         /* instructions:u */
 840         evsel = evsel__next(evsel);
 841         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 842         TEST_ASSERT_VAL("wrong config",
 843                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 844         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 845         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 846         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 847         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 848         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 849         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 850         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 851         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 852
 853         return 0;
 854 }
 855
 856 static int test__group4(struct evlist *evlist __maybe_unused)
 857 {
 858         struct evsel *evsel, *leader;
 859
 860         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 861         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 862
 863         /* cycles:u + p */
 864         evsel = leader = evlist__first(evlist);
 865         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 866         TEST_ASSERT_VAL("wrong config",
 867                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 868         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 869         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 870         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 871         /* use of precise requires exclude_guest */
 872         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 873         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 874         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 1);
 875         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 876         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 877         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 878         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 879         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 880
 881         /* instructions:kp + p */
 882         evsel = evsel__next(evsel);
 883         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 884         TEST_ASSERT_VAL("wrong config",
 885                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 886         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 887         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 888         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 889         /* use of precise requires exclude_guest */
 890         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 891         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 892         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
 893         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 894         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 895         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 896
 897         return 0;
 898 }
 899
 900 static int test__group5(struct evlist *evlist __maybe_unused)
 901 {
 902         struct evsel *evsel, *leader;
 903
 904         TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->core.nr_entries);
 905         TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->core.nr_groups);
 906
 907         /* cycles + G */
 908         evsel = leader = evlist__first(evlist);
 909         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 910         TEST_ASSERT_VAL("wrong config",
 911                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 912         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 913         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 914         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 915         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 916         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 917         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 918         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 919         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 920         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 921         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 922         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 923
 924         /* instructions + G */
 925         evsel = evsel__next(evsel);
 926         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 927         TEST_ASSERT_VAL("wrong config",
 928                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 929         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 930         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 931         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 932         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 933         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 934         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 935         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 936         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 937         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 938
 939         /* cycles:G */
 940         evsel = leader = evsel__next(evsel);
 941         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 942         TEST_ASSERT_VAL("wrong config",
 943                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 944         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 945         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 946         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 947         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 948         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 949         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 950         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 951         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 952         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 953         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 954         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 955
 956         /* instructions:G */
 957         evsel = evsel__next(evsel);
 958         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 959         TEST_ASSERT_VAL("wrong config",
 960                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 961         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 962         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 963         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 964         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 965         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 966         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 967         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 968         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 969
 970         /* cycles */
 971         evsel = evsel__next(evsel);
 972         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 973         TEST_ASSERT_VAL("wrong config",
 974                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 975         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 976         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 977         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 978         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 979         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 980         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 981         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 982
 983         return 0;
 984 }
 985
 986 static int test__group_gh1(struct evlist *evlist)
 987 {
 988         struct evsel *evsel, *leader;
 989
 990         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 991         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 992
 993         /* cycles + :H group modifier */
 994         evsel = leader = evlist__first(evlist);
 995         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 996         TEST_ASSERT_VAL("wrong config",
 997                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 998         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 999         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1000         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1001         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1002         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1003         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1004         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1005         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1006         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1007         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1008
1009         /* cache-misses:G + :H group modifier */
1010         evsel = evsel__next(evsel);
1011         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1012         TEST_ASSERT_VAL("wrong config",
1013                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1014         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1015         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1016         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1017         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1018         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1019         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1020         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1021         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1022
1023         return 0;
1024 }
1025
1026 static int test__group_gh2(struct evlist *evlist)
1027 {
1028         struct evsel *evsel, *leader;
1029
1030         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1031         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
1032
1033         /* cycles + :G group modifier */
1034         evsel = leader = evlist__first(evlist);
1035         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1036         TEST_ASSERT_VAL("wrong config",
1037                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1038         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1039         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1040         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1041         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1042         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1043         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1044         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1045         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1046         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1047         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1048
1049         /* cache-misses:H + :G group modifier */
1050         evsel = evsel__next(evsel);
1051         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1052         TEST_ASSERT_VAL("wrong config",
1053                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1054         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1055         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1056         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1057         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1058         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1059         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1060         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1061         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1062
1063         return 0;
1064 }
1065
1066 static int test__group_gh3(struct evlist *evlist)
1067 {
1068         struct evsel *evsel, *leader;
1069
1070         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1071         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
1072
1073         /* cycles:G + :u group modifier */
1074         evsel = leader = evlist__first(evlist);
1075         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1076         TEST_ASSERT_VAL("wrong config",
1077                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1078         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1079         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1080         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1081         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1082         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1083         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1084         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1085         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1086         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1087         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1088
1089         /* cache-misses:H + :u group modifier */
1090         evsel = evsel__next(evsel);
1091         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1092         TEST_ASSERT_VAL("wrong config",
1093                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1094         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1095         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1096         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1097         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1098         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1099         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1100         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1101         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1102
1103         return 0;
1104 }
1105
1106 static int test__group_gh4(struct evlist *evlist)
1107 {
1108         struct evsel *evsel, *leader;
1109
1110         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1111         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
1112
1113         /* cycles:G + :uG group modifier */
1114         evsel = leader = evlist__first(evlist);
1115         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1116         TEST_ASSERT_VAL("wrong config",
1117                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1118         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1119         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1120         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1121         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1122         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1123         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1124         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1125         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1126         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1127         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1128
1129         /* cache-misses:H + :uG group modifier */
1130         evsel = evsel__next(evsel);
1131         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1132         TEST_ASSERT_VAL("wrong config",
1133                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1134         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1135         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1136         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
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);
1140         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1141         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1142
1143         return 0;
1144 }
1145
1146 static int test__leader_sample1(struct evlist *evlist)
1147 {
1148         struct evsel *evsel, *leader;
1149
1150         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
1151
1152         /* cycles - sampling group leader */
1153         evsel = leader = evlist__first(evlist);
1154         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1155         TEST_ASSERT_VAL("wrong config",
1156                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1157         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1158         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1159         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1160         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1161         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1162         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1163         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1164         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1165         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1166
1167         /* cache-misses - not sampling */
1168         evsel = evsel__next(evsel);
1169         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1170         TEST_ASSERT_VAL("wrong config",
1171                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1172         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1173         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1174         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1175         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1176         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1177         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1178         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1179         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1180
1181         /* branch-misses - not sampling */
1182         evsel = evsel__next(evsel);
1183         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1184         TEST_ASSERT_VAL("wrong config",
1185                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1186         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1187         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1188         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1189         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1190         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1191         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1192         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1193         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1194         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1195
1196         return 0;
1197 }
1198
1199 static int test__leader_sample2(struct evlist *evlist __maybe_unused)
1200 {
1201         struct evsel *evsel, *leader;
1202
1203         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1204
1205         /* instructions - sampling group leader */
1206         evsel = leader = evlist__first(evlist);
1207         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1208         TEST_ASSERT_VAL("wrong config",
1209                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
1210         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1211         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1212         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1213         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1214         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1215         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1216         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1217         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1218         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1219
1220         /* branch-misses - not sampling */
1221         evsel = evsel__next(evsel);
1222         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1223         TEST_ASSERT_VAL("wrong config",
1224                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1225         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1226         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1227         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1228         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1229         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1230         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1231         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1232         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1233         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1234
1235         return 0;
1236 }
1237
1238 static int test__checkevent_pinned_modifier(struct evlist *evlist)
1239 {
1240         struct evsel *evsel = evlist__first(evlist);
1241
1242         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1243         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1244         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1245         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1246         TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1247
1248         return test__checkevent_symbolic_name(evlist);
1249 }
1250
1251 static int test__pinned_group(struct evlist *evlist)
1252 {
1253         struct evsel *evsel, *leader;
1254
1255         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
1256
1257         /* cycles - group leader */
1258         evsel = leader = evlist__first(evlist);
1259         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1260         TEST_ASSERT_VAL("wrong config",
1261                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1262         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1263         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1264         TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1265
1266         /* cache-misses - can not be pinned, but will go on with the leader */
1267         evsel = evsel__next(evsel);
1268         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1269         TEST_ASSERT_VAL("wrong config",
1270                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1271         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1272
1273         /* branch-misses - ditto */
1274         evsel = evsel__next(evsel);
1275         TEST_ASSERT_VAL("wrong config",
1276                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1277         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1278
1279         return 0;
1280 }
1281
1282 static int test__checkevent_exclusive_modifier(struct evlist *evlist)
1283 {
1284         struct evsel *evsel = evlist__first(evlist);
1285
1286         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1287         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1288         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1289         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1290         TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive);
1291
1292         return test__checkevent_symbolic_name(evlist);
1293 }
1294
1295 static int test__exclusive_group(struct evlist *evlist)
1296 {
1297         struct evsel *evsel, *leader;
1298
1299         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
1300
1301         /* cycles - group leader */
1302         evsel = leader = evlist__first(evlist);
1303         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1304         TEST_ASSERT_VAL("wrong config",
1305                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1306         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1307         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1308         TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive);
1309
1310         /* cache-misses - can not be pinned, but will go on with the leader */
1311         evsel = evsel__next(evsel);
1312         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1313         TEST_ASSERT_VAL("wrong config",
1314                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1315         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1316
1317         /* branch-misses - ditto */
1318         evsel = evsel__next(evsel);
1319         TEST_ASSERT_VAL("wrong config",
1320                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1321         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1322
1323         return 0;
1324 }
1325 static int test__checkevent_breakpoint_len(struct evlist *evlist)
1326 {
1327         struct evsel *evsel = evlist__first(evlist);
1328
1329         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1330         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1331         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
1332         TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
1333                                          evsel->core.attr.bp_type);
1334         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_1 ==
1335                                         evsel->core.attr.bp_len);
1336
1337         return 0;
1338 }
1339
1340 static int test__checkevent_breakpoint_len_w(struct evlist *evlist)
1341 {
1342         struct evsel *evsel = evlist__first(evlist);
1343
1344         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1345         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1346         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
1347         TEST_ASSERT_VAL("wrong bp_type", HW_BREAKPOINT_W ==
1348                                          evsel->core.attr.bp_type);
1349         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_2 ==
1350                                         evsel->core.attr.bp_len);
1351
1352         return 0;
1353 }
1354
1355 static int
1356 test__checkevent_breakpoint_len_rw_modifier(struct evlist *evlist)
1357 {
1358         struct evsel *evsel = evlist__first(evlist);
1359
1360         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1361         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1362         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1363         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1364
1365         return test__checkevent_breakpoint_rw(evlist);
1366 }
1367
1368 static int test__checkevent_precise_max_modifier(struct evlist *evlist)
1369 {
1370         struct evsel *evsel = evlist__first(evlist);
1371
1372         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1373         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1374         TEST_ASSERT_VAL("wrong config",
1375                         PERF_COUNT_SW_TASK_CLOCK == evsel->core.attr.config);
1376         return 0;
1377 }
1378
1379 static int test__checkevent_config_symbol(struct evlist *evlist)
1380 {
1381         struct evsel *evsel = evlist__first(evlist);
1382
1383         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "insn") == 0);
1384         return 0;
1385 }
1386
1387 static int test__checkevent_config_raw(struct evlist *evlist)
1388 {
1389         struct evsel *evsel = evlist__first(evlist);
1390
1391         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "rawpmu") == 0);
1392         return 0;
1393 }
1394
1395 static int test__checkevent_config_num(struct evlist *evlist)
1396 {
1397         struct evsel *evsel = evlist__first(evlist);
1398
1399         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "numpmu") == 0);
1400         return 0;
1401 }
1402
1403 static int test__checkevent_config_cache(struct evlist *evlist)
1404 {
1405         struct evsel *evsel = evlist__first(evlist);
1406
1407         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "cachepmu") == 0);
1408         return 0;
1409 }
1410
1411 static bool test__intel_pt_valid(void)
1412 {
1413         return !!perf_pmu__find("intel_pt");
1414 }
1415
1416 static int test__intel_pt(struct evlist *evlist)
1417 {
1418         struct evsel *evsel = evlist__first(evlist);
1419
1420         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "intel_pt//u") == 0);
1421         return 0;
1422 }
1423
1424 static int test__checkevent_complex_name(struct evlist *evlist)
1425 {
1426         struct evsel *evsel = evlist__first(evlist);
1427
1428         TEST_ASSERT_VAL("wrong complex name parsing", strcmp(evsel->name, "COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks") == 0);
1429         return 0;
1430 }
1431
1432 static int test__checkevent_raw_pmu(struct evlist *evlist)
1433 {
1434         struct evsel *evsel = evlist__first(evlist);
1435
1436         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1437         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1438         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1439         return 0;
1440 }
1441
1442 static int test__sym_event_slash(struct evlist *evlist)
1443 {
1444         struct evsel *evsel = evlist__first(evlist);
1445
1446         TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1447         TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES);
1448         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1449         return 0;
1450 }
1451
1452 static int test__sym_event_dc(struct evlist *evlist)
1453 {
1454         struct evsel *evsel = evlist__first(evlist);
1455
1456         TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1457         TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES);
1458         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1459         return 0;
1460 }
1461
1462 static int count_tracepoints(void)
1463 {
1464         struct dirent *events_ent;
1465         DIR *events_dir;
1466         int cnt = 0;
1467
1468         events_dir = tracing_events__opendir();
1469
1470         TEST_ASSERT_VAL("Can't open events dir", events_dir);
1471
1472         while ((events_ent = readdir(events_dir))) {
1473                 char *sys_path;
1474                 struct dirent *sys_ent;
1475                 DIR *sys_dir;
1476
1477                 if (!strcmp(events_ent->d_name, ".")
1478                     || !strcmp(events_ent->d_name, "..")
1479                     || !strcmp(events_ent->d_name, "enable")
1480                     || !strcmp(events_ent->d_name, "header_event")
1481                     || !strcmp(events_ent->d_name, "header_page"))
1482                         continue;
1483
1484                 sys_path = get_events_file(events_ent->d_name);
1485                 TEST_ASSERT_VAL("Can't get sys path", sys_path);
1486
1487                 sys_dir = opendir(sys_path);
1488                 TEST_ASSERT_VAL("Can't open sys dir", sys_dir);
1489
1490                 while ((sys_ent = readdir(sys_dir))) {
1491                         if (!strcmp(sys_ent->d_name, ".")
1492                             || !strcmp(sys_ent->d_name, "..")
1493                             || !strcmp(sys_ent->d_name, "enable")
1494                             || !strcmp(sys_ent->d_name, "filter"))
1495                                 continue;
1496
1497                         cnt++;
1498                 }
1499
1500                 closedir(sys_dir);
1501                 put_events_file(sys_path);
1502         }
1503
1504         closedir(events_dir);
1505         return cnt;
1506 }
1507
1508 static int test__all_tracepoints(struct evlist *evlist)
1509 {
1510         TEST_ASSERT_VAL("wrong events count",
1511                         count_tracepoints() == evlist->core.nr_entries);
1512
1513         return test__checkevent_tracepoint_multi(evlist);
1514 }
1515
1516 static int test__hybrid_hw_event_with_pmu(struct evlist *evlist)
1517 {
1518         struct evsel *evsel = evlist__first(evlist);
1519
1520         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1521         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1522         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1523         return 0;
1524 }
1525
1526 static int test__hybrid_hw_group_event(struct evlist *evlist)
1527 {
1528         struct evsel *evsel, *leader;
1529
1530         evsel = leader = evlist__first(evlist);
1531         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1532         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1533         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1534         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1535
1536         evsel = evsel__next(evsel);
1537         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1538         TEST_ASSERT_VAL("wrong config", 0xc0 == evsel->core.attr.config);
1539         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1540         return 0;
1541 }
1542
1543 static int test__hybrid_sw_hw_group_event(struct evlist *evlist)
1544 {
1545         struct evsel *evsel, *leader;
1546
1547         evsel = leader = evlist__first(evlist);
1548         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1549         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1550         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1551
1552         evsel = evsel__next(evsel);
1553         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1554         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1555         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1556         return 0;
1557 }
1558
1559 static int test__hybrid_hw_sw_group_event(struct evlist *evlist)
1560 {
1561         struct evsel *evsel, *leader;
1562
1563         evsel = leader = evlist__first(evlist);
1564         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1565         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1566         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1567         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1568
1569         evsel = evsel__next(evsel);
1570         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1571         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1572         return 0;
1573 }
1574
1575 static int test__hybrid_group_modifier1(struct evlist *evlist)
1576 {
1577         struct evsel *evsel, *leader;
1578
1579         evsel = leader = evlist__first(evlist);
1580         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1581         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1582         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1583         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1584         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1585         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1586
1587         evsel = evsel__next(evsel);
1588         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1589         TEST_ASSERT_VAL("wrong config", 0xc0 == evsel->core.attr.config);
1590         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1591         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1592         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1593         return 0;
1594 }
1595
1596 static int test__hybrid_raw1(struct evlist *evlist)
1597 {
1598         struct evsel *evsel = evlist__first(evlist);
1599
1600         if (!perf_pmu__hybrid_mounted("cpu_atom")) {
1601                 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1602                 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1603                 TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1604                 return 0;
1605         }
1606
1607         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1608         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1609         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1610
1611         /* The type of second event is randome value */
1612         evsel = evsel__next(evsel);
1613         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1614         return 0;
1615 }
1616
1617 static int test__hybrid_raw2(struct evlist *evlist)
1618 {
1619         struct evsel *evsel = evlist__first(evlist);
1620
1621         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1622         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1623         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1624         return 0;
1625 }
1626
1627 static int test__hybrid_cache_event(struct evlist *evlist)
1628 {
1629         struct evsel *evsel = evlist__first(evlist);
1630
1631         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1632         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type);
1633         TEST_ASSERT_VAL("wrong config", 0x2 == (evsel->core.attr.config & 0xffffffff));
1634         return 0;
1635 }
1636
1637 struct evlist_test {
1638         const char *name;
1639         __u32 type;
1640         const int id;
1641         bool (*valid)(void);
1642         int (*check)(struct evlist *evlist);
1643 };
1644
1645 static struct evlist_test test__events[] = {
1646         {
1647                 .name  = "syscalls:sys_enter_openat",
1648                 .check = test__checkevent_tracepoint,
1649                 .id    = 0,
1650         },
1651         {
1652                 .name  = "syscalls:*",
1653                 .check = test__checkevent_tracepoint_multi,
1654                 .id    = 1,
1655         },
1656         {
1657                 .name  = "r1a",
1658                 .check = test__checkevent_raw,
1659                 .id    = 2,
1660         },
1661         {
1662                 .name  = "1:1",
1663                 .check = test__checkevent_numeric,
1664                 .id    = 3,
1665         },
1666         {
1667                 .name  = "instructions",
1668                 .check = test__checkevent_symbolic_name,
1669                 .id    = 4,
1670         },
1671         {
1672                 .name  = "cycles/period=100000,config2/",
1673                 .check = test__checkevent_symbolic_name_config,
1674                 .id    = 5,
1675         },
1676         {
1677                 .name  = "faults",
1678                 .check = test__checkevent_symbolic_alias,
1679                 .id    = 6,
1680         },
1681         {
1682                 .name  = "L1-dcache-load-miss",
1683                 .check = test__checkevent_genhw,
1684                 .id    = 7,
1685         },
1686         {
1687                 .name  = "mem:0",
1688                 .check = test__checkevent_breakpoint,
1689                 .id    = 8,
1690         },
1691         {
1692                 .name  = "mem:0:x",
1693                 .check = test__checkevent_breakpoint_x,
1694                 .id    = 9,
1695         },
1696         {
1697                 .name  = "mem:0:r",
1698                 .check = test__checkevent_breakpoint_r,
1699                 .id    = 10,
1700         },
1701         {
1702                 .name  = "mem:0:w",
1703                 .check = test__checkevent_breakpoint_w,
1704                 .id    = 11,
1705         },
1706         {
1707                 .name  = "syscalls:sys_enter_openat:k",
1708                 .check = test__checkevent_tracepoint_modifier,
1709                 .id    = 12,
1710         },
1711         {
1712                 .name  = "syscalls:*:u",
1713                 .check = test__checkevent_tracepoint_multi_modifier,
1714                 .id    = 13,
1715         },
1716         {
1717                 .name  = "r1a:kp",
1718                 .check = test__checkevent_raw_modifier,
1719                 .id    = 14,
1720         },
1721         {
1722                 .name  = "1:1:hp",
1723                 .check = test__checkevent_numeric_modifier,
1724                 .id    = 15,
1725         },
1726         {
1727                 .name  = "instructions:h",
1728                 .check = test__checkevent_symbolic_name_modifier,
1729                 .id    = 16,
1730         },
1731         {
1732                 .name  = "faults:u",
1733                 .check = test__checkevent_symbolic_alias_modifier,
1734                 .id    = 17,
1735         },
1736         {
1737                 .name  = "L1-dcache-load-miss:kp",
1738                 .check = test__checkevent_genhw_modifier,
1739                 .id    = 18,
1740         },
1741         {
1742                 .name  = "mem:0:u",
1743                 .check = test__checkevent_breakpoint_modifier,
1744                 .id    = 19,
1745         },
1746         {
1747                 .name  = "mem:0:x:k",
1748                 .check = test__checkevent_breakpoint_x_modifier,
1749                 .id    = 20,
1750         },
1751         {
1752                 .name  = "mem:0:r:hp",
1753                 .check = test__checkevent_breakpoint_r_modifier,
1754                 .id    = 21,
1755         },
1756         {
1757                 .name  = "mem:0:w:up",
1758                 .check = test__checkevent_breakpoint_w_modifier,
1759                 .id    = 22,
1760         },
1761         {
1762                 .name  = "r1,syscalls:sys_enter_openat:k,1:1:hp",
1763                 .check = test__checkevent_list,
1764                 .id    = 23,
1765         },
1766         {
1767                 .name  = "instructions:G",
1768                 .check = test__checkevent_exclude_host_modifier,
1769                 .id    = 24,
1770         },
1771         {
1772                 .name  = "instructions:H",
1773                 .check = test__checkevent_exclude_guest_modifier,
1774                 .id    = 25,
1775         },
1776         {
1777                 .name  = "mem:0:rw",
1778                 .check = test__checkevent_breakpoint_rw,
1779                 .id    = 26,
1780         },
1781         {
1782                 .name  = "mem:0:rw:kp",
1783                 .check = test__checkevent_breakpoint_rw_modifier,
1784                 .id    = 27,
1785         },
1786         {
1787                 .name  = "{instructions:k,cycles:upp}",
1788                 .check = test__group1,
1789                 .id    = 28,
1790         },
1791         {
1792                 .name  = "{faults:k,cache-references}:u,cycles:k",
1793                 .check = test__group2,
1794                 .id    = 29,
1795         },
1796         {
1797                 .name  = "group1{syscalls:sys_enter_openat:H,cycles:kppp},group2{cycles,1:3}:G,instructions:u",
1798                 .check = test__group3,
1799                 .id    = 30,
1800         },
1801         {
1802                 .name  = "{cycles:u,instructions:kp}:p",
1803                 .check = test__group4,
1804                 .id    = 31,
1805         },
1806         {
1807                 .name  = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles",
1808                 .check = test__group5,
1809                 .id    = 32,
1810         },
1811         {
1812                 .name  = "*:*",
1813                 .check = test__all_tracepoints,
1814                 .id    = 33,
1815         },
1816         {
1817                 .name  = "{cycles,cache-misses:G}:H",
1818                 .check = test__group_gh1,
1819                 .id    = 34,
1820         },
1821         {
1822                 .name  = "{cycles,cache-misses:H}:G",
1823                 .check = test__group_gh2,
1824                 .id    = 35,
1825         },
1826         {
1827                 .name  = "{cycles:G,cache-misses:H}:u",
1828                 .check = test__group_gh3,
1829                 .id    = 36,
1830         },
1831         {
1832                 .name  = "{cycles:G,cache-misses:H}:uG",
1833                 .check = test__group_gh4,
1834                 .id    = 37,
1835         },
1836         {
1837                 .name  = "{cycles,cache-misses,branch-misses}:S",
1838                 .check = test__leader_sample1,
1839                 .id    = 38,
1840         },
1841         {
1842                 .name  = "{instructions,branch-misses}:Su",
1843                 .check = test__leader_sample2,
1844                 .id    = 39,
1845         },
1846         {
1847                 .name  = "instructions:uDp",
1848                 .check = test__checkevent_pinned_modifier,
1849                 .id    = 40,
1850         },
1851         {
1852                 .name  = "{cycles,cache-misses,branch-misses}:D",
1853                 .check = test__pinned_group,
1854                 .id    = 41,
1855         },
1856         {
1857                 .name  = "mem:0/1",
1858                 .check = test__checkevent_breakpoint_len,
1859                 .id    = 42,
1860         },
1861         {
1862                 .name  = "mem:0/2:w",
1863                 .check = test__checkevent_breakpoint_len_w,
1864                 .id    = 43,
1865         },
1866         {
1867                 .name  = "mem:0/4:rw:u",
1868                 .check = test__checkevent_breakpoint_len_rw_modifier,
1869                 .id    = 44
1870         },
1871 #if defined(__s390x__)
1872         {
1873                 .name  = "kvm-s390:kvm_s390_create_vm",
1874                 .check = test__checkevent_tracepoint,
1875                 .valid = kvm_s390_create_vm_valid,
1876                 .id    = 100,
1877         },
1878 #endif
1879         {
1880                 .name  = "instructions:I",
1881                 .check = test__checkevent_exclude_idle_modifier,
1882                 .id    = 45,
1883         },
1884         {
1885                 .name  = "instructions:kIG",
1886                 .check = test__checkevent_exclude_idle_modifier_1,
1887                 .id    = 46,
1888         },
1889         {
1890                 .name  = "task-clock:P,cycles",
1891                 .check = test__checkevent_precise_max_modifier,
1892                 .id    = 47,
1893         },
1894         {
1895                 .name  = "instructions/name=insn/",
1896                 .check = test__checkevent_config_symbol,
1897                 .id    = 48,
1898         },
1899         {
1900                 .name  = "r1234/name=rawpmu/",
1901                 .check = test__checkevent_config_raw,
1902                 .id    = 49,
1903         },
1904         {
1905                 .name  = "4:0x6530160/name=numpmu/",
1906                 .check = test__checkevent_config_num,
1907                 .id    = 50,
1908         },
1909         {
1910                 .name  = "L1-dcache-misses/name=cachepmu/",
1911                 .check = test__checkevent_config_cache,
1912                 .id    = 51,
1913         },
1914         {
1915                 .name  = "intel_pt//u",
1916                 .valid = test__intel_pt_valid,
1917                 .check = test__intel_pt,
1918                 .id    = 52,
1919         },
1920         {
1921                 .name  = "cycles/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks'/Duk",
1922                 .check = test__checkevent_complex_name,
1923                 .id    = 53
1924         },
1925         {
1926                 .name  = "cycles//u",
1927                 .check = test__sym_event_slash,
1928                 .id    = 54,
1929         },
1930         {
1931                 .name  = "cycles:k",
1932                 .check = test__sym_event_dc,
1933                 .id    = 55,
1934         },
1935         {
1936                 .name  = "instructions:uep",
1937                 .check = test__checkevent_exclusive_modifier,
1938                 .id    = 56,
1939         },
1940         {
1941                 .name  = "{cycles,cache-misses,branch-misses}:e",
1942                 .check = test__exclusive_group,
1943                 .id    = 57,
1944         },
1945 };
1946
1947 static struct evlist_test test__events_pmu[] = {
1948         {
1949                 .name  = "cpu/config=10,config1,config2=3,period=1000/u",
1950                 .check = test__checkevent_pmu,
1951                 .id    = 0,
1952         },
1953         {
1954                 .name  = "cpu/config=1,name=krava/u,cpu/config=2/u",
1955                 .check = test__checkevent_pmu_name,
1956                 .id    = 1,
1957         },
1958         {
1959                 .name  = "cpu/config=1,call-graph=fp,time,period=100000/,cpu/config=2,call-graph=no,time=0,period=2000/",
1960                 .check = test__checkevent_pmu_partial_time_callgraph,
1961                 .id    = 2,
1962         },
1963         {
1964                 .name  = "cpu/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks',period=0x1,event=0x2/ukp",
1965                 .check = test__checkevent_complex_name,
1966                 .id    = 3,
1967         },
1968         {
1969                 .name  = "software/r1a/",
1970                 .check = test__checkevent_raw_pmu,
1971                 .id    = 4,
1972         },
1973         {
1974                 .name  = "software/r0x1a/",
1975                 .check = test__checkevent_raw_pmu,
1976                 .id    = 4,
1977         },
1978 };
1979
1980 struct terms_test {
1981         const char *str;
1982         __u32 type;
1983         int (*check)(struct list_head *terms);
1984 };
1985
1986 static struct terms_test test__terms[] = {
1987         [0] = {
1988                 .str   = "config=10,config1,config2=3,umask=1,read,r0xead",
1989                 .check = test__checkterms_simple,
1990         },
1991 };
1992
1993 static struct evlist_test test__hybrid_events[] = {
1994         {
1995                 .name  = "cpu_core/cpu-cycles/",
1996                 .check = test__hybrid_hw_event_with_pmu,
1997                 .id    = 0,
1998         },
1999         {
2000                 .name  = "{cpu_core/cpu-cycles/,cpu_core/instructions/}",
2001                 .check = test__hybrid_hw_group_event,
2002                 .id    = 1,
2003         },
2004         {
2005                 .name  = "{cpu-clock,cpu_core/cpu-cycles/}",
2006                 .check = test__hybrid_sw_hw_group_event,
2007                 .id    = 2,
2008         },
2009         {
2010                 .name  = "{cpu_core/cpu-cycles/,cpu-clock}",
2011                 .check = test__hybrid_hw_sw_group_event,
2012                 .id    = 3,
2013         },
2014         {
2015                 .name  = "{cpu_core/cpu-cycles/k,cpu_core/instructions/u}",
2016                 .check = test__hybrid_group_modifier1,
2017                 .id    = 4,
2018         },
2019         {
2020                 .name  = "r1a",
2021                 .check = test__hybrid_raw1,
2022                 .id    = 5,
2023         },
2024         {
2025                 .name  = "cpu_core/r1a/",
2026                 .check = test__hybrid_raw2,
2027                 .id    = 6,
2028         },
2029         {
2030                 .name  = "cpu_core/config=10,config1,config2=3,period=1000/u",
2031                 .check = test__checkevent_pmu,
2032                 .id    = 7,
2033         },
2034         {
2035                 .name  = "cpu_core/LLC-loads/",
2036                 .check = test__hybrid_cache_event,
2037                 .id    = 8,
2038         },
2039 };
2040
2041 static int test_event(struct evlist_test *e)
2042 {
2043         struct parse_events_error err;
2044         struct evlist *evlist;
2045         int ret;
2046
2047         bzero(&err, sizeof(err));
2048         if (e->valid && !e->valid()) {
2049                 pr_debug("... SKIP");
2050                 return 0;
2051         }
2052
2053         evlist = evlist__new();
2054         if (evlist == NULL)
2055                 return -ENOMEM;
2056
2057         ret = parse_events(evlist, e->name, &err);
2058         if (ret) {
2059                 pr_debug("failed to parse event '%s', err %d, str '%s'\n",
2060                          e->name, ret, err.str);
2061                 parse_events_print_error(&err, e->name);
2062         } else {
2063                 ret = e->check(evlist);
2064         }
2065
2066         evlist__delete(evlist);
2067
2068         return ret;
2069 }
2070
2071 static int test_events(struct evlist_test *events, unsigned cnt)
2072 {
2073         int ret1, ret2 = 0;
2074         unsigned i;
2075
2076         for (i = 0; i < cnt; i++) {
2077                 struct evlist_test *e = &events[i];
2078
2079                 pr_debug("running test %d '%s'", e->id, e->name);
2080                 ret1 = test_event(e);
2081                 if (ret1)
2082                         ret2 = ret1;
2083                 pr_debug("\n");
2084         }
2085
2086         return ret2;
2087 }
2088
2089 static int test_term(struct terms_test *t)
2090 {
2091         struct list_head terms;
2092         int ret;
2093
2094         INIT_LIST_HEAD(&terms);
2095
2096         /*
2097          * The perf_pmu__test_parse_init prepares perf_pmu_events_list
2098          * which gets freed in parse_events_terms.
2099          */
2100         if (perf_pmu__test_parse_init())
2101                 return -1;
2102
2103         ret = parse_events_terms(&terms, t->str);
2104         if (ret) {
2105                 pr_debug("failed to parse terms '%s', err %d\n",
2106                          t->str , ret);
2107                 return ret;
2108         }
2109
2110         ret = t->check(&terms);
2111         parse_events_terms__purge(&terms);
2112
2113         return ret;
2114 }
2115
2116 static int test_terms(struct terms_test *terms, unsigned cnt)
2117 {
2118         int ret = 0;
2119         unsigned i;
2120
2121         for (i = 0; i < cnt; i++) {
2122                 struct terms_test *t = &terms[i];
2123
2124                 pr_debug("running test %d '%s'\n", i, t->str);
2125                 ret = test_term(t);
2126                 if (ret)
2127                         break;
2128         }
2129
2130         return ret;
2131 }
2132
2133 static int test_pmu(void)
2134 {
2135         struct stat st;
2136         char path[PATH_MAX];
2137         int ret;
2138
2139         snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/format/",
2140                  sysfs__mountpoint());
2141
2142         ret = stat(path, &st);
2143         if (ret)
2144                 pr_debug("omitting PMU cpu tests\n");
2145         return !ret;
2146 }
2147
2148 static int test_pmu_events(void)
2149 {
2150         struct stat st;
2151         char path[PATH_MAX];
2152         struct dirent *ent;
2153         DIR *dir;
2154         int ret;
2155
2156         snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/events/",
2157                  sysfs__mountpoint());
2158
2159         ret = stat(path, &st);
2160         if (ret) {
2161                 pr_debug("omitting PMU cpu events tests\n");
2162                 return 0;
2163         }
2164
2165         dir = opendir(path);
2166         if (!dir) {
2167                 pr_debug("can't open pmu event dir");
2168                 return -1;
2169         }
2170
2171         while (!ret && (ent = readdir(dir))) {
2172                 struct evlist_test e = { .id = 0, };
2173                 char name[2 * NAME_MAX + 1 + 12 + 3];
2174
2175                 /* Names containing . are special and cannot be used directly */
2176                 if (strchr(ent->d_name, '.'))
2177                         continue;
2178
2179                 snprintf(name, sizeof(name), "cpu/event=%s/u", ent->d_name);
2180
2181                 e.name  = name;
2182                 e.check = test__checkevent_pmu_events;
2183
2184                 ret = test_event(&e);
2185                 if (ret)
2186                         break;
2187                 snprintf(name, sizeof(name), "%s:u,cpu/event=%s/u", ent->d_name, ent->d_name);
2188                 e.name  = name;
2189                 e.check = test__checkevent_pmu_events_mix;
2190                 ret = test_event(&e);
2191         }
2192
2193         closedir(dir);
2194         return ret;
2195 }
2196
2197 int test__parse_events(struct test *test __maybe_unused, int subtest __maybe_unused)
2198 {
2199         int ret1, ret2 = 0;
2200
2201 #define TEST_EVENTS(tests)                              \
2202 do {                                                    \
2203         ret1 = test_events(tests, ARRAY_SIZE(tests));   \
2204         if (!ret2)                                      \
2205                 ret2 = ret1;                            \
2206 } while (0)
2207
2208         if (perf_pmu__has_hybrid()) {
2209                 TEST_EVENTS(test__hybrid_events);
2210                 return ret2;
2211         }
2212
2213         TEST_EVENTS(test__events);
2214
2215         if (test_pmu())
2216                 TEST_EVENTS(test__events_pmu);
2217
2218         if (test_pmu()) {
2219                 int ret = test_pmu_events();
2220                 if (ret)
2221                         return ret;
2222         }
2223
2224         ret1 = test_terms(test__terms, ARRAY_SIZE(test__terms));
2225         if (!ret2)
2226                 ret2 = ret1;
2227
2228         return ret2;
2229 }