1// SPDX-License-Identifier: GPL-2.0
   2#include <linux/hw_breakpoint.h>
   3#include <linux/err.h>
   4#include <linux/list_sort.h>
   5#include <linux/zalloc.h>
   6#include <dirent.h>
   7#include <errno.h>
   8#include <sys/ioctl.h>
   9#include <sys/param.h>
  10#include "term.h"
 
  11#include "evlist.h"
  12#include "evsel.h"
  13#include <subcmd/parse-options.h>
  14#include "parse-events.h"
  15#include "string2.h"
  16#include "strbuf.h"
  17#include "debug.h"
  18#include <api/fs/tracing_path.h>
  19#include <perf/cpumap.h>
  20#include <util/parse-events-bison.h>
  21#include <util/parse-events-flex.h>
  22#include "pmu.h"
  23#include "pmus.h"
  24#include "asm/bug.h"
  25#include "util/parse-branch-options.h"
  26#include "util/evsel_config.h"
  27#include "util/event.h"
  28#include "util/bpf-filter.h"
  29#include "util/util.h"
  30#include "tracepoint.h"
  31
  32#define MAX_NAME_LEN 100
  33
  34#ifdef PARSER_DEBUG
  35extern int parse_events_debug;
  36#endif
  37static int get_config_terms(struct parse_events_terms *head_config, struct list_head *head_terms);
  38static int parse_events_terms__copy(const struct parse_events_terms *src,
  39				    struct parse_events_terms *dest);
  40
  41struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
  42	[PERF_COUNT_HW_CPU_CYCLES] = {
  43		.symbol = "cpu-cycles",
  44		.alias  = "cycles",
  45	},
  46	[PERF_COUNT_HW_INSTRUCTIONS] = {
  47		.symbol = "instructions",
  48		.alias  = "",
  49	},
  50	[PERF_COUNT_HW_CACHE_REFERENCES] = {
  51		.symbol = "cache-references",
  52		.alias  = "",
  53	},
  54	[PERF_COUNT_HW_CACHE_MISSES] = {
  55		.symbol = "cache-misses",
  56		.alias  = "",
  57	},
  58	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
  59		.symbol = "branch-instructions",
  60		.alias  = "branches",
  61	},
  62	[PERF_COUNT_HW_BRANCH_MISSES] = {
  63		.symbol = "branch-misses",
  64		.alias  = "",
  65	},
  66	[PERF_COUNT_HW_BUS_CYCLES] = {
  67		.symbol = "bus-cycles",
  68		.alias  = "",
  69	},
  70	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
  71		.symbol = "stalled-cycles-frontend",
  72		.alias  = "idle-cycles-frontend",
  73	},
  74	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
  75		.symbol = "stalled-cycles-backend",
  76		.alias  = "idle-cycles-backend",
  77	},
  78	[PERF_COUNT_HW_REF_CPU_CYCLES] = {
  79		.symbol = "ref-cycles",
  80		.alias  = "",
  81	},
  82};
  83
  84struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
  85	[PERF_COUNT_SW_CPU_CLOCK] = {
  86		.symbol = "cpu-clock",
  87		.alias  = "",
  88	},
  89	[PERF_COUNT_SW_TASK_CLOCK] = {
  90		.symbol = "task-clock",
  91		.alias  = "",
  92	},
  93	[PERF_COUNT_SW_PAGE_FAULTS] = {
  94		.symbol = "page-faults",
  95		.alias  = "faults",
  96	},
  97	[PERF_COUNT_SW_CONTEXT_SWITCHES] = {
  98		.symbol = "context-switches",
  99		.alias  = "cs",
 100	},
 101	[PERF_COUNT_SW_CPU_MIGRATIONS] = {
 102		.symbol = "cpu-migrations",
 103		.alias  = "migrations",
 104	},
 105	[PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
 106		.symbol = "minor-faults",
 107		.alias  = "",
 108	},
 109	[PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
 110		.symbol = "major-faults",
 111		.alias  = "",
 112	},
 113	[PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
 114		.symbol = "alignment-faults",
 115		.alias  = "",
 116	},
 117	[PERF_COUNT_SW_EMULATION_FAULTS] = {
 118		.symbol = "emulation-faults",
 119		.alias  = "",
 120	},
 121	[PERF_COUNT_SW_DUMMY] = {
 122		.symbol = "dummy",
 123		.alias  = "",
 124	},
 125	[PERF_COUNT_SW_BPF_OUTPUT] = {
 126		.symbol = "bpf-output",
 127		.alias  = "",
 128	},
 129	[PERF_COUNT_SW_CGROUP_SWITCHES] = {
 130		.symbol = "cgroup-switches",
 131		.alias  = "",
 132	},
 133};
 134
 135const char *event_type(int type)
 136{
 137	switch (type) {
 138	case PERF_TYPE_HARDWARE:
 139		return "hardware";
 140
 141	case PERF_TYPE_SOFTWARE:
 142		return "software";
 143
 144	case PERF_TYPE_TRACEPOINT:
 145		return "tracepoint";
 146
 147	case PERF_TYPE_HW_CACHE:
 148		return "hardware-cache";
 149
 150	default:
 151		break;
 152	}
 153
 154	return "unknown";
 155}
 156
 157static char *get_config_str(struct parse_events_terms *head_terms,
 158			    enum parse_events__term_type type_term)
 159{
 160	struct parse_events_term *term;
 161
 162	if (!head_terms)
 163		return NULL;
 164
 165	list_for_each_entry(term, &head_terms->terms, list)
 166		if (term->type_term == type_term)
 167			return term->val.str;
 168
 169	return NULL;
 170}
 171
 172static char *get_config_metric_id(struct parse_events_terms *head_terms)
 173{
 174	return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_METRIC_ID);
 175}
 176
 177static char *get_config_name(struct parse_events_terms *head_terms)
 178{
 179	return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_NAME);
 180}
 181
 182/**
 183 * fix_raw - For each raw term see if there is an event (aka alias) in pmu that
 184 *           matches the raw's string value. If the string value matches an
 185 *           event then change the term to be an event, if not then change it to
 186 *           be a config term. For example, "read" may be an event of the PMU or
 187 *           a raw hex encoding of 0xead. The fix-up is done late so the PMU of
 188 *           the event can be determined and we don't need to scan all PMUs
 189 *           ahead-of-time.
 190 * @config_terms: the list of terms that may contain a raw term.
 191 * @pmu: the PMU to scan for events from.
 192 */
 193static void fix_raw(struct parse_events_terms *config_terms, struct perf_pmu *pmu)
 194{
 195	struct parse_events_term *term;
 196
 197	list_for_each_entry(term, &config_terms->terms, list) {
 198		u64 num;
 199
 200		if (term->type_term != PARSE_EVENTS__TERM_TYPE_RAW)
 201			continue;
 202
 203		if (perf_pmu__have_event(pmu, term->val.str)) {
 204			zfree(&term->config);
 205			term->config = term->val.str;
 206			term->type_val = PARSE_EVENTS__TERM_TYPE_NUM;
 207			term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
 208			term->val.num = 1;
 209			term->no_value = true;
 210			continue;
 211		}
 212
 213		zfree(&term->config);
 214		term->config = strdup("config");
 215		errno = 0;
 216		num = strtoull(term->val.str + 1, NULL, 16);
 217		assert(errno == 0);
 218		free(term->val.str);
 219		term->type_val = PARSE_EVENTS__TERM_TYPE_NUM;
 220		term->type_term = PARSE_EVENTS__TERM_TYPE_CONFIG;
 221		term->val.num = num;
 222		term->no_value = false;
 223	}
 224}
 225
 226static struct evsel *
 227__add_event(struct list_head *list, int *idx,
 228	    struct perf_event_attr *attr,
 229	    bool init_attr,
 230	    const char *name, const char *metric_id, struct perf_pmu *pmu,
 231	    struct list_head *config_terms, bool auto_merge_stats,
 232	    const char *cpu_list)
 233{
 234	struct evsel *evsel;
 235	struct perf_cpu_map *cpus = pmu ? perf_cpu_map__get(pmu->cpus) :
 236			       cpu_list ? perf_cpu_map__new(cpu_list) : NULL;
 237
 
 238	if (pmu)
 239		perf_pmu__warn_invalid_formats(pmu);
 240
 241	if (pmu && (attr->type == PERF_TYPE_RAW || attr->type >= PERF_TYPE_MAX)) {
 242		perf_pmu__warn_invalid_config(pmu, attr->config, name,
 243					      PERF_PMU_FORMAT_VALUE_CONFIG, "config");
 244		perf_pmu__warn_invalid_config(pmu, attr->config1, name,
 245					      PERF_PMU_FORMAT_VALUE_CONFIG1, "config1");
 246		perf_pmu__warn_invalid_config(pmu, attr->config2, name,
 247					      PERF_PMU_FORMAT_VALUE_CONFIG2, "config2");
 248		perf_pmu__warn_invalid_config(pmu, attr->config3, name,
 249					      PERF_PMU_FORMAT_VALUE_CONFIG3, "config3");
 250	}
 251	if (init_attr)
 252		event_attr_init(attr);
 253
 254	evsel = evsel__new_idx(attr, *idx);
 255	if (!evsel) {
 256		perf_cpu_map__put(cpus);
 257		return NULL;
 258	}
 259
 260	(*idx)++;
 261	evsel->core.cpus = cpus;
 262	evsel->core.own_cpus = perf_cpu_map__get(cpus);
 263	evsel->core.requires_cpu = pmu ? pmu->is_uncore : false;
 264	evsel->core.is_pmu_core = pmu ? pmu->is_core : false;
 265	evsel->auto_merge_stats = auto_merge_stats;
 266	evsel->pmu = pmu;
 267	evsel->pmu_name = pmu ? strdup(pmu->name) : NULL;
 268
 269	if (name)
 270		evsel->name = strdup(name);
 271
 272	if (metric_id)
 273		evsel->metric_id = strdup(metric_id);
 274
 275	if (config_terms)
 276		list_splice_init(config_terms, &evsel->config_terms);
 277
 278	if (list)
 279		list_add_tail(&evsel->core.node, list);
 280
 281	return evsel;
 282}
 283
 284struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
 285				      const char *name, const char *metric_id,
 286				      struct perf_pmu *pmu)
 287{
 288	return __add_event(/*list=*/NULL, &idx, attr, /*init_attr=*/false, name,
 289			   metric_id, pmu, /*config_terms=*/NULL,
 290			   /*auto_merge_stats=*/false, /*cpu_list=*/NULL);
 
 291}
 292
 293static int add_event(struct list_head *list, int *idx,
 294		     struct perf_event_attr *attr, const char *name,
 295		     const char *metric_id, struct list_head *config_terms)
 
 296{
 297	return __add_event(list, idx, attr, /*init_attr*/true, name, metric_id,
 298			   /*pmu=*/NULL, config_terms,
 299			   /*auto_merge_stats=*/false, /*cpu_list=*/NULL) ? 0 : -ENOMEM;
 300}
 301
 302static int add_event_tool(struct list_head *list, int *idx,
 303			  enum perf_tool_event tool_event)
 304{
 305	struct evsel *evsel;
 306	struct perf_event_attr attr = {
 307		.type = PERF_TYPE_SOFTWARE,
 308		.config = PERF_COUNT_SW_DUMMY,
 309	};
 310
 311	evsel = __add_event(list, idx, &attr, /*init_attr=*/true, /*name=*/NULL,
 312			    /*metric_id=*/NULL, /*pmu=*/NULL,
 313			    /*config_terms=*/NULL, /*auto_merge_stats=*/false,
 314			    /*cpu_list=*/"0");
 315	if (!evsel)
 316		return -ENOMEM;
 317	evsel->tool_event = tool_event;
 318	if (tool_event == PERF_TOOL_DURATION_TIME
 319	    || tool_event == PERF_TOOL_USER_TIME
 320	    || tool_event == PERF_TOOL_SYSTEM_TIME) {
 321		free((char *)evsel->unit);
 322		evsel->unit = strdup("ns");
 323	}
 324	return 0;
 325}
 326
 327/**
 328 * parse_aliases - search names for entries beginning or equalling str ignoring
 329 *                 case. If mutliple entries in names match str then the longest
 330 *                 is chosen.
 331 * @str: The needle to look for.
 332 * @names: The haystack to search.
 333 * @size: The size of the haystack.
 334 * @longest: Out argument giving the length of the matching entry.
 335 */
 336static int parse_aliases(const char *str, const char *const names[][EVSEL__MAX_ALIASES], int size,
 337			 int *longest)
 338{
 339	*longest = -1;
 340	for (int i = 0; i < size; i++) {
 341		for (int j = 0; j < EVSEL__MAX_ALIASES && names[i][j]; j++) {
 342			int n = strlen(names[i][j]);
 343
 344			if (n > *longest && !strncasecmp(str, names[i][j], n))
 345				*longest = n;
 346		}
 347		if (*longest > 0)
 348			return i;
 349	}
 350
 351	return -1;
 352}
 353
 354typedef int config_term_func_t(struct perf_event_attr *attr,
 355			       struct parse_events_term *term,
 356			       struct parse_events_error *err);
 357static int config_term_common(struct perf_event_attr *attr,
 358			      struct parse_events_term *term,
 359			      struct parse_events_error *err);
 360static int config_attr(struct perf_event_attr *attr,
 361		       struct parse_events_terms *head,
 362		       struct parse_events_error *err,
 363		       config_term_func_t config_term);
 364
 365/**
 366 * parse_events__decode_legacy_cache - Search name for the legacy cache event
 367 *                                     name composed of 1, 2 or 3 hyphen
 368 *                                     separated sections. The first section is
 369 *                                     the cache type while the others are the
 370 *                                     optional op and optional result. To make
 371 *                                     life hard the names in the table also
 372 *                                     contain hyphens and the longest name
 373 *                                     should always be selected.
 374 */
 375int parse_events__decode_legacy_cache(const char *name, int extended_pmu_type, __u64 *config)
 376{
 377	int len, cache_type = -1, cache_op = -1, cache_result = -1;
 378	const char *name_end = &name[strlen(name) + 1];
 379	const char *str = name;
 380
 381	cache_type = parse_aliases(str, evsel__hw_cache, PERF_COUNT_HW_CACHE_MAX, &len);
 382	if (cache_type == -1)
 383		return -EINVAL;
 384	str += len + 1;
 385
 386	if (str < name_end) {
 387		cache_op = parse_aliases(str, evsel__hw_cache_op,
 388					PERF_COUNT_HW_CACHE_OP_MAX, &len);
 389		if (cache_op >= 0) {
 390			if (!evsel__is_cache_op_valid(cache_type, cache_op))
 391				return -EINVAL;
 392			str += len + 1;
 393		} else {
 394			cache_result = parse_aliases(str, evsel__hw_cache_result,
 395						PERF_COUNT_HW_CACHE_RESULT_MAX, &len);
 396			if (cache_result >= 0)
 397				str += len + 1;
 398		}
 399	}
 400	if (str < name_end) {
 401		if (cache_op < 0) {
 402			cache_op = parse_aliases(str, evsel__hw_cache_op,
 403						PERF_COUNT_HW_CACHE_OP_MAX, &len);
 404			if (cache_op >= 0) {
 405				if (!evsel__is_cache_op_valid(cache_type, cache_op))
 406					return -EINVAL;
 407			}
 408		} else if (cache_result < 0) {
 409			cache_result = parse_aliases(str, evsel__hw_cache_result,
 410						PERF_COUNT_HW_CACHE_RESULT_MAX, &len);
 411		}
 412	}
 413
 414	/*
 415	 * Fall back to reads:
 416	 */
 417	if (cache_op == -1)
 418		cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 419
 420	/*
 421	 * Fall back to accesses:
 422	 */
 423	if (cache_result == -1)
 424		cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 425
 426	*config = cache_type | (cache_op << 8) | (cache_result << 16);
 427	if (perf_pmus__supports_extended_type())
 428		*config |= (__u64)extended_pmu_type << PERF_PMU_TYPE_SHIFT;
 429	return 0;
 430}
 431
 432/**
 433 * parse_events__filter_pmu - returns false if a wildcard PMU should be
 434 *                            considered, true if it should be filtered.
 435 */
 436bool parse_events__filter_pmu(const struct parse_events_state *parse_state,
 437			      const struct perf_pmu *pmu)
 438{
 439	if (parse_state->pmu_filter == NULL)
 440		return false;
 441
 442	return strcmp(parse_state->pmu_filter, pmu->name) != 0;
 443}
 444
 
 
 
 
 
 445int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
 446			   struct parse_events_state *parse_state,
 447			   struct parse_events_terms *head_config)
 448{
 449	struct perf_pmu *pmu = NULL;
 450	bool found_supported = false;
 451	const char *config_name = get_config_name(head_config);
 452	const char *metric_id = get_config_metric_id(head_config);
 453
 454	/* Legacy cache events are only supported by core PMUs. */
 455	while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
 456		LIST_HEAD(config_terms);
 457		struct perf_event_attr attr;
 458		int ret;
 459
 460		if (parse_events__filter_pmu(parse_state, pmu))
 461			continue;
 462
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 463		memset(&attr, 0, sizeof(attr));
 464		attr.type = PERF_TYPE_HW_CACHE;
 465
 466		ret = parse_events__decode_legacy_cache(name, pmu->type, &attr.config);
 467		if (ret)
 468			return ret;
 469
 470		found_supported = true;
 471
 472		if (head_config) {
 473			if (config_attr(&attr, head_config, parse_state->error, config_term_common))
 
 474				return -EINVAL;
 475
 476			if (get_config_terms(head_config, &config_terms))
 477				return -ENOMEM;
 478		}
 479
 480		if (__add_event(list, idx, &attr, /*init_attr*/true, config_name ?: name,
 481				metric_id, pmu, &config_terms, /*auto_merge_stats=*/false,
 482				/*cpu_list=*/NULL) == NULL)
 
 483			return -ENOMEM;
 484
 485		free_config_terms(&config_terms);
 486	}
 487	return found_supported ? 0 : -EINVAL;
 488}
 489
 490#ifdef HAVE_LIBTRACEEVENT
 491static void tracepoint_error(struct parse_events_error *e, int err,
 492			     const char *sys, const char *name, int column)
 493{
 494	const char *str;
 495	char help[BUFSIZ];
 496
 497	if (!e)
 498		return;
 499
 500	/*
 501	 * We get error directly from syscall errno ( > 0),
 502	 * or from encoded pointer's error ( < 0).
 503	 */
 504	err = abs(err);
 505
 506	switch (err) {
 507	case EACCES:
 508		str = "can't access trace events";
 509		break;
 510	case ENOENT:
 511		str = "unknown tracepoint";
 512		break;
 513	default:
 514		str = "failed to add tracepoint";
 515		break;
 516	}
 517
 518	tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
 519	parse_events_error__handle(e, column, strdup(str), strdup(help));
 520}
 521
 522static int add_tracepoint(struct list_head *list, int *idx,
 
 523			  const char *sys_name, const char *evt_name,
 524			  struct parse_events_error *err,
 525			  struct parse_events_terms *head_config, void *loc_)
 526{
 527	YYLTYPE *loc = loc_;
 528	struct evsel *evsel = evsel__newtp_idx(sys_name, evt_name, (*idx)++);
 
 529
 530	if (IS_ERR(evsel)) {
 531		tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name, loc->first_column);
 532		return PTR_ERR(evsel);
 533	}
 534
 535	if (head_config) {
 536		LIST_HEAD(config_terms);
 537
 538		if (get_config_terms(head_config, &config_terms))
 539			return -ENOMEM;
 540		list_splice(&config_terms, &evsel->config_terms);
 541	}
 542
 543	list_add_tail(&evsel->core.node, list);
 544	return 0;
 545}
 546
 547static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 
 548				      const char *sys_name, const char *evt_name,
 549				      struct parse_events_error *err,
 550				      struct parse_events_terms *head_config, YYLTYPE *loc)
 551{
 552	char *evt_path;
 553	struct dirent *evt_ent;
 554	DIR *evt_dir;
 555	int ret = 0, found = 0;
 556
 557	evt_path = get_events_file(sys_name);
 558	if (!evt_path) {
 559		tracepoint_error(err, errno, sys_name, evt_name, loc->first_column);
 560		return -1;
 561	}
 562	evt_dir = opendir(evt_path);
 563	if (!evt_dir) {
 564		put_events_file(evt_path);
 565		tracepoint_error(err, errno, sys_name, evt_name, loc->first_column);
 566		return -1;
 567	}
 568
 569	while (!ret && (evt_ent = readdir(evt_dir))) {
 570		if (!strcmp(evt_ent->d_name, ".")
 571		    || !strcmp(evt_ent->d_name, "..")
 572		    || !strcmp(evt_ent->d_name, "enable")
 573		    || !strcmp(evt_ent->d_name, "filter"))
 574			continue;
 575
 576		if (!strglobmatch(evt_ent->d_name, evt_name))
 577			continue;
 578
 579		found++;
 580
 581		ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name,
 582				     err, head_config, loc);
 583	}
 584
 585	if (!found) {
 586		tracepoint_error(err, ENOENT, sys_name, evt_name, loc->first_column);
 587		ret = -1;
 588	}
 589
 590	put_events_file(evt_path);
 591	closedir(evt_dir);
 592	return ret;
 593}
 594
 595static int add_tracepoint_event(struct list_head *list, int *idx,
 
 596				const char *sys_name, const char *evt_name,
 597				struct parse_events_error *err,
 598				struct parse_events_terms *head_config, YYLTYPE *loc)
 599{
 600	return strpbrk(evt_name, "*?") ?
 601		add_tracepoint_multi_event(list, idx, sys_name, evt_name,
 602					   err, head_config, loc) :
 603		add_tracepoint(list, idx, sys_name, evt_name,
 604			       err, head_config, loc);
 605}
 606
 607static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 
 608				    const char *sys_name, const char *evt_name,
 609				    struct parse_events_error *err,
 610				    struct parse_events_terms *head_config, YYLTYPE *loc)
 611{
 612	struct dirent *events_ent;
 613	DIR *events_dir;
 614	int ret = 0;
 615
 616	events_dir = tracing_events__opendir();
 617	if (!events_dir) {
 618		tracepoint_error(err, errno, sys_name, evt_name, loc->first_column);
 619		return -1;
 620	}
 621
 622	while (!ret && (events_ent = readdir(events_dir))) {
 623		if (!strcmp(events_ent->d_name, ".")
 624		    || !strcmp(events_ent->d_name, "..")
 625		    || !strcmp(events_ent->d_name, "enable")
 626		    || !strcmp(events_ent->d_name, "header_event")
 627		    || !strcmp(events_ent->d_name, "header_page"))
 628			continue;
 629
 630		if (!strglobmatch(events_ent->d_name, sys_name))
 631			continue;
 632
 633		ret = add_tracepoint_event(list, idx, events_ent->d_name,
 634					   evt_name, err, head_config, loc);
 635	}
 636
 637	closedir(events_dir);
 638	return ret;
 639}
 640#endif /* HAVE_LIBTRACEEVENT */
 641
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 642static int
 643parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
 644{
 645	int i;
 646
 647	for (i = 0; i < 3; i++) {
 648		if (!type || !type[i])
 649			break;
 650
 651#define CHECK_SET_TYPE(bit)		\
 652do {					\
 653	if (attr->bp_type & bit)	\
 654		return -EINVAL;		\
 655	else				\
 656		attr->bp_type |= bit;	\
 657} while (0)
 658
 659		switch (type[i]) {
 660		case 'r':
 661			CHECK_SET_TYPE(HW_BREAKPOINT_R);
 662			break;
 663		case 'w':
 664			CHECK_SET_TYPE(HW_BREAKPOINT_W);
 665			break;
 666		case 'x':
 667			CHECK_SET_TYPE(HW_BREAKPOINT_X);
 668			break;
 669		default:
 670			return -EINVAL;
 671		}
 672	}
 673
 674#undef CHECK_SET_TYPE
 675
 676	if (!attr->bp_type) /* Default */
 677		attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 678
 679	return 0;
 680}
 681
 682int parse_events_add_breakpoint(struct parse_events_state *parse_state,
 683				struct list_head *list,
 684				u64 addr, char *type, u64 len,
 685				struct parse_events_terms *head_config)
 686{
 687	struct perf_event_attr attr;
 688	LIST_HEAD(config_terms);
 689	const char *name;
 690
 691	memset(&attr, 0, sizeof(attr));
 692	attr.bp_addr = addr;
 693
 694	if (parse_breakpoint_type(type, &attr))
 695		return -EINVAL;
 696
 697	/* Provide some defaults if len is not specified */
 698	if (!len) {
 699		if (attr.bp_type == HW_BREAKPOINT_X)
 700			len = sizeof(long);
 701		else
 702			len = HW_BREAKPOINT_LEN_4;
 703	}
 704
 705	attr.bp_len = len;
 706
 707	attr.type = PERF_TYPE_BREAKPOINT;
 708	attr.sample_period = 1;
 709
 710	if (head_config) {
 711		if (config_attr(&attr, head_config, parse_state->error,
 712				config_term_common))
 713			return -EINVAL;
 714
 715		if (get_config_terms(head_config, &config_terms))
 716			return -ENOMEM;
 717	}
 718
 719	name = get_config_name(head_config);
 720
 721	return add_event(list, &parse_state->idx, &attr, name, /*mertic_id=*/NULL,
 722			 &config_terms);
 723}
 724
 725static int check_type_val(struct parse_events_term *term,
 726			  struct parse_events_error *err,
 727			  enum parse_events__term_val_type type)
 728{
 729	if (type == term->type_val)
 730		return 0;
 731
 732	if (err) {
 733		parse_events_error__handle(err, term->err_val,
 734					type == PARSE_EVENTS__TERM_TYPE_NUM
 735					? strdup("expected numeric value")
 736					: strdup("expected string value"),
 737					NULL);
 738	}
 739	return -EINVAL;
 740}
 741
 742static bool config_term_shrinked;
 743
 744static const char *config_term_name(enum parse_events__term_type term_type)
 745{
 746	/*
 747	 * Update according to parse-events.l
 748	 */
 749	static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
 750		[PARSE_EVENTS__TERM_TYPE_USER]			= "<sysfs term>",
 751		[PARSE_EVENTS__TERM_TYPE_CONFIG]		= "config",
 752		[PARSE_EVENTS__TERM_TYPE_CONFIG1]		= "config1",
 753		[PARSE_EVENTS__TERM_TYPE_CONFIG2]		= "config2",
 754		[PARSE_EVENTS__TERM_TYPE_CONFIG3]		= "config3",
 755		[PARSE_EVENTS__TERM_TYPE_NAME]			= "name",
 756		[PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD]		= "period",
 757		[PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ]		= "freq",
 758		[PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE]	= "branch_type",
 759		[PARSE_EVENTS__TERM_TYPE_TIME]			= "time",
 760		[PARSE_EVENTS__TERM_TYPE_CALLGRAPH]		= "call-graph",
 761		[PARSE_EVENTS__TERM_TYPE_STACKSIZE]		= "stack-size",
 762		[PARSE_EVENTS__TERM_TYPE_NOINHERIT]		= "no-inherit",
 763		[PARSE_EVENTS__TERM_TYPE_INHERIT]		= "inherit",
 764		[PARSE_EVENTS__TERM_TYPE_MAX_STACK]		= "max-stack",
 765		[PARSE_EVENTS__TERM_TYPE_MAX_EVENTS]		= "nr",
 766		[PARSE_EVENTS__TERM_TYPE_OVERWRITE]		= "overwrite",
 767		[PARSE_EVENTS__TERM_TYPE_NOOVERWRITE]		= "no-overwrite",
 768		[PARSE_EVENTS__TERM_TYPE_DRV_CFG]		= "driver-config",
 769		[PARSE_EVENTS__TERM_TYPE_PERCORE]		= "percore",
 770		[PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT]		= "aux-output",
 771		[PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE]	= "aux-sample-size",
 772		[PARSE_EVENTS__TERM_TYPE_METRIC_ID]		= "metric-id",
 773		[PARSE_EVENTS__TERM_TYPE_RAW]                   = "raw",
 774		[PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE]          = "legacy-cache",
 775		[PARSE_EVENTS__TERM_TYPE_HARDWARE]              = "hardware",
 776	};
 777	if ((unsigned int)term_type >= __PARSE_EVENTS__TERM_TYPE_NR)
 778		return "unknown term";
 779
 780	return config_term_names[term_type];
 781}
 782
 783static bool
 784config_term_avail(enum parse_events__term_type term_type, struct parse_events_error *err)
 785{
 786	char *err_str;
 787
 788	if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
 789		parse_events_error__handle(err, -1,
 790					strdup("Invalid term_type"), NULL);
 791		return false;
 792	}
 793	if (!config_term_shrinked)
 794		return true;
 795
 796	switch (term_type) {
 797	case PARSE_EVENTS__TERM_TYPE_CONFIG:
 798	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 799	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 800	case PARSE_EVENTS__TERM_TYPE_CONFIG3:
 801	case PARSE_EVENTS__TERM_TYPE_NAME:
 802	case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
 803	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 804	case PARSE_EVENTS__TERM_TYPE_PERCORE:
 805		return true;
 806	case PARSE_EVENTS__TERM_TYPE_USER:
 807	case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
 808	case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 809	case PARSE_EVENTS__TERM_TYPE_TIME:
 810	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
 811	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
 812	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
 813	case PARSE_EVENTS__TERM_TYPE_INHERIT:
 814	case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
 815	case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
 816	case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
 817	case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
 818	case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
 819	case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
 820	case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
 821	case PARSE_EVENTS__TERM_TYPE_RAW:
 822	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 823	case PARSE_EVENTS__TERM_TYPE_HARDWARE:
 824	default:
 825		if (!err)
 826			return false;
 827
 828		/* term_type is validated so indexing is safe */
 829		if (asprintf(&err_str, "'%s' is not usable in 'perf stat'",
 830			     config_term_name(term_type)) >= 0)
 831			parse_events_error__handle(err, -1, err_str, NULL);
 832		return false;
 833	}
 834}
 835
 836void parse_events__shrink_config_terms(void)
 837{
 838	config_term_shrinked = true;
 839}
 840
 841static int config_term_common(struct perf_event_attr *attr,
 842			      struct parse_events_term *term,
 843			      struct parse_events_error *err)
 844{
 845#define CHECK_TYPE_VAL(type)						   \
 846do {									   \
 847	if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \
 848		return -EINVAL;						   \
 849} while (0)
 850
 851	switch (term->type_term) {
 852	case PARSE_EVENTS__TERM_TYPE_CONFIG:
 853		CHECK_TYPE_VAL(NUM);
 854		attr->config = term->val.num;
 855		break;
 856	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 857		CHECK_TYPE_VAL(NUM);
 858		attr->config1 = term->val.num;
 859		break;
 860	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 861		CHECK_TYPE_VAL(NUM);
 862		attr->config2 = term->val.num;
 863		break;
 864	case PARSE_EVENTS__TERM_TYPE_CONFIG3:
 865		CHECK_TYPE_VAL(NUM);
 866		attr->config3 = term->val.num;
 867		break;
 868	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 869		CHECK_TYPE_VAL(NUM);
 870		break;
 871	case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
 872		CHECK_TYPE_VAL(NUM);
 873		break;
 874	case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 875		CHECK_TYPE_VAL(STR);
 876		if (strcmp(term->val.str, "no") &&
 877		    parse_branch_str(term->val.str,
 878				    &attr->branch_sample_type)) {
 879			parse_events_error__handle(err, term->err_val,
 880					strdup("invalid branch sample type"),
 881					NULL);
 882			return -EINVAL;
 883		}
 884		break;
 885	case PARSE_EVENTS__TERM_TYPE_TIME:
 886		CHECK_TYPE_VAL(NUM);
 887		if (term->val.num > 1) {
 888			parse_events_error__handle(err, term->err_val,
 889						strdup("expected 0 or 1"),
 890						NULL);
 891			return -EINVAL;
 892		}
 893		break;
 894	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
 895		CHECK_TYPE_VAL(STR);
 896		break;
 897	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
 898		CHECK_TYPE_VAL(NUM);
 899		break;
 900	case PARSE_EVENTS__TERM_TYPE_INHERIT:
 901		CHECK_TYPE_VAL(NUM);
 902		break;
 903	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
 904		CHECK_TYPE_VAL(NUM);
 905		break;
 906	case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
 907		CHECK_TYPE_VAL(NUM);
 908		break;
 909	case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
 910		CHECK_TYPE_VAL(NUM);
 911		break;
 912	case PARSE_EVENTS__TERM_TYPE_NAME:
 913		CHECK_TYPE_VAL(STR);
 914		break;
 915	case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
 916		CHECK_TYPE_VAL(STR);
 917		break;
 918	case PARSE_EVENTS__TERM_TYPE_RAW:
 919		CHECK_TYPE_VAL(STR);
 920		break;
 921	case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
 922		CHECK_TYPE_VAL(NUM);
 923		break;
 924	case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
 925		CHECK_TYPE_VAL(NUM);
 926		break;
 927	case PARSE_EVENTS__TERM_TYPE_PERCORE:
 928		CHECK_TYPE_VAL(NUM);
 929		if ((unsigned int)term->val.num > 1) {
 930			parse_events_error__handle(err, term->err_val,
 931						strdup("expected 0 or 1"),
 932						NULL);
 933			return -EINVAL;
 934		}
 935		break;
 936	case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
 937		CHECK_TYPE_VAL(NUM);
 938		break;
 939	case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
 940		CHECK_TYPE_VAL(NUM);
 941		if (term->val.num > UINT_MAX) {
 942			parse_events_error__handle(err, term->err_val,
 943						strdup("too big"),
 944						NULL);
 945			return -EINVAL;
 946		}
 947		break;
 948	case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
 949	case PARSE_EVENTS__TERM_TYPE_USER:
 950	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 951	case PARSE_EVENTS__TERM_TYPE_HARDWARE:
 952	default:
 953		parse_events_error__handle(err, term->err_term,
 954					strdup(config_term_name(term->type_term)),
 955					parse_events_formats_error_string(NULL));
 956		return -EINVAL;
 957	}
 958
 959	/*
 960	 * Check term availability after basic checking so
 961	 * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered.
 962	 *
 963	 * If check availability at the entry of this function,
 964	 * user will see "'<sysfs term>' is not usable in 'perf stat'"
 965	 * if an invalid config term is provided for legacy events
 966	 * (for example, instructions/badterm/...), which is confusing.
 967	 */
 968	if (!config_term_avail(term->type_term, err))
 969		return -EINVAL;
 970	return 0;
 971#undef CHECK_TYPE_VAL
 972}
 973
 974static int config_term_pmu(struct perf_event_attr *attr,
 975			   struct parse_events_term *term,
 976			   struct parse_events_error *err)
 977{
 978	if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE) {
 979		struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
 980
 981		if (!pmu) {
 982			char *err_str;
 983
 984			if (asprintf(&err_str, "Failed to find PMU for type %d", attr->type) >= 0)
 985				parse_events_error__handle(err, term->err_term,
 986							   err_str, /*help=*/NULL);
 987			return -EINVAL;
 988		}
 989		/*
 990		 * Rewrite the PMU event to a legacy cache one unless the PMU
 991		 * doesn't support legacy cache events or the event is present
 992		 * within the PMU.
 993		 */
 994		if (perf_pmu__supports_legacy_cache(pmu) &&
 995		    !perf_pmu__have_event(pmu, term->config)) {
 996			attr->type = PERF_TYPE_HW_CACHE;
 997			return parse_events__decode_legacy_cache(term->config, pmu->type,
 998								 &attr->config);
 999		} else {
1000			term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
1001			term->no_value = true;
1002		}
1003	}
1004	if (term->type_term == PARSE_EVENTS__TERM_TYPE_HARDWARE) {
1005		struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
1006
1007		if (!pmu) {
1008			char *err_str;
1009
1010			if (asprintf(&err_str, "Failed to find PMU for type %d", attr->type) >= 0)
1011				parse_events_error__handle(err, term->err_term,
1012							   err_str, /*help=*/NULL);
1013			return -EINVAL;
1014		}
1015		/*
1016		 * If the PMU has a sysfs or json event prefer it over
1017		 * legacy. ARM requires this.
1018		 */
1019		if (perf_pmu__have_event(pmu, term->config)) {
1020			term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
1021			term->no_value = true;
 
1022		} else {
1023			attr->type = PERF_TYPE_HARDWARE;
1024			attr->config = term->val.num;
1025			if (perf_pmus__supports_extended_type())
1026				attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;
1027		}
1028		return 0;
1029	}
1030	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
1031	    term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG) {
1032		/*
1033		 * Always succeed for sysfs terms, as we dont know
1034		 * at this point what type they need to have.
1035		 */
1036		return 0;
1037	}
1038	return config_term_common(attr, term, err);
1039}
1040
1041#ifdef HAVE_LIBTRACEEVENT
1042static int config_term_tracepoint(struct perf_event_attr *attr,
1043				  struct parse_events_term *term,
1044				  struct parse_events_error *err)
1045{
1046	switch (term->type_term) {
1047	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1048	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1049	case PARSE_EVENTS__TERM_TYPE_INHERIT:
1050	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1051	case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1052	case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1053	case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1054	case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1055	case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1056	case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1057		return config_term_common(attr, term, err);
1058	case PARSE_EVENTS__TERM_TYPE_USER:
1059	case PARSE_EVENTS__TERM_TYPE_CONFIG:
1060	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1061	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1062	case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1063	case PARSE_EVENTS__TERM_TYPE_NAME:
1064	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1065	case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1066	case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1067	case PARSE_EVENTS__TERM_TYPE_TIME:
1068	case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1069	case PARSE_EVENTS__TERM_TYPE_PERCORE:
1070	case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1071	case PARSE_EVENTS__TERM_TYPE_RAW:
1072	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
1073	case PARSE_EVENTS__TERM_TYPE_HARDWARE:
1074	default:
1075		if (err) {
1076			parse_events_error__handle(err, term->err_term,
1077						   strdup(config_term_name(term->type_term)),
1078				strdup("valid terms: call-graph,stack-size\n"));
 
1079		}
1080		return -EINVAL;
1081	}
1082
1083	return 0;
1084}
1085#endif
1086
1087static int config_attr(struct perf_event_attr *attr,
1088		       struct parse_events_terms *head,
1089		       struct parse_events_error *err,
1090		       config_term_func_t config_term)
1091{
1092	struct parse_events_term *term;
1093
1094	list_for_each_entry(term, &head->terms, list)
1095		if (config_term(attr, term, err))
1096			return -EINVAL;
1097
1098	return 0;
1099}
1100
1101static int get_config_terms(struct parse_events_terms *head_config, struct list_head *head_terms)
 
1102{
1103#define ADD_CONFIG_TERM(__type, __weak)				\
1104	struct evsel_config_term *__t;			\
1105								\
1106	__t = zalloc(sizeof(*__t));				\
1107	if (!__t)						\
1108		return -ENOMEM;					\
1109								\
1110	INIT_LIST_HEAD(&__t->list);				\
1111	__t->type       = EVSEL__CONFIG_TERM_ ## __type;	\
1112	__t->weak	= __weak;				\
1113	list_add_tail(&__t->list, head_terms)
1114
1115#define ADD_CONFIG_TERM_VAL(__type, __name, __val, __weak)	\
1116do {								\
1117	ADD_CONFIG_TERM(__type, __weak);			\
1118	__t->val.__name = __val;				\
1119} while (0)
1120
1121#define ADD_CONFIG_TERM_STR(__type, __val, __weak)		\
1122do {								\
1123	ADD_CONFIG_TERM(__type, __weak);			\
1124	__t->val.str = strdup(__val);				\
1125	if (!__t->val.str) {					\
1126		zfree(&__t);					\
1127		return -ENOMEM;					\
1128	}							\
1129	__t->free_str = true;					\
1130} while (0)
1131
1132	struct parse_events_term *term;
1133
1134	list_for_each_entry(term, &head_config->terms, list) {
1135		switch (term->type_term) {
1136		case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1137			ADD_CONFIG_TERM_VAL(PERIOD, period, term->val.num, term->weak);
1138			break;
1139		case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1140			ADD_CONFIG_TERM_VAL(FREQ, freq, term->val.num, term->weak);
1141			break;
1142		case PARSE_EVENTS__TERM_TYPE_TIME:
1143			ADD_CONFIG_TERM_VAL(TIME, time, term->val.num, term->weak);
1144			break;
1145		case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1146			ADD_CONFIG_TERM_STR(CALLGRAPH, term->val.str, term->weak);
1147			break;
1148		case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1149			ADD_CONFIG_TERM_STR(BRANCH, term->val.str, term->weak);
1150			break;
1151		case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1152			ADD_CONFIG_TERM_VAL(STACK_USER, stack_user,
1153					    term->val.num, term->weak);
1154			break;
1155		case PARSE_EVENTS__TERM_TYPE_INHERIT:
1156			ADD_CONFIG_TERM_VAL(INHERIT, inherit,
1157					    term->val.num ? 1 : 0, term->weak);
1158			break;
1159		case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1160			ADD_CONFIG_TERM_VAL(INHERIT, inherit,
1161					    term->val.num ? 0 : 1, term->weak);
1162			break;
1163		case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1164			ADD_CONFIG_TERM_VAL(MAX_STACK, max_stack,
1165					    term->val.num, term->weak);
1166			break;
1167		case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1168			ADD_CONFIG_TERM_VAL(MAX_EVENTS, max_events,
1169					    term->val.num, term->weak);
1170			break;
1171		case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1172			ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite,
1173					    term->val.num ? 1 : 0, term->weak);
1174			break;
1175		case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1176			ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite,
1177					    term->val.num ? 0 : 1, term->weak);
1178			break;
1179		case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1180			ADD_CONFIG_TERM_STR(DRV_CFG, term->val.str, term->weak);
1181			break;
1182		case PARSE_EVENTS__TERM_TYPE_PERCORE:
1183			ADD_CONFIG_TERM_VAL(PERCORE, percore,
1184					    term->val.num ? true : false, term->weak);
1185			break;
1186		case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1187			ADD_CONFIG_TERM_VAL(AUX_OUTPUT, aux_output,
1188					    term->val.num ? 1 : 0, term->weak);
1189			break;
1190		case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1191			ADD_CONFIG_TERM_VAL(AUX_SAMPLE_SIZE, aux_sample_size,
1192					    term->val.num, term->weak);
1193			break;
1194		case PARSE_EVENTS__TERM_TYPE_USER:
1195		case PARSE_EVENTS__TERM_TYPE_CONFIG:
1196		case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1197		case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1198		case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1199		case PARSE_EVENTS__TERM_TYPE_NAME:
1200		case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1201		case PARSE_EVENTS__TERM_TYPE_RAW:
1202		case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
1203		case PARSE_EVENTS__TERM_TYPE_HARDWARE:
1204		default:
1205			break;
1206		}
1207	}
1208	return 0;
1209}
1210
1211/*
1212 * Add EVSEL__CONFIG_TERM_CFG_CHG where cfg_chg will have a bit set for
1213 * each bit of attr->config that the user has changed.
1214 */
1215static int get_config_chgs(struct perf_pmu *pmu, struct parse_events_terms *head_config,
1216			   struct list_head *head_terms)
1217{
1218	struct parse_events_term *term;
1219	u64 bits = 0;
1220	int type;
1221
1222	list_for_each_entry(term, &head_config->terms, list) {
1223		switch (term->type_term) {
1224		case PARSE_EVENTS__TERM_TYPE_USER:
1225			type = perf_pmu__format_type(pmu, term->config);
1226			if (type != PERF_PMU_FORMAT_VALUE_CONFIG)
1227				continue;
1228			bits |= perf_pmu__format_bits(pmu, term->config);
1229			break;
1230		case PARSE_EVENTS__TERM_TYPE_CONFIG:
1231			bits = ~(u64)0;
1232			break;
1233		case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1234		case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1235		case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1236		case PARSE_EVENTS__TERM_TYPE_NAME:
1237		case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1238		case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1239		case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1240		case PARSE_EVENTS__TERM_TYPE_TIME:
1241		case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1242		case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1243		case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1244		case PARSE_EVENTS__TERM_TYPE_INHERIT:
1245		case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1246		case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1247		case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1248		case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1249		case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1250		case PARSE_EVENTS__TERM_TYPE_PERCORE:
1251		case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1252		case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1253		case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1254		case PARSE_EVENTS__TERM_TYPE_RAW:
1255		case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
1256		case PARSE_EVENTS__TERM_TYPE_HARDWARE:
1257		default:
1258			break;
1259		}
1260	}
1261
1262	if (bits)
1263		ADD_CONFIG_TERM_VAL(CFG_CHG, cfg_chg, bits, false);
1264
1265#undef ADD_CONFIG_TERM
1266	return 0;
1267}
1268
1269int parse_events_add_tracepoint(struct list_head *list, int *idx,
 
1270				const char *sys, const char *event,
1271				struct parse_events_error *err,
1272				struct parse_events_terms *head_config, void *loc_)
1273{
1274	YYLTYPE *loc = loc_;
1275#ifdef HAVE_LIBTRACEEVENT
1276	if (head_config) {
1277		struct perf_event_attr attr;
1278
1279		if (config_attr(&attr, head_config, err,
1280				config_term_tracepoint))
1281			return -EINVAL;
1282	}
1283
1284	if (strpbrk(sys, "*?"))
1285		return add_tracepoint_multi_sys(list, idx, sys, event,
1286						err, head_config, loc);
1287	else
1288		return add_tracepoint_event(list, idx, sys, event,
1289					    err, head_config, loc);
1290#else
 
1291	(void)list;
1292	(void)idx;
1293	(void)sys;
1294	(void)event;
1295	(void)head_config;
1296	parse_events_error__handle(err, loc->first_column, strdup("unsupported tracepoint"),
1297				strdup("libtraceevent is necessary for tracepoint support"));
1298	return -1;
1299#endif
1300}
1301
1302static int __parse_events_add_numeric(struct parse_events_state *parse_state,
1303				struct list_head *list,
1304				struct perf_pmu *pmu, u32 type, u32 extended_type,
1305				u64 config, struct parse_events_terms *head_config)
1306{
1307	struct perf_event_attr attr;
1308	LIST_HEAD(config_terms);
1309	const char *name, *metric_id;
1310	int ret;
1311
1312	memset(&attr, 0, sizeof(attr));
1313	attr.type = type;
1314	attr.config = config;
1315	if (extended_type && (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)) {
1316		assert(perf_pmus__supports_extended_type());
1317		attr.config |= (u64)extended_type << PERF_PMU_TYPE_SHIFT;
1318	}
1319
1320	if (head_config) {
1321		if (config_attr(&attr, head_config, parse_state->error,
1322				config_term_common))
1323			return -EINVAL;
1324
1325		if (get_config_terms(head_config, &config_terms))
1326			return -ENOMEM;
1327	}
1328
1329	name = get_config_name(head_config);
1330	metric_id = get_config_metric_id(head_config);
1331	ret = __add_event(list, &parse_state->idx, &attr, /*init_attr*/true, name,
1332			metric_id, pmu, &config_terms, /*auto_merge_stats=*/false,
1333			/*cpu_list=*/NULL) ? 0 : -ENOMEM;
 
1334	free_config_terms(&config_terms);
1335	return ret;
1336}
1337
1338int parse_events_add_numeric(struct parse_events_state *parse_state,
1339			     struct list_head *list,
1340			     u32 type, u64 config,
1341			     struct parse_events_terms *head_config,
1342			     bool wildcard)
1343{
1344	struct perf_pmu *pmu = NULL;
1345	bool found_supported = false;
1346
1347	/* Wildcards on numeric values are only supported by core PMUs. */
1348	if (wildcard && perf_pmus__supports_extended_type()) {
1349		while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
1350			int ret;
1351
1352			found_supported = true;
1353			if (parse_events__filter_pmu(parse_state, pmu))
1354				continue;
1355
1356			ret = __parse_events_add_numeric(parse_state, list, pmu,
1357							 type, pmu->type,
1358							 config, head_config);
1359			if (ret)
1360				return ret;
1361		}
1362		if (found_supported)
1363			return 0;
1364	}
1365	return __parse_events_add_numeric(parse_state, list, perf_pmus__find_by_type(type),
1366					type, /*extended_type=*/0, config, head_config);
1367}
1368
1369int parse_events_add_tool(struct parse_events_state *parse_state,
1370			  struct list_head *list,
1371			  int tool_event)
1372{
1373	return add_event_tool(list, &parse_state->idx, tool_event);
1374}
1375
1376static bool config_term_percore(struct list_head *config_terms)
1377{
1378	struct evsel_config_term *term;
1379
1380	list_for_each_entry(term, config_terms, list) {
1381		if (term->type == EVSEL__CONFIG_TERM_PERCORE)
1382			return term->val.percore;
1383	}
1384
1385	return false;
1386}
1387
1388int parse_events_add_pmu(struct parse_events_state *parse_state,
1389			 struct list_head *list, const char *name,
1390			 const struct parse_events_terms *const_parsed_terms,
1391			 bool auto_merge_stats, void *loc_)
1392{
1393	struct perf_event_attr attr;
1394	struct perf_pmu_info info;
1395	struct perf_pmu *pmu;
1396	struct evsel *evsel;
1397	struct parse_events_error *err = parse_state->error;
1398	YYLTYPE *loc = loc_;
1399	LIST_HEAD(config_terms);
1400	struct parse_events_terms parsed_terms;
1401	bool alias_rewrote_terms = false;
1402
1403	pmu = parse_state->fake_pmu ?: perf_pmus__find(name);
1404
1405	if (!pmu) {
1406		char *err_str;
1407
1408		if (asprintf(&err_str,
1409				"Cannot find PMU `%s'. Missing kernel support?",
1410				name) >= 0)
1411			parse_events_error__handle(err, loc->first_column, err_str, NULL);
1412		return -EINVAL;
1413	}
1414
1415	parse_events_terms__init(&parsed_terms);
1416	if (const_parsed_terms) {
1417		int ret = parse_events_terms__copy(const_parsed_terms, &parsed_terms);
1418
1419		if (ret)
1420			return ret;
1421	}
1422
1423	if (verbose > 1) {
1424		struct strbuf sb;
1425
1426		strbuf_init(&sb, /*hint=*/ 0);
1427		if (pmu->selectable && list_empty(&parsed_terms.terms)) {
1428			strbuf_addf(&sb, "%s//", name);
 
1429		} else {
1430			strbuf_addf(&sb, "%s/", name);
1431			parse_events_terms__to_strbuf(&parsed_terms, &sb);
1432			strbuf_addch(&sb, '/');
1433		}
1434		fprintf(stderr, "Attempt to add: %s\n", sb.buf);
1435		strbuf_release(&sb);
1436	}
1437	fix_raw(&parsed_terms, pmu);
1438
1439	memset(&attr, 0, sizeof(attr));
1440	if (pmu->perf_event_attr_init_default)
1441		pmu->perf_event_attr_init_default(pmu, &attr);
1442
1443	attr.type = pmu->type;
1444
1445	if (list_empty(&parsed_terms.terms)) {
1446		evsel = __add_event(list, &parse_state->idx, &attr,
1447				    /*init_attr=*/true, /*name=*/NULL,
1448				    /*metric_id=*/NULL, pmu,
1449				    /*config_terms=*/NULL, auto_merge_stats,
1450				    /*cpu_list=*/NULL);
1451		return evsel ? 0 : -ENOMEM;
1452	}
1453
 
 
 
 
 
 
 
 
 
1454	/* Configure attr/terms with a known PMU, this will set hardcoded terms. */
1455	if (config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
1456		parse_events_terms__exit(&parsed_terms);
1457		return -EINVAL;
1458	}
1459
1460	/* Look for event names in the terms and rewrite into format based terms. */
1461	if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, &parsed_terms,
1462							    &info, &alias_rewrote_terms, err)) {
 
1463		parse_events_terms__exit(&parsed_terms);
1464		return -EINVAL;
1465	}
1466
1467	if (verbose > 1) {
1468		struct strbuf sb;
1469
1470		strbuf_init(&sb, /*hint=*/ 0);
1471		parse_events_terms__to_strbuf(&parsed_terms, &sb);
1472		fprintf(stderr, "..after resolving event: %s/%s/\n", name, sb.buf);
1473		strbuf_release(&sb);
1474	}
1475
1476	/* Configure attr/terms again if an alias was expanded. */
1477	if (alias_rewrote_terms &&
1478	    config_attr(&attr, &parsed_terms, parse_state->error, config_term_pmu)) {
1479		parse_events_terms__exit(&parsed_terms);
1480		return -EINVAL;
1481	}
1482
1483	if (get_config_terms(&parsed_terms, &config_terms)) {
1484		parse_events_terms__exit(&parsed_terms);
1485		return -ENOMEM;
1486	}
1487
1488	/*
1489	 * When using default config, record which bits of attr->config were
1490	 * changed by the user.
1491	 */
1492	if (pmu->perf_event_attr_init_default &&
1493	    get_config_chgs(pmu, &parsed_terms, &config_terms)) {
1494		parse_events_terms__exit(&parsed_terms);
1495		return -ENOMEM;
1496	}
1497
1498	if (!parse_state->fake_pmu &&
1499	    perf_pmu__config(pmu, &attr, &parsed_terms, parse_state->error)) {
 
1500		free_config_terms(&config_terms);
1501		parse_events_terms__exit(&parsed_terms);
1502		return -EINVAL;
1503	}
1504
1505	evsel = __add_event(list, &parse_state->idx, &attr, /*init_attr=*/true,
1506			    get_config_name(&parsed_terms),
1507			    get_config_metric_id(&parsed_terms), pmu,
1508			    &config_terms, auto_merge_stats, /*cpu_list=*/NULL);
 
1509	if (!evsel) {
1510		parse_events_terms__exit(&parsed_terms);
1511		return -ENOMEM;
1512	}
1513
1514	if (evsel->name)
1515		evsel->use_config_name = true;
1516
1517	evsel->percore = config_term_percore(&evsel->config_terms);
1518
1519	if (parse_state->fake_pmu) {
1520		parse_events_terms__exit(&parsed_terms);
1521		return 0;
1522	}
1523
1524	parse_events_terms__exit(&parsed_terms);
1525	free((char *)evsel->unit);
1526	evsel->unit = strdup(info.unit);
1527	evsel->scale = info.scale;
1528	evsel->per_pkg = info.per_pkg;
1529	evsel->snapshot = info.snapshot;
1530	return 0;
1531}
1532
1533int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
1534			       const char *event_name,
1535			       const struct parse_events_terms *const_parsed_terms,
1536			       struct list_head **listp, void *loc_)
1537{
1538	struct parse_events_term *term;
1539	struct list_head *list = NULL;
1540	struct perf_pmu *pmu = NULL;
1541	YYLTYPE *loc = loc_;
1542	int ok = 0;
1543	const char *config;
1544	struct parse_events_terms parsed_terms;
1545
1546	*listp = NULL;
1547
1548	parse_events_terms__init(&parsed_terms);
1549	if (const_parsed_terms) {
1550		int ret = parse_events_terms__copy(const_parsed_terms, &parsed_terms);
1551
1552		if (ret)
1553			return ret;
1554	}
1555
1556	config = strdup(event_name);
1557	if (!config)
1558		goto out_err;
1559
1560	if (parse_events_term__num(&term,
1561				   PARSE_EVENTS__TERM_TYPE_USER,
1562				   config, /*num=*/1, /*novalue=*/true,
1563				   loc, /*loc_val=*/NULL) < 0) {
1564		zfree(&config);
1565		goto out_err;
1566	}
1567	list_add_tail(&term->list, &parsed_terms.terms);
1568
1569	/* Add it for all PMUs that support the alias */
1570	list = malloc(sizeof(struct list_head));
1571	if (!list)
1572		goto out_err;
1573
1574	INIT_LIST_HEAD(list);
1575
1576	while ((pmu = perf_pmus__scan(pmu)) != NULL) {
1577		bool auto_merge_stats;
1578
1579		if (parse_events__filter_pmu(parse_state, pmu))
1580			continue;
1581
1582		if (!perf_pmu__have_event(pmu, event_name))
1583			continue;
1584
1585		auto_merge_stats = perf_pmu__auto_merge_stats(pmu);
1586		if (!parse_events_add_pmu(parse_state, list, pmu->name,
1587					  &parsed_terms, auto_merge_stats, loc)) {
1588			struct strbuf sb;
1589
1590			strbuf_init(&sb, /*hint=*/ 0);
1591			parse_events_terms__to_strbuf(&parsed_terms, &sb);
1592			pr_debug("%s -> %s/%s/\n", event_name, pmu->name, sb.buf);
1593			strbuf_release(&sb);
1594			ok++;
1595		}
1596	}
1597
1598	if (parse_state->fake_pmu) {
1599		if (!parse_events_add_pmu(parse_state, list, event_name, &parsed_terms,
1600					  /*auto_merge_stats=*/true, loc)) {
1601			struct strbuf sb;
1602
1603			strbuf_init(&sb, /*hint=*/ 0);
1604			parse_events_terms__to_strbuf(&parsed_terms, &sb);
1605			pr_debug("%s -> %s/%s/\n", event_name, "fake_pmu", sb.buf);
1606			strbuf_release(&sb);
1607			ok++;
1608		}
1609	}
1610
1611out_err:
1612	parse_events_terms__exit(&parsed_terms);
1613	if (ok)
1614		*listp = list;
1615	else
1616		free(list);
1617
1618	return ok ? 0 : -1;
1619}
1620
1621int parse_events__modifier_group(struct list_head *list,
1622				 char *event_mod)
 
 
 
1623{
1624	return parse_events__modifier_event(list, event_mod, true);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1625}
1626
1627void parse_events__set_leader(char *name, struct list_head *list)
1628{
1629	struct evsel *leader;
1630
1631	if (list_empty(list)) {
1632		WARN_ONCE(true, "WARNING: failed to set leader: empty list");
1633		return;
1634	}
1635
1636	leader = list_first_entry(list, struct evsel, core.node);
1637	__perf_evlist__set_leader(list, &leader->core);
 
1638	leader->group_name = name;
1639}
1640
1641/* list_event is assumed to point to malloc'ed memory */
1642void parse_events_update_lists(struct list_head *list_event,
1643			       struct list_head *list_all)
 
 
1644{
1645	/*
1646	 * Called for single event definition. Update the
1647	 * 'all event' list, and reinit the 'single event'
1648	 * list, for next event definition.
1649	 */
1650	list_splice_tail(list_event, list_all);
1651	free(list_event);
1652}
1653
1654struct event_modifier {
1655	int eu;
1656	int ek;
1657	int eh;
1658	int eH;
1659	int eG;
1660	int eI;
1661	int precise;
1662	int precise_max;
1663	int exclude_GH;
1664	int sample_read;
1665	int pinned;
1666	int weak;
1667	int exclusive;
1668	int bpf_counter;
1669};
1670
1671static int get_event_modifier(struct event_modifier *mod, char *str,
1672			       struct evsel *evsel)
1673{
1674	int eu = evsel ? evsel->core.attr.exclude_user : 0;
1675	int ek = evsel ? evsel->core.attr.exclude_kernel : 0;
1676	int eh = evsel ? evsel->core.attr.exclude_hv : 0;
1677	int eH = evsel ? evsel->core.attr.exclude_host : 0;
1678	int eG = evsel ? evsel->core.attr.exclude_guest : 0;
1679	int eI = evsel ? evsel->core.attr.exclude_idle : 0;
1680	int precise = evsel ? evsel->core.attr.precise_ip : 0;
1681	int precise_max = 0;
1682	int sample_read = 0;
1683	int pinned = evsel ? evsel->core.attr.pinned : 0;
1684	int exclusive = evsel ? evsel->core.attr.exclusive : 0;
1685
1686	int exclude = eu | ek | eh;
1687	int exclude_GH = evsel ? evsel->exclude_GH : 0;
1688	int weak = 0;
1689	int bpf_counter = 0;
1690
1691	memset(mod, 0, sizeof(*mod));
 
 
 
 
 
 
 
 
1692
1693	while (*str) {
1694		if (*str == 'u') {
1695			if (!exclude)
1696				exclude = eu = ek = eh = 1;
1697			if (!exclude_GH && !perf_guest)
1698				eG = 1;
1699			eu = 0;
1700		} else if (*str == 'k') {
 
1701			if (!exclude)
1702				exclude = eu = ek = eh = 1;
1703			ek = 0;
1704		} else if (*str == 'h') {
 
1705			if (!exclude)
1706				exclude = eu = ek = eh = 1;
1707			eh = 0;
1708		} else if (*str == 'G') {
 
1709			if (!exclude_GH)
1710				exclude_GH = eG = eH = 1;
1711			eG = 0;
1712		} else if (*str == 'H') {
 
1713			if (!exclude_GH)
1714				exclude_GH = eG = eH = 1;
1715			eH = 0;
1716		} else if (*str == 'I') {
1717			eI = 1;
1718		} else if (*str == 'p') {
1719			precise++;
1720			/* use of precise requires exclude_guest */
1721			if (!exclude_GH)
1722				eG = 1;
1723		} else if (*str == 'P') {
1724			precise_max = 1;
1725		} else if (*str == 'S') {
1726			sample_read = 1;
1727		} else if (*str == 'D') {
1728			pinned = 1;
1729		} else if (*str == 'e') {
1730			exclusive = 1;
1731		} else if (*str == 'W') {
1732			weak = 1;
1733		} else if (*str == 'b') {
1734			bpf_counter = 1;
1735		} else
1736			break;
 
 
1737
1738		++str;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1739	}
1740
1741	/*
1742	 * precise ip:
1743	 *
1744	 *  0 - SAMPLE_IP can have arbitrary skid
1745	 *  1 - SAMPLE_IP must have constant skid
1746	 *  2 - SAMPLE_IP requested to have 0 skid
1747	 *  3 - SAMPLE_IP must have 0 skid
1748	 *
1749	 *  See also PERF_RECORD_MISC_EXACT_IP
1750	 */
1751	if (precise > 3)
1752		return -EINVAL;
1753
1754	mod->eu = eu;
1755	mod->ek = ek;
1756	mod->eh = eh;
1757	mod->eH = eH;
1758	mod->eG = eG;
1759	mod->eI = eI;
1760	mod->precise = precise;
1761	mod->precise_max = precise_max;
1762	mod->exclude_GH = exclude_GH;
1763	mod->sample_read = sample_read;
1764	mod->pinned = pinned;
1765	mod->weak = weak;
1766	mod->bpf_counter = bpf_counter;
1767	mod->exclusive = exclusive;
1768
1769	return 0;
1770}
1771
1772/*
1773 * Basic modifier sanity check to validate it contains only one
1774 * instance of any modifier (apart from 'p') present.
1775 */
1776static int check_modifier(char *str)
1777{
1778	char *p = str;
1779
1780	/* The sizeof includes 0 byte as well. */
1781	if (strlen(str) > (sizeof("ukhGHpppPSDIWeb") - 1))
1782		return -1;
1783
1784	while (*p) {
1785		if (*p != 'p' && strchr(p + 1, *p))
1786			return -1;
1787		p++;
1788	}
1789
1790	return 0;
1791}
1792
1793int parse_events__modifier_event(struct list_head *list, char *str, bool add)
 
 
1794{
1795	struct evsel *evsel;
1796	struct event_modifier mod;
1797
1798	if (str == NULL)
1799		return 0;
1800
1801	if (check_modifier(str))
1802		return -EINVAL;
1803
1804	if (!add && get_event_modifier(&mod, str, NULL))
1805		return -EINVAL;
1806
1807	__evlist__for_each_entry(list, evsel) {
1808		if (add && get_event_modifier(&mod, str, evsel))
1809			return -EINVAL;
1810
1811		evsel->core.attr.exclude_user   = mod.eu;
1812		evsel->core.attr.exclude_kernel = mod.ek;
1813		evsel->core.attr.exclude_hv     = mod.eh;
1814		evsel->core.attr.precise_ip     = mod.precise;
1815		evsel->core.attr.exclude_host   = mod.eH;
1816		evsel->core.attr.exclude_guest  = mod.eG;
1817		evsel->core.attr.exclude_idle   = mod.eI;
1818		evsel->exclude_GH          = mod.exclude_GH;
1819		evsel->sample_read         = mod.sample_read;
1820		evsel->precise_max         = mod.precise_max;
1821		evsel->weak_group	   = mod.weak;
1822		evsel->bpf_counter	   = mod.bpf_counter;
1823
1824		if (evsel__is_group_leader(evsel)) {
1825			evsel->core.attr.pinned = mod.pinned;
1826			evsel->core.attr.exclusive = mod.exclusive;
1827		}
1828	}
1829
1830	return 0;
1831}
1832
1833int parse_events_name(struct list_head *list, const char *name)
1834{
1835	struct evsel *evsel;
 
1836
1837	__evlist__for_each_entry(list, evsel) {
1838		if (!evsel->name) {
1839			evsel->name = strdup(name);
 
1840			if (!evsel->name)
1841				return -ENOMEM;
1842		}
1843	}
1844
 
1845	return 0;
1846}
1847
1848static int parse_events__scanner(const char *str,
1849				 FILE *input,
1850				 struct parse_events_state *parse_state)
1851{
1852	YY_BUFFER_STATE buffer;
1853	void *scanner;
1854	int ret;
1855
1856	ret = parse_events_lex_init_extra(parse_state, &scanner);
1857	if (ret)
1858		return ret;
1859
1860	if (str)
1861		buffer = parse_events__scan_string(str, scanner);
1862	else
1863	        parse_events_set_in(input, scanner);
1864
1865#ifdef PARSER_DEBUG
1866	parse_events_debug = 1;
1867	parse_events_set_debug(1, scanner);
1868#endif
1869	ret = parse_events_parse(parse_state, scanner);
1870
1871	if (str) {
1872		parse_events__flush_buffer(buffer, scanner);
1873		parse_events__delete_buffer(buffer, scanner);
1874	}
1875	parse_events_lex_destroy(scanner);
1876	return ret;
1877}
1878
1879/*
1880 * parse event config string, return a list of event terms.
1881 */
1882int parse_events_terms(struct parse_events_terms *terms, const char *str, FILE *input)
1883{
1884	struct parse_events_state parse_state = {
1885		.terms  = NULL,
1886		.stoken = PE_START_TERMS,
1887	};
1888	int ret;
1889
1890	ret = parse_events__scanner(str, input, &parse_state);
1891	if (!ret)
1892		list_splice(&parse_state.terms->terms, &terms->terms);
1893
1894	zfree(&parse_state.terms);
1895	return ret;
1896}
1897
1898static int evsel__compute_group_pmu_name(struct evsel *evsel,
1899					  const struct list_head *head)
1900{
1901	struct evsel *leader = evsel__leader(evsel);
1902	struct evsel *pos;
1903	const char *group_pmu_name;
1904	struct perf_pmu *pmu = evsel__find_pmu(evsel);
1905
1906	if (!pmu) {
1907		/*
1908		 * For PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE types the PMU
1909		 * is a core PMU, but in heterogeneous systems this is
1910		 * unknown. For now pick the first core PMU.
1911		 */
1912		pmu = perf_pmus__scan_core(NULL);
1913	}
1914	if (!pmu) {
1915		pr_debug("No PMU found for '%s'\n", evsel__name(evsel));
1916		return -EINVAL;
1917	}
1918	group_pmu_name = pmu->name;
1919	/*
1920	 * Software events may be in a group with other uncore PMU events. Use
1921	 * the pmu_name of the first non-software event to avoid breaking the
1922	 * software event out of the group.
1923	 *
1924	 * Aux event leaders, like intel_pt, expect a group with events from
1925	 * other PMUs, so substitute the AUX event's PMU in this case.
1926	 */
1927	if (perf_pmu__is_software(pmu) || evsel__is_aux_event(leader)) {
1928		struct perf_pmu *leader_pmu = evsel__find_pmu(leader);
1929
1930		if (!leader_pmu) {
1931			/* As with determining pmu above. */
1932			leader_pmu = perf_pmus__scan_core(NULL);
1933		}
1934		/*
1935		 * Starting with the leader, find the first event with a named
1936		 * non-software PMU. for_each_group_(member|evsel) isn't used as
1937		 * the list isn't yet sorted putting evsel's in the same group
1938		 * together.
1939		 */
1940		if (leader_pmu && !perf_pmu__is_software(leader_pmu)) {
1941			group_pmu_name = leader_pmu->name;
1942		} else if (leader->core.nr_members > 1) {
1943			list_for_each_entry(pos, head, core.node) {
1944				struct perf_pmu *pos_pmu;
1945
1946				if (pos == leader || evsel__leader(pos) != leader)
1947					continue;
1948				pos_pmu = evsel__find_pmu(pos);
1949				if (!pos_pmu) {
1950					/* As with determining pmu above. */
1951					pos_pmu = perf_pmus__scan_core(NULL);
1952				}
1953				if (pos_pmu && !perf_pmu__is_software(pos_pmu)) {
1954					group_pmu_name = pos_pmu->name;
1955					break;
1956				}
1957			}
1958		}
1959	}
1960	/* Assign the actual name taking care that the fake PMU lacks a name. */
1961	evsel->group_pmu_name = strdup(group_pmu_name ?: "fake");
1962	return evsel->group_pmu_name ? 0 : -ENOMEM;
1963}
1964
1965__weak int arch_evlist__cmp(const struct evsel *lhs, const struct evsel *rhs)
1966{
1967	/* Order by insertion index. */
1968	return lhs->core.idx - rhs->core.idx;
1969}
1970
1971static int evlist__cmp(void *_fg_idx, const struct list_head *l, const struct list_head *r)
1972{
1973	const struct perf_evsel *lhs_core = container_of(l, struct perf_evsel, node);
1974	const struct evsel *lhs = container_of(lhs_core, struct evsel, core);
1975	const struct perf_evsel *rhs_core = container_of(r, struct perf_evsel, node);
1976	const struct evsel *rhs = container_of(rhs_core, struct evsel, core);
1977	int *force_grouped_idx = _fg_idx;
1978	int lhs_sort_idx, rhs_sort_idx, ret;
1979	const char *lhs_pmu_name, *rhs_pmu_name;
1980	bool lhs_has_group, rhs_has_group;
1981
1982	/*
1983	 * First sort by grouping/leader. Read the leader idx only if the evsel
1984	 * is part of a group, by default ungrouped events will be sorted
1985	 * relative to grouped events based on where the first ungrouped event
1986	 * occurs. If both events don't have a group we want to fall-through to
1987	 * the arch specific sorting, that can reorder and fix things like
1988	 * Intel's topdown events.
1989	 */
1990	if (lhs_core->leader != lhs_core || lhs_core->nr_members > 1) {
1991		lhs_has_group = true;
1992		lhs_sort_idx = lhs_core->leader->idx;
1993	} else {
1994		lhs_has_group = false;
1995		lhs_sort_idx = *force_grouped_idx != -1 && arch_evsel__must_be_in_group(lhs)
1996			? *force_grouped_idx
1997			: lhs_core->idx;
1998	}
1999	if (rhs_core->leader != rhs_core || rhs_core->nr_members > 1) {
2000		rhs_has_group = true;
2001		rhs_sort_idx = rhs_core->leader->idx;
2002	} else {
2003		rhs_has_group = false;
2004		rhs_sort_idx = *force_grouped_idx != -1 && arch_evsel__must_be_in_group(rhs)
2005			? *force_grouped_idx
2006			: rhs_core->idx;
2007	}
2008
2009	if (lhs_sort_idx != rhs_sort_idx)
2010		return lhs_sort_idx - rhs_sort_idx;
2011
2012	/* Group by PMU if there is a group. Groups can't span PMUs. */
2013	if (lhs_has_group && rhs_has_group) {
2014		lhs_pmu_name = lhs->group_pmu_name;
2015		rhs_pmu_name = rhs->group_pmu_name;
2016		ret = strcmp(lhs_pmu_name, rhs_pmu_name);
2017		if (ret)
2018			return ret;
2019	}
2020
2021	/* Architecture specific sorting. */
2022	return arch_evlist__cmp(lhs, rhs);
2023}
2024
2025static int parse_events__sort_events_and_fix_groups(struct list_head *list)
2026{
2027	int idx = 0, force_grouped_idx = -1;
2028	struct evsel *pos, *cur_leader = NULL;
2029	struct perf_evsel *cur_leaders_grp = NULL;
2030	bool idx_changed = false, cur_leader_force_grouped = false;
2031	int orig_num_leaders = 0, num_leaders = 0;
2032	int ret;
2033
2034	/*
2035	 * Compute index to insert ungrouped events at. Place them where the
2036	 * first ungrouped event appears.
2037	 */
2038	list_for_each_entry(pos, list, core.node) {
2039		const struct evsel *pos_leader = evsel__leader(pos);
2040
2041		ret = evsel__compute_group_pmu_name(pos, list);
2042		if (ret)
2043			return ret;
2044
2045		if (pos == pos_leader)
2046			orig_num_leaders++;
2047
2048		/*
2049		 * Ensure indexes are sequential, in particular for multiple
2050		 * event lists being merged. The indexes are used to detect when
2051		 * the user order is modified.
2052		 */
2053		pos->core.idx = idx++;
2054
2055		/* Remember an index to sort all forced grouped events together to. */
2056		if (force_grouped_idx == -1 && pos == pos_leader && pos->core.nr_members < 2 &&
2057		    arch_evsel__must_be_in_group(pos))
2058			force_grouped_idx = pos->core.idx;
2059	}
2060
2061	/* Sort events. */
2062	list_sort(&force_grouped_idx, list, evlist__cmp);
2063
2064	/*
2065	 * Recompute groups, splitting for PMUs and adding groups for events
2066	 * that require them.
2067	 */
2068	idx = 0;
2069	list_for_each_entry(pos, list, core.node) {
2070		const struct evsel *pos_leader = evsel__leader(pos);
2071		const char *pos_pmu_name = pos->group_pmu_name;
2072		const char *cur_leader_pmu_name;
2073		bool pos_force_grouped = force_grouped_idx != -1 &&
2074			arch_evsel__must_be_in_group(pos);
2075
2076		/* Reset index and nr_members. */
2077		if (pos->core.idx != idx)
2078			idx_changed = true;
2079		pos->core.idx = idx++;
2080		pos->core.nr_members = 0;
2081
2082		/*
2083		 * Set the group leader respecting the given groupings and that
2084		 * groups can't span PMUs.
2085		 */
2086		if (!cur_leader)
2087			cur_leader = pos;
2088
2089		cur_leader_pmu_name = cur_leader->group_pmu_name;
2090		if ((cur_leaders_grp != pos->core.leader &&
2091		     (!pos_force_grouped || !cur_leader_force_grouped)) ||
2092		    strcmp(cur_leader_pmu_name, pos_pmu_name)) {
2093			/* Event is for a different group/PMU than last. */
2094			cur_leader = pos;
2095			/*
2096			 * Remember the leader's group before it is overwritten,
2097			 * so that later events match as being in the same
2098			 * group.
2099			 */
2100			cur_leaders_grp = pos->core.leader;
2101			/*
2102			 * Avoid forcing events into groups with events that
2103			 * don't need to be in the group.
2104			 */
2105			cur_leader_force_grouped = pos_force_grouped;
2106		}
2107		if (pos_leader != cur_leader) {
2108			/* The leader changed so update it. */
2109			evsel__set_leader(pos, cur_leader);
2110		}
2111	}
2112	list_for_each_entry(pos, list, core.node) {
2113		struct evsel *pos_leader = evsel__leader(pos);
2114
2115		if (pos == pos_leader)
2116			num_leaders++;
2117		pos_leader->core.nr_members++;
2118	}
2119	return (idx_changed || num_leaders != orig_num_leaders) ? 1 : 0;
2120}
2121
2122int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter,
2123		   struct parse_events_error *err, struct perf_pmu *fake_pmu,
2124		   bool warn_if_reordered)
2125{
2126	struct parse_events_state parse_state = {
2127		.list	  = LIST_HEAD_INIT(parse_state.list),
2128		.idx	  = evlist->core.nr_entries,
2129		.error	  = err,
2130		.stoken	  = PE_START_EVENTS,
2131		.fake_pmu = fake_pmu,
 
2132		.pmu_filter = pmu_filter,
2133		.match_legacy_cache_terms = true,
2134	};
2135	int ret, ret2;
2136
2137	ret = parse_events__scanner(str, /*input=*/ NULL, &parse_state);
2138
2139	if (!ret && list_empty(&parse_state.list)) {
2140		WARN_ONCE(true, "WARNING: event parser found nothing\n");
2141		return -1;
2142	}
2143
2144	ret2 = parse_events__sort_events_and_fix_groups(&parse_state.list);
2145	if (ret2 < 0)
2146		return ret;
2147
2148	if (ret2 && warn_if_reordered && !parse_state.wild_card_pmus)
2149		pr_warning("WARNING: events were regrouped to match PMUs\n");
2150
2151	/*
2152	 * Add list to the evlist even with errors to allow callers to clean up.
2153	 */
2154	evlist__splice_list_tail(evlist, &parse_state.list);
2155
2156	if (!ret) {
2157		struct evsel *last;
2158
2159		last = evlist__last(evlist);
2160		last->cmdline_group_boundary = true;
2161
2162		return 0;
2163	}
2164
2165	/*
2166	 * There are 2 users - builtin-record and builtin-test objects.
2167	 * Both call evlist__delete in case of error, so we dont
2168	 * need to bother.
2169	 */
2170	return ret;
2171}
2172
2173int parse_event(struct evlist *evlist, const char *str)
2174{
2175	struct parse_events_error err;
2176	int ret;
2177
2178	parse_events_error__init(&err);
2179	ret = parse_events(evlist, str, &err);
2180	parse_events_error__exit(&err);
2181	return ret;
2182}
2183
 
 
 
 
 
 
 
 
 
 
 
2184void parse_events_error__init(struct parse_events_error *err)
2185{
2186	bzero(err, sizeof(*err));
2187}
2188
2189void parse_events_error__exit(struct parse_events_error *err)
2190{
2191	zfree(&err->str);
2192	zfree(&err->help);
2193	zfree(&err->first_str);
2194	zfree(&err->first_help);
 
 
 
 
2195}
2196
2197void parse_events_error__handle(struct parse_events_error *err, int idx,
2198				char *str, char *help)
2199{
 
 
2200	if (WARN(!str || !err, "WARNING: failed to provide error string or struct\n"))
2201		goto out_free;
2202	switch (err->num_errors) {
2203	case 0:
2204		err->idx = idx;
2205		err->str = str;
2206		err->help = help;
2207		break;
2208	case 1:
2209		err->first_idx = err->idx;
2210		err->idx = idx;
2211		err->first_str = err->str;
2212		err->str = str;
2213		err->first_help = err->help;
2214		err->help = help;
2215		break;
2216	default:
2217		pr_debug("Multiple errors dropping message: %s (%s)\n",
2218			err->str, err->help ?: "<no help>");
2219		free(err->str);
2220		err->str = str;
2221		free(err->help);
2222		err->help = help;
2223		break;
2224	}
2225	err->num_errors++;
 
 
 
2226	return;
2227
2228out_free:
2229	free(str);
2230	free(help);
2231}
2232
2233#define MAX_WIDTH 1000
2234static int get_term_width(void)
2235{
2236	struct winsize ws;
2237
2238	get_term_dimensions(&ws);
2239	return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
2240}
2241
2242static void __parse_events_error__print(int err_idx, const char *err_str,
2243					const char *err_help, const char *event)
2244{
2245	const char *str = "invalid or unsupported event: ";
2246	char _buf[MAX_WIDTH];
2247	char *buf = (char *) event;
2248	int idx = 0;
2249	if (err_str) {
2250		/* -2 for extra '' in the final fprintf */
2251		int width       = get_term_width() - 2;
2252		int len_event   = strlen(event);
2253		int len_str, max_len, cut = 0;
2254
2255		/*
2256		 * Maximum error index indent, we will cut
2257		 * the event string if it's bigger.
2258		 */
2259		int max_err_idx = 13;
2260
2261		/*
2262		 * Let's be specific with the message when
2263		 * we have the precise error.
2264		 */
2265		str     = "event syntax error: ";
2266		len_str = strlen(str);
2267		max_len = width - len_str;
2268
2269		buf = _buf;
2270
2271		/* We're cutting from the beginning. */
2272		if (err_idx > max_err_idx)
2273			cut = err_idx - max_err_idx;
2274
2275		strncpy(buf, event + cut, max_len);
2276
2277		/* Mark cut parts with '..' on both sides. */
2278		if (cut)
2279			buf[0] = buf[1] = '.';
2280
2281		if ((len_event - cut) > max_len) {
2282			buf[max_len - 1] = buf[max_len - 2] = '.';
2283			buf[max_len] = 0;
2284		}
2285
2286		idx = len_str + err_idx - cut;
2287	}
2288
2289	fprintf(stderr, "%s'%s'\n", str, buf);
2290	if (idx) {
2291		fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err_str);
2292		if (err_help)
2293			fprintf(stderr, "\n%s\n", err_help);
2294	}
2295}
2296
2297void parse_events_error__print(struct parse_events_error *err,
2298			       const char *event)
2299{
2300	if (!err->num_errors)
2301		return;
 
 
 
 
 
 
 
 
2302
2303	__parse_events_error__print(err->idx, err->str, err->help, event);
 
 
 
 
 
 
 
2304
2305	if (err->num_errors > 1) {
2306		fputs("\nInitial error:\n", stderr);
2307		__parse_events_error__print(err->first_idx, err->first_str,
2308					err->first_help, event);
2309	}
 
2310}
2311
2312#undef MAX_WIDTH
2313
2314int parse_events_option(const struct option *opt, const char *str,
2315			int unset __maybe_unused)
2316{
2317	struct parse_events_option_args *args = opt->value;
2318	struct parse_events_error err;
2319	int ret;
2320
2321	parse_events_error__init(&err);
2322	ret = __parse_events(*args->evlistp, str, args->pmu_filter, &err,
2323			     /*fake_pmu=*/NULL, /*warn_if_reordered=*/true);
 
2324
2325	if (ret) {
2326		parse_events_error__print(&err, str);
2327		fprintf(stderr, "Run 'perf list' for a list of valid events\n");
2328	}
2329	parse_events_error__exit(&err);
2330
2331	return ret;
2332}
2333
2334int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset)
2335{
2336	struct parse_events_option_args *args = opt->value;
2337	int ret;
2338
2339	if (*args->evlistp == NULL) {
2340		*args->evlistp = evlist__new();
2341
2342		if (*args->evlistp == NULL) {
2343			fprintf(stderr, "Not enough memory to create evlist\n");
2344			return -1;
2345		}
2346	}
2347	ret = parse_events_option(opt, str, unset);
2348	if (ret) {
2349		evlist__delete(*args->evlistp);
2350		*args->evlistp = NULL;
2351	}
2352
2353	return ret;
2354}
2355
2356static int
2357foreach_evsel_in_last_glob(struct evlist *evlist,
2358			   int (*func)(struct evsel *evsel,
2359				       const void *arg),
2360			   const void *arg)
2361{
2362	struct evsel *last = NULL;
2363	int err;
2364
2365	/*
2366	 * Don't return when list_empty, give func a chance to report
2367	 * error when it found last == NULL.
2368	 *
2369	 * So no need to WARN here, let *func do this.
2370	 */
2371	if (evlist->core.nr_entries > 0)
2372		last = evlist__last(evlist);
2373
2374	do {
2375		err = (*func)(last, arg);
2376		if (err)
2377			return -1;
2378		if (!last)
2379			return 0;
2380
2381		if (last->core.node.prev == &evlist->core.entries)
2382			return 0;
2383		last = list_entry(last->core.node.prev, struct evsel, core.node);
2384	} while (!last->cmdline_group_boundary);
2385
2386	return 0;
2387}
2388
2389static int set_filter(struct evsel *evsel, const void *arg)
2390{
2391	const char *str = arg;
2392	bool found = false;
2393	int nr_addr_filters = 0;
2394	struct perf_pmu *pmu = NULL;
2395
2396	if (evsel == NULL) {
2397		fprintf(stderr,
2398			"--filter option should follow a -e tracepoint or HW tracer option\n");
2399		return -1;
2400	}
2401
2402	if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
2403		if (evsel__append_tp_filter(evsel, str) < 0) {
2404			fprintf(stderr,
2405				"not enough memory to hold filter string\n");
2406			return -1;
2407		}
2408
2409		return 0;
2410	}
2411
2412	while ((pmu = perf_pmus__scan(pmu)) != NULL)
2413		if (pmu->type == evsel->core.attr.type) {
2414			found = true;
2415			break;
2416		}
2417
2418	if (found)
2419		perf_pmu__scan_file(pmu, "nr_addr_filters",
2420				    "%d", &nr_addr_filters);
2421
2422	if (!nr_addr_filters)
2423		return perf_bpf_filter__parse(&evsel->bpf_filters, str);
2424
2425	if (evsel__append_addr_filter(evsel, str) < 0) {
2426		fprintf(stderr,
2427			"not enough memory to hold filter string\n");
2428		return -1;
2429	}
2430
2431	return 0;
2432}
2433
2434int parse_filter(const struct option *opt, const char *str,
2435		 int unset __maybe_unused)
2436{
2437	struct evlist *evlist = *(struct evlist **)opt->value;
2438
2439	return foreach_evsel_in_last_glob(evlist, set_filter,
2440					  (const void *)str);
2441}
2442
2443static int add_exclude_perf_filter(struct evsel *evsel,
2444				   const void *arg __maybe_unused)
2445{
2446	char new_filter[64];
2447
2448	if (evsel == NULL || evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
2449		fprintf(stderr,
2450			"--exclude-perf option should follow a -e tracepoint option\n");
2451		return -1;
2452	}
2453
2454	snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
2455
2456	if (evsel__append_tp_filter(evsel, new_filter) < 0) {
2457		fprintf(stderr,
2458			"not enough memory to hold filter string\n");
2459		return -1;
2460	}
2461
2462	return 0;
2463}
2464
2465int exclude_perf(const struct option *opt,
2466		 const char *arg __maybe_unused,
2467		 int unset __maybe_unused)
2468{
2469	struct evlist *evlist = *(struct evlist **)opt->value;
2470
2471	return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
2472					  NULL);
2473}
2474
2475int parse_events__is_hardcoded_term(struct parse_events_term *term)
2476{
2477	return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
2478}
2479
2480static int new_term(struct parse_events_term **_term,
2481		    struct parse_events_term *temp,
2482		    char *str, u64 num)
2483{
2484	struct parse_events_term *term;
2485
2486	term = malloc(sizeof(*term));
2487	if (!term)
2488		return -ENOMEM;
2489
2490	*term = *temp;
2491	INIT_LIST_HEAD(&term->list);
2492	term->weak = false;
2493
2494	switch (term->type_val) {
2495	case PARSE_EVENTS__TERM_TYPE_NUM:
2496		term->val.num = num;
2497		break;
2498	case PARSE_EVENTS__TERM_TYPE_STR:
2499		term->val.str = str;
2500		break;
2501	default:
2502		free(term);
2503		return -EINVAL;
2504	}
2505
2506	*_term = term;
2507	return 0;
2508}
2509
2510int parse_events_term__num(struct parse_events_term **term,
2511			   enum parse_events__term_type type_term,
2512			   const char *config, u64 num,
2513			   bool no_value,
2514			   void *loc_term_, void *loc_val_)
2515{
2516	YYLTYPE *loc_term = loc_term_;
2517	YYLTYPE *loc_val = loc_val_;
2518
2519	struct parse_events_term temp = {
2520		.type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
2521		.type_term = type_term,
2522		.config    = config ? : strdup(config_term_name(type_term)),
2523		.no_value  = no_value,
2524		.err_term  = loc_term ? loc_term->first_column : 0,
2525		.err_val   = loc_val  ? loc_val->first_column  : 0,
2526	};
2527
2528	return new_term(term, &temp, /*str=*/NULL, num);
2529}
2530
2531int parse_events_term__str(struct parse_events_term **term,
2532			   enum parse_events__term_type type_term,
2533			   char *config, char *str,
2534			   void *loc_term_, void *loc_val_)
2535{
2536	YYLTYPE *loc_term = loc_term_;
2537	YYLTYPE *loc_val = loc_val_;
2538
2539	struct parse_events_term temp = {
2540		.type_val  = PARSE_EVENTS__TERM_TYPE_STR,
2541		.type_term = type_term,
2542		.config    = config,
2543		.err_term  = loc_term ? loc_term->first_column : 0,
2544		.err_val   = loc_val  ? loc_val->first_column  : 0,
2545	};
2546
2547	return new_term(term, &temp, str, /*num=*/0);
2548}
2549
2550int parse_events_term__term(struct parse_events_term **term,
2551			    enum parse_events__term_type term_lhs,
2552			    enum parse_events__term_type term_rhs,
2553			    void *loc_term, void *loc_val)
2554{
2555	return parse_events_term__str(term, term_lhs, NULL,
2556				      strdup(config_term_name(term_rhs)),
2557				      loc_term, loc_val);
2558}
2559
2560int parse_events_term__clone(struct parse_events_term **new,
2561			     struct parse_events_term *term)
2562{
2563	char *str;
2564	struct parse_events_term temp = *term;
2565
2566	temp.used = false;
2567	if (term->config) {
2568		temp.config = strdup(term->config);
2569		if (!temp.config)
2570			return -ENOMEM;
2571	}
2572	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
2573		return new_term(new, &temp, /*str=*/NULL, term->val.num);
2574
2575	str = strdup(term->val.str);
2576	if (!str) {
2577		zfree(&temp.config);
2578		return -ENOMEM;
2579	}
2580	return new_term(new, &temp, str, /*num=*/0);
2581}
2582
2583void parse_events_term__delete(struct parse_events_term *term)
2584{
2585	if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
2586		zfree(&term->val.str);
2587
2588	zfree(&term->config);
2589	free(term);
2590}
2591
2592static int parse_events_terms__copy(const struct parse_events_terms *src,
2593				    struct parse_events_terms *dest)
2594{
2595	struct parse_events_term *term;
2596
2597	list_for_each_entry (term, &src->terms, list) {
2598		struct parse_events_term *n;
2599		int ret;
2600
2601		ret = parse_events_term__clone(&n, term);
2602		if (ret)
2603			return ret;
2604
2605		list_add_tail(&n->list, &dest->terms);
2606	}
2607	return 0;
2608}
2609
2610void parse_events_terms__init(struct parse_events_terms *terms)
2611{
2612	INIT_LIST_HEAD(&terms->terms);
2613}
2614
2615void parse_events_terms__exit(struct parse_events_terms *terms)
2616{
2617	struct parse_events_term *term, *h;
2618
2619	list_for_each_entry_safe(term, h, &terms->terms, list) {
2620		list_del_init(&term->list);
2621		parse_events_term__delete(term);
2622	}
2623}
2624
2625void parse_events_terms__delete(struct parse_events_terms *terms)
2626{
2627	if (!terms)
2628		return;
2629	parse_events_terms__exit(terms);
2630	free(terms);
2631}
2632
2633int parse_events_terms__to_strbuf(const struct parse_events_terms *terms, struct strbuf *sb)
2634{
2635	struct parse_events_term *term;
2636	bool first = true;
2637
2638	if (!terms)
2639		return 0;
2640
2641	list_for_each_entry(term, &terms->terms, list) {
2642		int ret;
2643
2644		if (!first) {
2645			ret = strbuf_addch(sb, ',');
2646			if (ret < 0)
2647				return ret;
2648		}
2649		first = false;
2650
2651		if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
2652			if (term->no_value) {
2653				assert(term->val.num == 1);
2654				ret = strbuf_addf(sb, "%s", term->config);
2655			} else
2656				ret = strbuf_addf(sb, "%s=%#"PRIx64, term->config, term->val.num);
2657		else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
2658			if (term->config) {
2659				ret = strbuf_addf(sb, "%s=", term->config);
2660				if (ret < 0)
2661					return ret;
2662			} else if ((unsigned int)term->type_term < __PARSE_EVENTS__TERM_TYPE_NR) {
2663				ret = strbuf_addf(sb, "%s=", config_term_name(term->type_term));
 
2664				if (ret < 0)
2665					return ret;
2666			}
2667			assert(!term->no_value);
2668			ret = strbuf_addf(sb, "%s", term->val.str);
2669		}
2670		if (ret < 0)
2671			return ret;
2672	}
2673	return 0;
2674}
2675
2676void parse_events_evlist_error(struct parse_events_state *parse_state,
2677			       int idx, const char *str)
2678{
2679	if (!parse_state->error)
2680		return;
2681
2682	parse_events_error__handle(parse_state->error, idx, strdup(str), NULL);
2683}
2684
2685static void config_terms_list(char *buf, size_t buf_sz)
2686{
2687	int i;
2688	bool first = true;
2689
2690	buf[0] = '\0';
2691	for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
2692		const char *name = config_term_name(i);
2693
2694		if (!config_term_avail(i, NULL))
2695			continue;
2696		if (!name)
2697			continue;
2698		if (name[0] == '<')
2699			continue;
2700
2701		if (strlen(buf) + strlen(name) + 2 >= buf_sz)
2702			return;
2703
2704		if (!first)
2705			strcat(buf, ",");
2706		else
2707			first = false;
2708		strcat(buf, name);
2709	}
2710}
2711
2712/*
2713 * Return string contains valid config terms of an event.
2714 * @additional_terms: For terms such as PMU sysfs terms.
2715 */
2716char *parse_events_formats_error_string(char *additional_terms)
2717{
2718	char *str;
2719	/* "no-overwrite" is the longest name */
2720	char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
2721			  (sizeof("no-overwrite") - 1)];
2722
2723	config_terms_list(static_terms, sizeof(static_terms));
2724	/* valid terms */
2725	if (additional_terms) {
2726		if (asprintf(&str, "valid terms: %s,%s",
2727			     additional_terms, static_terms) < 0)
2728			goto fail;
2729	} else {
2730		if (asprintf(&str, "valid terms: %s", static_terms) < 0)
2731			goto fail;
2732	}
2733	return str;
2734
2735fail:
2736	return NULL;
2737}