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