1#include <linux/hw_breakpoint.h>
   2#include <linux/err.h>
   3#include "util.h"
   4#include "../perf.h"
   5#include "evlist.h"
   6#include "evsel.h"
   7#include <subcmd/parse-options.h>
   8#include "parse-events.h"
   9#include <subcmd/exec-cmd.h>
  10#include "string.h"
  11#include "symbol.h"
  12#include "cache.h"
  13#include "header.h"
  14#include "bpf-loader.h"
  15#include "debug.h"
  16#include <api/fs/tracing_path.h>
  17#include "parse-events-bison.h"
  18#define YY_EXTRA_TYPE int
  19#include "parse-events-flex.h"
  20#include "pmu.h"
  21#include "thread_map.h"
  22#include "cpumap.h"
  23#include "asm/bug.h"
  24
  25#define MAX_NAME_LEN 100
  26
 
 
 
 
 
 
 
  27#ifdef PARSER_DEBUG
  28extern int parse_events_debug;
  29#endif
  30int parse_events_parse(void *data, void *scanner);
  31static int get_config_terms(struct list_head *head_config,
  32			    struct list_head *head_terms __maybe_unused);
  33
  34static struct perf_pmu_event_symbol *perf_pmu_events_list;
  35/*
  36 * The variable indicates the number of supported pmu event symbols.
  37 * 0 means not initialized and ready to init
  38 * -1 means failed to init, don't try anymore
  39 * >0 is the number of supported pmu event symbols
  40 */
  41static int perf_pmu_events_list_num;
  42
  43struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
  44	[PERF_COUNT_HW_CPU_CYCLES] = {
  45		.symbol = "cpu-cycles",
  46		.alias  = "cycles",
  47	},
  48	[PERF_COUNT_HW_INSTRUCTIONS] = {
  49		.symbol = "instructions",
  50		.alias  = "",
  51	},
  52	[PERF_COUNT_HW_CACHE_REFERENCES] = {
  53		.symbol = "cache-references",
  54		.alias  = "",
  55	},
  56	[PERF_COUNT_HW_CACHE_MISSES] = {
  57		.symbol = "cache-misses",
  58		.alias  = "",
  59	},
  60	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
  61		.symbol = "branch-instructions",
  62		.alias  = "branches",
  63	},
  64	[PERF_COUNT_HW_BRANCH_MISSES] = {
  65		.symbol = "branch-misses",
  66		.alias  = "",
  67	},
  68	[PERF_COUNT_HW_BUS_CYCLES] = {
  69		.symbol = "bus-cycles",
  70		.alias  = "",
  71	},
  72	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
  73		.symbol = "stalled-cycles-frontend",
  74		.alias  = "idle-cycles-frontend",
  75	},
  76	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
  77		.symbol = "stalled-cycles-backend",
  78		.alias  = "idle-cycles-backend",
  79	},
  80	[PERF_COUNT_HW_REF_CPU_CYCLES] = {
  81		.symbol = "ref-cycles",
  82		.alias  = "",
  83	},
  84};
  85
  86struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
  87	[PERF_COUNT_SW_CPU_CLOCK] = {
  88		.symbol = "cpu-clock",
  89		.alias  = "",
  90	},
  91	[PERF_COUNT_SW_TASK_CLOCK] = {
  92		.symbol = "task-clock",
  93		.alias  = "",
  94	},
  95	[PERF_COUNT_SW_PAGE_FAULTS] = {
  96		.symbol = "page-faults",
  97		.alias  = "faults",
  98	},
  99	[PERF_COUNT_SW_CONTEXT_SWITCHES] = {
 100		.symbol = "context-switches",
 101		.alias  = "cs",
 102	},
 103	[PERF_COUNT_SW_CPU_MIGRATIONS] = {
 104		.symbol = "cpu-migrations",
 105		.alias  = "migrations",
 106	},
 107	[PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
 108		.symbol = "minor-faults",
 109		.alias  = "",
 110	},
 111	[PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
 112		.symbol = "major-faults",
 113		.alias  = "",
 114	},
 115	[PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
 116		.symbol = "alignment-faults",
 117		.alias  = "",
 118	},
 119	[PERF_COUNT_SW_EMULATION_FAULTS] = {
 120		.symbol = "emulation-faults",
 121		.alias  = "",
 122	},
 123	[PERF_COUNT_SW_DUMMY] = {
 124		.symbol = "dummy",
 125		.alias  = "",
 126	},
 127	[PERF_COUNT_SW_BPF_OUTPUT] = {
 128		.symbol = "bpf-output",
 129		.alias  = "",
 130	},
 131};
 132
 133#define __PERF_EVENT_FIELD(config, name) \
 134	((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
 135
 136#define PERF_EVENT_RAW(config)		__PERF_EVENT_FIELD(config, RAW)
 137#define PERF_EVENT_CONFIG(config)	__PERF_EVENT_FIELD(config, CONFIG)
 138#define PERF_EVENT_TYPE(config)		__PERF_EVENT_FIELD(config, TYPE)
 139#define PERF_EVENT_ID(config)		__PERF_EVENT_FIELD(config, EVENT)
 140
 141#define for_each_subsystem(sys_dir, sys_dirent)			\
 142	while ((sys_dirent = readdir(sys_dir)) != NULL)		\
 143		if (sys_dirent->d_type == DT_DIR &&		\
 144		    (strcmp(sys_dirent->d_name, ".")) &&	\
 145		    (strcmp(sys_dirent->d_name, "..")))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 146
 147static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
 148{
 149	char evt_path[MAXPATHLEN];
 150	int fd;
 151
 152	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
 153			sys_dir->d_name, evt_dir->d_name);
 154	fd = open(evt_path, O_RDONLY);
 155	if (fd < 0)
 156		return -EINVAL;
 157	close(fd);
 158
 159	return 0;
 160}
 161
 162#define for_each_event(sys_dirent, evt_dir, evt_dirent)		\
 163	while ((evt_dirent = readdir(evt_dir)) != NULL)		\
 164		if (evt_dirent->d_type == DT_DIR &&		\
 165		    (strcmp(evt_dirent->d_name, ".")) &&	\
 166		    (strcmp(evt_dirent->d_name, "..")) &&	\
 167		    (!tp_event_has_id(sys_dirent, evt_dirent)))
 168
 169#define MAX_EVENT_LENGTH 512
 170
 171
 172struct tracepoint_path *tracepoint_id_to_path(u64 config)
 173{
 174	struct tracepoint_path *path = NULL;
 175	DIR *sys_dir, *evt_dir;
 176	struct dirent *sys_dirent, *evt_dirent;
 177	char id_buf[24];
 178	int fd;
 179	u64 id;
 180	char evt_path[MAXPATHLEN];
 181	char dir_path[MAXPATHLEN];
 182
 
 
 
 183	sys_dir = opendir(tracing_events_path);
 184	if (!sys_dir)
 185		return NULL;
 186
 187	for_each_subsystem(sys_dir, sys_dirent) {
 188
 189		snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
 190			 sys_dirent->d_name);
 191		evt_dir = opendir(dir_path);
 192		if (!evt_dir)
 193			continue;
 194
 195		for_each_event(sys_dirent, evt_dir, evt_dirent) {
 196
 197			snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
 198				 evt_dirent->d_name);
 199			fd = open(evt_path, O_RDONLY);
 200			if (fd < 0)
 201				continue;
 202			if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 203				close(fd);
 204				continue;
 205			}
 206			close(fd);
 207			id = atoll(id_buf);
 208			if (id == config) {
 209				closedir(evt_dir);
 210				closedir(sys_dir);
 211				path = zalloc(sizeof(*path));
 212				path->system = malloc(MAX_EVENT_LENGTH);
 213				if (!path->system) {
 214					free(path);
 215					return NULL;
 216				}
 217				path->name = malloc(MAX_EVENT_LENGTH);
 218				if (!path->name) {
 219					zfree(&path->system);
 220					free(path);
 221					return NULL;
 222				}
 223				strncpy(path->system, sys_dirent->d_name,
 224					MAX_EVENT_LENGTH);
 225				strncpy(path->name, evt_dirent->d_name,
 226					MAX_EVENT_LENGTH);
 227				return path;
 228			}
 229		}
 230		closedir(evt_dir);
 231	}
 232
 233	closedir(sys_dir);
 234	return NULL;
 235}
 236
 237struct tracepoint_path *tracepoint_name_to_path(const char *name)
 
 238{
 239	struct tracepoint_path *path = zalloc(sizeof(*path));
 240	char *str = strchr(name, ':');
 241
 242	if (path == NULL || str == NULL) {
 
 
 
 
 243		free(path);
 244		return NULL;
 245	}
 
 
 
 246
 247	path->system = strndup(name, str - name);
 248	path->name = strdup(str+1);
 
 
 
 
 
 249
 250	if (path->system == NULL || path->name == NULL) {
 251		zfree(&path->system);
 252		zfree(&path->name);
 253		free(path);
 254		path = NULL;
 
 
 
 
 
 
 255	}
 256
 257	return path;
 258}
 259
 260const char *event_type(int type)
 261{
 262	switch (type) {
 263	case PERF_TYPE_HARDWARE:
 264		return "hardware";
 265
 266	case PERF_TYPE_SOFTWARE:
 267		return "software";
 268
 269	case PERF_TYPE_TRACEPOINT:
 270		return "tracepoint";
 271
 272	case PERF_TYPE_HW_CACHE:
 273		return "hardware-cache";
 274
 275	default:
 276		break;
 277	}
 278
 279	return "unknown";
 280}
 281
 282static int parse_events__is_name_term(struct parse_events_term *term)
 283{
 284	return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 285}
 286
 287static char *get_config_name(struct list_head *head_terms)
 288{
 289	struct parse_events_term *term;
 290
 291	if (!head_terms)
 292		return NULL;
 
 
 293
 294	list_for_each_entry(term, head_terms, list)
 295		if (parse_events__is_name_term(term))
 296			return term->val.str;
 297
 298	return NULL;
 299}
 300
 301static struct perf_evsel *
 302__add_event(struct list_head *list, int *idx,
 303	    struct perf_event_attr *attr,
 304	    char *name, struct cpu_map *cpus,
 305	    struct list_head *config_terms)
 306{
 307	struct perf_evsel *evsel;
 308
 309	event_attr_init(attr);
 
 
 310
 311	evsel = perf_evsel__new_idx(attr, (*idx)++);
 312	if (!evsel)
 313		return NULL;
 314
 315	evsel->cpus     = cpu_map__get(cpus);
 316	evsel->own_cpus = cpu_map__get(cpus);
 
 
 
 317
 318	if (name)
 319		evsel->name = strdup(name);
 
 
 320
 321	if (config_terms)
 322		list_splice(config_terms, &evsel->config_terms);
 323
 324	list_add_tail(&evsel->node, list);
 325	return evsel;
 
 
 
 326}
 327
 328static int add_event(struct list_head *list, int *idx,
 329		     struct perf_event_attr *attr, char *name,
 330		     struct list_head *config_terms)
 331{
 332	return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 333}
 334
 335static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
 336{
 337	int i, j;
 338	int n, longest = -1;
 339
 340	for (i = 0; i < size; i++) {
 341		for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
 342			n = strlen(names[i][j]);
 343			if (n > longest && !strncasecmp(str, names[i][j], n))
 344				longest = n;
 345		}
 346		if (longest > 0)
 347			return i;
 348	}
 349
 350	return -1;
 351}
 352
 353typedef int config_term_func_t(struct perf_event_attr *attr,
 354			       struct parse_events_term *term,
 355			       struct parse_events_error *err);
 356static int config_term_common(struct perf_event_attr *attr,
 357			      struct parse_events_term *term,
 358			      struct parse_events_error *err);
 359static int config_attr(struct perf_event_attr *attr,
 360		       struct list_head *head,
 361		       struct parse_events_error *err,
 362		       config_term_func_t config_term);
 363
 364int parse_events_add_cache(struct list_head *list, int *idx,
 365			   char *type, char *op_result1, char *op_result2,
 366			   struct parse_events_error *err,
 367			   struct list_head *head_config)
 368{
 369	struct perf_event_attr attr;
 370	LIST_HEAD(config_terms);
 371	char name[MAX_NAME_LEN], *config_name;
 372	int cache_type = -1, cache_op = -1, cache_result = -1;
 373	char *op_result[2] = { op_result1, op_result2 };
 374	int i, n;
 375
 376	/*
 377	 * No fallback - if we cannot get a clear cache type
 378	 * then bail out:
 379	 */
 380	cache_type = parse_aliases(type, perf_evsel__hw_cache,
 381				   PERF_COUNT_HW_CACHE_MAX);
 382	if (cache_type == -1)
 383		return -EINVAL;
 384
 385	config_name = get_config_name(head_config);
 386	n = snprintf(name, MAX_NAME_LEN, "%s", type);
 387
 388	for (i = 0; (i < 2) && (op_result[i]); i++) {
 389		char *str = op_result[i];
 390
 391		n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
 392
 393		if (cache_op == -1) {
 394			cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
 395						 PERF_COUNT_HW_CACHE_OP_MAX);
 396			if (cache_op >= 0) {
 397				if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
 398					return -EINVAL;
 399				continue;
 400			}
 401		}
 402
 403		if (cache_result == -1) {
 404			cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
 405						     PERF_COUNT_HW_CACHE_RESULT_MAX);
 406			if (cache_result >= 0)
 407				continue;
 408		}
 409	}
 410
 411	/*
 412	 * Fall back to reads:
 413	 */
 414	if (cache_op == -1)
 415		cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 416
 417	/*
 418	 * Fall back to accesses:
 419	 */
 420	if (cache_result == -1)
 421		cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 422
 423	memset(&attr, 0, sizeof(attr));
 424	attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
 425	attr.type = PERF_TYPE_HW_CACHE;
 426
 427	if (head_config) {
 428		if (config_attr(&attr, head_config, err,
 429				config_term_common))
 430			return -EINVAL;
 431
 432		if (get_config_terms(head_config, &config_terms))
 433			return -ENOMEM;
 434	}
 435	return add_event(list, idx, &attr, config_name ? : name, &config_terms);
 436}
 437
 438static void tracepoint_error(struct parse_events_error *e, int err,
 439			     char *sys, char *name)
 440{
 441	char help[BUFSIZ];
 442
 443	if (!e)
 444		return;
 445
 446	/*
 447	 * We get error directly from syscall errno ( > 0),
 448	 * or from encoded pointer's error ( < 0).
 449	 */
 450	err = abs(err);
 451
 452	switch (err) {
 453	case EACCES:
 454		e->str = strdup("can't access trace events");
 455		break;
 456	case ENOENT:
 457		e->str = strdup("unknown tracepoint");
 458		break;
 459	default:
 460		e->str = strdup("failed to add tracepoint");
 461		break;
 462	}
 463
 464	tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
 465	e->help = strdup(help);
 466}
 467
 468static int add_tracepoint(struct list_head *list, int *idx,
 469			  char *sys_name, char *evt_name,
 470			  struct parse_events_error *err,
 471			  struct list_head *head_config)
 472{
 473	struct perf_evsel *evsel;
 474
 475	evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++);
 476	if (IS_ERR(evsel)) {
 477		tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name);
 478		return PTR_ERR(evsel);
 479	}
 480
 481	if (head_config) {
 482		LIST_HEAD(config_terms);
 483
 484		if (get_config_terms(head_config, &config_terms))
 485			return -ENOMEM;
 486		list_splice(&config_terms, &evsel->config_terms);
 487	}
 
 
 
 488
 489	list_add_tail(&evsel->node, list);
 490	return 0;
 491}
 492
 493static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 494				      char *sys_name, char *evt_name,
 495				      struct parse_events_error *err,
 496				      struct list_head *head_config)
 497{
 498	char evt_path[MAXPATHLEN];
 499	struct dirent *evt_ent;
 500	DIR *evt_dir;
 501	int ret = 0, found = 0;
 502
 503	snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
 504	evt_dir = opendir(evt_path);
 505	if (!evt_dir) {
 506		tracepoint_error(err, errno, sys_name, evt_name);
 507		return -1;
 508	}
 509
 510	while (!ret && (evt_ent = readdir(evt_dir))) {
 511		if (!strcmp(evt_ent->d_name, ".")
 512		    || !strcmp(evt_ent->d_name, "..")
 513		    || !strcmp(evt_ent->d_name, "enable")
 514		    || !strcmp(evt_ent->d_name, "filter"))
 515			continue;
 516
 517		if (!strglobmatch(evt_ent->d_name, evt_name))
 518			continue;
 519
 520		found++;
 521
 522		ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name,
 523				     err, head_config);
 524	}
 525
 526	if (!found) {
 527		tracepoint_error(err, ENOENT, sys_name, evt_name);
 528		ret = -1;
 529	}
 530
 531	closedir(evt_dir);
 532	return ret;
 533}
 534
 535static int add_tracepoint_event(struct list_head *list, int *idx,
 536				char *sys_name, char *evt_name,
 537				struct parse_events_error *err,
 538				struct list_head *head_config)
 539{
 540	return strpbrk(evt_name, "*?") ?
 541	       add_tracepoint_multi_event(list, idx, sys_name, evt_name,
 542					  err, head_config) :
 543	       add_tracepoint(list, idx, sys_name, evt_name,
 544			      err, head_config);
 545}
 546
 547static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 548				    char *sys_name, char *evt_name,
 549				    struct parse_events_error *err,
 550				    struct list_head *head_config)
 551{
 552	struct dirent *events_ent;
 553	DIR *events_dir;
 554	int ret = 0;
 555
 556	events_dir = opendir(tracing_events_path);
 557	if (!events_dir) {
 558		tracepoint_error(err, errno, sys_name, evt_name);
 559		return -1;
 560	}
 561
 562	while (!ret && (events_ent = readdir(events_dir))) {
 563		if (!strcmp(events_ent->d_name, ".")
 564		    || !strcmp(events_ent->d_name, "..")
 565		    || !strcmp(events_ent->d_name, "enable")
 566		    || !strcmp(events_ent->d_name, "header_event")
 567		    || !strcmp(events_ent->d_name, "header_page"))
 568			continue;
 569
 570		if (!strglobmatch(events_ent->d_name, sys_name))
 571			continue;
 572
 573		ret = add_tracepoint_event(list, idx, events_ent->d_name,
 574					   evt_name, err, head_config);
 575	}
 576
 577	closedir(events_dir);
 578	return ret;
 579}
 580
 581struct __add_bpf_event_param {
 582	struct parse_events_evlist *data;
 583	struct list_head *list;
 584	struct list_head *head_config;
 585};
 586
 587static int add_bpf_event(struct probe_trace_event *tev, int fd,
 588			 void *_param)
 589{
 590	LIST_HEAD(new_evsels);
 591	struct __add_bpf_event_param *param = _param;
 592	struct parse_events_evlist *evlist = param->data;
 593	struct list_head *list = param->list;
 594	struct perf_evsel *pos;
 595	int err;
 596
 597	pr_debug("add bpf event %s:%s and attach bpf program %d\n",
 598		 tev->group, tev->event, fd);
 599
 600	err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, tev->group,
 601					  tev->event, evlist->error,
 602					  param->head_config);
 603	if (err) {
 604		struct perf_evsel *evsel, *tmp;
 605
 606		pr_debug("Failed to add BPF event %s:%s\n",
 607			 tev->group, tev->event);
 608		list_for_each_entry_safe(evsel, tmp, &new_evsels, node) {
 609			list_del(&evsel->node);
 610			perf_evsel__delete(evsel);
 611		}
 612		return err;
 613	}
 614	pr_debug("adding %s:%s\n", tev->group, tev->event);
 615
 616	list_for_each_entry(pos, &new_evsels, node) {
 617		pr_debug("adding %s:%s to %p\n",
 618			 tev->group, tev->event, pos);
 619		pos->bpf_fd = fd;
 620	}
 621	list_splice(&new_evsels, list);
 622	return 0;
 623}
 624
 625int parse_events_load_bpf_obj(struct parse_events_evlist *data,
 626			      struct list_head *list,
 627			      struct bpf_object *obj,
 628			      struct list_head *head_config)
 629{
 630	int err;
 631	char errbuf[BUFSIZ];
 632	struct __add_bpf_event_param param = {data, list, head_config};
 633	static bool registered_unprobe_atexit = false;
 634
 635	if (IS_ERR(obj) || !obj) {
 636		snprintf(errbuf, sizeof(errbuf),
 637			 "Internal error: load bpf obj with NULL");
 638		err = -EINVAL;
 639		goto errout;
 640	}
 641
 642	/*
 643	 * Register atexit handler before calling bpf__probe() so
 644	 * bpf__probe() don't need to unprobe probe points its already
 645	 * created when failure.
 646	 */
 647	if (!registered_unprobe_atexit) {
 648		atexit(bpf__clear);
 649		registered_unprobe_atexit = true;
 650	}
 651
 652	err = bpf__probe(obj);
 653	if (err) {
 654		bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf));
 655		goto errout;
 656	}
 657
 658	err = bpf__load(obj);
 659	if (err) {
 660		bpf__strerror_load(obj, err, errbuf, sizeof(errbuf));
 661		goto errout;
 662	}
 663
 664	err = bpf__foreach_tev(obj, add_bpf_event, &param);
 665	if (err) {
 666		snprintf(errbuf, sizeof(errbuf),
 667			 "Attach events in BPF object failed");
 668		goto errout;
 669	}
 670
 671	return 0;
 672errout:
 673	data->error->help = strdup("(add -v to see detail)");
 674	data->error->str = strdup(errbuf);
 675	return err;
 676}
 677
 678static int
 679parse_events_config_bpf(struct parse_events_evlist *data,
 680			struct bpf_object *obj,
 681			struct list_head *head_config)
 682{
 683	struct parse_events_term *term;
 684	int error_pos;
 685
 686	if (!head_config || list_empty(head_config))
 687		return 0;
 688
 689	list_for_each_entry(term, head_config, list) {
 690		char errbuf[BUFSIZ];
 691		int err;
 692
 693		if (term->type_term != PARSE_EVENTS__TERM_TYPE_USER) {
 694			snprintf(errbuf, sizeof(errbuf),
 695				 "Invalid config term for BPF object");
 696			errbuf[BUFSIZ - 1] = '\0';
 697
 698			data->error->idx = term->err_term;
 699			data->error->str = strdup(errbuf);
 700			return -EINVAL;
 701		}
 702
 703		err = bpf__config_obj(obj, term, data->evlist, &error_pos);
 704		if (err) {
 705			bpf__strerror_config_obj(obj, term, data->evlist,
 706						 &error_pos, err, errbuf,
 707						 sizeof(errbuf));
 708			data->error->help = strdup(
 709"Hint:\tValid config terms:\n"
 710"     \tmap:[<arraymap>].value<indices>=[value]\n"
 711"     \tmap:[<eventmap>].event<indices>=[event]\n"
 712"\n"
 713"     \twhere <indices> is something like [0,3...5] or [all]\n"
 714"     \t(add -v to see detail)");
 715			data->error->str = strdup(errbuf);
 716			if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE)
 717				data->error->idx = term->err_val;
 718			else
 719				data->error->idx = term->err_term + error_pos;
 720			return err;
 721		}
 722	}
 723	return 0;
 724}
 725
 726/*
 727 * Split config terms:
 728 * perf record -e bpf.c/call-graph=fp,map:array.value[0]=1/ ...
 729 *  'call-graph=fp' is 'evt config', should be applied to each
 730 *  events in bpf.c.
 731 * 'map:array.value[0]=1' is 'obj config', should be processed
 732 * with parse_events_config_bpf.
 733 *
 734 * Move object config terms from the first list to obj_head_config.
 735 */
 736static void
 737split_bpf_config_terms(struct list_head *evt_head_config,
 738		       struct list_head *obj_head_config)
 739{
 740	struct parse_events_term *term, *temp;
 741
 742	/*
 743	 * Currectly, all possible user config term
 744	 * belong to bpf object. parse_events__is_hardcoded_term()
 745	 * happends to be a good flag.
 746	 *
 747	 * See parse_events_config_bpf() and
 748	 * config_term_tracepoint().
 749	 */
 750	list_for_each_entry_safe(term, temp, evt_head_config, list)
 751		if (!parse_events__is_hardcoded_term(term))
 752			list_move_tail(&term->list, obj_head_config);
 753}
 754
 755int parse_events_load_bpf(struct parse_events_evlist *data,
 756			  struct list_head *list,
 757			  char *bpf_file_name,
 758			  bool source,
 759			  struct list_head *head_config)
 760{
 761	int err;
 762	struct bpf_object *obj;
 763	LIST_HEAD(obj_head_config);
 764
 765	if (head_config)
 766		split_bpf_config_terms(head_config, &obj_head_config);
 767
 768	obj = bpf__prepare_load(bpf_file_name, source);
 769	if (IS_ERR(obj)) {
 770		char errbuf[BUFSIZ];
 771
 772		err = PTR_ERR(obj);
 773
 774		if (err == -ENOTSUP)
 775			snprintf(errbuf, sizeof(errbuf),
 776				 "BPF support is not compiled");
 777		else
 778			bpf__strerror_prepare_load(bpf_file_name,
 779						   source,
 780						   -err, errbuf,
 781						   sizeof(errbuf));
 782
 783		data->error->help = strdup("(add -v to see detail)");
 784		data->error->str = strdup(errbuf);
 785		return err;
 786	}
 787
 788	err = parse_events_load_bpf_obj(data, list, obj, head_config);
 789	if (err)
 790		return err;
 791	err = parse_events_config_bpf(data, obj, &obj_head_config);
 792
 793	/*
 794	 * Caller doesn't know anything about obj_head_config,
 795	 * so combine them together again before returnning.
 796	 */
 797	if (head_config)
 798		list_splice_tail(&obj_head_config, head_config);
 799	return err;
 800}
 801
 802static int
 803parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
 804{
 805	int i;
 806
 807	for (i = 0; i < 3; i++) {
 808		if (!type || !type[i])
 809			break;
 810
 811#define CHECK_SET_TYPE(bit)		\
 812do {					\
 813	if (attr->bp_type & bit)	\
 814		return -EINVAL;		\
 815	else				\
 816		attr->bp_type |= bit;	\
 817} while (0)
 818
 819		switch (type[i]) {
 820		case 'r':
 821			CHECK_SET_TYPE(HW_BREAKPOINT_R);
 822			break;
 823		case 'w':
 824			CHECK_SET_TYPE(HW_BREAKPOINT_W);
 825			break;
 826		case 'x':
 827			CHECK_SET_TYPE(HW_BREAKPOINT_X);
 828			break;
 829		default:
 830			return -EINVAL;
 831		}
 832	}
 833
 834#undef CHECK_SET_TYPE
 835
 836	if (!attr->bp_type) /* Default */
 837		attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 838
 839	return 0;
 840}
 841
 842int parse_events_add_breakpoint(struct list_head *list, int *idx,
 843				void *ptr, char *type, u64 len)
 844{
 845	struct perf_event_attr attr;
 
 846
 847	memset(&attr, 0, sizeof(attr));
 848	attr.bp_addr = (unsigned long) ptr;
 849
 850	if (parse_breakpoint_type(type, &attr))
 851		return -EINVAL;
 852
 853	/* Provide some defaults if len is not specified */
 854	if (!len) {
 855		if (attr.bp_type == HW_BREAKPOINT_X)
 856			len = sizeof(long);
 857		else
 858			len = HW_BREAKPOINT_LEN_4;
 859	}
 860
 861	attr.bp_len = len;
 862
 863	attr.type = PERF_TYPE_BREAKPOINT;
 864	attr.sample_period = 1;
 865
 866	return add_event(list, idx, &attr, NULL, NULL);
 867}
 868
 869static int check_type_val(struct parse_events_term *term,
 870			  struct parse_events_error *err,
 871			  int type)
 872{
 873	if (type == term->type_val)
 874		return 0;
 875
 876	if (err) {
 877		err->idx = term->err_val;
 878		if (type == PARSE_EVENTS__TERM_TYPE_NUM)
 879			err->str = strdup("expected numeric value");
 880		else
 881			err->str = strdup("expected string value");
 882	}
 883	return -EINVAL;
 884}
 885
 886/*
 887 * Update according to parse-events.l
 888 */
 889static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
 890	[PARSE_EVENTS__TERM_TYPE_USER]			= "<sysfs term>",
 891	[PARSE_EVENTS__TERM_TYPE_CONFIG]		= "config",
 892	[PARSE_EVENTS__TERM_TYPE_CONFIG1]		= "config1",
 893	[PARSE_EVENTS__TERM_TYPE_CONFIG2]		= "config2",
 894	[PARSE_EVENTS__TERM_TYPE_NAME]			= "name",
 895	[PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD]		= "period",
 896	[PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ]		= "freq",
 897	[PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE]	= "branch_type",
 898	[PARSE_EVENTS__TERM_TYPE_TIME]			= "time",
 899	[PARSE_EVENTS__TERM_TYPE_CALLGRAPH]		= "call-graph",
 900	[PARSE_EVENTS__TERM_TYPE_STACKSIZE]		= "stack-size",
 901	[PARSE_EVENTS__TERM_TYPE_NOINHERIT]		= "no-inherit",
 902	[PARSE_EVENTS__TERM_TYPE_INHERIT]		= "inherit",
 903};
 904
 905static bool config_term_shrinked;
 906
 907static bool
 908config_term_avail(int term_type, struct parse_events_error *err)
 909{
 910	if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
 911		err->str = strdup("Invalid term_type");
 912		return false;
 913	}
 914	if (!config_term_shrinked)
 915		return true;
 916
 917	switch (term_type) {
 918	case PARSE_EVENTS__TERM_TYPE_CONFIG:
 919	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 920	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 921	case PARSE_EVENTS__TERM_TYPE_NAME:
 922		return true;
 923	default:
 924		if (!err)
 925			return false;
 926
 927		/* term_type is validated so indexing is safe */
 928		if (asprintf(&err->str, "'%s' is not usable in 'perf stat'",
 929			     config_term_names[term_type]) < 0)
 930			err->str = NULL;
 931		return false;
 932	}
 933}
 934
 935void parse_events__shrink_config_terms(void)
 936{
 937	config_term_shrinked = true;
 938}
 939
 940static int config_term_common(struct perf_event_attr *attr,
 941			      struct parse_events_term *term,
 942			      struct parse_events_error *err)
 943{
 944#define CHECK_TYPE_VAL(type)						   \
 945do {									   \
 946	if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \
 947		return -EINVAL;						   \
 948} while (0)
 949
 950	switch (term->type_term) {
 951	case PARSE_EVENTS__TERM_TYPE_CONFIG:
 952		CHECK_TYPE_VAL(NUM);
 953		attr->config = term->val.num;
 954		break;
 955	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 956		CHECK_TYPE_VAL(NUM);
 957		attr->config1 = term->val.num;
 958		break;
 959	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 960		CHECK_TYPE_VAL(NUM);
 961		attr->config2 = term->val.num;
 962		break;
 963	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 964		CHECK_TYPE_VAL(NUM);
 965		break;
 966	case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
 967		CHECK_TYPE_VAL(NUM);
 968		break;
 969	case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 970		/*
 971		 * TODO uncomment when the field is available
 972		 * attr->branch_sample_type = term->val.num;
 973		 */
 974		break;
 975	case PARSE_EVENTS__TERM_TYPE_TIME:
 976		CHECK_TYPE_VAL(NUM);
 977		if (term->val.num > 1) {
 978			err->str = strdup("expected 0 or 1");
 979			err->idx = term->err_val;
 980			return -EINVAL;
 981		}
 982		break;
 983	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
 984		CHECK_TYPE_VAL(STR);
 985		break;
 986	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
 987		CHECK_TYPE_VAL(NUM);
 988		break;
 989	case PARSE_EVENTS__TERM_TYPE_INHERIT:
 990		CHECK_TYPE_VAL(NUM);
 991		break;
 992	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
 993		CHECK_TYPE_VAL(NUM);
 994		break;
 995	case PARSE_EVENTS__TERM_TYPE_NAME:
 996		CHECK_TYPE_VAL(STR);
 997		break;
 998	default:
 999		err->str = strdup("unknown term");
1000		err->idx = term->err_term;
1001		err->help = parse_events_formats_error_string(NULL);
1002		return -EINVAL;
1003	}
1004
1005	/*
1006	 * Check term availbility after basic checking so
1007	 * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered.
1008	 *
1009	 * If check availbility at the entry of this function,
1010	 * user will see "'<sysfs term>' is not usable in 'perf stat'"
1011	 * if an invalid config term is provided for legacy events
1012	 * (for example, instructions/badterm/...), which is confusing.
1013	 */
1014	if (!config_term_avail(term->type_term, err))
1015		return -EINVAL;
1016	return 0;
1017#undef CHECK_TYPE_VAL
1018}
1019
1020static int config_term_pmu(struct perf_event_attr *attr,
1021			   struct parse_events_term *term,
1022			   struct parse_events_error *err)
1023{
1024	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER)
1025		/*
1026		 * Always succeed for sysfs terms, as we dont know
1027		 * at this point what type they need to have.
1028		 */
1029		return 0;
1030	else
1031		return config_term_common(attr, term, err);
1032}
1033
1034static int config_term_tracepoint(struct perf_event_attr *attr,
1035				  struct parse_events_term *term,
1036				  struct parse_events_error *err)
1037{
1038	switch (term->type_term) {
1039	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1040	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1041	case PARSE_EVENTS__TERM_TYPE_INHERIT:
1042	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1043		return config_term_common(attr, term, err);
1044	default:
1045		if (err) {
1046			err->idx = term->err_term;
1047			err->str = strdup("unknown term");
1048			err->help = strdup("valid terms: call-graph,stack-size\n");
1049		}
1050		return -EINVAL;
1051	}
1052
1053	return 0;
1054}
1055
1056static int config_attr(struct perf_event_attr *attr,
1057		       struct list_head *head,
1058		       struct parse_events_error *err,
1059		       config_term_func_t config_term)
1060{
1061	struct parse_events_term *term;
1062
1063	list_for_each_entry(term, head, list)
1064		if (config_term(attr, term, err))
1065			return -EINVAL;
1066
1067	return 0;
1068}
1069
1070static int get_config_terms(struct list_head *head_config,
1071			    struct list_head *head_terms __maybe_unused)
 
1072{
1073#define ADD_CONFIG_TERM(__type, __name, __val)			\
1074do {								\
1075	struct perf_evsel_config_term *__t;			\
1076								\
1077	__t = zalloc(sizeof(*__t));				\
1078	if (!__t)						\
1079		return -ENOMEM;					\
1080								\
1081	INIT_LIST_HEAD(&__t->list);				\
1082	__t->type       = PERF_EVSEL__CONFIG_TERM_ ## __type;	\
1083	__t->val.__name = __val;				\
1084	list_add_tail(&__t->list, head_terms);			\
1085} while (0)
1086
1087	struct parse_events_term *term;
 
 
1088
1089	list_for_each_entry(term, head_config, list) {
1090		switch (term->type_term) {
1091		case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1092			ADD_CONFIG_TERM(PERIOD, period, term->val.num);
1093			break;
1094		case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1095			ADD_CONFIG_TERM(FREQ, freq, term->val.num);
1096			break;
1097		case PARSE_EVENTS__TERM_TYPE_TIME:
1098			ADD_CONFIG_TERM(TIME, time, term->val.num);
1099			break;
1100		case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1101			ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str);
1102			break;
1103		case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1104			ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num);
1105			break;
1106		case PARSE_EVENTS__TERM_TYPE_INHERIT:
1107			ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 1 : 0);
1108			break;
1109		case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1110			ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 0 : 1);
1111			break;
1112		default:
1113			break;
1114		}
1115	}
1116#undef ADD_EVSEL_CONFIG
1117	return 0;
1118}
1119
1120int parse_events_add_tracepoint(struct list_head *list, int *idx,
1121				char *sys, char *event,
1122				struct parse_events_error *err,
1123				struct list_head *head_config)
1124{
1125	if (head_config) {
1126		struct perf_event_attr attr;
1127
1128		if (config_attr(&attr, head_config, err,
1129				config_term_tracepoint))
1130			return -EINVAL;
1131	}
1132
1133	if (strpbrk(sys, "*?"))
1134		return add_tracepoint_multi_sys(list, idx, sys, event,
1135						err, head_config);
1136	else
1137		return add_tracepoint_event(list, idx, sys, event,
1138					    err, head_config);
1139}
1140
1141int parse_events_add_numeric(struct parse_events_evlist *data,
1142			     struct list_head *list,
1143			     u32 type, u64 config,
1144			     struct list_head *head_config)
1145{
1146	struct perf_event_attr attr;
1147	LIST_HEAD(config_terms);
1148
1149	memset(&attr, 0, sizeof(attr));
1150	attr.type = type;
1151	attr.config = config;
1152
1153	if (head_config) {
1154		if (config_attr(&attr, head_config, data->error,
1155				config_term_common))
1156			return -EINVAL;
1157
1158		if (get_config_terms(head_config, &config_terms))
1159			return -ENOMEM;
1160	}
1161
1162	return add_event(list, &data->idx, &attr,
1163			 get_config_name(head_config), &config_terms);
1164}
1165
1166int parse_events_add_pmu(struct parse_events_evlist *data,
1167			 struct list_head *list, char *name,
1168			 struct list_head *head_config)
1169{
1170	struct perf_event_attr attr;
1171	struct perf_pmu_info info;
1172	struct perf_pmu *pmu;
1173	struct perf_evsel *evsel;
1174	LIST_HEAD(config_terms);
1175
1176	pmu = perf_pmu__find(name);
1177	if (!pmu)
1178		return -EINVAL;
1179
1180	if (pmu->default_config) {
1181		memcpy(&attr, pmu->default_config,
1182		       sizeof(struct perf_event_attr));
1183	} else {
1184		memset(&attr, 0, sizeof(attr));
1185	}
1186
1187	if (!head_config) {
1188		attr.type = pmu->type;
1189		evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL);
1190		return evsel ? 0 : -ENOMEM;
1191	}
1192
1193	if (perf_pmu__check_alias(pmu, head_config, &info))
1194		return -EINVAL;
1195
1196	/*
1197	 * Configure hardcoded terms first, no need to check
1198	 * return value when called with fail == 0 ;)
1199	 */
1200	if (config_attr(&attr, head_config, data->error, config_term_pmu))
1201		return -EINVAL;
1202
1203	if (get_config_terms(head_config, &config_terms))
1204		return -ENOMEM;
1205
1206	if (perf_pmu__config(pmu, &attr, head_config, data->error))
1207		return -EINVAL;
1208
1209	evsel = __add_event(list, &data->idx, &attr,
1210			    get_config_name(head_config), pmu->cpus,
1211			    &config_terms);
1212	if (evsel) {
1213		evsel->unit = info.unit;
1214		evsel->scale = info.scale;
1215		evsel->per_pkg = info.per_pkg;
1216		evsel->snapshot = info.snapshot;
1217	}
1218
1219	return evsel ? 0 : -ENOMEM;
1220}
1221
1222int parse_events__modifier_group(struct list_head *list,
1223				 char *event_mod)
1224{
1225	return parse_events__modifier_event(list, event_mod, true);
1226}
1227
1228void parse_events__set_leader(char *name, struct list_head *list)
1229{
1230	struct perf_evsel *leader;
1231
1232	if (list_empty(list)) {
1233		WARN_ONCE(true, "WARNING: failed to set leader: empty list");
1234		return;
1235	}
1236
1237	__perf_evlist__set_leader(list);
1238	leader = list_entry(list->next, struct perf_evsel, node);
1239	leader->group_name = name ? strdup(name) : NULL;
1240}
1241
1242/* list_event is assumed to point to malloc'ed memory */
1243void parse_events_update_lists(struct list_head *list_event,
1244			       struct list_head *list_all)
1245{
1246	/*
1247	 * Called for single event definition. Update the
1248	 * 'all event' list, and reinit the 'single event'
1249	 * list, for next event definition.
1250	 */
1251	list_splice_tail(list_event, list_all);
1252	free(list_event);
1253}
1254
1255struct event_modifier {
1256	int eu;
1257	int ek;
1258	int eh;
1259	int eH;
1260	int eG;
1261	int eI;
1262	int precise;
1263	int precise_max;
1264	int exclude_GH;
1265	int sample_read;
1266	int pinned;
1267};
1268
1269static int get_event_modifier(struct event_modifier *mod, char *str,
1270			       struct perf_evsel *evsel)
1271{
1272	int eu = evsel ? evsel->attr.exclude_user : 0;
1273	int ek = evsel ? evsel->attr.exclude_kernel : 0;
1274	int eh = evsel ? evsel->attr.exclude_hv : 0;
1275	int eH = evsel ? evsel->attr.exclude_host : 0;
1276	int eG = evsel ? evsel->attr.exclude_guest : 0;
1277	int eI = evsel ? evsel->attr.exclude_idle : 0;
1278	int precise = evsel ? evsel->attr.precise_ip : 0;
1279	int precise_max = 0;
1280	int sample_read = 0;
1281	int pinned = evsel ? evsel->attr.pinned : 0;
1282
1283	int exclude = eu | ek | eh;
1284	int exclude_GH = evsel ? evsel->exclude_GH : 0;
1285
1286	memset(mod, 0, sizeof(*mod));
 
1287
1288	while (*str) {
1289		if (*str == 'u') {
1290			if (!exclude)
1291				exclude = eu = ek = eh = 1;
1292			eu = 0;
1293		} else if (*str == 'k') {
1294			if (!exclude)
1295				exclude = eu = ek = eh = 1;
1296			ek = 0;
1297		} else if (*str == 'h') {
1298			if (!exclude)
1299				exclude = eu = ek = eh = 1;
1300			eh = 0;
1301		} else if (*str == 'G') {
1302			if (!exclude_GH)
1303				exclude_GH = eG = eH = 1;
1304			eG = 0;
1305		} else if (*str == 'H') {
1306			if (!exclude_GH)
1307				exclude_GH = eG = eH = 1;
1308			eH = 0;
1309		} else if (*str == 'I') {
1310			eI = 1;
1311		} else if (*str == 'p') {
1312			precise++;
1313			/* use of precise requires exclude_guest */
1314			if (!exclude_GH)
1315				eG = 1;
1316		} else if (*str == 'P') {
1317			precise_max = 1;
1318		} else if (*str == 'S') {
1319			sample_read = 1;
1320		} else if (*str == 'D') {
1321			pinned = 1;
1322		} else
1323			break;
1324
1325		++str;
1326	}
1327
1328	/*
1329	 * precise ip:
1330	 *
1331	 *  0 - SAMPLE_IP can have arbitrary skid
1332	 *  1 - SAMPLE_IP must have constant skid
1333	 *  2 - SAMPLE_IP requested to have 0 skid
1334	 *  3 - SAMPLE_IP must have 0 skid
1335	 *
1336	 *  See also PERF_RECORD_MISC_EXACT_IP
1337	 */
1338	if (precise > 3)
1339		return -EINVAL;
1340
1341	mod->eu = eu;
1342	mod->ek = ek;
1343	mod->eh = eh;
1344	mod->eH = eH;
1345	mod->eG = eG;
1346	mod->eI = eI;
1347	mod->precise = precise;
1348	mod->precise_max = precise_max;
1349	mod->exclude_GH = exclude_GH;
1350	mod->sample_read = sample_read;
1351	mod->pinned = pinned;
1352
1353	return 0;
1354}
1355
1356/*
1357 * Basic modifier sanity check to validate it contains only one
1358 * instance of any modifier (apart from 'p') present.
1359 */
1360static int check_modifier(char *str)
1361{
1362	char *p = str;
1363
1364	/* The sizeof includes 0 byte as well. */
1365	if (strlen(str) > (sizeof("ukhGHpppPSDI") - 1))
1366		return -1;
1367
1368	while (*p) {
1369		if (*p != 'p' && strchr(p + 1, *p))
1370			return -1;
1371		p++;
1372	}
1373
1374	return 0;
1375}
1376
1377int parse_events__modifier_event(struct list_head *list, char *str, bool add)
1378{
1379	struct perf_evsel *evsel;
1380	struct event_modifier mod;
1381
1382	if (str == NULL)
1383		return 0;
1384
1385	if (check_modifier(str))
1386		return -EINVAL;
1387
1388	if (!add && get_event_modifier(&mod, str, NULL))
1389		return -EINVAL;
1390
1391	__evlist__for_each(list, evsel) {
1392		if (add && get_event_modifier(&mod, str, evsel))
1393			return -EINVAL;
1394
1395		evsel->attr.exclude_user   = mod.eu;
1396		evsel->attr.exclude_kernel = mod.ek;
1397		evsel->attr.exclude_hv     = mod.eh;
1398		evsel->attr.precise_ip     = mod.precise;
1399		evsel->attr.exclude_host   = mod.eH;
1400		evsel->attr.exclude_guest  = mod.eG;
1401		evsel->attr.exclude_idle   = mod.eI;
1402		evsel->exclude_GH          = mod.exclude_GH;
1403		evsel->sample_read         = mod.sample_read;
1404		evsel->precise_max         = mod.precise_max;
1405
1406		if (perf_evsel__is_group_leader(evsel))
1407			evsel->attr.pinned = mod.pinned;
1408	}
1409
1410	return 0;
1411}
1412
1413int parse_events_name(struct list_head *list, char *name)
1414{
1415	struct perf_evsel *evsel;
1416
1417	__evlist__for_each(list, evsel) {
1418		if (!evsel->name)
1419			evsel->name = strdup(name);
1420	}
1421
1422	return 0;
1423}
1424
1425static int
1426comp_pmu(const void *p1, const void *p2)
1427{
1428	struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1;
1429	struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2;
1430
1431	return strcmp(pmu1->symbol, pmu2->symbol);
1432}
1433
1434static void perf_pmu__parse_cleanup(void)
1435{
1436	if (perf_pmu_events_list_num > 0) {
1437		struct perf_pmu_event_symbol *p;
1438		int i;
1439
1440		for (i = 0; i < perf_pmu_events_list_num; i++) {
1441			p = perf_pmu_events_list + i;
1442			free(p->symbol);
1443		}
1444		free(perf_pmu_events_list);
1445		perf_pmu_events_list = NULL;
1446		perf_pmu_events_list_num = 0;
1447	}
1448}
1449
1450#define SET_SYMBOL(str, stype)		\
1451do {					\
1452	p->symbol = str;		\
1453	if (!p->symbol)			\
1454		goto err;		\
1455	p->type = stype;		\
1456} while (0)
1457
1458/*
1459 * Read the pmu events list from sysfs
1460 * Save it into perf_pmu_events_list
1461 */
1462static void perf_pmu__parse_init(void)
1463{
1464
1465	struct perf_pmu *pmu = NULL;
1466	struct perf_pmu_alias *alias;
1467	int len = 0;
1468
1469	pmu = perf_pmu__find("cpu");
1470	if ((pmu == NULL) || list_empty(&pmu->aliases)) {
1471		perf_pmu_events_list_num = -1;
1472		return;
1473	}
1474	list_for_each_entry(alias, &pmu->aliases, list) {
1475		if (strchr(alias->name, '-'))
1476			len++;
1477		len++;
1478	}
1479	perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len);
1480	if (!perf_pmu_events_list)
1481		return;
1482	perf_pmu_events_list_num = len;
1483
1484	len = 0;
1485	list_for_each_entry(alias, &pmu->aliases, list) {
1486		struct perf_pmu_event_symbol *p = perf_pmu_events_list + len;
1487		char *tmp = strchr(alias->name, '-');
1488
1489		if (tmp != NULL) {
1490			SET_SYMBOL(strndup(alias->name, tmp - alias->name),
1491					PMU_EVENT_SYMBOL_PREFIX);
1492			p++;
1493			SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX);
1494			len += 2;
1495		} else {
1496			SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL);
1497			len++;
1498		}
1499	}
1500	qsort(perf_pmu_events_list, len,
1501		sizeof(struct perf_pmu_event_symbol), comp_pmu);
1502
1503	return;
1504err:
1505	perf_pmu__parse_cleanup();
1506}
1507
1508enum perf_pmu_event_symbol_type
1509perf_pmu__parse_check(const char *name)
1510{
1511	struct perf_pmu_event_symbol p, *r;
1512
1513	/* scan kernel pmu events from sysfs if needed */
1514	if (perf_pmu_events_list_num == 0)
1515		perf_pmu__parse_init();
1516	/*
1517	 * name "cpu" could be prefix of cpu-cycles or cpu// events.
1518	 * cpu-cycles has been handled by hardcode.
1519	 * So it must be cpu// events, not kernel pmu event.
1520	 */
1521	if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu"))
1522		return PMU_EVENT_SYMBOL_ERR;
1523
1524	p.symbol = strdup(name);
1525	r = bsearch(&p, perf_pmu_events_list,
1526			(size_t) perf_pmu_events_list_num,
1527			sizeof(struct perf_pmu_event_symbol), comp_pmu);
1528	free(p.symbol);
1529	return r ? r->type : PMU_EVENT_SYMBOL_ERR;
1530}
1531
1532static int parse_events__scanner(const char *str, void *data, int start_token)
1533{
 
 
1534	YY_BUFFER_STATE buffer;
1535	void *scanner;
1536	int ret;
1537
1538	ret = parse_events_lex_init_extra(start_token, &scanner);
1539	if (ret)
1540		return ret;
1541
1542	buffer = parse_events__scan_string(str, scanner);
1543
1544#ifdef PARSER_DEBUG
1545	parse_events_debug = 1;
1546#endif
1547	ret = parse_events_parse(data, scanner);
1548
1549	parse_events__flush_buffer(buffer, scanner);
1550	parse_events__delete_buffer(buffer, scanner);
1551	parse_events_lex_destroy(scanner);
1552	return ret;
1553}
1554
1555/*
1556 * parse event config string, return a list of event terms.
1557 */
1558int parse_events_terms(struct list_head *terms, const char *str)
1559{
1560	struct parse_events_terms data = {
1561		.terms = NULL,
1562	};
1563	int ret;
1564
1565	ret = parse_events__scanner(str, &data, PE_START_TERMS);
1566	if (!ret) {
1567		list_splice(data.terms, terms);
1568		zfree(&data.terms);
1569		return 0;
1570	}
1571
1572	parse_events_terms__delete(data.terms);
1573	return ret;
1574}
1575
1576int parse_events(struct perf_evlist *evlist, const char *str,
1577		 struct parse_events_error *err)
1578{
1579	struct parse_events_evlist data = {
1580		.list   = LIST_HEAD_INIT(data.list),
1581		.idx    = evlist->nr_entries,
1582		.error  = err,
1583		.evlist = evlist,
1584	};
1585	int ret;
1586
1587	ret = parse_events__scanner(str, &data, PE_START_EVENTS);
1588	perf_pmu__parse_cleanup();
1589	if (!ret) {
1590		struct perf_evsel *last;
1591
1592		if (list_empty(&data.list)) {
1593			WARN_ONCE(true, "WARNING: event parser found nothing");
1594			return -1;
1595		}
1596
1597		perf_evlist__splice_list_tail(evlist, &data.list);
1598		evlist->nr_groups += data.nr_groups;
1599		last = perf_evlist__last(evlist);
1600		last->cmdline_group_boundary = true;
1601
1602		return 0;
1603	}
1604
1605	/*
1606	 * There are 2 users - builtin-record and builtin-test objects.
1607	 * Both call perf_evlist__delete in case of error, so we dont
1608	 * need to bother.
1609	 */
1610	return ret;
1611}
1612
1613#define MAX_WIDTH 1000
1614static int get_term_width(void)
1615{
1616	struct winsize ws;
1617
1618	get_term_dimensions(&ws);
1619	return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
1620}
1621
1622static void parse_events_print_error(struct parse_events_error *err,
1623				     const char *event)
1624{
1625	const char *str = "invalid or unsupported event: ";
1626	char _buf[MAX_WIDTH];
1627	char *buf = (char *) event;
1628	int idx = 0;
1629
1630	if (err->str) {
1631		/* -2 for extra '' in the final fprintf */
1632		int width       = get_term_width() - 2;
1633		int len_event   = strlen(event);
1634		int len_str, max_len, cut = 0;
1635
1636		/*
1637		 * Maximum error index indent, we will cut
1638		 * the event string if it's bigger.
1639		 */
1640		int max_err_idx = 13;
1641
1642		/*
1643		 * Let's be specific with the message when
1644		 * we have the precise error.
1645		 */
1646		str     = "event syntax error: ";
1647		len_str = strlen(str);
1648		max_len = width - len_str;
1649
1650		buf = _buf;
1651
1652		/* We're cutting from the beggining. */
1653		if (err->idx > max_err_idx)
1654			cut = err->idx - max_err_idx;
1655
1656		strncpy(buf, event + cut, max_len);
1657
1658		/* Mark cut parts with '..' on both sides. */
1659		if (cut)
1660			buf[0] = buf[1] = '.';
1661
1662		if ((len_event - cut) > max_len) {
1663			buf[max_len - 1] = buf[max_len - 2] = '.';
1664			buf[max_len] = 0;
1665		}
1666
1667		idx = len_str + err->idx - cut;
1668	}
1669
1670	fprintf(stderr, "%s'%s'\n", str, buf);
1671	if (idx) {
1672		fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str);
1673		if (err->help)
1674			fprintf(stderr, "\n%s\n", err->help);
1675		free(err->str);
1676		free(err->help);
1677	}
1678
1679	fprintf(stderr, "Run 'perf list' for a list of valid events\n");
 
1680}
1681
1682#undef MAX_WIDTH
1683
1684int parse_events_option(const struct option *opt, const char *str,
1685			int unset __maybe_unused)
1686{
1687	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1688	struct parse_events_error err = { .idx = 0, };
1689	int ret = parse_events(evlist, str, &err);
1690
1691	if (ret)
1692		parse_events_print_error(&err, str);
1693
1694	return ret;
1695}
1696
1697static int
1698foreach_evsel_in_last_glob(struct perf_evlist *evlist,
1699			   int (*func)(struct perf_evsel *evsel,
1700				       const void *arg),
1701			   const void *arg)
1702{
1703	struct perf_evsel *last = NULL;
1704	int err;
1705
1706	/*
1707	 * Don't return when list_empty, give func a chance to report
1708	 * error when it found last == NULL.
1709	 *
1710	 * So no need to WARN here, let *func do this.
1711	 */
1712	if (evlist->nr_entries > 0)
1713		last = perf_evlist__last(evlist);
1714
1715	do {
1716		err = (*func)(last, arg);
1717		if (err)
1718			return -1;
1719		if (!last)
1720			return 0;
1721
1722		if (last->node.prev == &evlist->entries)
1723			return 0;
1724		last = list_entry(last->node.prev, struct perf_evsel, node);
1725	} while (!last->cmdline_group_boundary);
1726
1727	return 0;
1728}
1729
1730static int set_filter(struct perf_evsel *evsel, const void *arg)
1731{
1732	const char *str = arg;
1733
1734	if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
1735		fprintf(stderr,
1736			"--filter option should follow a -e tracepoint option\n");
1737		return -1;
1738	}
1739
1740	if (perf_evsel__append_filter(evsel, "&&", str) < 0) {
1741		fprintf(stderr,
1742			"not enough memory to hold filter string\n");
1743		return -1;
1744	}
1745
1746	return 0;
1747}
1748
1749int parse_filter(const struct option *opt, const char *str,
1750		 int unset __maybe_unused)
1751{
1752	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
 
1753
1754	return foreach_evsel_in_last_glob(evlist, set_filter,
1755					  (const void *)str);
1756}
1757
1758static int add_exclude_perf_filter(struct perf_evsel *evsel,
1759				   const void *arg __maybe_unused)
1760{
1761	char new_filter[64];
1762
1763	if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
1764		fprintf(stderr,
1765			"--exclude-perf option should follow a -e tracepoint option\n");
1766		return -1;
1767	}
1768
1769	snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
1770
1771	if (perf_evsel__append_filter(evsel, "&&", new_filter) < 0) {
1772		fprintf(stderr,
1773			"not enough memory to hold filter string\n");
1774		return -1;
1775	}
1776
1777	return 0;
1778}
1779
1780int exclude_perf(const struct option *opt,
1781		 const char *arg __maybe_unused,
1782		 int unset __maybe_unused)
1783{
1784	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1785
1786	return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
1787					  NULL);
1788}
1789
1790static const char * const event_type_descriptors[] = {
1791	"Hardware event",
1792	"Software event",
1793	"Tracepoint event",
1794	"Hardware cache event",
1795	"Raw hardware event descriptor",
1796	"Hardware breakpoint",
1797};
1798
1799static int cmp_string(const void *a, const void *b)
1800{
1801	const char * const *as = a;
1802	const char * const *bs = b;
1803
1804	return strcmp(*as, *bs);
1805}
1806
1807/*
1808 * Print the events from <debugfs_mount_point>/tracing/events
1809 */
1810
1811void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
1812			     bool name_only)
1813{
1814	DIR *sys_dir, *evt_dir;
1815	struct dirent *sys_dirent, *evt_dirent;
1816	char evt_path[MAXPATHLEN];
1817	char dir_path[MAXPATHLEN];
1818	char **evt_list = NULL;
1819	unsigned int evt_i = 0, evt_num = 0;
1820	bool evt_num_known = false;
1821
1822restart:
 
 
1823	sys_dir = opendir(tracing_events_path);
1824	if (!sys_dir)
1825		return;
1826
1827	if (evt_num_known) {
1828		evt_list = zalloc(sizeof(char *) * evt_num);
1829		if (!evt_list)
1830			goto out_close_sys_dir;
1831	}
1832
1833	for_each_subsystem(sys_dir, sys_dirent) {
1834		if (subsys_glob != NULL &&
1835		    !strglobmatch(sys_dirent->d_name, subsys_glob))
1836			continue;
1837
1838		snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1839			 sys_dirent->d_name);
1840		evt_dir = opendir(dir_path);
1841		if (!evt_dir)
1842			continue;
1843
1844		for_each_event(sys_dirent, evt_dir, evt_dirent) {
1845			if (event_glob != NULL &&
1846			    !strglobmatch(evt_dirent->d_name, event_glob))
1847				continue;
1848
1849			if (!evt_num_known) {
1850				evt_num++;
1851				continue;
1852			}
1853
1854			snprintf(evt_path, MAXPATHLEN, "%s:%s",
1855				 sys_dirent->d_name, evt_dirent->d_name);
1856
1857			evt_list[evt_i] = strdup(evt_path);
1858			if (evt_list[evt_i] == NULL)
1859				goto out_close_evt_dir;
1860			evt_i++;
1861		}
1862		closedir(evt_dir);
1863	}
1864	closedir(sys_dir);
1865
1866	if (!evt_num_known) {
1867		evt_num_known = true;
1868		goto restart;
1869	}
1870	qsort(evt_list, evt_num, sizeof(char *), cmp_string);
1871	evt_i = 0;
1872	while (evt_i < evt_num) {
1873		if (name_only) {
1874			printf("%s ", evt_list[evt_i++]);
1875			continue;
1876		}
1877		printf("  %-50s [%s]\n", evt_list[evt_i++],
1878				event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1879	}
1880	if (evt_num && pager_in_use())
1881		printf("\n");
1882
1883out_free:
1884	evt_num = evt_i;
1885	for (evt_i = 0; evt_i < evt_num; evt_i++)
1886		zfree(&evt_list[evt_i]);
1887	zfree(&evt_list);
1888	return;
1889
1890out_close_evt_dir:
1891	closedir(evt_dir);
1892out_close_sys_dir:
1893	closedir(sys_dir);
1894
1895	printf("FATAL: not enough memory to print %s\n",
1896			event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1897	if (evt_list)
1898		goto out_free;
1899}
1900
1901/*
1902 * Check whether event is in <debugfs_mount_point>/tracing/events
1903 */
1904
1905int is_valid_tracepoint(const char *event_string)
1906{
1907	DIR *sys_dir, *evt_dir;
1908	struct dirent *sys_dirent, *evt_dirent;
1909	char evt_path[MAXPATHLEN];
1910	char dir_path[MAXPATHLEN];
1911
 
 
 
1912	sys_dir = opendir(tracing_events_path);
1913	if (!sys_dir)
1914		return 0;
1915
1916	for_each_subsystem(sys_dir, sys_dirent) {
1917
1918		snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1919			 sys_dirent->d_name);
1920		evt_dir = opendir(dir_path);
1921		if (!evt_dir)
1922			continue;
1923
1924		for_each_event(sys_dirent, evt_dir, evt_dirent) {
1925			snprintf(evt_path, MAXPATHLEN, "%s:%s",
1926				 sys_dirent->d_name, evt_dirent->d_name);
1927			if (!strcmp(evt_path, event_string)) {
1928				closedir(evt_dir);
1929				closedir(sys_dir);
1930				return 1;
1931			}
1932		}
1933		closedir(evt_dir);
1934	}
1935	closedir(sys_dir);
1936	return 0;
1937}
1938
1939static bool is_event_supported(u8 type, unsigned config)
1940{
1941	bool ret = true;
1942	int open_return;
1943	struct perf_evsel *evsel;
1944	struct perf_event_attr attr = {
1945		.type = type,
1946		.config = config,
1947		.disabled = 1,
1948	};
1949	struct {
1950		struct thread_map map;
1951		int threads[1];
1952	} tmap = {
1953		.map.nr	 = 1,
1954		.threads = { 0 },
1955	};
1956
1957	evsel = perf_evsel__new(&attr);
1958	if (evsel) {
1959		open_return = perf_evsel__open(evsel, NULL, &tmap.map);
1960		ret = open_return >= 0;
1961
1962		if (open_return == -EACCES) {
1963			/*
1964			 * This happens if the paranoid value
1965			 * /proc/sys/kernel/perf_event_paranoid is set to 2
1966			 * Re-run with exclude_kernel set; we don't do that
1967			 * by default as some ARM machines do not support it.
1968			 *
1969			 */
1970			evsel->attr.exclude_kernel = 1;
1971			ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0;
1972		}
1973		perf_evsel__delete(evsel);
1974	}
1975
1976	return ret;
1977}
 
1978
1979int print_hwcache_events(const char *event_glob, bool name_only)
1980{
1981	unsigned int type, op, i, evt_i = 0, evt_num = 0;
1982	char name[64];
1983	char **evt_list = NULL;
1984	bool evt_num_known = false;
1985
1986restart:
1987	if (evt_num_known) {
1988		evt_list = zalloc(sizeof(char *) * evt_num);
1989		if (!evt_list)
1990			goto out_enomem;
1991	}
 
 
 
 
 
1992
1993	for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
1994		for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
1995			/* skip invalid cache type */
1996			if (!perf_evsel__is_cache_op_valid(type, op))
1997				continue;
1998
1999			for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
2000				__perf_evsel__hw_cache_type_op_res_name(type, op, i,
2001									name, sizeof(name));
2002				if (event_glob != NULL && !strglobmatch(name, event_glob))
2003					continue;
2004
2005				if (!is_event_supported(PERF_TYPE_HW_CACHE,
2006							type | (op << 8) | (i << 16)))
2007					continue;
2008
2009				if (!evt_num_known) {
2010					evt_num++;
2011					continue;
2012				}
2013
2014				evt_list[evt_i] = strdup(name);
2015				if (evt_list[evt_i] == NULL)
2016					goto out_enomem;
2017				evt_i++;
2018			}
2019		}
2020	}
2021
2022	if (!evt_num_known) {
2023		evt_num_known = true;
2024		goto restart;
2025	}
2026	qsort(evt_list, evt_num, sizeof(char *), cmp_string);
2027	evt_i = 0;
2028	while (evt_i < evt_num) {
2029		if (name_only) {
2030			printf("%s ", evt_list[evt_i++]);
2031			continue;
2032		}
2033		printf("  %-50s [%s]\n", evt_list[evt_i++],
2034				event_type_descriptors[PERF_TYPE_HW_CACHE]);
2035	}
2036	if (evt_num && pager_in_use())
2037		printf("\n");
2038
2039out_free:
2040	evt_num = evt_i;
2041	for (evt_i = 0; evt_i < evt_num; evt_i++)
2042		zfree(&evt_list[evt_i]);
2043	zfree(&evt_list);
2044	return evt_num;
2045
2046out_enomem:
2047	printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]);
2048	if (evt_list)
2049		goto out_free;
2050	return evt_num;
2051}
2052
2053void print_symbol_events(const char *event_glob, unsigned type,
2054				struct event_symbol *syms, unsigned max,
2055				bool name_only)
2056{
2057	unsigned int i, evt_i = 0, evt_num = 0;
 
2058	char name[MAX_NAME_LEN];
2059	char **evt_list = NULL;
2060	bool evt_num_known = false;
2061
2062restart:
2063	if (evt_num_known) {
2064		evt_list = zalloc(sizeof(char *) * evt_num);
2065		if (!evt_list)
2066			goto out_enomem;
2067		syms -= max;
2068	}
2069
2070	for (i = 0; i < max; i++, syms++) {
 
 
 
 
2071
2072		if (event_glob != NULL && syms->symbol != NULL &&
2073		    !(strglobmatch(syms->symbol, event_glob) ||
2074		      (syms->alias && strglobmatch(syms->alias, event_glob))))
2075			continue;
2076
2077		if (!is_event_supported(type, i))
2078			continue;
2079
2080		if (!evt_num_known) {
2081			evt_num++;
2082			continue;
2083		}
2084
2085		if (!name_only && strlen(syms->alias))
2086			snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
2087		else
2088			strncpy(name, syms->symbol, MAX_NAME_LEN);
 
 
2089
2090		evt_list[evt_i] = strdup(name);
2091		if (evt_list[evt_i] == NULL)
2092			goto out_enomem;
2093		evt_i++;
2094	}
2095
2096	if (!evt_num_known) {
2097		evt_num_known = true;
2098		goto restart;
2099	}
2100	qsort(evt_list, evt_num, sizeof(char *), cmp_string);
2101	evt_i = 0;
2102	while (evt_i < evt_num) {
2103		if (name_only) {
2104			printf("%s ", evt_list[evt_i++]);
2105			continue;
2106		}
2107		printf("  %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]);
2108	}
2109	if (evt_num && pager_in_use())
2110		printf("\n");
2111
2112out_free:
2113	evt_num = evt_i;
2114	for (evt_i = 0; evt_i < evt_num; evt_i++)
2115		zfree(&evt_list[evt_i]);
2116	zfree(&evt_list);
2117	return;
2118
2119out_enomem:
2120	printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]);
2121	if (evt_list)
2122		goto out_free;
2123}
2124
2125/*
2126 * Print the help text for the event symbols:
2127 */
2128void print_events(const char *event_glob, bool name_only)
2129{
2130	print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
2131			    event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
2132
2133	print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
2134			    event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
2135
2136	print_hwcache_events(event_glob, name_only);
2137
2138	print_pmu_events(event_glob, name_only);
2139
2140	if (event_glob != NULL)
2141		return;
2142
2143	if (!name_only) {
2144		printf("  %-50s [%s]\n",
2145		       "rNNN",
2146		       event_type_descriptors[PERF_TYPE_RAW]);
2147		printf("  %-50s [%s]\n",
2148		       "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
2149		       event_type_descriptors[PERF_TYPE_RAW]);
2150		if (pager_in_use())
2151			printf("   (see 'man perf-list' on how to encode it)\n\n");
2152
2153		printf("  %-50s [%s]\n",
2154		       "mem:<addr>[/len][:access]",
2155			event_type_descriptors[PERF_TYPE_BREAKPOINT]);
2156		if (pager_in_use())
2157			printf("\n");
2158	}
2159
2160	print_tracepoint_events(NULL, NULL, name_only);
2161}
2162
2163int parse_events__is_hardcoded_term(struct parse_events_term *term)
2164{
2165	return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
2166}
2167
2168static int new_term(struct parse_events_term **_term, int type_val,
2169		    int type_term, char *config,
2170		    char *str, u64 num, int err_term, int err_val)
2171{
2172	struct parse_events_term *term;
2173
2174	term = zalloc(sizeof(*term));
2175	if (!term)
2176		return -ENOMEM;
2177
2178	INIT_LIST_HEAD(&term->list);
2179	term->type_val  = type_val;
2180	term->type_term = type_term;
2181	term->config = config;
2182	term->err_term = err_term;
2183	term->err_val  = err_val;
2184
2185	switch (type_val) {
2186	case PARSE_EVENTS__TERM_TYPE_NUM:
2187		term->val.num = num;
2188		break;
2189	case PARSE_EVENTS__TERM_TYPE_STR:
2190		term->val.str = str;
2191		break;
2192	default:
2193		free(term);
2194		return -EINVAL;
2195	}
2196
2197	*_term = term;
2198	return 0;
2199}
2200
2201int parse_events_term__num(struct parse_events_term **term,
2202			   int type_term, char *config, u64 num,
2203			   void *loc_term_, void *loc_val_)
2204{
2205	YYLTYPE *loc_term = loc_term_;
2206	YYLTYPE *loc_val = loc_val_;
2207
2208	return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
2209			config, NULL, num,
2210			loc_term ? loc_term->first_column : 0,
2211			loc_val ? loc_val->first_column : 0);
2212}
2213
2214int parse_events_term__str(struct parse_events_term **term,
2215			   int type_term, char *config, char *str,
2216			   void *loc_term_, void *loc_val_)
2217{
2218	YYLTYPE *loc_term = loc_term_;
2219	YYLTYPE *loc_val = loc_val_;
2220
2221	return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
2222			config, str, 0,
2223			loc_term ? loc_term->first_column : 0,
2224			loc_val ? loc_val->first_column : 0);
2225}
2226
2227int parse_events_term__sym_hw(struct parse_events_term **term,
2228			      char *config, unsigned idx)
2229{
2230	struct event_symbol *sym;
2231
2232	BUG_ON(idx >= PERF_COUNT_HW_MAX);
2233	sym = &event_symbols_hw[idx];
2234
2235	if (config)
2236		return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
2237				PARSE_EVENTS__TERM_TYPE_USER, config,
2238				(char *) sym->symbol, 0, 0, 0);
2239	else
2240		return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
2241				PARSE_EVENTS__TERM_TYPE_USER,
2242				(char *) "event", (char *) sym->symbol,
2243				0, 0, 0);
2244}
2245
2246int parse_events_term__clone(struct parse_events_term **new,
2247			     struct parse_events_term *term)
2248{
2249	return new_term(new, term->type_val, term->type_term, term->config,
2250			term->val.str, term->val.num,
2251			term->err_term, term->err_val);
2252}
2253
2254void parse_events_terms__purge(struct list_head *terms)
2255{
2256	struct parse_events_term *term, *h;
2257
2258	list_for_each_entry_safe(term, h, terms, list) {
2259		if (term->array.nr_ranges)
2260			free(term->array.ranges);
2261		list_del_init(&term->list);
2262		free(term);
2263	}
2264}
2265
2266void parse_events_terms__delete(struct list_head *terms)
2267{
2268	if (!terms)
2269		return;
2270	parse_events_terms__purge(terms);
2271	free(terms);
2272}
2273
2274void parse_events__clear_array(struct parse_events_array *a)
2275{
2276	free(a->ranges);
2277}
2278
2279void parse_events_evlist_error(struct parse_events_evlist *data,
2280			       int idx, const char *str)
2281{
2282	struct parse_events_error *err = data->error;
2283
2284	if (!err)
2285		return;
2286	err->idx = idx;
2287	err->str = strdup(str);
2288	WARN_ONCE(!err->str, "WARNING: failed to allocate error string");
2289}
2290
2291static void config_terms_list(char *buf, size_t buf_sz)
2292{
2293	int i;
2294	bool first = true;
2295
2296	buf[0] = '\0';
2297	for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
2298		const char *name = config_term_names[i];
2299
2300		if (!config_term_avail(i, NULL))
2301			continue;
2302		if (!name)
2303			continue;
2304		if (name[0] == '<')
2305			continue;
2306
2307		if (strlen(buf) + strlen(name) + 2 >= buf_sz)
2308			return;
2309
2310		if (!first)
2311			strcat(buf, ",");
2312		else
2313			first = false;
2314		strcat(buf, name);
2315	}
2316}
2317
2318/*
2319 * Return string contains valid config terms of an event.
2320 * @additional_terms: For terms such as PMU sysfs terms.
2321 */
2322char *parse_events_formats_error_string(char *additional_terms)
2323{
2324	char *str;
2325	/* "branch_type" is the longest name */
2326	char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
2327			  (sizeof("branch_type") - 1)];
2328
2329	config_terms_list(static_terms, sizeof(static_terms));
2330	/* valid terms */
2331	if (additional_terms) {
2332		if (asprintf(&str, "valid terms: %s,%s",
2333			     additional_terms, static_terms) < 0)
2334			goto fail;
2335	} else {
2336		if (asprintf(&str, "valid terms: %s", static_terms) < 0)
2337			goto fail;
2338	}
2339	return str;
2340
2341fail:
2342	return NULL;
2343}