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