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