1 // SPDX-License-Identifier: GPL-2.0 2 #include "parse-events.h" 3 #include "evsel.h" 4 #include "evlist.h" 5 #include <api/fs/fs.h> 6 #include "tests.h" 7 #include "debug.h" 8 #include "pmu.h" 9 #include "pmus.h" 10 #include <dirent.h> 11 #include <errno.h> 12 #include "fncache.h" 13 #include <sys/types.h> 14 #include <sys/stat.h> 15 #include <unistd.h> 16 #include <linux/kernel.h> 17 #include <linux/hw_breakpoint.h> 18 #include <api/fs/tracing_path.h> 19 20 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \ 21 PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD) 22 23 static int num_core_entries(void) 24 { 25 /* 26 * If the kernel supports extended type, expect events to be 27 * opened once for each core PMU type. Otherwise fall back to the legacy 28 * behavior of opening only one event even though there are multiple 29 * PMUs 30 */ 31 if (perf_pmus__supports_extended_type()) 32 return perf_pmus__num_core_pmus(); 33 34 return 1; 35 } 36 37 static bool test_config(const struct evsel *evsel, __u64 expected_config) 38 { 39 __u32 type = evsel->core.attr.type; 40 __u64 config = evsel->core.attr.config; 41 42 if (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE) { 43 /* 44 * HARDWARE and HW_CACHE events encode the PMU's extended type 45 * in the top 32-bits. Mask in order to ignore. 46 */ 47 config &= PERF_HW_EVENT_MASK; 48 } 49 return config == expected_config; 50 } 51 52 static bool test_perf_config(const struct perf_evsel *evsel, __u64 expected_config) 53 { 54 return (evsel->attr.config & PERF_HW_EVENT_MASK) == expected_config; 55 } 56 57 #ifdef HAVE_LIBTRACEEVENT 58 59 #if defined(__s390x__) 60 /* Return true if kvm module is available and loaded. Test this 61 * and return success when trace point kvm_s390_create_vm 62 * exists. Otherwise this test always fails. 63 */ 64 static bool kvm_s390_create_vm_valid(void) 65 { 66 char *eventfile; 67 bool rc = false; 68 69 eventfile = get_events_file("kvm-s390"); 70 71 if (eventfile) { 72 DIR *mydir = opendir(eventfile); 73 74 if (mydir) { 75 rc = true; 76 closedir(mydir); 77 } 78 put_events_file(eventfile); 79 } 80 81 return rc; 82 } 83 #endif 84 85 static int test__checkevent_tracepoint(struct evlist *evlist) 86 { 87 struct evsel *evsel = evlist__first(evlist); 88 89 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 90 TEST_ASSERT_VAL("wrong number of groups", 0 == evlist__nr_groups(evlist)); 91 TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type); 92 TEST_ASSERT_VAL("wrong sample_type", 93 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type); 94 TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period); 95 return TEST_OK; 96 } 97 98 static int test__checkevent_tracepoint_multi(struct evlist *evlist) 99 { 100 struct evsel *evsel; 101 102 TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1); 103 TEST_ASSERT_VAL("wrong number of groups", 0 == evlist__nr_groups(evlist)); 104 105 evlist__for_each_entry(evlist, evsel) { 106 TEST_ASSERT_VAL("wrong type", 107 PERF_TYPE_TRACEPOINT == evsel->core.attr.type); 108 TEST_ASSERT_VAL("wrong sample_type", 109 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type); 110 TEST_ASSERT_VAL("wrong sample_period", 111 1 == evsel->core.attr.sample_period); 112 } 113 return TEST_OK; 114 } 115 #endif /* HAVE_LIBTRACEEVENT */ 116 117 static int test__checkevent_raw(struct evlist *evlist) 118 { 119 struct perf_evsel *evsel; 120 bool raw_type_match = false; 121 122 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries); 123 124 perf_evlist__for_each_evsel(&evlist->core, evsel) { 125 struct perf_pmu *pmu __maybe_unused = NULL; 126 bool type_matched = false; 127 128 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, 0x1a)); 129 TEST_ASSERT_VAL("event not parsed as raw type", 130 evsel->attr.type == PERF_TYPE_RAW); 131 #if defined(__aarch64__) 132 /* 133 * Arm doesn't have a real raw type PMU in sysfs, so raw events 134 * would never match any PMU. However, RAW events on Arm will 135 * always successfully open on the first available core PMU 136 * so no need to test for a matching type here. 137 */ 138 type_matched = raw_type_match = true; 139 #else 140 while ((pmu = perf_pmus__scan(pmu)) != NULL) { 141 if (pmu->type == evsel->attr.type) { 142 TEST_ASSERT_VAL("PMU type expected once", !type_matched); 143 type_matched = true; 144 if (pmu->type == PERF_TYPE_RAW) 145 raw_type_match = true; 146 } 147 } 148 #endif 149 TEST_ASSERT_VAL("No PMU found for type", type_matched); 150 } 151 TEST_ASSERT_VAL("Raw PMU not matched", raw_type_match); 152 return TEST_OK; 153 } 154 155 static int test__checkevent_numeric(struct evlist *evlist) 156 { 157 struct evsel *evsel = evlist__first(evlist); 158 159 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 160 TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type); 161 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1)); 162 return TEST_OK; 163 } 164 165 166 static int assert_hw(struct perf_evsel *evsel, enum perf_hw_id id, const char *name) 167 { 168 struct perf_pmu *pmu; 169 170 if (evsel->attr.type == PERF_TYPE_HARDWARE) { 171 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, id)); 172 return 0; 173 } 174 pmu = perf_pmus__find_by_type(evsel->attr.type); 175 176 TEST_ASSERT_VAL("unexpected PMU type", pmu); 177 TEST_ASSERT_VAL("PMU missing event", perf_pmu__have_event(pmu, name)); 178 return 0; 179 } 180 181 static int test__checkevent_symbolic_name(struct evlist *evlist) 182 { 183 struct perf_evsel *evsel; 184 185 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries); 186 187 perf_evlist__for_each_evsel(&evlist->core, evsel) { 188 int ret = assert_hw(evsel, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 189 190 if (ret) 191 return ret; 192 } 193 194 return TEST_OK; 195 } 196 197 static int test__checkevent_symbolic_name_config(struct evlist *evlist) 198 { 199 struct perf_evsel *evsel; 200 201 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries); 202 203 perf_evlist__for_each_evsel(&evlist->core, evsel) { 204 int ret = assert_hw(evsel, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 205 206 if (ret) 207 return ret; 208 /* 209 * The period value gets configured within evlist__config, 210 * while this test executes only parse events method. 211 */ 212 TEST_ASSERT_VAL("wrong period", 0 == evsel->attr.sample_period); 213 TEST_ASSERT_VAL("wrong config1", 0 == evsel->attr.config1); 214 TEST_ASSERT_VAL("wrong config2", 1 == evsel->attr.config2); 215 } 216 return TEST_OK; 217 } 218 219 static int test__checkevent_symbolic_alias(struct evlist *evlist) 220 { 221 struct evsel *evsel = evlist__first(evlist); 222 223 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 224 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type); 225 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_SW_PAGE_FAULTS)); 226 return TEST_OK; 227 } 228 229 static int test__checkevent_genhw(struct evlist *evlist) 230 { 231 struct perf_evsel *evsel; 232 233 TEST_ASSERT_VAL("wrong number of entries", 0 != evlist->core.nr_entries); 234 235 perf_evlist__for_each_entry(&evlist->core, evsel) { 236 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->attr.type); 237 TEST_ASSERT_VAL("wrong config", test_perf_config(evsel, 1 << 16)); 238 } 239 return TEST_OK; 240 } 241 242 static int test__checkevent_breakpoint(struct evlist *evlist) 243 { 244 struct evsel *evsel = evlist__first(evlist); 245 246 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 247 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 248 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 249 TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) == 250 evsel->core.attr.bp_type); 251 TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_4 == 252 evsel->core.attr.bp_len); 253 return TEST_OK; 254 } 255 256 static int test__checkevent_breakpoint_x(struct evlist *evlist) 257 { 258 struct evsel *evsel = evlist__first(evlist); 259 260 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 261 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 262 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 263 TEST_ASSERT_VAL("wrong bp_type", 264 HW_BREAKPOINT_X == evsel->core.attr.bp_type); 265 TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->core.attr.bp_len); 266 return TEST_OK; 267 } 268 269 static int test__checkevent_breakpoint_r(struct evlist *evlist) 270 { 271 struct evsel *evsel = evlist__first(evlist); 272 273 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 274 TEST_ASSERT_VAL("wrong type", 275 PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 276 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 277 TEST_ASSERT_VAL("wrong bp_type", 278 HW_BREAKPOINT_R == evsel->core.attr.bp_type); 279 TEST_ASSERT_VAL("wrong bp_len", 280 HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len); 281 return TEST_OK; 282 } 283 284 static int test__checkevent_breakpoint_w(struct evlist *evlist) 285 { 286 struct evsel *evsel = evlist__first(evlist); 287 288 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 289 TEST_ASSERT_VAL("wrong type", 290 PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 291 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 292 TEST_ASSERT_VAL("wrong bp_type", 293 HW_BREAKPOINT_W == evsel->core.attr.bp_type); 294 TEST_ASSERT_VAL("wrong bp_len", 295 HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len); 296 return TEST_OK; 297 } 298 299 static int test__checkevent_breakpoint_rw(struct evlist *evlist) 300 { 301 struct evsel *evsel = evlist__first(evlist); 302 303 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 304 TEST_ASSERT_VAL("wrong type", 305 PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 306 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 307 TEST_ASSERT_VAL("wrong bp_type", 308 (HW_BREAKPOINT_R|HW_BREAKPOINT_W) == evsel->core.attr.bp_type); 309 TEST_ASSERT_VAL("wrong bp_len", 310 HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len); 311 return TEST_OK; 312 } 313 314 #ifdef HAVE_LIBTRACEEVENT 315 static int test__checkevent_tracepoint_modifier(struct evlist *evlist) 316 { 317 struct evsel *evsel = evlist__first(evlist); 318 319 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 320 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 321 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 322 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 323 324 return test__checkevent_tracepoint(evlist); 325 } 326 327 static int 328 test__checkevent_tracepoint_multi_modifier(struct evlist *evlist) 329 { 330 struct perf_evsel *evsel; 331 332 TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1); 333 334 perf_evlist__for_each_entry(&evlist->core, evsel) { 335 TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user); 336 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel); 337 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv); 338 TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip); 339 } 340 341 return test__checkevent_tracepoint_multi(evlist); 342 } 343 #endif /* HAVE_LIBTRACEEVENT */ 344 345 static int test__checkevent_raw_modifier(struct evlist *evlist) 346 { 347 struct perf_evsel *evsel; 348 349 perf_evlist__for_each_entry(&evlist->core, evsel) { 350 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user); 351 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel); 352 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv); 353 TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip); 354 } 355 return test__checkevent_raw(evlist); 356 } 357 358 static int test__checkevent_numeric_modifier(struct evlist *evlist) 359 { 360 struct perf_evsel *evsel; 361 362 perf_evlist__for_each_entry(&evlist->core, evsel) { 363 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user); 364 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel); 365 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv); 366 TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip); 367 } 368 return test__checkevent_numeric(evlist); 369 } 370 371 static int test__checkevent_symbolic_name_modifier(struct evlist *evlist) 372 { 373 struct perf_evsel *evsel; 374 375 TEST_ASSERT_VAL("wrong number of entries", 376 evlist->core.nr_entries == num_core_entries()); 377 378 perf_evlist__for_each_entry(&evlist->core, evsel) { 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 } 384 return test__checkevent_symbolic_name(evlist); 385 } 386 387 static int test__checkevent_exclude_host_modifier(struct evlist *evlist) 388 { 389 struct perf_evsel *evsel; 390 391 perf_evlist__for_each_entry(&evlist->core, evsel) { 392 TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest); 393 TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host); 394 } 395 return test__checkevent_symbolic_name(evlist); 396 } 397 398 static int test__checkevent_exclude_guest_modifier(struct evlist *evlist) 399 { 400 struct perf_evsel *evsel; 401 402 perf_evlist__for_each_entry(&evlist->core, evsel) { 403 TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest); 404 TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host); 405 } 406 return test__checkevent_symbolic_name(evlist); 407 } 408 409 static int test__checkevent_symbolic_alias_modifier(struct evlist *evlist) 410 { 411 struct evsel *evsel = evlist__first(evlist); 412 413 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 414 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 415 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 416 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 417 418 return test__checkevent_symbolic_alias(evlist); 419 } 420 421 static int test__checkevent_genhw_modifier(struct evlist *evlist) 422 { 423 struct perf_evsel *evsel; 424 425 perf_evlist__for_each_entry(&evlist->core, evsel) { 426 TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user); 427 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel); 428 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv); 429 TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip); 430 } 431 return test__checkevent_genhw(evlist); 432 } 433 434 static int test__checkevent_exclude_idle_modifier(struct evlist *evlist) 435 { 436 struct evsel *evsel = evlist__first(evlist); 437 438 TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle); 439 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 440 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 441 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 442 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 443 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 444 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 445 446 return test__checkevent_symbolic_name(evlist); 447 } 448 449 static int test__checkevent_exclude_idle_modifier_1(struct evlist *evlist) 450 { 451 struct evsel *evsel = evlist__first(evlist); 452 453 TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle); 454 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 455 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 456 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 457 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 458 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 459 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 460 461 return test__checkevent_symbolic_name(evlist); 462 } 463 464 static int test__checkevent_breakpoint_modifier(struct evlist *evlist) 465 { 466 struct evsel *evsel = evlist__first(evlist); 467 468 469 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 470 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 471 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 472 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 473 TEST_ASSERT_VAL("wrong name", 474 !strcmp(evsel__name(evsel), "mem:0:u")); 475 476 return test__checkevent_breakpoint(evlist); 477 } 478 479 static int test__checkevent_breakpoint_x_modifier(struct evlist *evlist) 480 { 481 struct evsel *evsel = evlist__first(evlist); 482 483 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 484 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 485 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 486 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 487 TEST_ASSERT_VAL("wrong name", 488 !strcmp(evsel__name(evsel), "mem:0:x:k")); 489 490 return test__checkevent_breakpoint_x(evlist); 491 } 492 493 static int test__checkevent_breakpoint_r_modifier(struct evlist *evlist) 494 { 495 struct evsel *evsel = evlist__first(evlist); 496 497 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 498 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 499 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 500 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 501 TEST_ASSERT_VAL("wrong name", 502 !strcmp(evsel__name(evsel), "mem:0:r:hp")); 503 504 return test__checkevent_breakpoint_r(evlist); 505 } 506 507 static int test__checkevent_breakpoint_w_modifier(struct evlist *evlist) 508 { 509 struct evsel *evsel = evlist__first(evlist); 510 511 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 512 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 513 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 514 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 515 TEST_ASSERT_VAL("wrong name", 516 !strcmp(evsel__name(evsel), "mem:0:w:up")); 517 518 return test__checkevent_breakpoint_w(evlist); 519 } 520 521 static int test__checkevent_breakpoint_rw_modifier(struct evlist *evlist) 522 { 523 struct evsel *evsel = evlist__first(evlist); 524 525 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 526 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 527 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 528 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 529 TEST_ASSERT_VAL("wrong name", 530 !strcmp(evsel__name(evsel), "mem:0:rw:kp")); 531 532 return test__checkevent_breakpoint_rw(evlist); 533 } 534 535 static int test__checkevent_breakpoint_modifier_name(struct evlist *evlist) 536 { 537 struct evsel *evsel = evlist__first(evlist); 538 539 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 540 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 541 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 542 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 543 TEST_ASSERT_VAL("wrong name", 544 !strcmp(evsel__name(evsel), "breakpoint")); 545 546 return test__checkevent_breakpoint(evlist); 547 } 548 549 static int test__checkevent_breakpoint_x_modifier_name(struct evlist *evlist) 550 { 551 struct evsel *evsel = evlist__first(evlist); 552 553 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 554 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 555 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 556 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 557 TEST_ASSERT_VAL("wrong name", 558 !strcmp(evsel__name(evsel), "breakpoint")); 559 560 return test__checkevent_breakpoint_x(evlist); 561 } 562 563 static int test__checkevent_breakpoint_r_modifier_name(struct evlist *evlist) 564 { 565 struct evsel *evsel = evlist__first(evlist); 566 567 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 568 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 569 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 570 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 571 TEST_ASSERT_VAL("wrong name", 572 !strcmp(evsel__name(evsel), "breakpoint")); 573 574 return test__checkevent_breakpoint_r(evlist); 575 } 576 577 static int test__checkevent_breakpoint_w_modifier_name(struct evlist *evlist) 578 { 579 struct evsel *evsel = evlist__first(evlist); 580 581 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 582 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 583 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 584 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 585 TEST_ASSERT_VAL("wrong name", 586 !strcmp(evsel__name(evsel), "breakpoint")); 587 588 return test__checkevent_breakpoint_w(evlist); 589 } 590 591 static int test__checkevent_breakpoint_rw_modifier_name(struct evlist *evlist) 592 { 593 struct evsel *evsel = evlist__first(evlist); 594 595 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 596 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 597 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 598 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 599 TEST_ASSERT_VAL("wrong name", 600 !strcmp(evsel__name(evsel), "breakpoint")); 601 602 return test__checkevent_breakpoint_rw(evlist); 603 } 604 605 static int test__checkevent_breakpoint_2_events(struct evlist *evlist) 606 { 607 struct evsel *evsel = evlist__first(evlist); 608 609 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 610 611 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 612 TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "breakpoint1")); 613 614 evsel = evsel__next(evsel); 615 616 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 617 TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "breakpoint2")); 618 619 return TEST_OK; 620 } 621 622 static int test__checkevent_pmu(struct evlist *evlist) 623 { 624 625 struct evsel *evsel = evlist__first(evlist); 626 627 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 628 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 629 TEST_ASSERT_VAL("wrong config", test_config(evsel, 10)); 630 TEST_ASSERT_VAL("wrong config1", 1 == evsel->core.attr.config1); 631 TEST_ASSERT_VAL("wrong config2", 3 == evsel->core.attr.config2); 632 TEST_ASSERT_VAL("wrong config3", 0 == evsel->core.attr.config3); 633 /* 634 * The period value gets configured within evlist__config, 635 * while this test executes only parse events method. 636 */ 637 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period); 638 639 return TEST_OK; 640 } 641 642 #ifdef HAVE_LIBTRACEEVENT 643 static int test__checkevent_list(struct evlist *evlist) 644 { 645 struct evsel *evsel = evlist__first(evlist); 646 647 TEST_ASSERT_VAL("wrong number of entries", 3 <= evlist->core.nr_entries); 648 649 /* r1 */ 650 TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT != evsel->core.attr.type); 651 while (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) { 652 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1)); 653 TEST_ASSERT_VAL("wrong config1", 0 == evsel->core.attr.config1); 654 TEST_ASSERT_VAL("wrong config2", 0 == evsel->core.attr.config2); 655 TEST_ASSERT_VAL("wrong config3", 0 == evsel->core.attr.config3); 656 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 657 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 658 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 659 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 660 evsel = evsel__next(evsel); 661 } 662 663 /* syscalls:sys_enter_openat:k */ 664 TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type); 665 TEST_ASSERT_VAL("wrong sample_type", 666 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type); 667 TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period); 668 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 669 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 670 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 671 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 672 673 /* 1:1:hp */ 674 evsel = evsel__next(evsel); 675 TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type); 676 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1)); 677 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 678 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 679 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 680 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 681 682 return TEST_OK; 683 } 684 #endif 685 686 static int test__checkevent_pmu_name(struct evlist *evlist) 687 { 688 struct evsel *evsel = evlist__first(evlist); 689 690 /* cpu/config=1,name=krava/u */ 691 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 692 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 693 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1)); 694 TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "krava")); 695 696 /* cpu/config=2/u" */ 697 evsel = evsel__next(evsel); 698 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 699 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 700 TEST_ASSERT_VAL("wrong config", test_config(evsel, 2)); 701 TEST_ASSERT_VAL("wrong name", 702 !strcmp(evsel__name(evsel), "cpu/config=2/u")); 703 704 return TEST_OK; 705 } 706 707 static int test__checkevent_pmu_partial_time_callgraph(struct evlist *evlist) 708 { 709 struct evsel *evsel = evlist__first(evlist); 710 711 /* cpu/config=1,call-graph=fp,time,period=100000/ */ 712 TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries); 713 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 714 TEST_ASSERT_VAL("wrong config", test_config(evsel, 1)); 715 /* 716 * The period, time and callgraph value gets configured within evlist__config, 717 * while this test executes only parse events method. 718 */ 719 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period); 720 TEST_ASSERT_VAL("wrong callgraph", !evsel__has_callchain(evsel)); 721 TEST_ASSERT_VAL("wrong time", !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type)); 722 723 /* cpu/config=2,call-graph=no,time=0,period=2000/ */ 724 evsel = evsel__next(evsel); 725 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type); 726 TEST_ASSERT_VAL("wrong config", test_config(evsel, 2)); 727 /* 728 * The period, time and callgraph value gets configured within evlist__config, 729 * while this test executes only parse events method. 730 */ 731 TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period); 732 TEST_ASSERT_VAL("wrong callgraph", !evsel__has_callchain(evsel)); 733 TEST_ASSERT_VAL("wrong time", !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type)); 734 735 return TEST_OK; 736 } 737 738 static int test__checkevent_pmu_events(struct evlist *evlist) 739 { 740 struct evsel *evsel = evlist__first(evlist); 741 742 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 743 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type || 744 strcmp(evsel->pmu_name, "cpu")); 745 TEST_ASSERT_VAL("wrong exclude_user", 746 !evsel->core.attr.exclude_user); 747 TEST_ASSERT_VAL("wrong exclude_kernel", 748 evsel->core.attr.exclude_kernel); 749 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 750 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 751 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned); 752 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive); 753 754 return TEST_OK; 755 } 756 757 758 static int test__checkevent_pmu_events_mix(struct evlist *evlist) 759 { 760 struct evsel *evsel = NULL; 761 762 /* 763 * The wild card event will be opened at least once, but it may be 764 * opened on each core PMU. 765 */ 766 TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries >= 2); 767 for (int i = 0; i < evlist->core.nr_entries - 1; i++) { 768 evsel = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 769 /* pmu-event:u */ 770 TEST_ASSERT_VAL("wrong exclude_user", 771 !evsel->core.attr.exclude_user); 772 TEST_ASSERT_VAL("wrong exclude_kernel", 773 evsel->core.attr.exclude_kernel); 774 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 775 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 776 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned); 777 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive); 778 } 779 /* cpu/pmu-event/u*/ 780 evsel = evsel__next(evsel); 781 TEST_ASSERT_VAL("wrong type", evsel__find_pmu(evsel)->is_core); 782 TEST_ASSERT_VAL("wrong exclude_user", 783 !evsel->core.attr.exclude_user); 784 TEST_ASSERT_VAL("wrong exclude_kernel", 785 evsel->core.attr.exclude_kernel); 786 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 787 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 788 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned); 789 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.pinned); 790 791 return TEST_OK; 792 } 793 794 static int test__checkterms_simple(struct parse_events_terms *terms) 795 { 796 struct parse_events_term *term; 797 798 /* config=10 */ 799 term = list_entry(terms->terms.next, struct parse_events_term, list); 800 TEST_ASSERT_VAL("wrong type term", 801 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG); 802 TEST_ASSERT_VAL("wrong type val", 803 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM); 804 TEST_ASSERT_VAL("wrong val", term->val.num == 10); 805 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config")); 806 807 /* config1 */ 808 term = list_entry(term->list.next, struct parse_events_term, list); 809 TEST_ASSERT_VAL("wrong type term", 810 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1); 811 TEST_ASSERT_VAL("wrong type val", 812 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM); 813 TEST_ASSERT_VAL("wrong val", term->val.num == 1); 814 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config1")); 815 816 /* config2=3 */ 817 term = list_entry(term->list.next, struct parse_events_term, list); 818 TEST_ASSERT_VAL("wrong type term", 819 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2); 820 TEST_ASSERT_VAL("wrong type val", 821 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM); 822 TEST_ASSERT_VAL("wrong val", term->val.num == 3); 823 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config2")); 824 825 /* config3=4 */ 826 term = list_entry(term->list.next, struct parse_events_term, list); 827 TEST_ASSERT_VAL("wrong type term", 828 term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG3); 829 TEST_ASSERT_VAL("wrong type val", 830 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM); 831 TEST_ASSERT_VAL("wrong val", term->val.num == 4); 832 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config3")); 833 834 /* umask=1*/ 835 term = list_entry(term->list.next, struct parse_events_term, list); 836 TEST_ASSERT_VAL("wrong type term", 837 term->type_term == PARSE_EVENTS__TERM_TYPE_USER); 838 TEST_ASSERT_VAL("wrong type val", 839 term->type_val == PARSE_EVENTS__TERM_TYPE_NUM); 840 TEST_ASSERT_VAL("wrong val", term->val.num == 1); 841 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "umask")); 842 843 /* 844 * read 845 * 846 * The perf_pmu__test_parse_init injects 'read' term into 847 * perf_pmu_events_list, so 'read' is evaluated as read term 848 * and not as raw event with 'ead' hex value. 849 */ 850 term = list_entry(term->list.next, struct parse_events_term, list); 851 TEST_ASSERT_VAL("wrong type term", 852 term->type_term == PARSE_EVENTS__TERM_TYPE_RAW); 853 TEST_ASSERT_VAL("wrong type val", 854 term->type_val == PARSE_EVENTS__TERM_TYPE_STR); 855 TEST_ASSERT_VAL("wrong val", !strcmp(term->val.str, "read")); 856 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "raw")); 857 858 /* 859 * r0xead 860 * 861 * To be still able to pass 'ead' value with 'r' syntax, 862 * we added support to parse 'r0xHEX' event. 863 */ 864 term = list_entry(term->list.next, struct parse_events_term, list); 865 TEST_ASSERT_VAL("wrong type term", 866 term->type_term == PARSE_EVENTS__TERM_TYPE_RAW); 867 TEST_ASSERT_VAL("wrong type val", 868 term->type_val == PARSE_EVENTS__TERM_TYPE_STR); 869 TEST_ASSERT_VAL("wrong val", !strcmp(term->val.str, "r0xead")); 870 TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "raw")); 871 return TEST_OK; 872 } 873 874 static int test__group1(struct evlist *evlist) 875 { 876 struct evsel *evsel, *leader; 877 878 TEST_ASSERT_VAL("wrong number of entries", 879 evlist->core.nr_entries == (num_core_entries() * 2)); 880 TEST_ASSERT_VAL("wrong number of groups", 881 evlist__nr_groups(evlist) == num_core_entries()); 882 883 for (int i = 0; i < num_core_entries(); i++) { 884 int ret; 885 886 /* instructions:k */ 887 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 888 ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 889 if (ret) 890 return ret; 891 892 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 893 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 894 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 895 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 896 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 897 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 898 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 899 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 900 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 901 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 902 903 /* cycles:upp */ 904 evsel = evsel__next(evsel); 905 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 906 if (ret) 907 return ret; 908 909 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 910 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 911 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 912 /* use of precise requires exclude_guest */ 913 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 914 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 915 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2); 916 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 917 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 918 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 919 } 920 return TEST_OK; 921 } 922 923 static int test__group2(struct evlist *evlist) 924 { 925 struct evsel *evsel, *leader = NULL; 926 927 TEST_ASSERT_VAL("wrong number of entries", 928 evlist->core.nr_entries == (2 * num_core_entries() + 1)); 929 /* 930 * TODO: Currently the software event won't be grouped with the hardware 931 * event except for 1 PMU. 932 */ 933 TEST_ASSERT_VAL("wrong number of groups", 1 == evlist__nr_groups(evlist)); 934 935 evlist__for_each_entry(evlist, evsel) { 936 int ret; 937 938 if (evsel->core.attr.type == PERF_TYPE_SOFTWARE) { 939 /* faults + :ku modifier */ 940 leader = evsel; 941 TEST_ASSERT_VAL("wrong config", 942 test_config(evsel, PERF_COUNT_SW_PAGE_FAULTS)); 943 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 944 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 945 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 946 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 947 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 948 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 949 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 950 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 951 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 952 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 953 continue; 954 } 955 if (evsel->core.attr.type == PERF_TYPE_HARDWARE && 956 test_config(evsel, PERF_COUNT_HW_CACHE_REFERENCES)) { 957 /* cache-references + :u modifier */ 958 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 959 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 960 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 961 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 962 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 963 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 964 if (evsel__has_leader(evsel, leader)) 965 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 966 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 967 continue; 968 } 969 /* cycles:k */ 970 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 971 if (ret) 972 return ret; 973 974 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 975 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 976 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 977 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 978 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 979 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 980 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 981 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 982 } 983 return TEST_OK; 984 } 985 986 #ifdef HAVE_LIBTRACEEVENT 987 static int test__group3(struct evlist *evlist __maybe_unused) 988 { 989 struct evsel *evsel, *group1_leader = NULL, *group2_leader = NULL; 990 int ret; 991 992 TEST_ASSERT_VAL("wrong number of entries", 993 evlist->core.nr_entries == (3 * perf_pmus__num_core_pmus() + 2)); 994 /* 995 * Currently the software event won't be grouped with the hardware event 996 * except for 1 PMU. This means there are always just 2 groups 997 * regardless of the number of core PMUs. 998 */ 999 TEST_ASSERT_VAL("wrong number of groups", 2 == evlist__nr_groups(evlist)); 1000 1001 evlist__for_each_entry(evlist, evsel) { 1002 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) { 1003 /* group1 syscalls:sys_enter_openat:H */ 1004 group1_leader = evsel; 1005 TEST_ASSERT_VAL("wrong sample_type", 1006 evsel->core.attr.sample_type == PERF_TP_SAMPLE_TYPE); 1007 TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period); 1008 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1009 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1010 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1011 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1012 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1013 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1014 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1015 TEST_ASSERT_VAL("wrong group name", !strcmp(evsel->group_name, "group1")); 1016 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1017 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1018 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1019 continue; 1020 } 1021 if (evsel->core.attr.type == PERF_TYPE_HARDWARE && 1022 test_config(evsel, PERF_COUNT_HW_CPU_CYCLES)) { 1023 if (evsel->core.attr.exclude_user) { 1024 /* group1 cycles:kppp */ 1025 TEST_ASSERT_VAL("wrong exclude_user", 1026 evsel->core.attr.exclude_user); 1027 TEST_ASSERT_VAL("wrong exclude_kernel", 1028 !evsel->core.attr.exclude_kernel); 1029 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1030 /* use of precise requires exclude_guest */ 1031 TEST_ASSERT_VAL("wrong exclude guest", 1032 evsel->core.attr.exclude_guest); 1033 TEST_ASSERT_VAL("wrong exclude host", 1034 !evsel->core.attr.exclude_host); 1035 TEST_ASSERT_VAL("wrong precise_ip", 1036 evsel->core.attr.precise_ip == 3); 1037 if (evsel__has_leader(evsel, group1_leader)) { 1038 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1039 TEST_ASSERT_VAL("wrong group_idx", 1040 evsel__group_idx(evsel) == 1); 1041 } 1042 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1043 } else { 1044 /* group2 cycles + G modifier */ 1045 group2_leader = evsel; 1046 TEST_ASSERT_VAL("wrong exclude_kernel", 1047 !evsel->core.attr.exclude_kernel); 1048 TEST_ASSERT_VAL("wrong exclude_hv", 1049 !evsel->core.attr.exclude_hv); 1050 TEST_ASSERT_VAL("wrong exclude guest", 1051 !evsel->core.attr.exclude_guest); 1052 TEST_ASSERT_VAL("wrong exclude host", 1053 evsel->core.attr.exclude_host); 1054 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1055 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1056 if (evsel->core.nr_members == 2) { 1057 TEST_ASSERT_VAL("wrong group_idx", 1058 evsel__group_idx(evsel) == 0); 1059 } 1060 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1061 } 1062 continue; 1063 } 1064 if (evsel->core.attr.type == 1) { 1065 /* group2 1:3 + G modifier */ 1066 TEST_ASSERT_VAL("wrong config", test_config(evsel, 3)); 1067 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1068 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1069 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1070 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1071 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1072 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1073 if (evsel__has_leader(evsel, group2_leader)) 1074 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1075 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1076 continue; 1077 } 1078 /* instructions:u */ 1079 ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 1080 if (ret) 1081 return ret; 1082 1083 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1084 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1085 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1086 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1087 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1088 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1089 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1090 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1091 } 1092 return TEST_OK; 1093 } 1094 #endif 1095 1096 static int test__group4(struct evlist *evlist __maybe_unused) 1097 { 1098 struct evsel *evsel, *leader; 1099 1100 TEST_ASSERT_VAL("wrong number of entries", 1101 evlist->core.nr_entries == (num_core_entries() * 2)); 1102 TEST_ASSERT_VAL("wrong number of groups", 1103 num_core_entries() == evlist__nr_groups(evlist)); 1104 1105 for (int i = 0; i < num_core_entries(); i++) { 1106 int ret; 1107 1108 /* cycles:u + p */ 1109 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1110 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1111 if (ret) 1112 return ret; 1113 1114 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1115 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1116 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1117 /* use of precise requires exclude_guest */ 1118 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1119 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1120 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 1); 1121 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1122 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1123 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1124 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1125 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1126 1127 /* instructions:kp + p */ 1128 evsel = evsel__next(evsel); 1129 ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 1130 if (ret) 1131 return ret; 1132 1133 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 1134 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1135 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1136 /* use of precise requires exclude_guest */ 1137 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1138 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1139 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2); 1140 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1141 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1142 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1143 } 1144 return TEST_OK; 1145 } 1146 1147 static int test__group5(struct evlist *evlist __maybe_unused) 1148 { 1149 struct evsel *evsel = NULL, *leader; 1150 int ret; 1151 1152 TEST_ASSERT_VAL("wrong number of entries", 1153 evlist->core.nr_entries == (5 * num_core_entries())); 1154 TEST_ASSERT_VAL("wrong number of groups", 1155 evlist__nr_groups(evlist) == (2 * num_core_entries())); 1156 1157 for (int i = 0; i < num_core_entries(); i++) { 1158 /* cycles + G */ 1159 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1160 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1161 if (ret) 1162 return ret; 1163 1164 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1165 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1166 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1167 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1168 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1169 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1170 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1171 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1172 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1173 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1174 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1175 1176 /* instructions + G */ 1177 evsel = evsel__next(evsel); 1178 ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 1179 if (ret) 1180 return ret; 1181 1182 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1183 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1184 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1185 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1186 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1187 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1188 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1189 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1190 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1191 } 1192 for (int i = 0; i < num_core_entries(); i++) { 1193 /* cycles:G */ 1194 evsel = leader = evsel__next(evsel); 1195 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1196 if (ret) 1197 return ret; 1198 1199 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1200 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1201 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1202 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1203 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1204 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1205 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1206 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1207 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1208 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1209 TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read); 1210 1211 /* instructions:G */ 1212 evsel = evsel__next(evsel); 1213 ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 1214 if (ret) 1215 return ret; 1216 1217 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1218 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1219 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1220 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1221 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1222 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1223 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1224 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1225 } 1226 for (int i = 0; i < num_core_entries(); i++) { 1227 /* cycles */ 1228 evsel = evsel__next(evsel); 1229 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1230 if (ret) 1231 return ret; 1232 1233 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1234 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1235 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1236 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1237 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1238 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1239 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1240 } 1241 return TEST_OK; 1242 } 1243 1244 static int test__group_gh1(struct evlist *evlist) 1245 { 1246 struct evsel *evsel = NULL, *leader; 1247 1248 TEST_ASSERT_VAL("wrong number of entries", 1249 evlist->core.nr_entries == (2 * num_core_entries())); 1250 TEST_ASSERT_VAL("wrong number of groups", 1251 evlist__nr_groups(evlist) == num_core_entries()); 1252 1253 for (int i = 0; i < num_core_entries(); i++) { 1254 int ret; 1255 1256 /* cycles + :H group modifier */ 1257 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1258 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1259 if (ret) 1260 return ret; 1261 1262 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1263 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1264 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1265 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1266 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1267 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1268 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1269 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1270 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1271 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1272 1273 /* cache-misses:G + :H group modifier */ 1274 evsel = evsel__next(evsel); 1275 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1276 if (ret) 1277 return ret; 1278 1279 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1280 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1281 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1282 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1283 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1284 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1285 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1286 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1287 } 1288 return TEST_OK; 1289 } 1290 1291 static int test__group_gh2(struct evlist *evlist) 1292 { 1293 struct evsel *evsel = NULL, *leader; 1294 1295 TEST_ASSERT_VAL("wrong number of entries", 1296 evlist->core.nr_entries == (2 * num_core_entries())); 1297 TEST_ASSERT_VAL("wrong number of groups", 1298 evlist__nr_groups(evlist) == num_core_entries()); 1299 1300 for (int i = 0; i < num_core_entries(); i++) { 1301 int ret; 1302 1303 /* cycles + :G group modifier */ 1304 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1305 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1306 if (ret) 1307 return ret; 1308 1309 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1310 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1311 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1312 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1313 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1314 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1315 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1316 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1317 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1318 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1319 1320 /* cache-misses:H + :G group modifier */ 1321 evsel = evsel__next(evsel); 1322 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1323 if (ret) 1324 return ret; 1325 1326 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1327 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1328 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1329 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1330 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1331 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1332 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1333 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1334 } 1335 return TEST_OK; 1336 } 1337 1338 static int test__group_gh3(struct evlist *evlist) 1339 { 1340 struct evsel *evsel = NULL, *leader; 1341 1342 TEST_ASSERT_VAL("wrong number of entries", 1343 evlist->core.nr_entries == (2 * num_core_entries())); 1344 TEST_ASSERT_VAL("wrong number of groups", 1345 evlist__nr_groups(evlist) == num_core_entries()); 1346 1347 for (int i = 0; i < num_core_entries(); i++) { 1348 int ret; 1349 1350 /* cycles:G + :u group modifier */ 1351 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1352 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1353 if (ret) 1354 return ret; 1355 1356 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1357 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1358 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1359 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1360 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1361 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1362 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1363 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1364 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1365 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1366 1367 /* cache-misses:H + :u group modifier */ 1368 evsel = evsel__next(evsel); 1369 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1370 if (ret) 1371 return ret; 1372 1373 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1374 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1375 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1376 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1377 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1378 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1379 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1380 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1381 } 1382 return TEST_OK; 1383 } 1384 1385 static int test__group_gh4(struct evlist *evlist) 1386 { 1387 struct evsel *evsel = NULL, *leader; 1388 1389 TEST_ASSERT_VAL("wrong number of entries", 1390 evlist->core.nr_entries == (2 * num_core_entries())); 1391 TEST_ASSERT_VAL("wrong number of groups", 1392 evlist__nr_groups(evlist) == num_core_entries()); 1393 1394 for (int i = 0; i < num_core_entries(); i++) { 1395 int ret; 1396 1397 /* cycles:G + :uG group modifier */ 1398 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1399 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1400 if (ret) 1401 return ret; 1402 1403 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1404 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1405 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1406 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1407 TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host); 1408 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1409 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1410 TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel)); 1411 TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2); 1412 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0); 1413 1414 /* cache-misses:H + :uG group modifier */ 1415 evsel = evsel__next(evsel); 1416 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1417 if (ret) 1418 return ret; 1419 1420 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1421 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1422 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1423 TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest); 1424 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1425 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1426 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1427 TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1); 1428 } 1429 return TEST_OK; 1430 } 1431 1432 static int test__leader_sample1(struct evlist *evlist) 1433 { 1434 struct evsel *evsel = NULL, *leader; 1435 1436 TEST_ASSERT_VAL("wrong number of entries", 1437 evlist->core.nr_entries == (3 * num_core_entries())); 1438 1439 for (int i = 0; i < num_core_entries(); i++) { 1440 int ret; 1441 1442 /* cycles - sampling group leader */ 1443 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1444 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1445 if (ret) 1446 return ret; 1447 1448 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1449 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1450 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1451 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1452 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1453 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1454 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1455 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1456 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read); 1457 1458 /* cache-misses - not sampling */ 1459 evsel = evsel__next(evsel); 1460 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1461 if (ret) 1462 return ret; 1463 1464 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1465 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1466 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1467 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1468 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1469 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1470 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1471 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read); 1472 1473 /* branch-misses - not sampling */ 1474 evsel = evsel__next(evsel); 1475 ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses"); 1476 if (ret) 1477 return ret; 1478 1479 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1480 TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel); 1481 TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv); 1482 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1483 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1484 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1485 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1486 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1487 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read); 1488 } 1489 return TEST_OK; 1490 } 1491 1492 static int test__leader_sample2(struct evlist *evlist __maybe_unused) 1493 { 1494 struct evsel *evsel = NULL, *leader; 1495 1496 TEST_ASSERT_VAL("wrong number of entries", 1497 evlist->core.nr_entries == (2 * num_core_entries())); 1498 1499 for (int i = 0; i < num_core_entries(); i++) { 1500 int ret; 1501 1502 /* instructions - sampling group leader */ 1503 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1504 ret = assert_hw(&evsel->core, PERF_COUNT_HW_INSTRUCTIONS, "instructions"); 1505 if (ret) 1506 return ret; 1507 1508 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1509 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1510 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1511 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1512 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1513 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1514 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1515 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1516 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read); 1517 1518 /* branch-misses - not sampling */ 1519 evsel = evsel__next(evsel); 1520 ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses"); 1521 if (ret) 1522 return ret; 1523 1524 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1525 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1526 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1527 TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest); 1528 TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host); 1529 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1530 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1531 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1532 TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read); 1533 } 1534 return TEST_OK; 1535 } 1536 1537 static int test__checkevent_pinned_modifier(struct evlist *evlist) 1538 { 1539 struct evsel *evsel = NULL; 1540 1541 TEST_ASSERT_VAL("wrong number of entries", 1542 evlist->core.nr_entries == num_core_entries()); 1543 1544 for (int i = 0; i < num_core_entries(); i++) { 1545 evsel = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1546 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1547 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1548 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1549 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 1550 TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned); 1551 } 1552 return test__checkevent_symbolic_name(evlist); 1553 } 1554 1555 static int test__pinned_group(struct evlist *evlist) 1556 { 1557 struct evsel *evsel = NULL, *leader; 1558 1559 TEST_ASSERT_VAL("wrong number of entries", 1560 evlist->core.nr_entries == (3 * num_core_entries())); 1561 1562 for (int i = 0; i < num_core_entries(); i++) { 1563 int ret; 1564 1565 /* cycles - group leader */ 1566 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1567 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1568 if (ret) 1569 return ret; 1570 1571 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1572 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1573 /* TODO: The group modifier is not copied to the split group leader. */ 1574 if (perf_pmus__num_core_pmus() == 1) 1575 TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned); 1576 1577 /* cache-misses - can not be pinned, but will go on with the leader */ 1578 evsel = evsel__next(evsel); 1579 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1580 if (ret) 1581 return ret; 1582 1583 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned); 1584 1585 /* branch-misses - ditto */ 1586 evsel = evsel__next(evsel); 1587 ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses"); 1588 if (ret) 1589 return ret; 1590 1591 TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned); 1592 } 1593 return TEST_OK; 1594 } 1595 1596 static int test__checkevent_exclusive_modifier(struct evlist *evlist) 1597 { 1598 struct evsel *evsel = evlist__first(evlist); 1599 1600 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1601 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1602 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1603 TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip); 1604 TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive); 1605 1606 return test__checkevent_symbolic_name(evlist); 1607 } 1608 1609 static int test__exclusive_group(struct evlist *evlist) 1610 { 1611 struct evsel *evsel = NULL, *leader; 1612 1613 TEST_ASSERT_VAL("wrong number of entries", 1614 evlist->core.nr_entries == 3 * num_core_entries()); 1615 1616 for (int i = 0; i < num_core_entries(); i++) { 1617 int ret; 1618 1619 /* cycles - group leader */ 1620 evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel)); 1621 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1622 if (ret) 1623 return ret; 1624 1625 TEST_ASSERT_VAL("wrong group name", !evsel->group_name); 1626 TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader)); 1627 /* TODO: The group modifier is not copied to the split group leader. */ 1628 if (perf_pmus__num_core_pmus() == 1) 1629 TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive); 1630 1631 /* cache-misses - can not be pinned, but will go on with the leader */ 1632 evsel = evsel__next(evsel); 1633 ret = assert_hw(&evsel->core, PERF_COUNT_HW_CACHE_MISSES, "cache-misses"); 1634 if (ret) 1635 return ret; 1636 1637 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive); 1638 1639 /* branch-misses - ditto */ 1640 evsel = evsel__next(evsel); 1641 ret = assert_hw(&evsel->core, PERF_COUNT_HW_BRANCH_MISSES, "branch-misses"); 1642 if (ret) 1643 return ret; 1644 1645 TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive); 1646 } 1647 return TEST_OK; 1648 } 1649 static int test__checkevent_breakpoint_len(struct evlist *evlist) 1650 { 1651 struct evsel *evsel = evlist__first(evlist); 1652 1653 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 1654 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 1655 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 1656 TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) == 1657 evsel->core.attr.bp_type); 1658 TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_1 == 1659 evsel->core.attr.bp_len); 1660 1661 return TEST_OK; 1662 } 1663 1664 static int test__checkevent_breakpoint_len_w(struct evlist *evlist) 1665 { 1666 struct evsel *evsel = evlist__first(evlist); 1667 1668 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 1669 TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type); 1670 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0)); 1671 TEST_ASSERT_VAL("wrong bp_type", HW_BREAKPOINT_W == 1672 evsel->core.attr.bp_type); 1673 TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_2 == 1674 evsel->core.attr.bp_len); 1675 1676 return TEST_OK; 1677 } 1678 1679 static int 1680 test__checkevent_breakpoint_len_rw_modifier(struct evlist *evlist) 1681 { 1682 struct evsel *evsel = evlist__first(evlist); 1683 1684 TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user); 1685 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1686 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv); 1687 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip); 1688 1689 return test__checkevent_breakpoint_rw(evlist); 1690 } 1691 1692 static int test__checkevent_precise_max_modifier(struct evlist *evlist) 1693 { 1694 struct evsel *evsel = evlist__first(evlist); 1695 1696 TEST_ASSERT_VAL("wrong number of entries", 1697 evlist->core.nr_entries == 1 + num_core_entries()); 1698 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type); 1699 TEST_ASSERT_VAL("wrong config", test_config(evsel, PERF_COUNT_SW_TASK_CLOCK)); 1700 return TEST_OK; 1701 } 1702 1703 static int test__checkevent_config_symbol(struct evlist *evlist) 1704 { 1705 struct evsel *evsel = evlist__first(evlist); 1706 1707 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "insn")); 1708 return TEST_OK; 1709 } 1710 1711 static int test__checkevent_config_raw(struct evlist *evlist) 1712 { 1713 struct evsel *evsel = evlist__first(evlist); 1714 1715 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "rawpmu")); 1716 return TEST_OK; 1717 } 1718 1719 static int test__checkevent_config_num(struct evlist *evlist) 1720 { 1721 struct evsel *evsel = evlist__first(evlist); 1722 1723 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "numpmu")); 1724 return TEST_OK; 1725 } 1726 1727 static int test__checkevent_config_cache(struct evlist *evlist) 1728 { 1729 struct evsel *evsel = evlist__first(evlist); 1730 1731 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "cachepmu")); 1732 return test__checkevent_genhw(evlist); 1733 } 1734 1735 static bool test__pmu_cpu_valid(void) 1736 { 1737 return !!perf_pmus__find("cpu"); 1738 } 1739 1740 static bool test__pmu_cpu_event_valid(void) 1741 { 1742 struct perf_pmu *pmu = perf_pmus__find("cpu"); 1743 1744 if (!pmu) 1745 return false; 1746 1747 return perf_pmu__has_format(pmu, "event"); 1748 } 1749 1750 static bool test__intel_pt_valid(void) 1751 { 1752 return !!perf_pmus__find("intel_pt"); 1753 } 1754 1755 static int test__intel_pt(struct evlist *evlist) 1756 { 1757 struct evsel *evsel = evlist__first(evlist); 1758 1759 TEST_ASSERT_VAL("wrong name setting", evsel__name_is(evsel, "intel_pt//u")); 1760 return TEST_OK; 1761 } 1762 1763 static int test__checkevent_complex_name(struct evlist *evlist) 1764 { 1765 struct evsel *evsel = evlist__first(evlist); 1766 1767 TEST_ASSERT_VAL("wrong complex name parsing", 1768 evsel__name_is(evsel, 1769 "COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks")); 1770 return TEST_OK; 1771 } 1772 1773 static int test__checkevent_raw_pmu(struct evlist *evlist) 1774 { 1775 struct evsel *evsel = evlist__first(evlist); 1776 1777 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries); 1778 TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type); 1779 TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a)); 1780 return TEST_OK; 1781 } 1782 1783 static int test__sym_event_slash(struct evlist *evlist) 1784 { 1785 struct evsel *evsel = evlist__first(evlist); 1786 int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1787 1788 if (ret) 1789 return ret; 1790 1791 TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel); 1792 return TEST_OK; 1793 } 1794 1795 static int test__sym_event_dc(struct evlist *evlist) 1796 { 1797 struct evsel *evsel = evlist__first(evlist); 1798 int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1799 1800 if (ret) 1801 return ret; 1802 1803 TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user); 1804 return TEST_OK; 1805 } 1806 1807 static int test__term_equal_term(struct evlist *evlist) 1808 { 1809 struct evsel *evsel = evlist__first(evlist); 1810 int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1811 1812 if (ret) 1813 return ret; 1814 1815 TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "name") == 0); 1816 return TEST_OK; 1817 } 1818 1819 static int test__term_equal_legacy(struct evlist *evlist) 1820 { 1821 struct evsel *evsel = evlist__first(evlist); 1822 int ret = assert_hw(&evsel->core, PERF_COUNT_HW_CPU_CYCLES, "cycles"); 1823 1824 if (ret) 1825 return ret; 1826 1827 TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "l1d") == 0); 1828 return TEST_OK; 1829 } 1830 1831 #ifdef HAVE_LIBTRACEEVENT 1832 static int count_tracepoints(void) 1833 { 1834 struct dirent *events_ent; 1835 DIR *events_dir; 1836 int cnt = 0; 1837 1838 events_dir = tracing_events__opendir(); 1839 1840 TEST_ASSERT_VAL("Can't open events dir", events_dir); 1841 1842 while ((events_ent = readdir(events_dir))) { 1843 char *sys_path; 1844 struct dirent *sys_ent; 1845 DIR *sys_dir; 1846 1847 if (!strcmp(events_ent->d_name, ".") 1848 || !strcmp(events_ent->d_name, "..") 1849 || !strcmp(events_ent->d_name, "enable") 1850 || !strcmp(events_ent->d_name, "header_event") 1851 || !strcmp(events_ent->d_name, "header_page")) 1852 continue; 1853 1854 sys_path = get_events_file(events_ent->d_name); 1855 TEST_ASSERT_VAL("Can't get sys path", sys_path); 1856 1857 sys_dir = opendir(sys_path); 1858 TEST_ASSERT_VAL("Can't open sys dir", sys_dir); 1859 1860 while ((sys_ent = readdir(sys_dir))) { 1861 if (!strcmp(sys_ent->d_name, ".") 1862 || !strcmp(sys_ent->d_name, "..") 1863 || !strcmp(sys_ent->d_name, "enable") 1864 || !strcmp(sys_ent->d_name, "filter")) 1865 continue; 1866 1867 cnt++; 1868 } 1869 1870 closedir(sys_dir); 1871 put_events_file(sys_path); 1872 } 1873 1874 closedir(events_dir); 1875 return cnt; 1876 } 1877 1878 static int test__all_tracepoints(struct evlist *evlist) 1879 { 1880 TEST_ASSERT_VAL("wrong events count", 1881 count_tracepoints() == evlist->core.nr_entries); 1882 1883 return test__checkevent_tracepoint_multi(evlist); 1884 } 1885 #endif /* HAVE_LIBTRACEVENT */ 1886 1887 struct evlist_test { 1888 const char *name; 1889 bool (*valid)(void); 1890 int (*check)(struct evlist *evlist); 1891 }; 1892 1893 static const struct evlist_test test__events[] = { 1894 #ifdef HAVE_LIBTRACEEVENT 1895 { 1896 .name = "syscalls:sys_enter_openat", 1897 .check = test__checkevent_tracepoint, 1898 /* 0 */ 1899 }, 1900 { 1901 .name = "syscalls:*", 1902 .check = test__checkevent_tracepoint_multi, 1903 /* 1 */ 1904 }, 1905 #endif 1906 { 1907 .name = "r1a", 1908 .check = test__checkevent_raw, 1909 /* 2 */ 1910 }, 1911 { 1912 .name = "1:1", 1913 .check = test__checkevent_numeric, 1914 /* 3 */ 1915 }, 1916 { 1917 .name = "instructions", 1918 .check = test__checkevent_symbolic_name, 1919 /* 4 */ 1920 }, 1921 { 1922 .name = "cycles/period=100000,config2/", 1923 .check = test__checkevent_symbolic_name_config, 1924 /* 5 */ 1925 }, 1926 { 1927 .name = "faults", 1928 .check = test__checkevent_symbolic_alias, 1929 /* 6 */ 1930 }, 1931 { 1932 .name = "L1-dcache-load-miss", 1933 .check = test__checkevent_genhw, 1934 /* 7 */ 1935 }, 1936 { 1937 .name = "mem:0", 1938 .check = test__checkevent_breakpoint, 1939 /* 8 */ 1940 }, 1941 { 1942 .name = "mem:0:x", 1943 .check = test__checkevent_breakpoint_x, 1944 /* 9 */ 1945 }, 1946 { 1947 .name = "mem:0:r", 1948 .check = test__checkevent_breakpoint_r, 1949 /* 0 */ 1950 }, 1951 { 1952 .name = "mem:0:w", 1953 .check = test__checkevent_breakpoint_w, 1954 /* 1 */ 1955 }, 1956 #ifdef HAVE_LIBTRACEEVENT 1957 { 1958 .name = "syscalls:sys_enter_openat:k", 1959 .check = test__checkevent_tracepoint_modifier, 1960 /* 2 */ 1961 }, 1962 { 1963 .name = "syscalls:*:u", 1964 .check = test__checkevent_tracepoint_multi_modifier, 1965 /* 3 */ 1966 }, 1967 #endif 1968 { 1969 .name = "r1a:kp", 1970 .check = test__checkevent_raw_modifier, 1971 /* 4 */ 1972 }, 1973 { 1974 .name = "1:1:hp", 1975 .check = test__checkevent_numeric_modifier, 1976 /* 5 */ 1977 }, 1978 { 1979 .name = "instructions:h", 1980 .check = test__checkevent_symbolic_name_modifier, 1981 /* 6 */ 1982 }, 1983 { 1984 .name = "faults:u", 1985 .check = test__checkevent_symbolic_alias_modifier, 1986 /* 7 */ 1987 }, 1988 { 1989 .name = "L1-dcache-load-miss:kp", 1990 .check = test__checkevent_genhw_modifier, 1991 /* 8 */ 1992 }, 1993 { 1994 .name = "mem:0:u", 1995 .check = test__checkevent_breakpoint_modifier, 1996 /* 9 */ 1997 }, 1998 { 1999 .name = "mem:0:x:k", 2000 .check = test__checkevent_breakpoint_x_modifier, 2001 /* 0 */ 2002 }, 2003 { 2004 .name = "mem:0:r:hp", 2005 .check = test__checkevent_breakpoint_r_modifier, 2006 /* 1 */ 2007 }, 2008 { 2009 .name = "mem:0:w:up", 2010 .check = test__checkevent_breakpoint_w_modifier, 2011 /* 2 */ 2012 }, 2013 #ifdef HAVE_LIBTRACEEVENT 2014 { 2015 .name = "r1,syscalls:sys_enter_openat:k,1:1:hp", 2016 .check = test__checkevent_list, 2017 /* 3 */ 2018 }, 2019 #endif 2020 { 2021 .name = "instructions:G", 2022 .check = test__checkevent_exclude_host_modifier, 2023 /* 4 */ 2024 }, 2025 { 2026 .name = "instructions:H", 2027 .check = test__checkevent_exclude_guest_modifier, 2028 /* 5 */ 2029 }, 2030 { 2031 .name = "mem:0:rw", 2032 .check = test__checkevent_breakpoint_rw, 2033 /* 6 */ 2034 }, 2035 { 2036 .name = "mem:0:rw:kp", 2037 .check = test__checkevent_breakpoint_rw_modifier, 2038 /* 7 */ 2039 }, 2040 { 2041 .name = "{instructions:k,cycles:upp}", 2042 .check = test__group1, 2043 /* 8 */ 2044 }, 2045 { 2046 .name = "{faults:k,cache-references}:u,cycles:k", 2047 .check = test__group2, 2048 /* 9 */ 2049 }, 2050 #ifdef HAVE_LIBTRACEEVENT 2051 { 2052 .name = "group1{syscalls:sys_enter_openat:H,cycles:kppp},group2{cycles,1:3}:G,instructions:u", 2053 .check = test__group3, 2054 /* 0 */ 2055 }, 2056 #endif 2057 { 2058 .name = "{cycles:u,instructions:kp}:p", 2059 .check = test__group4, 2060 /* 1 */ 2061 }, 2062 { 2063 .name = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles", 2064 .check = test__group5, 2065 /* 2 */ 2066 }, 2067 #ifdef HAVE_LIBTRACEEVENT 2068 { 2069 .name = "*:*", 2070 .check = test__all_tracepoints, 2071 /* 3 */ 2072 }, 2073 #endif 2074 { 2075 .name = "{cycles,cache-misses:G}:H", 2076 .check = test__group_gh1, 2077 /* 4 */ 2078 }, 2079 { 2080 .name = "{cycles,cache-misses:H}:G", 2081 .check = test__group_gh2, 2082 /* 5 */ 2083 }, 2084 { 2085 .name = "{cycles:G,cache-misses:H}:u", 2086 .check = test__group_gh3, 2087 /* 6 */ 2088 }, 2089 { 2090 .name = "{cycles:G,cache-misses:H}:uG", 2091 .check = test__group_gh4, 2092 /* 7 */ 2093 }, 2094 { 2095 .name = "{cycles,cache-misses,branch-misses}:S", 2096 .check = test__leader_sample1, 2097 /* 8 */ 2098 }, 2099 { 2100 .name = "{instructions,branch-misses}:Su", 2101 .check = test__leader_sample2, 2102 /* 9 */ 2103 }, 2104 { 2105 .name = "instructions:uDp", 2106 .check = test__checkevent_pinned_modifier, 2107 /* 0 */ 2108 }, 2109 { 2110 .name = "{cycles,cache-misses,branch-misses}:D", 2111 .check = test__pinned_group, 2112 /* 1 */ 2113 }, 2114 { 2115 .name = "mem:0/1", 2116 .check = test__checkevent_breakpoint_len, 2117 /* 2 */ 2118 }, 2119 { 2120 .name = "mem:0/2:w", 2121 .check = test__checkevent_breakpoint_len_w, 2122 /* 3 */ 2123 }, 2124 { 2125 .name = "mem:0/4:rw:u", 2126 .check = test__checkevent_breakpoint_len_rw_modifier, 2127 /* 4 */ 2128 }, 2129 #if defined(__s390x__) && defined(HAVE_LIBTRACEEVENT) 2130 { 2131 .name = "kvm-s390:kvm_s390_create_vm", 2132 .check = test__checkevent_tracepoint, 2133 .valid = kvm_s390_create_vm_valid, 2134 /* 0 */ 2135 }, 2136 #endif 2137 { 2138 .name = "instructions:I", 2139 .check = test__checkevent_exclude_idle_modifier, 2140 /* 5 */ 2141 }, 2142 { 2143 .name = "instructions:kIG", 2144 .check = test__checkevent_exclude_idle_modifier_1, 2145 /* 6 */ 2146 }, 2147 { 2148 .name = "task-clock:P,cycles", 2149 .check = test__checkevent_precise_max_modifier, 2150 /* 7 */ 2151 }, 2152 { 2153 .name = "instructions/name=insn/", 2154 .check = test__checkevent_config_symbol, 2155 /* 8 */ 2156 }, 2157 { 2158 .name = "r1234/name=rawpmu/", 2159 .check = test__checkevent_config_raw, 2160 /* 9 */ 2161 }, 2162 { 2163 .name = "4:0x6530160/name=numpmu/", 2164 .check = test__checkevent_config_num, 2165 /* 0 */ 2166 }, 2167 { 2168 .name = "L1-dcache-misses/name=cachepmu/", 2169 .check = test__checkevent_config_cache, 2170 /* 1 */ 2171 }, 2172 { 2173 .name = "intel_pt//u", 2174 .valid = test__intel_pt_valid, 2175 .check = test__intel_pt, 2176 /* 2 */ 2177 }, 2178 { 2179 .name = "cycles/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks'/Duk", 2180 .check = test__checkevent_complex_name, 2181 /* 3 */ 2182 }, 2183 { 2184 .name = "cycles//u", 2185 .check = test__sym_event_slash, 2186 /* 4 */ 2187 }, 2188 { 2189 .name = "cycles:k", 2190 .check = test__sym_event_dc, 2191 /* 5 */ 2192 }, 2193 { 2194 .name = "instructions:uep", 2195 .check = test__checkevent_exclusive_modifier, 2196 /* 6 */ 2197 }, 2198 { 2199 .name = "{cycles,cache-misses,branch-misses}:e", 2200 .check = test__exclusive_group, 2201 /* 7 */ 2202 }, 2203 { 2204 .name = "cycles/name=name/", 2205 .check = test__term_equal_term, 2206 /* 8 */ 2207 }, 2208 { 2209 .name = "cycles/name=l1d/", 2210 .check = test__term_equal_legacy, 2211 /* 9 */ 2212 }, 2213 { 2214 .name = "mem:0/name=breakpoint/", 2215 .check = test__checkevent_breakpoint, 2216 /* 0 */ 2217 }, 2218 { 2219 .name = "mem:0:x/name=breakpoint/", 2220 .check = test__checkevent_breakpoint_x, 2221 /* 1 */ 2222 }, 2223 { 2224 .name = "mem:0:r/name=breakpoint/", 2225 .check = test__checkevent_breakpoint_r, 2226 /* 2 */ 2227 }, 2228 { 2229 .name = "mem:0:w/name=breakpoint/", 2230 .check = test__checkevent_breakpoint_w, 2231 /* 3 */ 2232 }, 2233 { 2234 .name = "mem:0/name=breakpoint/u", 2235 .check = test__checkevent_breakpoint_modifier_name, 2236 /* 4 */ 2237 }, 2238 { 2239 .name = "mem:0:x/name=breakpoint/k", 2240 .check = test__checkevent_breakpoint_x_modifier_name, 2241 /* 5 */ 2242 }, 2243 { 2244 .name = "mem:0:r/name=breakpoint/hp", 2245 .check = test__checkevent_breakpoint_r_modifier_name, 2246 /* 6 */ 2247 }, 2248 { 2249 .name = "mem:0:w/name=breakpoint/up", 2250 .check = test__checkevent_breakpoint_w_modifier_name, 2251 /* 7 */ 2252 }, 2253 { 2254 .name = "mem:0:rw/name=breakpoint/", 2255 .check = test__checkevent_breakpoint_rw, 2256 /* 8 */ 2257 }, 2258 { 2259 .name = "mem:0:rw/name=breakpoint/kp", 2260 .check = test__checkevent_breakpoint_rw_modifier_name, 2261 /* 9 */ 2262 }, 2263 { 2264 .name = "mem:0/1/name=breakpoint/", 2265 .check = test__checkevent_breakpoint_len, 2266 /* 0 */ 2267 }, 2268 { 2269 .name = "mem:0/2:w/name=breakpoint/", 2270 .check = test__checkevent_breakpoint_len_w, 2271 /* 1 */ 2272 }, 2273 { 2274 .name = "mem:0/4:rw/name=breakpoint/u", 2275 .check = test__checkevent_breakpoint_len_rw_modifier, 2276 /* 2 */ 2277 }, 2278 { 2279 .name = "mem:0/1/name=breakpoint1/,mem:0/4:rw/name=breakpoint2/", 2280 .check = test__checkevent_breakpoint_2_events, 2281 /* 3 */ 2282 }, 2283 }; 2284 2285 static const struct evlist_test test__events_pmu[] = { 2286 { 2287 .name = "cpu/config=10,config1=1,config2=3,period=1000/u", 2288 .valid = test__pmu_cpu_valid, 2289 .check = test__checkevent_pmu, 2290 /* 0 */ 2291 }, 2292 { 2293 .name = "cpu/config=1,name=krava/u,cpu/config=2/u", 2294 .valid = test__pmu_cpu_valid, 2295 .check = test__checkevent_pmu_name, 2296 /* 1 */ 2297 }, 2298 { 2299 .name = "cpu/config=1,call-graph=fp,time,period=100000/,cpu/config=2,call-graph=no,time=0,period=2000/", 2300 .valid = test__pmu_cpu_valid, 2301 .check = test__checkevent_pmu_partial_time_callgraph, 2302 /* 2 */ 2303 }, 2304 { 2305 .name = "cpu/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks',period=0x1,event=0x2/ukp", 2306 .valid = test__pmu_cpu_event_valid, 2307 .check = test__checkevent_complex_name, 2308 /* 3 */ 2309 }, 2310 { 2311 .name = "software/r1a/", 2312 .check = test__checkevent_raw_pmu, 2313 /* 4 */ 2314 }, 2315 { 2316 .name = "software/r0x1a/", 2317 .check = test__checkevent_raw_pmu, 2318 /* 5 */ 2319 }, 2320 { 2321 .name = "cpu/L1-dcache-load-miss/", 2322 .valid = test__pmu_cpu_valid, 2323 .check = test__checkevent_genhw, 2324 /* 6 */ 2325 }, 2326 { 2327 .name = "cpu/L1-dcache-load-miss/kp", 2328 .valid = test__pmu_cpu_valid, 2329 .check = test__checkevent_genhw_modifier, 2330 /* 7 */ 2331 }, 2332 { 2333 .name = "cpu/L1-dcache-misses,name=cachepmu/", 2334 .valid = test__pmu_cpu_valid, 2335 .check = test__checkevent_config_cache, 2336 /* 8 */ 2337 }, 2338 { 2339 .name = "cpu/instructions/", 2340 .valid = test__pmu_cpu_valid, 2341 .check = test__checkevent_symbolic_name, 2342 /* 9 */ 2343 }, 2344 { 2345 .name = "cpu/cycles,period=100000,config2/", 2346 .valid = test__pmu_cpu_valid, 2347 .check = test__checkevent_symbolic_name_config, 2348 /* 0 */ 2349 }, 2350 { 2351 .name = "cpu/instructions/h", 2352 .valid = test__pmu_cpu_valid, 2353 .check = test__checkevent_symbolic_name_modifier, 2354 /* 1 */ 2355 }, 2356 { 2357 .name = "cpu/instructions/G", 2358 .valid = test__pmu_cpu_valid, 2359 .check = test__checkevent_exclude_host_modifier, 2360 /* 2 */ 2361 }, 2362 { 2363 .name = "cpu/instructions/H", 2364 .valid = test__pmu_cpu_valid, 2365 .check = test__checkevent_exclude_guest_modifier, 2366 /* 3 */ 2367 }, 2368 { 2369 .name = "{cpu/instructions/k,cpu/cycles/upp}", 2370 .valid = test__pmu_cpu_valid, 2371 .check = test__group1, 2372 /* 4 */ 2373 }, 2374 { 2375 .name = "{cpu/cycles/u,cpu/instructions/kp}:p", 2376 .valid = test__pmu_cpu_valid, 2377 .check = test__group4, 2378 /* 5 */ 2379 }, 2380 { 2381 .name = "{cpu/cycles/,cpu/cache-misses/G}:H", 2382 .valid = test__pmu_cpu_valid, 2383 .check = test__group_gh1, 2384 /* 6 */ 2385 }, 2386 { 2387 .name = "{cpu/cycles/,cpu/cache-misses/H}:G", 2388 .valid = test__pmu_cpu_valid, 2389 .check = test__group_gh2, 2390 /* 7 */ 2391 }, 2392 { 2393 .name = "{cpu/cycles/G,cpu/cache-misses/H}:u", 2394 .valid = test__pmu_cpu_valid, 2395 .check = test__group_gh3, 2396 /* 8 */ 2397 }, 2398 { 2399 .name = "{cpu/cycles/G,cpu/cache-misses/H}:uG", 2400 .valid = test__pmu_cpu_valid, 2401 .check = test__group_gh4, 2402 /* 9 */ 2403 }, 2404 { 2405 .name = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:S", 2406 .valid = test__pmu_cpu_valid, 2407 .check = test__leader_sample1, 2408 /* 0 */ 2409 }, 2410 { 2411 .name = "{cpu/instructions/,cpu/branch-misses/}:Su", 2412 .valid = test__pmu_cpu_valid, 2413 .check = test__leader_sample2, 2414 /* 1 */ 2415 }, 2416 { 2417 .name = "cpu/instructions/uDp", 2418 .valid = test__pmu_cpu_valid, 2419 .check = test__checkevent_pinned_modifier, 2420 /* 2 */ 2421 }, 2422 { 2423 .name = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:D", 2424 .valid = test__pmu_cpu_valid, 2425 .check = test__pinned_group, 2426 /* 3 */ 2427 }, 2428 { 2429 .name = "cpu/instructions/I", 2430 .valid = test__pmu_cpu_valid, 2431 .check = test__checkevent_exclude_idle_modifier, 2432 /* 4 */ 2433 }, 2434 { 2435 .name = "cpu/instructions/kIG", 2436 .valid = test__pmu_cpu_valid, 2437 .check = test__checkevent_exclude_idle_modifier_1, 2438 /* 5 */ 2439 }, 2440 { 2441 .name = "cpu/cycles/u", 2442 .valid = test__pmu_cpu_valid, 2443 .check = test__sym_event_slash, 2444 /* 6 */ 2445 }, 2446 { 2447 .name = "cpu/cycles/k", 2448 .valid = test__pmu_cpu_valid, 2449 .check = test__sym_event_dc, 2450 /* 7 */ 2451 }, 2452 { 2453 .name = "cpu/instructions/uep", 2454 .valid = test__pmu_cpu_valid, 2455 .check = test__checkevent_exclusive_modifier, 2456 /* 8 */ 2457 }, 2458 { 2459 .name = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:e", 2460 .valid = test__pmu_cpu_valid, 2461 .check = test__exclusive_group, 2462 /* 9 */ 2463 }, 2464 { 2465 .name = "cpu/cycles,name=name/", 2466 .valid = test__pmu_cpu_valid, 2467 .check = test__term_equal_term, 2468 /* 0 */ 2469 }, 2470 { 2471 .name = "cpu/cycles,name=l1d/", 2472 .valid = test__pmu_cpu_valid, 2473 .check = test__term_equal_legacy, 2474 /* 1 */ 2475 }, 2476 }; 2477 2478 struct terms_test { 2479 const char *str; 2480 int (*check)(struct parse_events_terms *terms); 2481 }; 2482 2483 static const struct terms_test test__terms[] = { 2484 [0] = { 2485 .str = "config=10,config1,config2=3,config3=4,umask=1,read,r0xead", 2486 .check = test__checkterms_simple, 2487 }, 2488 }; 2489 2490 static int test_event(const struct evlist_test *e) 2491 { 2492 struct parse_events_error err; 2493 struct evlist *evlist; 2494 int ret; 2495 2496 if (e->valid && !e->valid()) { 2497 pr_debug("... SKIP\n"); 2498 return TEST_OK; 2499 } 2500 2501 evlist = evlist__new(); 2502 if (evlist == NULL) { 2503 pr_err("Failed allocation"); 2504 return TEST_FAIL; 2505 } 2506 parse_events_error__init(&err); 2507 ret = parse_events(evlist, e->name, &err); 2508 if (ret) { 2509 pr_debug("failed to parse event '%s', err %d, str '%s'\n", 2510 e->name, ret, err.str); 2511 parse_events_error__print(&err, e->name); 2512 ret = TEST_FAIL; 2513 if (err.str && strstr(err.str, "can't access trace events")) 2514 ret = TEST_SKIP; 2515 } else { 2516 ret = e->check(evlist); 2517 } 2518 parse_events_error__exit(&err); 2519 evlist__delete(evlist); 2520 2521 return ret; 2522 } 2523 2524 static int test_event_fake_pmu(const char *str) 2525 { 2526 struct parse_events_error err; 2527 struct evlist *evlist; 2528 int ret; 2529 2530 evlist = evlist__new(); 2531 if (!evlist) 2532 return -ENOMEM; 2533 2534 parse_events_error__init(&err); 2535 ret = __parse_events(evlist, str, /*pmu_filter=*/NULL, &err, 2536 &perf_pmu__fake, /*warn_if_reordered=*/true); 2537 if (ret) { 2538 pr_debug("failed to parse event '%s', err %d, str '%s'\n", 2539 str, ret, err.str); 2540 parse_events_error__print(&err, str); 2541 } 2542 2543 parse_events_error__exit(&err); 2544 evlist__delete(evlist); 2545 2546 return ret; 2547 } 2548 2549 static int combine_test_results(int existing, int latest) 2550 { 2551 if (existing == TEST_FAIL) 2552 return TEST_FAIL; 2553 if (existing == TEST_SKIP) 2554 return latest == TEST_OK ? TEST_SKIP : latest; 2555 return latest; 2556 } 2557 2558 static int test_events(const struct evlist_test *events, int cnt) 2559 { 2560 int ret = TEST_OK; 2561 2562 for (int i = 0; i < cnt; i++) { 2563 const struct evlist_test *e = &events[i]; 2564 int test_ret; 2565 2566 pr_debug("running test %d '%s'\n", i, e->name); 2567 test_ret = test_event(e); 2568 if (test_ret != TEST_OK) { 2569 pr_debug("Event test failure: test %d '%s'", i, e->name); 2570 ret = combine_test_results(ret, test_ret); 2571 } 2572 } 2573 2574 return ret; 2575 } 2576 2577 static int test__events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 2578 { 2579 return test_events(test__events, ARRAY_SIZE(test__events)); 2580 } 2581 2582 static int test_term(const struct terms_test *t) 2583 { 2584 struct parse_events_terms terms; 2585 int ret; 2586 2587 2588 parse_events_terms__init(&terms); 2589 ret = parse_events_terms(&terms, t->str, /*input=*/ NULL); 2590 if (ret) { 2591 pr_debug("failed to parse terms '%s', err %d\n", 2592 t->str , ret); 2593 return ret; 2594 } 2595 2596 ret = t->check(&terms); 2597 parse_events_terms__exit(&terms); 2598 2599 return ret; 2600 } 2601 2602 static int test_terms(const struct terms_test *terms, int cnt) 2603 { 2604 int ret = 0; 2605 2606 for (int i = 0; i < cnt; i++) { 2607 const struct terms_test *t = &terms[i]; 2608 2609 pr_debug("running test %d '%s'\n", i, t->str); 2610 ret = test_term(t); 2611 if (ret) 2612 break; 2613 } 2614 2615 return ret; 2616 } 2617 2618 static int test__terms2(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 2619 { 2620 return test_terms(test__terms, ARRAY_SIZE(test__terms)); 2621 } 2622 2623 static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 2624 { 2625 struct perf_pmu *pmu = NULL; 2626 int ret = TEST_OK; 2627 2628 while ((pmu = perf_pmus__scan(pmu)) != NULL) { 2629 struct stat st; 2630 char path[PATH_MAX]; 2631 char pmu_event[PATH_MAX]; 2632 char *buf = NULL; 2633 FILE *file; 2634 struct dirent *ent; 2635 size_t len = 0; 2636 DIR *dir; 2637 int err; 2638 int n; 2639 2640 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/events/", 2641 sysfs__mountpoint(), pmu->name); 2642 2643 err = stat(path, &st); 2644 if (err) { 2645 pr_debug("skipping PMU %s events tests: %s\n", pmu->name, path); 2646 continue; 2647 } 2648 2649 dir = opendir(path); 2650 if (!dir) { 2651 pr_debug("can't open pmu event dir: %s\n", path); 2652 ret = combine_test_results(ret, TEST_SKIP); 2653 continue; 2654 } 2655 2656 while ((ent = readdir(dir))) { 2657 struct evlist_test e = { .name = NULL, }; 2658 char name[2 * NAME_MAX + 1 + 12 + 3]; 2659 int test_ret; 2660 bool is_event_parameterized = 0; 2661 2662 /* Names containing . are special and cannot be used directly */ 2663 if (strchr(ent->d_name, '.')) 2664 continue; 2665 2666 /* exclude parameterized ones (name contains '?') */ 2667 n = snprintf(pmu_event, sizeof(pmu_event), "%s%s", path, ent->d_name); 2668 if (n >= PATH_MAX) { 2669 pr_err("pmu event name crossed PATH_MAX(%d) size\n", PATH_MAX); 2670 continue; 2671 } 2672 2673 file = fopen(pmu_event, "r"); 2674 if (!file) { 2675 pr_debug("can't open pmu event file for '%s'\n", ent->d_name); 2676 ret = combine_test_results(ret, TEST_FAIL); 2677 continue; 2678 } 2679 2680 if (getline(&buf, &len, file) < 0) { 2681 pr_debug(" pmu event: %s is a null event\n", ent->d_name); 2682 ret = combine_test_results(ret, TEST_FAIL); 2683 fclose(file); 2684 continue; 2685 } 2686 2687 if (strchr(buf, '?')) 2688 is_event_parameterized = 1; 2689 2690 free(buf); 2691 buf = NULL; 2692 fclose(file); 2693 2694 if (is_event_parameterized == 1) { 2695 pr_debug("skipping parameterized PMU event: %s which contains ?\n", pmu_event); 2696 continue; 2697 } 2698 2699 snprintf(name, sizeof(name), "%s/event=%s/u", pmu->name, ent->d_name); 2700 2701 e.name = name; 2702 e.check = test__checkevent_pmu_events; 2703 2704 test_ret = test_event(&e); 2705 if (test_ret != TEST_OK) { 2706 pr_debug("Test PMU event failed for '%s'", name); 2707 ret = combine_test_results(ret, test_ret); 2708 } 2709 2710 if (!is_pmu_core(pmu->name)) 2711 continue; 2712 2713 /* 2714 * Names containing '-' are recognized as prefixes and suffixes 2715 * due to '-' being a legacy PMU separator. This fails when the 2716 * prefix or suffix collides with an existing legacy token. For 2717 * example, branch-brs has a prefix (branch) that collides with 2718 * a PE_NAME_CACHE_TYPE token causing a parse error as a suffix 2719 * isn't expected after this. As event names in the config 2720 * slashes are allowed a '-' in the name we check this works 2721 * above. 2722 */ 2723 if (strchr(ent->d_name, '-')) 2724 continue; 2725 2726 snprintf(name, sizeof(name), "%s:u,%s/event=%s/u", 2727 ent->d_name, pmu->name, ent->d_name); 2728 e.name = name; 2729 e.check = test__checkevent_pmu_events_mix; 2730 test_ret = test_event(&e); 2731 if (test_ret != TEST_OK) { 2732 pr_debug("Test PMU event failed for '%s'", name); 2733 ret = combine_test_results(ret, test_ret); 2734 } 2735 } 2736 2737 closedir(dir); 2738 } 2739 return ret; 2740 } 2741 2742 static int test__pmu_events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 2743 { 2744 return test_events(test__events_pmu, ARRAY_SIZE(test__events_pmu)); 2745 } 2746 2747 static bool test_alias(char **event, char **alias) 2748 { 2749 char path[PATH_MAX]; 2750 DIR *dir; 2751 struct dirent *dent; 2752 const char *sysfs = sysfs__mountpoint(); 2753 char buf[128]; 2754 FILE *file; 2755 2756 if (!sysfs) 2757 return false; 2758 2759 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/", sysfs); 2760 dir = opendir(path); 2761 if (!dir) 2762 return false; 2763 2764 while ((dent = readdir(dir))) { 2765 if (!strcmp(dent->d_name, ".") || 2766 !strcmp(dent->d_name, "..")) 2767 continue; 2768 2769 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/alias", 2770 sysfs, dent->d_name); 2771 2772 if (!file_available(path)) 2773 continue; 2774 2775 file = fopen(path, "r"); 2776 if (!file) 2777 continue; 2778 2779 if (!fgets(buf, sizeof(buf), file)) { 2780 fclose(file); 2781 continue; 2782 } 2783 2784 /* Remove the last '\n' */ 2785 buf[strlen(buf) - 1] = 0; 2786 2787 fclose(file); 2788 *event = strdup(dent->d_name); 2789 *alias = strdup(buf); 2790 closedir(dir); 2791 2792 if (*event == NULL || *alias == NULL) { 2793 free(*event); 2794 free(*alias); 2795 return false; 2796 } 2797 2798 return true; 2799 } 2800 2801 closedir(dir); 2802 return false; 2803 } 2804 2805 static int test__checkevent_pmu_events_alias(struct evlist *evlist) 2806 { 2807 struct evsel *evsel1 = evlist__first(evlist); 2808 struct evsel *evsel2 = evlist__last(evlist); 2809 2810 TEST_ASSERT_VAL("wrong type", evsel1->core.attr.type == evsel2->core.attr.type); 2811 TEST_ASSERT_VAL("wrong config", evsel1->core.attr.config == evsel2->core.attr.config); 2812 return TEST_OK; 2813 } 2814 2815 static int test__pmu_events_alias(char *event, char *alias) 2816 { 2817 struct evlist_test e = { .name = NULL, }; 2818 char name[2 * NAME_MAX + 20]; 2819 2820 snprintf(name, sizeof(name), "%s/event=1/,%s/event=1/", 2821 event, alias); 2822 2823 e.name = name; 2824 e.check = test__checkevent_pmu_events_alias; 2825 return test_event(&e); 2826 } 2827 2828 static int test__alias(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 2829 { 2830 char *event, *alias; 2831 int ret; 2832 2833 if (!test_alias(&event, &alias)) 2834 return TEST_SKIP; 2835 2836 ret = test__pmu_events_alias(event, alias); 2837 2838 free(event); 2839 free(alias); 2840 return ret; 2841 } 2842 2843 static int test__pmu_events_alias2(struct test_suite *test __maybe_unused, 2844 int subtest __maybe_unused) 2845 { 2846 static const char events[][30] = { 2847 "event-hyphen", 2848 "event-two-hyph", 2849 }; 2850 int ret = TEST_OK; 2851 2852 for (unsigned int i = 0; i < ARRAY_SIZE(events); i++) { 2853 int test_ret = test_event_fake_pmu(&events[i][0]); 2854 2855 if (test_ret != TEST_OK) { 2856 pr_debug("check_parse_fake %s failed\n", &events[i][0]); 2857 ret = combine_test_results(ret, test_ret); 2858 } 2859 } 2860 2861 return ret; 2862 } 2863 2864 static struct test_case tests__parse_events[] = { 2865 TEST_CASE_REASON("Test event parsing", 2866 events2, 2867 "permissions"), 2868 TEST_CASE_REASON("Parsing of all PMU events from sysfs", 2869 pmu_events, 2870 "permissions"), 2871 TEST_CASE_REASON("Parsing of given PMU events from sysfs", 2872 pmu_events2, 2873 "permissions"), 2874 TEST_CASE_REASON("Parsing of aliased events from sysfs", alias, 2875 "no aliases in sysfs"), 2876 TEST_CASE("Parsing of aliased events", pmu_events_alias2), 2877 TEST_CASE("Parsing of terms (event modifiers)", terms2), 2878 { .name = NULL, } 2879 }; 2880 2881 struct test_suite suite__parse_events = { 2882 .desc = "Parse event definition strings", 2883 .test_cases = tests__parse_events, 2884 }; 2885