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