tools/perf/tests/parse-events.c

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