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