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