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 */
  26static 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
  47static 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
  60static 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
  78static 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
  88static 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
  98static 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
 109static 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
 130static 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
 141static 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
 151static 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
 165static 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
 178static 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
 193static 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
 208static 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
 
 223static 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
 235static int
 236test__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
 254static 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
 266static 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
 278static 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
 290static 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
 300static 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
 310static 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
 322static 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
 334static 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
 349static 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
 364static 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(perf_evsel__name(evsel), "mem:0:u"));
 375
 376	return test__checkevent_breakpoint(evlist);
 377}
 378
 379static 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(perf_evsel__name(evsel), "mem:0:x:k"));
 389
 390	return test__checkevent_breakpoint_x(evlist);
 391}
 392
 393static 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(perf_evsel__name(evsel), "mem:0:r:hp"));
 403
 404	return test__checkevent_breakpoint_r(evlist);
 405}
 406
 407static 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(perf_evsel__name(evsel), "mem:0:w:up"));
 417
 418	return test__checkevent_breakpoint_w(evlist);
 419}
 420
 421static 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(perf_evsel__name(evsel), "mem:0:rw:kp"));
 431
 432	return test__checkevent_breakpoint_rw(evlist);
 433}
 434
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 435static 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
 
 454static 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 = perf_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 = perf_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
 493static 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(perf_evsel__name(evsel), "krava"));
 502
 503	/* cpu/config=2/u" */
 504	evsel = perf_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(perf_evsel__name(evsel), "cpu/config=2/u"));
 510
 511	return 0;
 512}
 513
 514static 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 = perf_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
 547static 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
 565static 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 = perf_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
 594static 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	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 635}
 636
 637static int test__group1(struct evlist *evlist)
 638{
 639	struct evsel *evsel, *leader;
 640
 641	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 642	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 
 
 643
 644	/* instructions:k */
 645	evsel = leader = evlist__first(evlist);
 646	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 647	TEST_ASSERT_VAL("wrong config",
 648			PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 649	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 650	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 651	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 652	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 653	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 654	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 655	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 656	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 657	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 658	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 659
 660	/* cycles:upp */
 661	evsel = perf_evsel__next(evsel);
 662	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 663	TEST_ASSERT_VAL("wrong config",
 664			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 665	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 666	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 667	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 668	/* use of precise requires exclude_guest */
 669	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 670	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 671	TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
 672	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 673	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 674	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 675
 676	return 0;
 
 
 
 
 
 
 
 
 
 
 677}
 678
 679static int test__group2(struct evlist *evlist)
 680{
 681	struct evsel *evsel, *leader;
 682
 683	TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 684	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 685
 686	/* faults + :ku modifier */
 687	evsel = leader = evlist__first(evlist);
 688	TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
 689	TEST_ASSERT_VAL("wrong config",
 690			PERF_COUNT_SW_PAGE_FAULTS == evsel->core.attr.config);
 691	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 692	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 693	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 694	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 695	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 696	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 697	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 698	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 699	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 700	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 701
 702	/* cache-references + :u modifier */
 703	evsel = perf_evsel__next(evsel);
 704	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 705	TEST_ASSERT_VAL("wrong config",
 706			PERF_COUNT_HW_CACHE_REFERENCES == evsel->core.attr.config);
 707	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 708	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 709	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 710	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 711	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 712	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 713	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 714	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 715	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 716
 717	/* cycles:k */
 718	evsel = perf_evsel__next(evsel);
 719	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 720	TEST_ASSERT_VAL("wrong config",
 721			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 722	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 723	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 724	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 725	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 726	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 727	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 728	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 729	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 730
 731	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 732}
 733
 
 734static int test__group3(struct evlist *evlist __maybe_unused)
 735{
 736	struct evsel *evsel, *leader;
 737
 738	TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->core.nr_entries);
 739	TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->nr_groups);
 740
 741	/* group1 syscalls:sys_enter_openat:H */
 742	evsel = leader = evlist__first(evlist);
 743	TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
 744	TEST_ASSERT_VAL("wrong sample_type",
 745		PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
 746	TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
 747	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 748	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 749	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 750	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 751	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 752	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 753	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 754	TEST_ASSERT_VAL("wrong group name",
 755		!strcmp(leader->group_name, "group1"));
 756	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 757	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 758	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 759
 760	/* group1 cycles:kppp */
 761	evsel = perf_evsel__next(evsel);
 762	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 763	TEST_ASSERT_VAL("wrong config",
 764			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 765	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 766	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 767	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 768	/* use of precise requires exclude_guest */
 769	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 770	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 771	TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 3);
 772	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 773	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 774	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 775	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 776
 777	/* group2 cycles + G modifier */
 778	evsel = leader = perf_evsel__next(evsel);
 779	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 780	TEST_ASSERT_VAL("wrong config",
 781			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 782	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 783	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 784	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 785	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 786	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 787	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 788	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 789	TEST_ASSERT_VAL("wrong group name",
 790		!strcmp(leader->group_name, "group2"));
 791	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 792	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 793	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 794
 795	/* group2 1:3 + G modifier */
 796	evsel = perf_evsel__next(evsel);
 797	TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
 798	TEST_ASSERT_VAL("wrong config", 3 == evsel->core.attr.config);
 799	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 800	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 801	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 802	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 803	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 804	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 805	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 806	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 807	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 808
 809	/* instructions:u */
 810	evsel = perf_evsel__next(evsel);
 811	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 812	TEST_ASSERT_VAL("wrong config",
 813			PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 814	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 815	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 816	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 817	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 818	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 819	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 820	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 821	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 822
 823	return 0;
 
 
 
 
 
 
 
 
 
 824}
 
 825
 826static int test__group4(struct evlist *evlist __maybe_unused)
 827{
 828	struct evsel *evsel, *leader;
 829
 830	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 831	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 
 
 832
 833	/* cycles:u + p */
 834	evsel = leader = evlist__first(evlist);
 835	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 836	TEST_ASSERT_VAL("wrong config",
 837			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 838	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 839	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 840	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 841	/* use of precise requires exclude_guest */
 842	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 843	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 844	TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 1);
 845	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 846	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 847	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 848	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 849	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 850
 851	/* instructions:kp + p */
 852	evsel = perf_evsel__next(evsel);
 853	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 854	TEST_ASSERT_VAL("wrong config",
 855			PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 856	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 857	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 858	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 859	/* use of precise requires exclude_guest */
 860	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 861	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 862	TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
 863	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 864	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 865	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 866
 867	return 0;
 
 
 
 
 
 
 
 
 
 
 868}
 869
 870static int test__group5(struct evlist *evlist __maybe_unused)
 871{
 872	struct evsel *evsel, *leader;
 
 873
 874	TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->core.nr_entries);
 875	TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 876
 877	/* cycles + G */
 878	evsel = leader = evlist__first(evlist);
 879	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 880	TEST_ASSERT_VAL("wrong config",
 881			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 882	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 883	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 884	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 885	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 886	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 887	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 888	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 889	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 890	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 891	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 892	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 893
 894	/* instructions + G */
 895	evsel = perf_evsel__next(evsel);
 896	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 897	TEST_ASSERT_VAL("wrong config",
 898			PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 899	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 900	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 901	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 902	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 903	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 904	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 905	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 906	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 907	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 908
 909	/* cycles:G */
 910	evsel = leader = perf_evsel__next(evsel);
 911	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 912	TEST_ASSERT_VAL("wrong config",
 913			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 914	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 915	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 916	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 917	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 918	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 919	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 920	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 921	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 922	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 923	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 924	TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 925
 926	/* instructions:G */
 927	evsel = perf_evsel__next(evsel);
 928	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 929	TEST_ASSERT_VAL("wrong config",
 930			PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 931	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 932	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 933	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 934	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 935	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 936	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 937	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 938	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 939
 940	/* cycles */
 941	evsel = perf_evsel__next(evsel);
 942	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 943	TEST_ASSERT_VAL("wrong config",
 944			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 945	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 946	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 947	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 948	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 949	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 950	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 951	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 
 
 
 
 952
 953	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 954}
 955
 956static int test__group_gh1(struct evlist *evlist)
 957{
 958	struct evsel *evsel, *leader;
 959
 960	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 961	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 
 
 962
 963	/* cycles + :H group modifier */
 964	evsel = leader = evlist__first(evlist);
 965	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 966	TEST_ASSERT_VAL("wrong config",
 967			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 968	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 969	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 970	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 971	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 972	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 973	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 974	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 975	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 976	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 977	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 978
 979	/* cache-misses:G + :H group modifier */
 980	evsel = perf_evsel__next(evsel);
 981	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 982	TEST_ASSERT_VAL("wrong config",
 983			PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
 984	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 985	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 986	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 987	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 988	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 989	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 990	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
 991	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 992
 993	return 0;
 
 
 
 
 
 
 
 
 
 994}
 995
 996static int test__group_gh2(struct evlist *evlist)
 997{
 998	struct evsel *evsel, *leader;
 999
1000	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1001	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 
 
1002
1003	/* cycles + :G group modifier */
1004	evsel = leader = evlist__first(evlist);
1005	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1006	TEST_ASSERT_VAL("wrong config",
1007			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1008	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1009	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1010	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1011	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1012	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1013	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1014	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1015	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
1016	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1017	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
1018
1019	/* cache-misses:H + :G group modifier */
1020	evsel = perf_evsel__next(evsel);
1021	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1022	TEST_ASSERT_VAL("wrong config",
1023			PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1024	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1025	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1026	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1027	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1028	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1029	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1030	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1031	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
1032
1033	return 0;
 
 
 
 
 
 
 
 
 
1034}
1035
1036static int test__group_gh3(struct evlist *evlist)
1037{
1038	struct evsel *evsel, *leader;
1039
1040	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1041	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 
 
1042
1043	/* cycles:G + :u group modifier */
1044	evsel = leader = evlist__first(evlist);
1045	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1046	TEST_ASSERT_VAL("wrong config",
1047			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1048	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1049	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1050	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1051	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1052	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1053	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1054	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1055	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
1056	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1057	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
1058
1059	/* cache-misses:H + :u group modifier */
1060	evsel = perf_evsel__next(evsel);
1061	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1062	TEST_ASSERT_VAL("wrong config",
1063			PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1064	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1065	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1066	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1067	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1068	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1069	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1070	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1071	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
1072
1073	return 0;
 
 
 
 
 
 
 
 
 
1074}
1075
1076static int test__group_gh4(struct evlist *evlist)
1077{
1078	struct evsel *evsel, *leader;
1079
1080	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1081	TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
 
 
 
 
 
 
 
 
 
 
1082
1083	/* cycles:G + :uG group modifier */
1084	evsel = leader = evlist__first(evlist);
1085	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1086	TEST_ASSERT_VAL("wrong config",
1087			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1088	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1089	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1090	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1091	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1092	TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1093	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1094	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1095	TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
1096	TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1097	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
1098
1099	/* cache-misses:H + :uG group modifier */
1100	evsel = perf_evsel__next(evsel);
1101	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1102	TEST_ASSERT_VAL("wrong config",
1103			PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1104	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1105	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1106	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1107	TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1108	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1109	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1110	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1111	TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
1112
1113	return 0;
 
 
 
 
 
 
 
 
 
1114}
1115
1116static int test__leader_sample1(struct evlist *evlist)
1117{
1118	struct evsel *evsel, *leader;
1119
1120	TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 
1121
1122	/* cycles - sampling group leader */
1123	evsel = leader = evlist__first(evlist);
1124	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1125	TEST_ASSERT_VAL("wrong config",
1126			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1127	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1128	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1129	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1130	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1131	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1132	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1133	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1134	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1135	TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1136
1137	/* cache-misses - not sampling */
1138	evsel = perf_evsel__next(evsel);
1139	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1140	TEST_ASSERT_VAL("wrong config",
1141			PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1142	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1143	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1144	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1145	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1146	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1147	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1148	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1149	TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1150
1151	/* branch-misses - not sampling */
1152	evsel = perf_evsel__next(evsel);
1153	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1154	TEST_ASSERT_VAL("wrong config",
1155			PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1156	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1157	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1158	TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1159	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1160	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1161	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1162	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1163	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1164	TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1165
1166	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1167}
1168
1169static int test__leader_sample2(struct evlist *evlist __maybe_unused)
1170{
1171	struct evsel *evsel, *leader;
1172
1173	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 
1174
1175	/* instructions - sampling group leader */
1176	evsel = leader = evlist__first(evlist);
1177	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1178	TEST_ASSERT_VAL("wrong config",
1179			PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
1180	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1181	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1182	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1183	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1184	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1185	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1186	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1187	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1188	TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1189
1190	/* branch-misses - not sampling */
1191	evsel = perf_evsel__next(evsel);
1192	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1193	TEST_ASSERT_VAL("wrong config",
1194			PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1195	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1196	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1197	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1198	TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1199	TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1200	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1201	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1202	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1203	TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1204
1205	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1206}
1207
1208static int test__checkevent_pinned_modifier(struct evlist *evlist)
1209{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1210	struct evsel *evsel = evlist__first(evlist);
1211
1212	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1213	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1214	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1215	TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1216	TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1217
1218	return test__checkevent_symbolic_name(evlist);
1219}
1220
1221static int test__pinned_group(struct evlist *evlist)
1222{
1223	struct evsel *evsel, *leader;
1224
1225	TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 
1226
1227	/* cycles - group leader */
1228	evsel = leader = evlist__first(evlist);
1229	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1230	TEST_ASSERT_VAL("wrong config",
1231			PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1232	TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1233	TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
1234	TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1235
1236	/* cache-misses - can not be pinned, but will go on with the leader */
1237	evsel = perf_evsel__next(evsel);
1238	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1239	TEST_ASSERT_VAL("wrong config",
1240			PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1241	TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1242
1243	/* branch-misses - ditto */
1244	evsel = perf_evsel__next(evsel);
1245	TEST_ASSERT_VAL("wrong config",
1246			PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1247	TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1248
1249	return 0;
1250}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1251
 
 
 
 
1252static int test__checkevent_breakpoint_len(struct evlist *evlist)
1253{
1254	struct evsel *evsel = evlist__first(evlist);
1255
1256	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1257	TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1258	TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
1259	TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
1260					 evsel->core.attr.bp_type);
1261	TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_1 ==
1262					evsel->core.attr.bp_len);
1263
1264	return 0;
1265}
1266
1267static int test__checkevent_breakpoint_len_w(struct evlist *evlist)
1268{
1269	struct evsel *evsel = evlist__first(evlist);
1270
1271	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1272	TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1273	TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
1274	TEST_ASSERT_VAL("wrong bp_type", HW_BREAKPOINT_W ==
1275					 evsel->core.attr.bp_type);
1276	TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_2 ==
1277					evsel->core.attr.bp_len);
1278
1279	return 0;
1280}
1281
1282static int
1283test__checkevent_breakpoint_len_rw_modifier(struct evlist *evlist)
1284{
1285	struct evsel *evsel = evlist__first(evlist);
1286
1287	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1288	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1289	TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1290	TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1291
1292	return test__checkevent_breakpoint_rw(evlist);
1293}
1294
1295static int test__checkevent_precise_max_modifier(struct evlist *evlist)
1296{
1297	struct evsel *evsel = evlist__first(evlist);
1298
1299	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 
1300	TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1301	TEST_ASSERT_VAL("wrong config",
1302			PERF_COUNT_SW_TASK_CLOCK == evsel->core.attr.config);
1303	return 0;
1304}
1305
1306static int test__checkevent_config_symbol(struct evlist *evlist)
1307{
1308	struct evsel *evsel = evlist__first(evlist);
1309
1310	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "insn") == 0);
1311	return 0;
1312}
1313
1314static int test__checkevent_config_raw(struct evlist *evlist)
1315{
1316	struct evsel *evsel = evlist__first(evlist);
1317
1318	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "rawpmu") == 0);
1319	return 0;
1320}
1321
1322static int test__checkevent_config_num(struct evlist *evlist)
1323{
1324	struct evsel *evsel = evlist__first(evlist);
1325
1326	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "numpmu") == 0);
1327	return 0;
1328}
1329
1330static int test__checkevent_config_cache(struct evlist *evlist)
1331{
1332	struct evsel *evsel = evlist__first(evlist);
1333
1334	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "cachepmu") == 0);
1335	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1336}
1337
1338static bool test__intel_pt_valid(void)
1339{
1340	return !!perf_pmu__find("intel_pt");
1341}
1342
1343static int test__intel_pt(struct evlist *evlist)
1344{
1345	struct evsel *evsel = evlist__first(evlist);
1346
1347	TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "intel_pt//u") == 0);
1348	return 0;
1349}
1350
1351static int test__checkevent_complex_name(struct evlist *evlist)
1352{
1353	struct evsel *evsel = evlist__first(evlist);
1354
1355	TEST_ASSERT_VAL("wrong complex name parsing", strcmp(evsel->name, "COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks") == 0);
1356	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
1357}
1358
1359static int test__sym_event_slash(struct evlist *evlist)
1360{
1361	struct evsel *evsel = evlist__first(evlist);
 
 
 
 
1362
1363	TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1364	TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES);
1365	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1366	return 0;
1367}
1368
1369static int test__sym_event_dc(struct evlist *evlist)
1370{
1371	struct evsel *evsel = evlist__first(evlist);
 
 
 
 
1372
1373	TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1374	TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES);
1375	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1376	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1377}
1378
 
1379static int count_tracepoints(void)
1380{
1381	struct dirent *events_ent;
1382	DIR *events_dir;
1383	int cnt = 0;
1384
1385	events_dir = tracing_events__opendir();
1386
1387	TEST_ASSERT_VAL("Can't open events dir", events_dir);
1388
1389	while ((events_ent = readdir(events_dir))) {
1390		char *sys_path;
1391		struct dirent *sys_ent;
1392		DIR *sys_dir;
1393
1394		if (!strcmp(events_ent->d_name, ".")
1395		    || !strcmp(events_ent->d_name, "..")
1396		    || !strcmp(events_ent->d_name, "enable")
1397		    || !strcmp(events_ent->d_name, "header_event")
1398		    || !strcmp(events_ent->d_name, "header_page"))
1399			continue;
1400
1401		sys_path = get_events_file(events_ent->d_name);
1402		TEST_ASSERT_VAL("Can't get sys path", sys_path);
1403
1404		sys_dir = opendir(sys_path);
1405		TEST_ASSERT_VAL("Can't open sys dir", sys_dir);
1406
1407		while ((sys_ent = readdir(sys_dir))) {
1408			if (!strcmp(sys_ent->d_name, ".")
1409			    || !strcmp(sys_ent->d_name, "..")
1410			    || !strcmp(sys_ent->d_name, "enable")
1411			    || !strcmp(sys_ent->d_name, "filter"))
1412				continue;
1413
1414			cnt++;
1415		}
1416
1417		closedir(sys_dir);
1418		put_events_file(sys_path);
1419	}
1420
1421	closedir(events_dir);
1422	return cnt;
1423}
1424
1425static int test__all_tracepoints(struct evlist *evlist)
1426{
1427	TEST_ASSERT_VAL("wrong events count",
1428			count_tracepoints() == evlist->core.nr_entries);
1429
1430	return test__checkevent_tracepoint_multi(evlist);
1431}
 
1432
1433struct evlist_test {
1434	const char *name;
1435	__u32 type;
1436	const int id;
1437	bool (*valid)(void);
1438	int (*check)(struct evlist *evlist);
1439};
1440
1441static struct evlist_test test__events[] = {
 
1442	{
1443		.name  = "syscalls:sys_enter_openat",
1444		.check = test__checkevent_tracepoint,
1445		.id    = 0,
1446	},
1447	{
1448		.name  = "syscalls:*",
1449		.check = test__checkevent_tracepoint_multi,
1450		.id    = 1,
1451	},
 
1452	{
1453		.name  = "r1a",
1454		.check = test__checkevent_raw,
1455		.id    = 2,
1456	},
1457	{
1458		.name  = "1:1",
1459		.check = test__checkevent_numeric,
1460		.id    = 3,
1461	},
1462	{
1463		.name  = "instructions",
1464		.check = test__checkevent_symbolic_name,
1465		.id    = 4,
1466	},
1467	{
1468		.name  = "cycles/period=100000,config2/",
1469		.check = test__checkevent_symbolic_name_config,
1470		.id    = 5,
1471	},
1472	{
1473		.name  = "faults",
1474		.check = test__checkevent_symbolic_alias,
1475		.id    = 6,
1476	},
1477	{
1478		.name  = "L1-dcache-load-miss",
1479		.check = test__checkevent_genhw,
1480		.id    = 7,
1481	},
1482	{
1483		.name  = "mem:0",
1484		.check = test__checkevent_breakpoint,
1485		.id    = 8,
1486	},
1487	{
1488		.name  = "mem:0:x",
1489		.check = test__checkevent_breakpoint_x,
1490		.id    = 9,
1491	},
1492	{
1493		.name  = "mem:0:r",
1494		.check = test__checkevent_breakpoint_r,
1495		.id    = 10,
1496	},
1497	{
1498		.name  = "mem:0:w",
1499		.check = test__checkevent_breakpoint_w,
1500		.id    = 11,
1501	},
 
1502	{
1503		.name  = "syscalls:sys_enter_openat:k",
1504		.check = test__checkevent_tracepoint_modifier,
1505		.id    = 12,
1506	},
1507	{
1508		.name  = "syscalls:*:u",
1509		.check = test__checkevent_tracepoint_multi_modifier,
1510		.id    = 13,
1511	},
 
1512	{
1513		.name  = "r1a:kp",
1514		.check = test__checkevent_raw_modifier,
1515		.id    = 14,
1516	},
1517	{
1518		.name  = "1:1:hp",
1519		.check = test__checkevent_numeric_modifier,
1520		.id    = 15,
1521	},
1522	{
1523		.name  = "instructions:h",
1524		.check = test__checkevent_symbolic_name_modifier,
1525		.id    = 16,
1526	},
1527	{
1528		.name  = "faults:u",
1529		.check = test__checkevent_symbolic_alias_modifier,
1530		.id    = 17,
1531	},
1532	{
1533		.name  = "L1-dcache-load-miss:kp",
1534		.check = test__checkevent_genhw_modifier,
1535		.id    = 18,
1536	},
1537	{
1538		.name  = "mem:0:u",
1539		.check = test__checkevent_breakpoint_modifier,
1540		.id    = 19,
1541	},
1542	{
1543		.name  = "mem:0:x:k",
1544		.check = test__checkevent_breakpoint_x_modifier,
1545		.id    = 20,
1546	},
1547	{
1548		.name  = "mem:0:r:hp",
1549		.check = test__checkevent_breakpoint_r_modifier,
1550		.id    = 21,
1551	},
1552	{
1553		.name  = "mem:0:w:up",
1554		.check = test__checkevent_breakpoint_w_modifier,
1555		.id    = 22,
1556	},
 
1557	{
1558		.name  = "r1,syscalls:sys_enter_openat:k,1:1:hp",
1559		.check = test__checkevent_list,
1560		.id    = 23,
1561	},
 
1562	{
1563		.name  = "instructions:G",
1564		.check = test__checkevent_exclude_host_modifier,
1565		.id    = 24,
1566	},
1567	{
1568		.name  = "instructions:H",
1569		.check = test__checkevent_exclude_guest_modifier,
1570		.id    = 25,
1571	},
1572	{
1573		.name  = "mem:0:rw",
1574		.check = test__checkevent_breakpoint_rw,
1575		.id    = 26,
1576	},
1577	{
1578		.name  = "mem:0:rw:kp",
1579		.check = test__checkevent_breakpoint_rw_modifier,
1580		.id    = 27,
1581	},
1582	{
1583		.name  = "{instructions:k,cycles:upp}",
1584		.check = test__group1,
1585		.id    = 28,
1586	},
1587	{
1588		.name  = "{faults:k,cache-references}:u,cycles:k",
1589		.check = test__group2,
1590		.id    = 29,
1591	},
 
1592	{
1593		.name  = "group1{syscalls:sys_enter_openat:H,cycles:kppp},group2{cycles,1:3}:G,instructions:u",
1594		.check = test__group3,
1595		.id    = 30,
1596	},
 
1597	{
1598		.name  = "{cycles:u,instructions:kp}:p",
1599		.check = test__group4,
1600		.id    = 31,
1601	},
1602	{
1603		.name  = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles",
1604		.check = test__group5,
1605		.id    = 32,
1606	},
 
1607	{
1608		.name  = "*:*",
1609		.check = test__all_tracepoints,
1610		.id    = 33,
1611	},
 
1612	{
1613		.name  = "{cycles,cache-misses:G}:H",
1614		.check = test__group_gh1,
1615		.id    = 34,
1616	},
1617	{
1618		.name  = "{cycles,cache-misses:H}:G",
1619		.check = test__group_gh2,
1620		.id    = 35,
1621	},
1622	{
1623		.name  = "{cycles:G,cache-misses:H}:u",
1624		.check = test__group_gh3,
1625		.id    = 36,
1626	},
1627	{
1628		.name  = "{cycles:G,cache-misses:H}:uG",
1629		.check = test__group_gh4,
1630		.id    = 37,
1631	},
1632	{
1633		.name  = "{cycles,cache-misses,branch-misses}:S",
1634		.check = test__leader_sample1,
1635		.id    = 38,
1636	},
1637	{
1638		.name  = "{instructions,branch-misses}:Su",
1639		.check = test__leader_sample2,
1640		.id    = 39,
1641	},
1642	{
1643		.name  = "instructions:uDp",
1644		.check = test__checkevent_pinned_modifier,
1645		.id    = 40,
1646	},
1647	{
1648		.name  = "{cycles,cache-misses,branch-misses}:D",
1649		.check = test__pinned_group,
1650		.id    = 41,
1651	},
1652	{
1653		.name  = "mem:0/1",
1654		.check = test__checkevent_breakpoint_len,
1655		.id    = 42,
1656	},
1657	{
1658		.name  = "mem:0/2:w",
1659		.check = test__checkevent_breakpoint_len_w,
1660		.id    = 43,
1661	},
1662	{
1663		.name  = "mem:0/4:rw:u",
1664		.check = test__checkevent_breakpoint_len_rw_modifier,
1665		.id    = 44
1666	},
1667#if defined(__s390x__)
1668	{
1669		.name  = "kvm-s390:kvm_s390_create_vm",
1670		.check = test__checkevent_tracepoint,
1671		.valid = kvm_s390_create_vm_valid,
1672		.id    = 100,
1673	},
1674#endif
1675	{
1676		.name  = "instructions:I",
1677		.check = test__checkevent_exclude_idle_modifier,
1678		.id    = 45,
1679	},
1680	{
1681		.name  = "instructions:kIG",
1682		.check = test__checkevent_exclude_idle_modifier_1,
1683		.id    = 46,
1684	},
1685	{
1686		.name  = "task-clock:P,cycles",
1687		.check = test__checkevent_precise_max_modifier,
1688		.id    = 47,
1689	},
1690	{
1691		.name  = "instructions/name=insn/",
1692		.check = test__checkevent_config_symbol,
1693		.id    = 48,
1694	},
1695	{
1696		.name  = "r1234/name=rawpmu/",
1697		.check = test__checkevent_config_raw,
1698		.id    = 49,
1699	},
1700	{
1701		.name  = "4:0x6530160/name=numpmu/",
1702		.check = test__checkevent_config_num,
1703		.id    = 50,
1704	},
1705	{
1706		.name  = "L1-dcache-misses/name=cachepmu/",
1707		.check = test__checkevent_config_cache,
1708		.id    = 51,
1709	},
1710	{
1711		.name  = "intel_pt//u",
1712		.valid = test__intel_pt_valid,
1713		.check = test__intel_pt,
1714		.id    = 52,
1715	},
1716	{
1717		.name  = "cycles/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks'/Duk",
1718		.check = test__checkevent_complex_name,
1719		.id    = 53
1720	},
1721	{
1722		.name  = "cycles//u",
1723		.check = test__sym_event_slash,
1724		.id    = 54,
1725	},
1726	{
1727		.name  = "cycles:k",
1728		.check = test__sym_event_dc,
1729		.id    = 55,
1730	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1731};
1732
1733static struct evlist_test test__events_pmu[] = {
1734	{
1735		.name  = "cpu/config=10,config1,config2=3,period=1000/u",
 
1736		.check = test__checkevent_pmu,
1737		.id    = 0,
1738	},
1739	{
1740		.name  = "cpu/config=1,name=krava/u,cpu/config=2/u",
 
1741		.check = test__checkevent_pmu_name,
1742		.id    = 1,
1743	},
1744	{
1745		.name  = "cpu/config=1,call-graph=fp,time,period=100000/,cpu/config=2,call-graph=no,time=0,period=2000/",
 
1746		.check = test__checkevent_pmu_partial_time_callgraph,
1747		.id    = 2,
1748	},
1749	{
1750		.name  = "cpu/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks',period=0x1,event=0x2/ukp",
 
1751		.check = test__checkevent_complex_name,
1752		.id    = 3,
1753	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1754};
1755
1756struct terms_test {
1757	const char *str;
1758	__u32 type;
1759	int (*check)(struct list_head *terms);
1760};
1761
1762static struct terms_test test__terms[] = {
1763	[0] = {
1764		.str   = "config=10,config1,config2=3,umask=1",
1765		.check = test__checkterms_simple,
1766	},
1767};
1768
1769static int test_event(struct evlist_test *e)
1770{
1771	struct parse_events_error err = { .idx = 0, };
1772	struct evlist *evlist;
1773	int ret;
1774
1775	if (e->valid && !e->valid()) {
1776		pr_debug("... SKIP");
1777		return 0;
1778	}
1779
1780	evlist = evlist__new();
1781	if (evlist == NULL)
1782		return -ENOMEM;
1783
1784	ret = parse_events(evlist, e->name, &err);
 
 
 
1785	if (ret) {
1786		pr_debug("failed to parse event '%s', err %d, str '%s'\n",
1787			 e->name, ret, err.str);
1788		parse_events_print_error(&err, e->name);
 
 
1789	} else {
1790		ret = e->check(evlist);
1791	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1792
 
1793	evlist__delete(evlist);
1794
1795	return ret;
1796}
1797
1798static int test_events(struct evlist_test *events, unsigned cnt)
 
 
 
 
 
 
 
 
 
1799{
1800	int ret1, ret2 = 0;
1801	unsigned i;
1802
1803	for (i = 0; i < cnt; i++) {
1804		struct evlist_test *e = &events[i];
 
1805
1806		pr_debug("running test %d '%s'", e->id, e->name);
1807		ret1 = test_event(e);
1808		if (ret1)
1809			ret2 = ret1;
1810		pr_debug("\n");
 
1811	}
1812
1813	return ret2;
1814}
1815
1816static int test_term(struct terms_test *t)
1817{
1818	struct list_head terms;
 
 
 
 
 
1819	int ret;
1820
1821	INIT_LIST_HEAD(&terms);
1822
1823	ret = parse_events_terms(&terms, t->str);
 
1824	if (ret) {
1825		pr_debug("failed to parse terms '%s', err %d\n",
1826			 t->str , ret);
1827		return ret;
1828	}
1829
1830	ret = t->check(&terms);
1831	parse_events_terms__purge(&terms);
1832
1833	return ret;
1834}
1835
1836static int test_terms(struct terms_test *terms, unsigned cnt)
1837{
1838	int ret = 0;
1839	unsigned i;
1840
1841	for (i = 0; i < cnt; i++) {
1842		struct terms_test *t = &terms[i];
1843
1844		pr_debug("running test %d '%s'\n", i, t->str);
1845		ret = test_term(t);
1846		if (ret)
1847			break;
1848	}
1849
1850	return ret;
1851}
1852
1853static int test_pmu(void)
1854{
1855	struct stat st;
1856	char path[PATH_MAX];
1857	int ret;
1858
1859	snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/format/",
1860		 sysfs__mountpoint());
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1861
1862	ret = stat(path, &st);
1863	if (ret)
1864		pr_debug("omitting PMU cpu tests\n");
1865	return !ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1866}
1867
1868static int test_pmu_events(void)
 
 
 
 
 
1869{
1870	struct stat st;
1871	char path[PATH_MAX];
1872	struct dirent *ent;
1873	DIR *dir;
1874	int ret;
 
 
 
1875
1876	snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/events/",
1877		 sysfs__mountpoint());
1878
1879	ret = stat(path, &st);
1880	if (ret) {
1881		pr_debug("omitting PMU cpu events tests\n");
1882		return 0;
1883	}
1884
 
1885	dir = opendir(path);
1886	if (!dir) {
1887		pr_debug("can't open pmu event dir");
1888		return -1;
1889	}
1890
1891	while (!ret && (ent = readdir(dir))) {
1892		struct evlist_test e = { .id = 0, };
1893		char name[2 * NAME_MAX + 1 + 12 + 3];
 
 
 
 
1894
1895		/* Names containing . are special and cannot be used directly */
1896		if (strchr(ent->d_name, '.'))
1897			continue;
1898
1899		snprintf(name, sizeof(name), "cpu/event=%s/u", ent->d_name);
 
 
1900
1901		e.name  = name;
1902		e.check = test__checkevent_pmu_events;
 
 
1903
1904		ret = test_event(&e);
1905		if (ret)
1906			break;
1907		snprintf(name, sizeof(name), "%s:u,cpu/event=%s/u", ent->d_name, ent->d_name);
1908		e.name  = name;
1909		e.check = test__checkevent_pmu_events_mix;
1910		ret = test_event(&e);
 
 
 
 
 
 
 
 
1911	}
1912
1913	closedir(dir);
1914	return ret;
1915}
1916
1917int test__parse_events(struct test *test __maybe_unused, int subtest __maybe_unused)
1918{
1919	int ret1, ret2 = 0;
 
 
 
 
 
 
1920
1921#define TEST_EVENTS(tests)				\
1922do {							\
1923	ret1 = test_events(tests, ARRAY_SIZE(tests));	\
1924	if (!ret2)					\
1925		ret2 = ret1;				\
1926} while (0)
1927
1928	TEST_EVENTS(test__events);
 
1929
1930	if (test_pmu())
1931		TEST_EVENTS(test__events_pmu);
 
 
1932
1933	if (test_pmu()) {
1934		int ret = test_pmu_events();
1935		if (ret)
1936			return ret;
1937	}
1938
1939	ret1 = test_terms(test__terms, ARRAY_SIZE(test__terms));
1940	if (!ret2)
1941		ret2 = ret1;
1942
1943	return ret2;
 
 
 
 
1944}