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