parse-events.c 60.6 KB
Newer Older
1
#include <linux/hw_breakpoint.h>
2
#include <linux/err.h>
3
#include <dirent.h>
4
#include <errno.h>
5
#include <sys/ioctl.h>
6
#include <sys/param.h>
7
#include "term.h"
8
#include "../perf.h"
9
#include "evlist.h"
10
#include "evsel.h"
11
#include <subcmd/parse-options.h>
12
#include "parse-events.h"
13
#include <subcmd/exec-cmd.h>
14
#include "string2.h"
15
#include "strlist.h"
16
#include "symbol.h"
17
#include "cache.h"
18
#include "header.h"
19
#include "bpf-loader.h"
20
#include "debug.h"
21
#include <api/fs/tracing_path.h>
22
#include "parse-events-bison.h"
23
#define YY_EXTRA_TYPE int
24
#include "parse-events-flex.h"
25
#include "pmu.h"
26
#include "thread_map.h"
27
#include "cpumap.h"
28
#include "probe-file.h"
29
#include "asm/bug.h"
30
#include "util/parse-branch-options.h"
31
#include "metricgroup.h"
32 33

#define MAX_NAME_LEN 100
34

35 36 37
#ifdef PARSER_DEBUG
extern int parse_events_debug;
#endif
38
int parse_events_parse(void *parse_state, void *scanner);
39 40
static int get_config_terms(struct list_head *head_config,
			    struct list_head *head_terms __maybe_unused);
41

42 43 44 45 46 47 48 49 50
static struct perf_pmu_event_symbol *perf_pmu_events_list;
/*
 * The variable indicates the number of supported pmu event symbols.
 * 0 means not initialized and ready to init
 * -1 means failed to init, don't try anymore
 * >0 is the number of supported pmu event symbols
 */
static int perf_pmu_events_list_num;

51
struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
	[PERF_COUNT_HW_CPU_CYCLES] = {
		.symbol = "cpu-cycles",
		.alias  = "cycles",
	},
	[PERF_COUNT_HW_INSTRUCTIONS] = {
		.symbol = "instructions",
		.alias  = "",
	},
	[PERF_COUNT_HW_CACHE_REFERENCES] = {
		.symbol = "cache-references",
		.alias  = "",
	},
	[PERF_COUNT_HW_CACHE_MISSES] = {
		.symbol = "cache-misses",
		.alias  = "",
	},
	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
		.symbol = "branch-instructions",
		.alias  = "branches",
	},
	[PERF_COUNT_HW_BRANCH_MISSES] = {
		.symbol = "branch-misses",
		.alias  = "",
	},
	[PERF_COUNT_HW_BUS_CYCLES] = {
		.symbol = "bus-cycles",
		.alias  = "",
	},
	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
		.symbol = "stalled-cycles-frontend",
		.alias  = "idle-cycles-frontend",
	},
	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
		.symbol = "stalled-cycles-backend",
		.alias  = "idle-cycles-backend",
	},
	[PERF_COUNT_HW_REF_CPU_CYCLES] = {
		.symbol = "ref-cycles",
		.alias  = "",
	},
};

94
struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
	[PERF_COUNT_SW_CPU_CLOCK] = {
		.symbol = "cpu-clock",
		.alias  = "",
	},
	[PERF_COUNT_SW_TASK_CLOCK] = {
		.symbol = "task-clock",
		.alias  = "",
	},
	[PERF_COUNT_SW_PAGE_FAULTS] = {
		.symbol = "page-faults",
		.alias  = "faults",
	},
	[PERF_COUNT_SW_CONTEXT_SWITCHES] = {
		.symbol = "context-switches",
		.alias  = "cs",
	},
	[PERF_COUNT_SW_CPU_MIGRATIONS] = {
		.symbol = "cpu-migrations",
		.alias  = "migrations",
	},
	[PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
		.symbol = "minor-faults",
		.alias  = "",
	},
	[PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
		.symbol = "major-faults",
		.alias  = "",
	},
	[PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
		.symbol = "alignment-faults",
		.alias  = "",
	},
	[PERF_COUNT_SW_EMULATION_FAULTS] = {
		.symbol = "emulation-faults",
		.alias  = "",
	},
131 132 133 134
	[PERF_COUNT_SW_DUMMY] = {
		.symbol = "dummy",
		.alias  = "",
	},
135 136 137 138
	[PERF_COUNT_SW_BPF_OUTPUT] = {
		.symbol = "bpf-output",
		.alias  = "",
	},
139 140
};

141 142
#define __PERF_EVENT_FIELD(config, name) \
	((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
143

144
#define PERF_EVENT_RAW(config)		__PERF_EVENT_FIELD(config, RAW)
145
#define PERF_EVENT_CONFIG(config)	__PERF_EVENT_FIELD(config, CONFIG)
146
#define PERF_EVENT_TYPE(config)		__PERF_EVENT_FIELD(config, TYPE)
147
#define PERF_EVENT_ID(config)		__PERF_EVENT_FIELD(config, EVENT)
148

149 150 151 152 153
#define for_each_subsystem(sys_dir, sys_dirent)			\
	while ((sys_dirent = readdir(sys_dir)) != NULL)		\
		if (sys_dirent->d_type == DT_DIR &&		\
		    (strcmp(sys_dirent->d_name, ".")) &&	\
		    (strcmp(sys_dirent->d_name, "..")))
154

155 156 157 158 159
static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
{
	char evt_path[MAXPATHLEN];
	int fd;

160
	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
161 162 163 164 165 166 167 168 169
			sys_dir->d_name, evt_dir->d_name);
	fd = open(evt_path, O_RDONLY);
	if (fd < 0)
		return -EINVAL;
	close(fd);

	return 0;
}

170 171 172 173 174 175
#define for_each_event(sys_dirent, evt_dir, evt_dirent)		\
	while ((evt_dirent = readdir(evt_dir)) != NULL)		\
		if (evt_dirent->d_type == DT_DIR &&		\
		    (strcmp(evt_dirent->d_name, ".")) &&	\
		    (strcmp(evt_dirent->d_name, "..")) &&	\
		    (!tp_event_has_id(sys_dirent, evt_dirent)))
176

L
Li Zefan 已提交
177
#define MAX_EVENT_LENGTH 512
178 179


180
struct tracepoint_path *tracepoint_id_to_path(u64 config)
181
{
182
	struct tracepoint_path *path = NULL;
183
	DIR *sys_dir, *evt_dir;
184
	struct dirent *sys_dirent, *evt_dirent;
185
	char id_buf[24];
E
Eric Dumazet 已提交
186
	int fd;
187 188
	u64 id;
	char evt_path[MAXPATHLEN];
E
Eric Dumazet 已提交
189
	char dir_path[MAXPATHLEN];
190

191
	sys_dir = opendir(tracing_events_path);
192
	if (!sys_dir)
E
Eric Dumazet 已提交
193
		return NULL;
194

195
	for_each_subsystem(sys_dir, sys_dirent) {
E
Eric Dumazet 已提交
196

197
		snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
198
			 sys_dirent->d_name);
E
Eric Dumazet 已提交
199 200
		evt_dir = opendir(dir_path);
		if (!evt_dir)
201
			continue;
E
Eric Dumazet 已提交
202

203
		for_each_event(sys_dirent, evt_dir, evt_dirent) {
E
Eric Dumazet 已提交
204 205

			snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
206
				 evt_dirent->d_name);
E
Eric Dumazet 已提交
207
			fd = open(evt_path, O_RDONLY);
208 209 210 211 212 213 214 215 216 217 218
			if (fd < 0)
				continue;
			if (read(fd, id_buf, sizeof(id_buf)) < 0) {
				close(fd);
				continue;
			}
			close(fd);
			id = atoll(id_buf);
			if (id == config) {
				closedir(evt_dir);
				closedir(sys_dir);
219
				path = zalloc(sizeof(*path));
220 221
				if (!path)
					return NULL;
222 223 224 225 226 227 228
				path->system = malloc(MAX_EVENT_LENGTH);
				if (!path->system) {
					free(path);
					return NULL;
				}
				path->name = malloc(MAX_EVENT_LENGTH);
				if (!path->name) {
229
					zfree(&path->system);
230 231 232
					free(path);
					return NULL;
				}
233
				strncpy(path->system, sys_dirent->d_name,
234
					MAX_EVENT_LENGTH);
235
				strncpy(path->name, evt_dirent->d_name,
236 237
					MAX_EVENT_LENGTH);
				return path;
238 239 240 241 242 243
			}
		}
		closedir(evt_dir);
	}

	closedir(sys_dir);
244 245 246
	return NULL;
}

247 248 249 250 251 252 253 254 255 256 257 258 259 260
struct tracepoint_path *tracepoint_name_to_path(const char *name)
{
	struct tracepoint_path *path = zalloc(sizeof(*path));
	char *str = strchr(name, ':');

	if (path == NULL || str == NULL) {
		free(path);
		return NULL;
	}

	path->system = strndup(name, str - name);
	path->name = strdup(str+1);

	if (path->system == NULL || path->name == NULL) {
261 262
		zfree(&path->system);
		zfree(&path->name);
263
		zfree(&path);
264 265 266 267 268
	}

	return path;
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
const char *event_type(int type)
{
	switch (type) {
	case PERF_TYPE_HARDWARE:
		return "hardware";

	case PERF_TYPE_SOFTWARE:
		return "software";

	case PERF_TYPE_TRACEPOINT:
		return "tracepoint";

	case PERF_TYPE_HW_CACHE:
		return "hardware-cache";

	default:
		break;
	}

	return "unknown";
}

291 292 293 294
static int parse_events__is_name_term(struct parse_events_term *term)
{
	return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
}
Y
Yan, Zheng 已提交
295

296 297 298 299 300 301 302 303 304 305 306 307 308
static char *get_config_name(struct list_head *head_terms)
{
	struct parse_events_term *term;

	if (!head_terms)
		return NULL;

	list_for_each_entry(term, head_terms, list)
		if (parse_events__is_name_term(term))
			return term->val.str;

	return NULL;
}
Y
Yan, Zheng 已提交
309

310 311 312
static struct perf_evsel *
__add_event(struct list_head *list, int *idx,
	    struct perf_event_attr *attr,
313
	    char *name, struct cpu_map *cpus,
314
	    struct list_head *config_terms, bool auto_merge_stats)
315 316 317 318 319
{
	struct perf_evsel *evsel;

	event_attr_init(attr);

320
	evsel = perf_evsel__new_idx(attr, *idx);
321
	if (!evsel)
322
		return NULL;
323

324
	(*idx)++;
325 326 327
	evsel->cpus        = cpu_map__get(cpus);
	evsel->own_cpus    = cpu_map__get(cpus);
	evsel->system_wide = !!cpus;
328
	evsel->auto_merge_stats = auto_merge_stats;
329

330 331
	if (name)
		evsel->name = strdup(name);
332 333 334 335

	if (config_terms)
		list_splice(config_terms, &evsel->config_terms);

336
	list_add_tail(&evsel->node, list);
337
	return evsel;
338 339
}

340
static int add_event(struct list_head *list, int *idx,
341 342
		     struct perf_event_attr *attr, char *name,
		     struct list_head *config_terms)
Y
Yan, Zheng 已提交
343
{
344
	return __add_event(list, idx, attr, name, NULL, config_terms, false) ? 0 : -ENOMEM;
Y
Yan, Zheng 已提交
345 346
}

347
static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
348 349
{
	int i, j;
350
	int n, longest = -1;
351 352

	for (i = 0; i < size; i++) {
353
		for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
354
			n = strlen(names[i][j]);
355
			if (n > longest && !strncasecmp(str, names[i][j], n))
356 357
				longest = n;
		}
358
		if (longest > 0)
359
			return i;
360 361
	}

362
	return -1;
363 364
}

365 366 367 368 369 370 371 372 373 374 375
typedef int config_term_func_t(struct perf_event_attr *attr,
			       struct parse_events_term *term,
			       struct parse_events_error *err);
static int config_term_common(struct perf_event_attr *attr,
			      struct parse_events_term *term,
			      struct parse_events_error *err);
static int config_attr(struct perf_event_attr *attr,
		       struct list_head *head,
		       struct parse_events_error *err,
		       config_term_func_t config_term);

376
int parse_events_add_cache(struct list_head *list, int *idx,
377
			   char *type, char *op_result1, char *op_result2,
378
			   struct parse_events_error *err,
379
			   struct list_head *head_config)
380
{
381
	struct perf_event_attr attr;
382 383
	LIST_HEAD(config_terms);
	char name[MAX_NAME_LEN], *config_name;
384
	int cache_type = -1, cache_op = -1, cache_result = -1;
385 386
	char *op_result[2] = { op_result1, op_result2 };
	int i, n;
387 388 389 390 391

	/*
	 * No fallback - if we cannot get a clear cache type
	 * then bail out:
	 */
392
	cache_type = parse_aliases(type, perf_evsel__hw_cache,
393
				   PERF_COUNT_HW_CACHE_MAX);
394
	if (cache_type == -1)
395 396
		return -EINVAL;

397
	config_name = get_config_name(head_config);
398
	n = snprintf(name, MAX_NAME_LEN, "%s", type);
399

400 401 402
	for (i = 0; (i < 2) && (op_result[i]); i++) {
		char *str = op_result[i];

403
		n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
404 405

		if (cache_op == -1) {
406
			cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
407
						 PERF_COUNT_HW_CACHE_OP_MAX);
408
			if (cache_op >= 0) {
409
				if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
410
					return -EINVAL;
411 412 413 414 415
				continue;
			}
		}

		if (cache_result == -1) {
416 417
			cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
						     PERF_COUNT_HW_CACHE_RESULT_MAX);
418 419 420 421
			if (cache_result >= 0)
				continue;
		}
	}
422 423 424 425

	/*
	 * Fall back to reads:
	 */
426 427
	if (cache_op == -1)
		cache_op = PERF_COUNT_HW_CACHE_OP_READ;
428 429 430 431 432 433 434

	/*
	 * Fall back to accesses:
	 */
	if (cache_result == -1)
		cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;

435 436 437
	memset(&attr, 0, sizeof(attr));
	attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
	attr.type = PERF_TYPE_HW_CACHE;
438 439

	if (head_config) {
440
		if (config_attr(&attr, head_config, err,
441 442 443 444 445 446 447
				config_term_common))
			return -EINVAL;

		if (get_config_terms(head_config, &config_terms))
			return -ENOMEM;
	}
	return add_event(list, idx, &attr, config_name ? : name, &config_terms);
448 449
}

450
static void tracepoint_error(struct parse_events_error *e, int err,
451
			     const char *sys, const char *name)
452 453 454
{
	char help[BUFSIZ];

455 456 457
	if (!e)
		return;

458 459 460 461 462 463 464 465
	/*
	 * We get error directly from syscall errno ( > 0),
	 * or from encoded pointer's error ( < 0).
	 */
	err = abs(err);

	switch (err) {
	case EACCES:
466
		e->str = strdup("can't access trace events");
467 468
		break;
	case ENOENT:
469
		e->str = strdup("unknown tracepoint");
470 471
		break;
	default:
472
		e->str = strdup("failed to add tracepoint");
473 474 475 476
		break;
	}

	tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
477
	e->help = strdup(help);
478 479
}

480
static int add_tracepoint(struct list_head *list, int *idx,
481
			  const char *sys_name, const char *evt_name,
482
			  struct parse_events_error *err,
483
			  struct list_head *head_config)
484
{
485
	struct perf_evsel *evsel;
486

487
	evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++);
488
	if (IS_ERR(evsel)) {
489
		tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name);
490
		return PTR_ERR(evsel);
491
	}
492

493 494 495 496 497 498 499 500
	if (head_config) {
		LIST_HEAD(config_terms);

		if (get_config_terms(head_config, &config_terms))
			return -ENOMEM;
		list_splice(&config_terms, &evsel->config_terms);
	}

501 502
	list_add_tail(&evsel->node, list);
	return 0;
503 504
}

505
static int add_tracepoint_multi_event(struct list_head *list, int *idx,
506
				      const char *sys_name, const char *evt_name,
507
				      struct parse_events_error *err,
508
				      struct list_head *head_config)
509 510 511 512
{
	char evt_path[MAXPATHLEN];
	struct dirent *evt_ent;
	DIR *evt_dir;
513
	int ret = 0, found = 0;
514

515
	snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
516 517
	evt_dir = opendir(evt_path);
	if (!evt_dir) {
518
		tracepoint_error(err, errno, sys_name, evt_name);
519
		return -1;
520 521
	}

522
	while (!ret && (evt_ent = readdir(evt_dir))) {
523 524 525 526 527 528
		if (!strcmp(evt_ent->d_name, ".")
		    || !strcmp(evt_ent->d_name, "..")
		    || !strcmp(evt_ent->d_name, "enable")
		    || !strcmp(evt_ent->d_name, "filter"))
			continue;

529
		if (!strglobmatch(evt_ent->d_name, evt_name))
530 531
			continue;

532 533
		found++;

534
		ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name,
535
				     err, head_config);
536 537
	}

538 539 540 541 542
	if (!found) {
		tracepoint_error(err, ENOENT, sys_name, evt_name);
		ret = -1;
	}

543
	closedir(evt_dir);
544
	return ret;
545 546
}

547
static int add_tracepoint_event(struct list_head *list, int *idx,
548
				const char *sys_name, const char *evt_name,
549
				struct parse_events_error *err,
550
				struct list_head *head_config)
551 552
{
	return strpbrk(evt_name, "*?") ?
553
	       add_tracepoint_multi_event(list, idx, sys_name, evt_name,
554
					  err, head_config) :
555
	       add_tracepoint(list, idx, sys_name, evt_name,
556
			      err, head_config);
557 558
}

559
static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
560
				    const char *sys_name, const char *evt_name,
561
				    struct parse_events_error *err,
562
				    struct list_head *head_config)
563 564 565 566 567 568 569
{
	struct dirent *events_ent;
	DIR *events_dir;
	int ret = 0;

	events_dir = opendir(tracing_events_path);
	if (!events_dir) {
570
		tracepoint_error(err, errno, sys_name, evt_name);
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
		return -1;
	}

	while (!ret && (events_ent = readdir(events_dir))) {
		if (!strcmp(events_ent->d_name, ".")
		    || !strcmp(events_ent->d_name, "..")
		    || !strcmp(events_ent->d_name, "enable")
		    || !strcmp(events_ent->d_name, "header_event")
		    || !strcmp(events_ent->d_name, "header_page"))
			continue;

		if (!strglobmatch(events_ent->d_name, sys_name))
			continue;

		ret = add_tracepoint_event(list, idx, events_ent->d_name,
586
					   evt_name, err, head_config);
587 588 589 590 591 592
	}

	closedir(events_dir);
	return ret;
}

593
struct __add_bpf_event_param {
594
	struct parse_events_state *parse_state;
595
	struct list_head *list;
596
	struct list_head *head_config;
597 598
};

599
static int add_bpf_event(const char *group, const char *event, int fd,
600 601 602 603
			 void *_param)
{
	LIST_HEAD(new_evsels);
	struct __add_bpf_event_param *param = _param;
604
	struct parse_events_state *parse_state = param->parse_state;
605
	struct list_head *list = param->list;
606
	struct perf_evsel *pos;
607 608 609
	int err;

	pr_debug("add bpf event %s:%s and attach bpf program %d\n",
610
		 group, event, fd);
611

612 613
	err = parse_events_add_tracepoint(&new_evsels, &parse_state->idx, group,
					  event, parse_state->error,
614
					  param->head_config);
615 616 617 618
	if (err) {
		struct perf_evsel *evsel, *tmp;

		pr_debug("Failed to add BPF event %s:%s\n",
619
			 group, event);
620 621 622 623 624 625
		list_for_each_entry_safe(evsel, tmp, &new_evsels, node) {
			list_del(&evsel->node);
			perf_evsel__delete(evsel);
		}
		return err;
	}
626
	pr_debug("adding %s:%s\n", group, event);
627

628 629
	list_for_each_entry(pos, &new_evsels, node) {
		pr_debug("adding %s:%s to %p\n",
630
			 group, event, pos);
631 632
		pos->bpf_fd = fd;
	}
633 634 635 636
	list_splice(&new_evsels, list);
	return 0;
}

637
int parse_events_load_bpf_obj(struct parse_events_state *parse_state,
638
			      struct list_head *list,
639 640
			      struct bpf_object *obj,
			      struct list_head *head_config)
641 642 643
{
	int err;
	char errbuf[BUFSIZ];
644
	struct __add_bpf_event_param param = {parse_state, list, head_config};
645
	static bool registered_unprobe_atexit = false;
646 647 648 649 650 651 652 653

	if (IS_ERR(obj) || !obj) {
		snprintf(errbuf, sizeof(errbuf),
			 "Internal error: load bpf obj with NULL");
		err = -EINVAL;
		goto errout;
	}

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
	/*
	 * Register atexit handler before calling bpf__probe() so
	 * bpf__probe() don't need to unprobe probe points its already
	 * created when failure.
	 */
	if (!registered_unprobe_atexit) {
		atexit(bpf__clear);
		registered_unprobe_atexit = true;
	}

	err = bpf__probe(obj);
	if (err) {
		bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf));
		goto errout;
	}

670 671 672 673 674 675
	err = bpf__load(obj);
	if (err) {
		bpf__strerror_load(obj, err, errbuf, sizeof(errbuf));
		goto errout;
	}

676
	err = bpf__foreach_event(obj, add_bpf_event, &param);
677 678 679 680 681 682 683
	if (err) {
		snprintf(errbuf, sizeof(errbuf),
			 "Attach events in BPF object failed");
		goto errout;
	}

	return 0;
684
errout:
685 686
	parse_state->error->help = strdup("(add -v to see detail)");
	parse_state->error->str = strdup(errbuf);
687 688 689
	return err;
}

690
static int
691
parse_events_config_bpf(struct parse_events_state *parse_state,
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
			struct bpf_object *obj,
			struct list_head *head_config)
{
	struct parse_events_term *term;
	int error_pos;

	if (!head_config || list_empty(head_config))
		return 0;

	list_for_each_entry(term, head_config, list) {
		char errbuf[BUFSIZ];
		int err;

		if (term->type_term != PARSE_EVENTS__TERM_TYPE_USER) {
			snprintf(errbuf, sizeof(errbuf),
				 "Invalid config term for BPF object");
			errbuf[BUFSIZ - 1] = '\0';

710 711
			parse_state->error->idx = term->err_term;
			parse_state->error->str = strdup(errbuf);
712 713 714
			return -EINVAL;
		}

715
		err = bpf__config_obj(obj, term, parse_state->evlist, &error_pos);
716
		if (err) {
717
			bpf__strerror_config_obj(obj, term, parse_state->evlist,
718 719
						 &error_pos, err, errbuf,
						 sizeof(errbuf));
720
			parse_state->error->help = strdup(
721
"Hint:\tValid config terms:\n"
722 723
"     \tmap:[<arraymap>].value<indices>=[value]\n"
"     \tmap:[<eventmap>].event<indices>=[event]\n"
724
"\n"
725
"     \twhere <indices> is something like [0,3...5] or [all]\n"
726
"     \t(add -v to see detail)");
727
			parse_state->error->str = strdup(errbuf);
728
			if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE)
729
				parse_state->error->idx = term->err_val;
730
			else
731
				parse_state->error->idx = term->err_term + error_pos;
732 733 734 735 736 737
			return err;
		}
	}
	return 0;
}

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
/*
 * Split config terms:
 * perf record -e bpf.c/call-graph=fp,map:array.value[0]=1/ ...
 *  'call-graph=fp' is 'evt config', should be applied to each
 *  events in bpf.c.
 * 'map:array.value[0]=1' is 'obj config', should be processed
 * with parse_events_config_bpf.
 *
 * Move object config terms from the first list to obj_head_config.
 */
static void
split_bpf_config_terms(struct list_head *evt_head_config,
		       struct list_head *obj_head_config)
{
	struct parse_events_term *term, *temp;

	/*
	 * Currectly, all possible user config term
	 * belong to bpf object. parse_events__is_hardcoded_term()
	 * happends to be a good flag.
	 *
	 * See parse_events_config_bpf() and
	 * config_term_tracepoint().
	 */
	list_for_each_entry_safe(term, temp, evt_head_config, list)
		if (!parse_events__is_hardcoded_term(term))
			list_move_tail(&term->list, obj_head_config);
}

767
int parse_events_load_bpf(struct parse_events_state *parse_state,
768
			  struct list_head *list,
769
			  char *bpf_file_name,
770 771
			  bool source,
			  struct list_head *head_config)
772
{
773
	int err;
774 775 776 777 778
	struct bpf_object *obj;
	LIST_HEAD(obj_head_config);

	if (head_config)
		split_bpf_config_terms(head_config, &obj_head_config);
779

780
	obj = bpf__prepare_load(bpf_file_name, source);
781
	if (IS_ERR(obj)) {
782 783
		char errbuf[BUFSIZ];

784
		err = PTR_ERR(obj);
785 786 787 788 789

		if (err == -ENOTSUP)
			snprintf(errbuf, sizeof(errbuf),
				 "BPF support is not compiled");
		else
790 791 792 793
			bpf__strerror_prepare_load(bpf_file_name,
						   source,
						   -err, errbuf,
						   sizeof(errbuf));
794

795 796
		parse_state->error->help = strdup("(add -v to see detail)");
		parse_state->error->str = strdup(errbuf);
797 798 799
		return err;
	}

800
	err = parse_events_load_bpf_obj(parse_state, list, obj, head_config);
801 802
	if (err)
		return err;
803
	err = parse_events_config_bpf(parse_state, obj, &obj_head_config);
804 805 806 807 808 809 810 811

	/*
	 * Caller doesn't know anything about obj_head_config,
	 * so combine them together again before returnning.
	 */
	if (head_config)
		list_splice_tail(&obj_head_config, head_config);
	return err;
812 813
}

814 815
static int
parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
816 817 818 819
{
	int i;

	for (i = 0; i < 3; i++) {
820
		if (!type || !type[i])
821 822
			break;

823 824 825 826 827 828 829 830
#define CHECK_SET_TYPE(bit)		\
do {					\
	if (attr->bp_type & bit)	\
		return -EINVAL;		\
	else				\
		attr->bp_type |= bit;	\
} while (0)

831 832
		switch (type[i]) {
		case 'r':
833
			CHECK_SET_TYPE(HW_BREAKPOINT_R);
834 835
			break;
		case 'w':
836
			CHECK_SET_TYPE(HW_BREAKPOINT_W);
837 838
			break;
		case 'x':
839
			CHECK_SET_TYPE(HW_BREAKPOINT_X);
840 841
			break;
		default:
842
			return -EINVAL;
843 844
		}
	}
845

846 847
#undef CHECK_SET_TYPE

848 849 850
	if (!attr->bp_type) /* Default */
		attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;

851
	return 0;
852 853
}

854
int parse_events_add_breakpoint(struct list_head *list, int *idx,
855
				void *ptr, char *type, u64 len)
856
{
857
	struct perf_event_attr attr;
858

859
	memset(&attr, 0, sizeof(attr));
860
	attr.bp_addr = (unsigned long) ptr;
861

862 863
	if (parse_breakpoint_type(type, &attr))
		return -EINVAL;
864

865 866 867 868 869 870 871 872 873
	/* Provide some defaults if len is not specified */
	if (!len) {
		if (attr.bp_type == HW_BREAKPOINT_X)
			len = sizeof(long);
		else
			len = HW_BREAKPOINT_LEN_4;
	}

	attr.bp_len = len;
874

875
	attr.type = PERF_TYPE_BREAKPOINT;
876
	attr.sample_period = 1;
877

878
	return add_event(list, idx, &attr, NULL, NULL);
879 880
}

881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
static int check_type_val(struct parse_events_term *term,
			  struct parse_events_error *err,
			  int type)
{
	if (type == term->type_val)
		return 0;

	if (err) {
		err->idx = term->err_val;
		if (type == PARSE_EVENTS__TERM_TYPE_NUM)
			err->str = strdup("expected numeric value");
		else
			err->str = strdup("expected string value");
	}
	return -EINVAL;
}

898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
/*
 * Update according to parse-events.l
 */
static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
	[PARSE_EVENTS__TERM_TYPE_USER]			= "<sysfs term>",
	[PARSE_EVENTS__TERM_TYPE_CONFIG]		= "config",
	[PARSE_EVENTS__TERM_TYPE_CONFIG1]		= "config1",
	[PARSE_EVENTS__TERM_TYPE_CONFIG2]		= "config2",
	[PARSE_EVENTS__TERM_TYPE_NAME]			= "name",
	[PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD]		= "period",
	[PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ]		= "freq",
	[PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE]	= "branch_type",
	[PARSE_EVENTS__TERM_TYPE_TIME]			= "time",
	[PARSE_EVENTS__TERM_TYPE_CALLGRAPH]		= "call-graph",
	[PARSE_EVENTS__TERM_TYPE_STACKSIZE]		= "stack-size",
	[PARSE_EVENTS__TERM_TYPE_NOINHERIT]		= "no-inherit",
	[PARSE_EVENTS__TERM_TYPE_INHERIT]		= "inherit",
915
	[PARSE_EVENTS__TERM_TYPE_MAX_STACK]		= "max-stack",
W
Wang Nan 已提交
916 917
	[PARSE_EVENTS__TERM_TYPE_OVERWRITE]		= "overwrite",
	[PARSE_EVENTS__TERM_TYPE_NOOVERWRITE]		= "no-overwrite",
918
	[PARSE_EVENTS__TERM_TYPE_DRV_CFG]		= "driver-config",
919 920
};

921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
static bool config_term_shrinked;

static bool
config_term_avail(int term_type, struct parse_events_error *err)
{
	if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
		err->str = strdup("Invalid term_type");
		return false;
	}
	if (!config_term_shrinked)
		return true;

	switch (term_type) {
	case PARSE_EVENTS__TERM_TYPE_CONFIG:
	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
	case PARSE_EVENTS__TERM_TYPE_NAME:
938
	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
		return true;
	default:
		if (!err)
			return false;

		/* term_type is validated so indexing is safe */
		if (asprintf(&err->str, "'%s' is not usable in 'perf stat'",
			     config_term_names[term_type]) < 0)
			err->str = NULL;
		return false;
	}
}

void parse_events__shrink_config_terms(void)
{
	config_term_shrinked = true;
}

957 958 959
static int config_term_common(struct perf_event_attr *attr,
			      struct parse_events_term *term,
			      struct parse_events_error *err)
960
{
961 962 963 964
#define CHECK_TYPE_VAL(type)						   \
do {									   \
	if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \
		return -EINVAL;						   \
965 966 967
} while (0)

	switch (term->type_term) {
968
	case PARSE_EVENTS__TERM_TYPE_CONFIG:
969
		CHECK_TYPE_VAL(NUM);
970 971 972
		attr->config = term->val.num;
		break;
	case PARSE_EVENTS__TERM_TYPE_CONFIG1:
973
		CHECK_TYPE_VAL(NUM);
974 975 976
		attr->config1 = term->val.num;
		break;
	case PARSE_EVENTS__TERM_TYPE_CONFIG2:
977
		CHECK_TYPE_VAL(NUM);
978 979 980
		attr->config2 = term->val.num;
		break;
	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
981
		CHECK_TYPE_VAL(NUM);
982
		break;
983 984 985
	case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
		CHECK_TYPE_VAL(NUM);
		break;
986
	case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
987 988 989 990 991 992 993
		CHECK_TYPE_VAL(STR);
		if (strcmp(term->val.str, "no") &&
		    parse_branch_str(term->val.str, &attr->branch_sample_type)) {
			err->str = strdup("invalid branch sample type");
			err->idx = term->err_val;
			return -EINVAL;
		}
994
		break;
K
Kan Liang 已提交
995 996 997 998 999 1000 1001 1002
	case PARSE_EVENTS__TERM_TYPE_TIME:
		CHECK_TYPE_VAL(NUM);
		if (term->val.num > 1) {
			err->str = strdup("expected 0 or 1");
			err->idx = term->err_val;
			return -EINVAL;
		}
		break;
1003 1004 1005 1006 1007 1008
	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
		CHECK_TYPE_VAL(STR);
		break;
	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
		CHECK_TYPE_VAL(NUM);
		break;
1009 1010 1011 1012 1013 1014
	case PARSE_EVENTS__TERM_TYPE_INHERIT:
		CHECK_TYPE_VAL(NUM);
		break;
	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
		CHECK_TYPE_VAL(NUM);
		break;
W
Wang Nan 已提交
1015 1016 1017 1018 1019 1020
	case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
		CHECK_TYPE_VAL(NUM);
		break;
	case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
		CHECK_TYPE_VAL(NUM);
		break;
1021 1022 1023
	case PARSE_EVENTS__TERM_TYPE_NAME:
		CHECK_TYPE_VAL(STR);
		break;
1024 1025 1026
	case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
		CHECK_TYPE_VAL(NUM);
		break;
1027
	default:
1028 1029 1030
		err->str = strdup("unknown term");
		err->idx = term->err_term;
		err->help = parse_events_formats_error_string(NULL);
1031 1032
		return -EINVAL;
	}
1033

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
	/*
	 * Check term availbility after basic checking so
	 * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered.
	 *
	 * If check availbility at the entry of this function,
	 * user will see "'<sysfs term>' is not usable in 'perf stat'"
	 * if an invalid config term is provided for legacy events
	 * (for example, instructions/badterm/...), which is confusing.
	 */
	if (!config_term_avail(term->type_term, err))
		return -EINVAL;
1045
	return 0;
1046
#undef CHECK_TYPE_VAL
1047 1048
}

1049 1050 1051 1052
static int config_term_pmu(struct perf_event_attr *attr,
			   struct parse_events_term *term,
			   struct parse_events_error *err)
{
1053 1054
	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
	    term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG)
1055 1056 1057 1058 1059 1060 1061 1062 1063
		/*
		 * Always succeed for sysfs terms, as we dont know
		 * at this point what type they need to have.
		 */
		return 0;
	else
		return config_term_common(attr, term, err);
}

1064 1065 1066 1067 1068 1069 1070
static int config_term_tracepoint(struct perf_event_attr *attr,
				  struct parse_events_term *term,
				  struct parse_events_error *err)
{
	switch (term->type_term) {
	case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
	case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1071 1072
	case PARSE_EVENTS__TERM_TYPE_INHERIT:
	case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1073
	case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
W
Wang Nan 已提交
1074 1075
	case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
	case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
		return config_term_common(attr, term, err);
	default:
		if (err) {
			err->idx = term->err_term;
			err->str = strdup("unknown term");
			err->help = strdup("valid terms: call-graph,stack-size\n");
		}
		return -EINVAL;
	}

	return 0;
}

1089
static int config_attr(struct perf_event_attr *attr,
1090
		       struct list_head *head,
1091 1092
		       struct parse_events_error *err,
		       config_term_func_t config_term)
1093
{
1094
	struct parse_events_term *term;
1095 1096

	list_for_each_entry(term, head, list)
1097
		if (config_term(attr, term, err))
1098 1099 1100 1101 1102
			return -EINVAL;

	return 0;
}

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
static int get_config_terms(struct list_head *head_config,
			    struct list_head *head_terms __maybe_unused)
{
#define ADD_CONFIG_TERM(__type, __name, __val)			\
do {								\
	struct perf_evsel_config_term *__t;			\
								\
	__t = zalloc(sizeof(*__t));				\
	if (!__t)						\
		return -ENOMEM;					\
								\
	INIT_LIST_HEAD(&__t->list);				\
	__t->type       = PERF_EVSEL__CONFIG_TERM_ ## __type;	\
	__t->val.__name = __val;				\
	list_add_tail(&__t->list, head_terms);			\
} while (0)

	struct parse_events_term *term;

	list_for_each_entry(term, head_config, list) {
		switch (term->type_term) {
1124 1125
		case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
			ADD_CONFIG_TERM(PERIOD, period, term->val.num);
K
Kan Liang 已提交
1126
			break;
1127 1128 1129
		case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
			ADD_CONFIG_TERM(FREQ, freq, term->val.num);
			break;
K
Kan Liang 已提交
1130 1131 1132
		case PARSE_EVENTS__TERM_TYPE_TIME:
			ADD_CONFIG_TERM(TIME, time, term->val.num);
			break;
1133 1134 1135
		case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
			ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str);
			break;
1136 1137 1138
		case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
			ADD_CONFIG_TERM(BRANCH, branch, term->val.str);
			break;
1139 1140 1141
		case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
			ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num);
			break;
1142 1143 1144 1145 1146 1147
		case PARSE_EVENTS__TERM_TYPE_INHERIT:
			ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 1 : 0);
			break;
		case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
			ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 0 : 1);
			break;
1148 1149 1150
		case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
			ADD_CONFIG_TERM(MAX_STACK, max_stack, term->val.num);
			break;
W
Wang Nan 已提交
1151 1152 1153 1154 1155 1156
		case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
			ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 1 : 0);
			break;
		case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
			ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 0 : 1);
			break;
1157 1158 1159
		case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
			ADD_CONFIG_TERM(DRV_CFG, drv_cfg, term->val.str);
			break;
1160 1161 1162 1163 1164 1165 1166 1167
		default:
			break;
		}
	}
#undef ADD_EVSEL_CONFIG
	return 0;
}

1168
int parse_events_add_tracepoint(struct list_head *list, int *idx,
1169
				const char *sys, const char *event,
1170
				struct parse_events_error *err,
1171 1172 1173 1174 1175
				struct list_head *head_config)
{
	if (head_config) {
		struct perf_event_attr attr;

1176
		if (config_attr(&attr, head_config, err,
1177 1178 1179 1180 1181 1182
				config_term_tracepoint))
			return -EINVAL;
	}

	if (strpbrk(sys, "*?"))
		return add_tracepoint_multi_sys(list, idx, sys, event,
1183
						err, head_config);
1184 1185
	else
		return add_tracepoint_event(list, idx, sys, event,
1186
					    err, head_config);
1187 1188
}

1189
int parse_events_add_numeric(struct parse_events_state *parse_state,
1190
			     struct list_head *list,
1191
			     u32 type, u64 config,
1192
			     struct list_head *head_config)
1193
{
1194
	struct perf_event_attr attr;
1195
	LIST_HEAD(config_terms);
1196

1197 1198 1199
	memset(&attr, 0, sizeof(attr));
	attr.type = type;
	attr.config = config;
1200

1201
	if (head_config) {
1202
		if (config_attr(&attr, head_config, parse_state->error,
1203
				config_term_common))
1204 1205 1206 1207 1208
			return -EINVAL;

		if (get_config_terms(head_config, &config_terms))
			return -ENOMEM;
	}
1209

1210
	return add_event(list, &parse_state->idx, &attr,
1211
			 get_config_name(head_config), &config_terms);
1212
}
1213

1214
static int __parse_events_add_pmu(struct parse_events_state *parse_state,
1215
			 struct list_head *list, char *name,
1216
			 struct list_head *head_config, bool auto_merge_stats)
1217 1218
{
	struct perf_event_attr attr;
1219
	struct perf_pmu_info info;
1220
	struct perf_pmu *pmu;
1221
	struct perf_evsel *evsel;
1222
	LIST_HEAD(config_terms);
1223 1224 1225 1226 1227

	pmu = perf_pmu__find(name);
	if (!pmu)
		return -EINVAL;

1228 1229 1230 1231 1232 1233
	if (pmu->default_config) {
		memcpy(&attr, pmu->default_config,
		       sizeof(struct perf_event_attr));
	} else {
		memset(&attr, 0, sizeof(attr));
	}
1234

1235 1236
	if (!head_config) {
		attr.type = pmu->type;
1237
		evsel = __add_event(list, &parse_state->idx, &attr, NULL, pmu->cpus, NULL, auto_merge_stats);
1238 1239 1240
		return evsel ? 0 : -ENOMEM;
	}

1241
	if (perf_pmu__check_alias(pmu, head_config, &info))
1242 1243
		return -EINVAL;

1244 1245 1246 1247
	/*
	 * Configure hardcoded terms first, no need to check
	 * return value when called with fail == 0 ;)
	 */
1248
	if (config_attr(&attr, head_config, parse_state->error, config_term_pmu))
1249
		return -EINVAL;
1250

1251 1252 1253
	if (get_config_terms(head_config, &config_terms))
		return -ENOMEM;

1254
	if (perf_pmu__config(pmu, &attr, head_config, parse_state->error))
1255 1256
		return -EINVAL;

1257
	evsel = __add_event(list, &parse_state->idx, &attr,
1258
			    get_config_name(head_config), pmu->cpus,
1259
			    &config_terms, auto_merge_stats);
1260
	if (evsel) {
1261 1262
		evsel->unit = info.unit;
		evsel->scale = info.scale;
1263
		evsel->per_pkg = info.per_pkg;
1264
		evsel->snapshot = info.snapshot;
1265
		evsel->metric_expr = info.metric_expr;
1266
		evsel->metric_name = info.metric_name;
1267 1268 1269
	}

	return evsel ? 0 : -ENOMEM;
1270 1271
}

1272 1273 1274 1275 1276 1277 1278
int parse_events_add_pmu(struct parse_events_state *parse_state,
			 struct list_head *list, char *name,
			 struct list_head *head_config)
{
	return __parse_events_add_pmu(parse_state, list, name, head_config, false);
}

1279
int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
			       char *str, struct list_head **listp)
{
	struct list_head *head;
	struct parse_events_term *term;
	struct list_head *list;
	struct perf_pmu *pmu = NULL;
	int ok = 0;

	*listp = NULL;
	/* Add it for all PMUs that support the alias */
	list = malloc(sizeof(struct list_head));
	if (!list)
		return -1;
	INIT_LIST_HEAD(list);
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
		struct perf_pmu_alias *alias;

		list_for_each_entry(alias, &pmu->aliases, list) {
			if (!strcasecmp(alias->name, str)) {
				head = malloc(sizeof(struct list_head));
				if (!head)
					return -1;
				INIT_LIST_HEAD(head);
				if (parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
							   str, 1, false, &str, NULL) < 0)
					return -1;
				list_add_tail(&term->list, head);

1308 1309
				if (!__parse_events_add_pmu(parse_state, list,
							    pmu->name, head, true)) {
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
					pr_debug("%s -> %s/%s/\n", str,
						 pmu->name, alias->str);
					ok++;
				}

				parse_events_terms__delete(head);
			}
		}
	}
	if (!ok)
		return -1;
	*listp = list;
	return 0;
}

1325 1326
int parse_events__modifier_group(struct list_head *list,
				 char *event_mod)
1327
{
1328 1329 1330
	return parse_events__modifier_event(list, event_mod, true);
}

1331
void parse_events__set_leader(char *name, struct list_head *list)
1332 1333 1334
{
	struct perf_evsel *leader;

1335 1336 1337 1338 1339
	if (list_empty(list)) {
		WARN_ONCE(true, "WARNING: failed to set leader: empty list");
		return;
	}

1340 1341
	__perf_evlist__set_leader(list);
	leader = list_entry(list->next, struct perf_evsel, node);
1342
	leader->group_name = name ? strdup(name) : NULL;
1343 1344
}

1345
/* list_event is assumed to point to malloc'ed memory */
1346 1347 1348 1349 1350
void parse_events_update_lists(struct list_head *list_event,
			       struct list_head *list_all)
{
	/*
	 * Called for single event definition. Update the
1351
	 * 'all event' list, and reinit the 'single event'
1352 1353 1354
	 * list, for next event definition.
	 */
	list_splice_tail(list_event, list_all);
1355
	free(list_event);
1356 1357
}

1358 1359 1360 1361 1362 1363
struct event_modifier {
	int eu;
	int ek;
	int eh;
	int eH;
	int eG;
1364
	int eI;
1365
	int precise;
1366
	int precise_max;
1367
	int exclude_GH;
1368
	int sample_read;
1369
	int pinned;
1370
	int weak;
1371 1372 1373 1374
};

static int get_event_modifier(struct event_modifier *mod, char *str,
			       struct perf_evsel *evsel)
1375
{
1376 1377 1378 1379 1380
	int eu = evsel ? evsel->attr.exclude_user : 0;
	int ek = evsel ? evsel->attr.exclude_kernel : 0;
	int eh = evsel ? evsel->attr.exclude_hv : 0;
	int eH = evsel ? evsel->attr.exclude_host : 0;
	int eG = evsel ? evsel->attr.exclude_guest : 0;
1381
	int eI = evsel ? evsel->attr.exclude_idle : 0;
1382
	int precise = evsel ? evsel->attr.precise_ip : 0;
1383
	int precise_max = 0;
1384
	int sample_read = 0;
1385
	int pinned = evsel ? evsel->attr.pinned : 0;
1386

1387 1388
	int exclude = eu | ek | eh;
	int exclude_GH = evsel ? evsel->exclude_GH : 0;
1389
	int weak = 0;
1390 1391

	memset(mod, 0, sizeof(*mod));
1392

1393
	while (*str) {
P
Peter Zijlstra 已提交
1394 1395 1396
		if (*str == 'u') {
			if (!exclude)
				exclude = eu = ek = eh = 1;
1397
			eu = 0;
P
Peter Zijlstra 已提交
1398 1399 1400
		} else if (*str == 'k') {
			if (!exclude)
				exclude = eu = ek = eh = 1;
1401
			ek = 0;
P
Peter Zijlstra 已提交
1402 1403 1404
		} else if (*str == 'h') {
			if (!exclude)
				exclude = eu = ek = eh = 1;
1405
			eh = 0;
1406 1407 1408 1409 1410 1411 1412 1413
		} else if (*str == 'G') {
			if (!exclude_GH)
				exclude_GH = eG = eH = 1;
			eG = 0;
		} else if (*str == 'H') {
			if (!exclude_GH)
				exclude_GH = eG = eH = 1;
			eH = 0;
1414 1415
		} else if (*str == 'I') {
			eI = 1;
P
Peter Zijlstra 已提交
1416 1417
		} else if (*str == 'p') {
			precise++;
1418 1419 1420
			/* use of precise requires exclude_guest */
			if (!exclude_GH)
				eG = 1;
1421 1422
		} else if (*str == 'P') {
			precise_max = 1;
1423 1424
		} else if (*str == 'S') {
			sample_read = 1;
1425 1426
		} else if (*str == 'D') {
			pinned = 1;
1427 1428
		} else if (*str == 'W') {
			weak = 1;
P
Peter Zijlstra 已提交
1429
		} else
1430
			break;
P
Peter Zijlstra 已提交
1431

1432
		++str;
1433
	}
1434

1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
	/*
	 * precise ip:
	 *
	 *  0 - SAMPLE_IP can have arbitrary skid
	 *  1 - SAMPLE_IP must have constant skid
	 *  2 - SAMPLE_IP requested to have 0 skid
	 *  3 - SAMPLE_IP must have 0 skid
	 *
	 *  See also PERF_RECORD_MISC_EXACT_IP
	 */
	if (precise > 3)
		return -EINVAL;
1447

1448 1449 1450 1451 1452
	mod->eu = eu;
	mod->ek = ek;
	mod->eh = eh;
	mod->eH = eH;
	mod->eG = eG;
1453
	mod->eI = eI;
1454
	mod->precise = precise;
1455
	mod->precise_max = precise_max;
1456
	mod->exclude_GH = exclude_GH;
1457
	mod->sample_read = sample_read;
1458
	mod->pinned = pinned;
1459
	mod->weak = weak;
1460

1461 1462 1463
	return 0;
}

1464 1465 1466 1467 1468 1469 1470 1471 1472
/*
 * Basic modifier sanity check to validate it contains only one
 * instance of any modifier (apart from 'p') present.
 */
static int check_modifier(char *str)
{
	char *p = str;

	/* The sizeof includes 0 byte as well. */
1473
	if (strlen(str) > (sizeof("ukhGHpppPSDIW") - 1))
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
		return -1;

	while (*p) {
		if (*p != 'p' && strchr(p + 1, *p))
			return -1;
		p++;
	}

	return 0;
}

1485 1486 1487 1488 1489 1490 1491 1492
int parse_events__modifier_event(struct list_head *list, char *str, bool add)
{
	struct perf_evsel *evsel;
	struct event_modifier mod;

	if (str == NULL)
		return 0;

1493 1494 1495
	if (check_modifier(str))
		return -EINVAL;

1496 1497 1498
	if (!add && get_event_modifier(&mod, str, NULL))
		return -EINVAL;

1499
	__evlist__for_each_entry(list, evsel) {
1500 1501 1502 1503 1504 1505 1506 1507 1508
		if (add && get_event_modifier(&mod, str, evsel))
			return -EINVAL;

		evsel->attr.exclude_user   = mod.eu;
		evsel->attr.exclude_kernel = mod.ek;
		evsel->attr.exclude_hv     = mod.eh;
		evsel->attr.precise_ip     = mod.precise;
		evsel->attr.exclude_host   = mod.eH;
		evsel->attr.exclude_guest  = mod.eG;
1509
		evsel->attr.exclude_idle   = mod.eI;
1510
		evsel->exclude_GH          = mod.exclude_GH;
1511
		evsel->sample_read         = mod.sample_read;
1512
		evsel->precise_max         = mod.precise_max;
1513
		evsel->weak_group	   = mod.weak;
1514 1515 1516

		if (perf_evsel__is_group_leader(evsel))
			evsel->attr.pinned = mod.pinned;
1517
	}
1518

1519 1520
	return 0;
}
1521

1522 1523 1524 1525
int parse_events_name(struct list_head *list, char *name)
{
	struct perf_evsel *evsel;

1526
	__evlist__for_each_entry(list, evsel) {
1527 1528 1529 1530 1531 1532 1533
		if (!evsel->name)
			evsel->name = strdup(name);
	}

	return 0;
}

1534 1535 1536 1537 1538 1539
static int
comp_pmu(const void *p1, const void *p2)
{
	struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1;
	struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2;

1540
	return strcasecmp(pmu1->symbol, pmu2->symbol);
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
}

static void perf_pmu__parse_cleanup(void)
{
	if (perf_pmu_events_list_num > 0) {
		struct perf_pmu_event_symbol *p;
		int i;

		for (i = 0; i < perf_pmu_events_list_num; i++) {
			p = perf_pmu_events_list + i;
1551
			zfree(&p->symbol);
1552
		}
1553
		zfree(&perf_pmu_events_list);
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
		perf_pmu_events_list_num = 0;
	}
}

#define SET_SYMBOL(str, stype)		\
do {					\
	p->symbol = str;		\
	if (!p->symbol)			\
		goto err;		\
	p->type = stype;		\
} while (0)

/*
 * Read the pmu events list from sysfs
 * Save it into perf_pmu_events_list
 */
static void perf_pmu__parse_init(void)
{

	struct perf_pmu *pmu = NULL;
	struct perf_pmu_alias *alias;
	int len = 0;

1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
	pmu = NULL;
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
		list_for_each_entry(alias, &pmu->aliases, list) {
			if (strchr(alias->name, '-'))
				len++;
			len++;
		}
	}

	if (len == 0) {
1587 1588 1589 1590 1591 1592 1593 1594 1595
		perf_pmu_events_list_num = -1;
		return;
	}
	perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len);
	if (!perf_pmu_events_list)
		return;
	perf_pmu_events_list_num = len;

	len = 0;
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
	pmu = NULL;
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
		list_for_each_entry(alias, &pmu->aliases, list) {
			struct perf_pmu_event_symbol *p = perf_pmu_events_list + len;
			char *tmp = strchr(alias->name, '-');

			if (tmp != NULL) {
				SET_SYMBOL(strndup(alias->name, tmp - alias->name),
						PMU_EVENT_SYMBOL_PREFIX);
				p++;
				SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX);
				len += 2;
			} else {
				SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL);
				len++;
			}
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
		}
	}
	qsort(perf_pmu_events_list, len,
		sizeof(struct perf_pmu_event_symbol), comp_pmu);

	return;
err:
	perf_pmu__parse_cleanup();
}

enum perf_pmu_event_symbol_type
perf_pmu__parse_check(const char *name)
{
	struct perf_pmu_event_symbol p, *r;

	/* scan kernel pmu events from sysfs if needed */
	if (perf_pmu_events_list_num == 0)
		perf_pmu__parse_init();
	/*
	 * name "cpu" could be prefix of cpu-cycles or cpu// events.
	 * cpu-cycles has been handled by hardcode.
	 * So it must be cpu// events, not kernel pmu event.
	 */
	if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu"))
		return PMU_EVENT_SYMBOL_ERR;

	p.symbol = strdup(name);
	r = bsearch(&p, perf_pmu_events_list,
			(size_t) perf_pmu_events_list_num,
			sizeof(struct perf_pmu_event_symbol), comp_pmu);
1642
	zfree(&p.symbol);
1643 1644 1645
	return r ? r->type : PMU_EVENT_SYMBOL_ERR;
}

1646
static int parse_events__scanner(const char *str, void *parse_state, int start_token)
1647
{
1648
	YY_BUFFER_STATE buffer;
1649
	void *scanner;
1650
	int ret;
1651

1652
	ret = parse_events_lex_init_extra(start_token, &scanner);
1653 1654 1655 1656
	if (ret)
		return ret;

	buffer = parse_events__scan_string(str, scanner);
1657

1658 1659 1660
#ifdef PARSER_DEBUG
	parse_events_debug = 1;
#endif
1661
	ret = parse_events_parse(parse_state, scanner);
1662 1663 1664 1665 1666 1667

	parse_events__flush_buffer(buffer, scanner);
	parse_events__delete_buffer(buffer, scanner);
	parse_events_lex_destroy(scanner);
	return ret;
}
1668

1669 1670 1671 1672 1673
/*
 * parse event config string, return a list of event terms.
 */
int parse_events_terms(struct list_head *terms, const char *str)
{
1674
	struct parse_events_state parse_state = {
1675 1676 1677 1678
		.terms = NULL,
	};
	int ret;

1679
	ret = parse_events__scanner(str, &parse_state, PE_START_TERMS);
1680
	if (!ret) {
1681 1682
		list_splice(parse_state.terms, terms);
		zfree(&parse_state.terms);
1683 1684 1685
		return 0;
	}

1686
	parse_events_terms__delete(parse_state.terms);
1687 1688 1689
	return ret;
}

1690 1691
int parse_events(struct perf_evlist *evlist, const char *str,
		 struct parse_events_error *err)
1692
{
1693 1694
	struct parse_events_state parse_state = {
		.list   = LIST_HEAD_INIT(parse_state.list),
1695 1696 1697
		.idx    = evlist->nr_entries,
		.error  = err,
		.evlist = evlist,
1698 1699
	};
	int ret;
1700

1701
	ret = parse_events__scanner(str, &parse_state, PE_START_EVENTS);
1702
	perf_pmu__parse_cleanup();
1703
	if (!ret) {
1704 1705
		struct perf_evsel *last;

1706
		if (list_empty(&parse_state.list)) {
1707 1708 1709 1710
			WARN_ONCE(true, "WARNING: event parser found nothing");
			return -1;
		}

1711 1712
		perf_evlist__splice_list_tail(evlist, &parse_state.list);
		evlist->nr_groups += parse_state.nr_groups;
1713 1714 1715
		last = perf_evlist__last(evlist);
		last->cmdline_group_boundary = true;

1716 1717
		return 0;
	}
1718

1719 1720 1721 1722 1723
	/*
	 * There are 2 users - builtin-record and builtin-test objects.
	 * Both call perf_evlist__delete in case of error, so we dont
	 * need to bother.
	 */
1724
	return ret;
1725 1726
}

1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753
#define MAX_WIDTH 1000
static int get_term_width(void)
{
	struct winsize ws;

	get_term_dimensions(&ws);
	return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
}

static void parse_events_print_error(struct parse_events_error *err,
				     const char *event)
{
	const char *str = "invalid or unsupported event: ";
	char _buf[MAX_WIDTH];
	char *buf = (char *) event;
	int idx = 0;

	if (err->str) {
		/* -2 for extra '' in the final fprintf */
		int width       = get_term_width() - 2;
		int len_event   = strlen(event);
		int len_str, max_len, cut = 0;

		/*
		 * Maximum error index indent, we will cut
		 * the event string if it's bigger.
		 */
1754
		int max_err_idx = 13;
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765

		/*
		 * Let's be specific with the message when
		 * we have the precise error.
		 */
		str     = "event syntax error: ";
		len_str = strlen(str);
		max_len = width - len_str;

		buf = _buf;

1766
		/* We're cutting from the beginning. */
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
		if (err->idx > max_err_idx)
			cut = err->idx - max_err_idx;

		strncpy(buf, event + cut, max_len);

		/* Mark cut parts with '..' on both sides. */
		if (cut)
			buf[0] = buf[1] = '.';

		if ((len_event - cut) > max_len) {
			buf[max_len - 1] = buf[max_len - 2] = '.';
			buf[max_len] = 0;
		}

		idx = len_str + err->idx - cut;
	}

	fprintf(stderr, "%s'%s'\n", str, buf);
	if (idx) {
		fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str);
		if (err->help)
			fprintf(stderr, "\n%s\n", err->help);
1789 1790
		zfree(&err->str);
		zfree(&err->help);
1791 1792 1793 1794 1795 1796 1797
	}

	fprintf(stderr, "Run 'perf list' for a list of valid events\n");
}

#undef MAX_WIDTH

1798
int parse_events_option(const struct option *opt, const char *str,
1799
			int unset __maybe_unused)
1800 1801
{
	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1802 1803 1804 1805 1806
	struct parse_events_error err = { .idx = 0, };
	int ret = parse_events(evlist, str, &err);

	if (ret)
		parse_events_print_error(&err, str);
1807 1808

	return ret;
1809 1810
}

1811 1812 1813 1814 1815
static int
foreach_evsel_in_last_glob(struct perf_evlist *evlist,
			   int (*func)(struct perf_evsel *evsel,
				       const void *arg),
			   const void *arg)
L
Li Zefan 已提交
1816
{
1817
	struct perf_evsel *last = NULL;
1818
	int err;
L
Li Zefan 已提交
1819

1820 1821 1822 1823 1824 1825
	/*
	 * Don't return when list_empty, give func a chance to report
	 * error when it found last == NULL.
	 *
	 * So no need to WARN here, let *func do this.
	 */
1826
	if (evlist->nr_entries > 0)
1827
		last = perf_evlist__last(evlist);
1828

1829
	do {
1830 1831
		err = (*func)(last, arg);
		if (err)
1832
			return -1;
1833 1834
		if (!last)
			return 0;
1835 1836 1837 1838 1839

		if (last->node.prev == &evlist->entries)
			return 0;
		last = list_entry(last->node.prev, struct perf_evsel, node);
	} while (!last->cmdline_group_boundary);
L
Li Zefan 已提交
1840 1841 1842 1843

	return 0;
}

1844 1845 1846
static int set_filter(struct perf_evsel *evsel, const void *arg)
{
	const char *str = arg;
1847 1848 1849
	bool found = false;
	int nr_addr_filters = 0;
	struct perf_pmu *pmu = NULL;
1850

1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861
	if (evsel == NULL)
		goto err;

	if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
		if (perf_evsel__append_tp_filter(evsel, str) < 0) {
			fprintf(stderr,
				"not enough memory to hold filter string\n");
			return -1;
		}

		return 0;
1862 1863
	}

1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
	while ((pmu = perf_pmu__scan(pmu)) != NULL)
		if (pmu->type == evsel->attr.type) {
			found = true;
			break;
		}

	if (found)
		perf_pmu__scan_file(pmu, "nr_addr_filters",
				    "%d", &nr_addr_filters);

	if (!nr_addr_filters)
		goto err;

	if (perf_evsel__append_addr_filter(evsel, str) < 0) {
1878 1879 1880 1881 1882 1883
		fprintf(stderr,
			"not enough memory to hold filter string\n");
		return -1;
	}

	return 0;
1884 1885 1886 1887 1888 1889

err:
	fprintf(stderr,
		"--filter option should follow a -e tracepoint or HW tracer option\n");

	return -1;
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
}

int parse_filter(const struct option *opt, const char *str,
		 int unset __maybe_unused)
{
	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;

	return foreach_evsel_in_last_glob(evlist, set_filter,
					  (const void *)str);
}

static int add_exclude_perf_filter(struct perf_evsel *evsel,
				   const void *arg __maybe_unused)
{
	char new_filter[64];

	if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
		fprintf(stderr,
			"--exclude-perf option should follow a -e tracepoint option\n");
		return -1;
	}

	snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());

1914
	if (perf_evsel__append_tp_filter(evsel, new_filter) < 0) {
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
		fprintf(stderr,
			"not enough memory to hold filter string\n");
		return -1;
	}

	return 0;
}

int exclude_perf(const struct option *opt,
		 const char *arg __maybe_unused,
		 int unset __maybe_unused)
{
	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;

	return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
					  NULL);
}

1933 1934 1935 1936 1937
static const char * const event_type_descriptors[] = {
	"Hardware event",
	"Software event",
	"Tracepoint event",
	"Hardware cache event",
1938 1939
	"Raw hardware event descriptor",
	"Hardware breakpoint",
1940 1941
};

1942 1943 1944 1945 1946 1947 1948 1949
static int cmp_string(const void *a, const void *b)
{
	const char * const *as = a;
	const char * const *bs = b;

	return strcmp(*as, *bs);
}

1950 1951 1952 1953
/*
 * Print the events from <debugfs_mount_point>/tracing/events
 */

1954 1955
void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
			     bool name_only)
1956 1957
{
	DIR *sys_dir, *evt_dir;
1958
	struct dirent *sys_dirent, *evt_dirent;
1959
	char evt_path[MAXPATHLEN];
E
Eric Dumazet 已提交
1960
	char dir_path[MAXPATHLEN];
1961 1962 1963
	char **evt_list = NULL;
	unsigned int evt_i = 0, evt_num = 0;
	bool evt_num_known = false;
1964

1965
restart:
1966
	sys_dir = opendir(tracing_events_path);
1967
	if (!sys_dir)
E
Eric Dumazet 已提交
1968
		return;
1969

1970 1971 1972 1973 1974 1975
	if (evt_num_known) {
		evt_list = zalloc(sizeof(char *) * evt_num);
		if (!evt_list)
			goto out_close_sys_dir;
	}

1976
	for_each_subsystem(sys_dir, sys_dirent) {
1977
		if (subsys_glob != NULL &&
1978
		    !strglobmatch(sys_dirent->d_name, subsys_glob))
1979
			continue;
E
Eric Dumazet 已提交
1980

1981
		snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1982
			 sys_dirent->d_name);
E
Eric Dumazet 已提交
1983 1984
		evt_dir = opendir(dir_path);
		if (!evt_dir)
1985
			continue;
E
Eric Dumazet 已提交
1986

1987
		for_each_event(sys_dirent, evt_dir, evt_dirent) {
1988
			if (event_glob != NULL &&
1989
			    !strglobmatch(evt_dirent->d_name, event_glob))
1990 1991
				continue;

1992 1993
			if (!evt_num_known) {
				evt_num++;
1994 1995 1996
				continue;
			}

1997
			snprintf(evt_path, MAXPATHLEN, "%s:%s",
1998
				 sys_dirent->d_name, evt_dirent->d_name);
1999 2000 2001 2002 2003

			evt_list[evt_i] = strdup(evt_path);
			if (evt_list[evt_i] == NULL)
				goto out_close_evt_dir;
			evt_i++;
2004 2005 2006 2007
		}
		closedir(evt_dir);
	}
	closedir(sys_dir);
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022

	if (!evt_num_known) {
		evt_num_known = true;
		goto restart;
	}
	qsort(evt_list, evt_num, sizeof(char *), cmp_string);
	evt_i = 0;
	while (evt_i < evt_num) {
		if (name_only) {
			printf("%s ", evt_list[evt_i++]);
			continue;
		}
		printf("  %-50s [%s]\n", evt_list[evt_i++],
				event_type_descriptors[PERF_TYPE_TRACEPOINT]);
	}
2023
	if (evt_num && pager_in_use())
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
		printf("\n");

out_free:
	evt_num = evt_i;
	for (evt_i = 0; evt_i < evt_num; evt_i++)
		zfree(&evt_list[evt_i]);
	zfree(&evt_list);
	return;

out_close_evt_dir:
	closedir(evt_dir);
out_close_sys_dir:
	closedir(sys_dir);

	printf("FATAL: not enough memory to print %s\n",
			event_type_descriptors[PERF_TYPE_TRACEPOINT]);
	if (evt_list)
		goto out_free;
2042 2043
}

2044 2045 2046 2047 2048 2049 2050
/*
 * Check whether event is in <debugfs_mount_point>/tracing/events
 */

int is_valid_tracepoint(const char *event_string)
{
	DIR *sys_dir, *evt_dir;
2051
	struct dirent *sys_dirent, *evt_dirent;
2052 2053 2054
	char evt_path[MAXPATHLEN];
	char dir_path[MAXPATHLEN];

2055
	sys_dir = opendir(tracing_events_path);
2056 2057 2058
	if (!sys_dir)
		return 0;

2059
	for_each_subsystem(sys_dir, sys_dirent) {
2060

2061
		snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
2062
			 sys_dirent->d_name);
2063 2064 2065 2066
		evt_dir = opendir(dir_path);
		if (!evt_dir)
			continue;

2067
		for_each_event(sys_dirent, evt_dir, evt_dirent) {
2068
			snprintf(evt_path, MAXPATHLEN, "%s:%s",
2069
				 sys_dirent->d_name, evt_dirent->d_name);
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
			if (!strcmp(evt_path, event_string)) {
				closedir(evt_dir);
				closedir(sys_dir);
				return 1;
			}
		}
		closedir(evt_dir);
	}
	closedir(sys_dir);
	return 0;
}

2082 2083 2084
static bool is_event_supported(u8 type, unsigned config)
{
	bool ret = true;
2085
	int open_return;
2086 2087 2088 2089 2090 2091
	struct perf_evsel *evsel;
	struct perf_event_attr attr = {
		.type = type,
		.config = config,
		.disabled = 1,
	};
2092 2093 2094 2095
	struct thread_map *tmap = thread_map__new_by_tid(0);

	if (tmap == NULL)
		return false;
2096

2097
	evsel = perf_evsel__new(&attr);
2098
	if (evsel) {
2099
		open_return = perf_evsel__open(evsel, NULL, tmap);
2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
		ret = open_return >= 0;

		if (open_return == -EACCES) {
			/*
			 * This happens if the paranoid value
			 * /proc/sys/kernel/perf_event_paranoid is set to 2
			 * Re-run with exclude_kernel set; we don't do that
			 * by default as some ARM machines do not support it.
			 *
			 */
			evsel->attr.exclude_kernel = 1;
2111
			ret = perf_evsel__open(evsel, NULL, tmap) >= 0;
2112
		}
2113 2114 2115 2116 2117 2118
		perf_evsel__delete(evsel);
	}

	return ret;
}

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141
void print_sdt_events(const char *subsys_glob, const char *event_glob,
		      bool name_only)
{
	struct probe_cache *pcache;
	struct probe_cache_entry *ent;
	struct strlist *bidlist, *sdtlist;
	struct strlist_config cfg = {.dont_dupstr = true};
	struct str_node *nd, *nd2;
	char *buf, *path, *ptr = NULL;
	bool show_detail = false;
	int ret;

	sdtlist = strlist__new(NULL, &cfg);
	if (!sdtlist) {
		pr_debug("Failed to allocate new strlist for SDT\n");
		return;
	}
	bidlist = build_id_cache__list_all(true);
	if (!bidlist) {
		pr_debug("Failed to get buildids: %d\n", errno);
		return;
	}
	strlist__for_each_entry(nd, bidlist) {
2142
		pcache = probe_cache__new(nd->s, NULL);
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
		if (!pcache)
			continue;
		list_for_each_entry(ent, &pcache->entries, node) {
			if (!ent->sdt)
				continue;
			if (subsys_glob &&
			    !strglobmatch(ent->pev.group, subsys_glob))
				continue;
			if (event_glob &&
			    !strglobmatch(ent->pev.event, event_glob))
				continue;
			ret = asprintf(&buf, "%s:%s@%s", ent->pev.group,
					ent->pev.event, nd->s);
			if (ret > 0)
				strlist__add(sdtlist, buf);
		}
		probe_cache__delete(pcache);
	}
	strlist__delete(bidlist);

	strlist__for_each_entry(nd, sdtlist) {
		buf = strchr(nd->s, '@');
		if (buf)
			*(buf++) = '\0';
		if (name_only) {
			printf("%s ", nd->s);
			continue;
		}
		nd2 = strlist__next(nd);
		if (nd2) {
			ptr = strchr(nd2->s, '@');
			if (ptr)
				*ptr = '\0';
			if (strcmp(nd->s, nd2->s) == 0)
				show_detail = true;
		}
		if (show_detail) {
			path = build_id_cache__origname(buf);
			ret = asprintf(&buf, "%s@%s(%.12s)", nd->s, path, buf);
			if (ret > 0) {
				printf("  %-50s [%s]\n", buf, "SDT event");
				free(buf);
			}
		} else
			printf("  %-50s [%s]\n", nd->s, "SDT event");
		if (nd2) {
			if (strcmp(nd->s, nd2->s) != 0)
				show_detail = false;
			if (ptr)
				*ptr = '@';
		}
	}
	strlist__delete(sdtlist);
}

2198
int print_hwcache_events(const char *event_glob, bool name_only)
2199
{
2200
	unsigned int type, op, i, evt_i = 0, evt_num = 0;
2201
	char name[64];
2202 2203 2204 2205 2206 2207 2208 2209 2210
	char **evt_list = NULL;
	bool evt_num_known = false;

restart:
	if (evt_num_known) {
		evt_list = zalloc(sizeof(char *) * evt_num);
		if (!evt_list)
			goto out_enomem;
	}
2211 2212 2213 2214

	for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
		for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
			/* skip invalid cache type */
2215
			if (!perf_evsel__is_cache_op_valid(type, op))
2216 2217 2218
				continue;

			for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
2219 2220
				__perf_evsel__hw_cache_type_op_res_name(type, op, i,
									name, sizeof(name));
2221
				if (event_glob != NULL && !strglobmatch(name, event_glob))
2222 2223
					continue;

2224 2225 2226 2227
				if (!is_event_supported(PERF_TYPE_HW_CACHE,
							type | (op << 8) | (i << 16)))
					continue;

2228 2229 2230 2231 2232 2233 2234 2235 2236
				if (!evt_num_known) {
					evt_num++;
					continue;
				}

				evt_list[evt_i] = strdup(name);
				if (evt_list[evt_i] == NULL)
					goto out_enomem;
				evt_i++;
2237 2238 2239 2240
			}
		}
	}

2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
	if (!evt_num_known) {
		evt_num_known = true;
		goto restart;
	}
	qsort(evt_list, evt_num, sizeof(char *), cmp_string);
	evt_i = 0;
	while (evt_i < evt_num) {
		if (name_only) {
			printf("%s ", evt_list[evt_i++]);
			continue;
		}
		printf("  %-50s [%s]\n", evt_list[evt_i++],
				event_type_descriptors[PERF_TYPE_HW_CACHE]);
	}
2255
	if (evt_num && pager_in_use())
2256
		printf("\n");
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269

out_free:
	evt_num = evt_i;
	for (evt_i = 0; evt_i < evt_num; evt_i++)
		zfree(&evt_list[evt_i]);
	zfree(&evt_list);
	return evt_num;

out_enomem:
	printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]);
	if (evt_list)
		goto out_free;
	return evt_num;
2270 2271
}

2272
void print_symbol_events(const char *event_glob, unsigned type,
2273 2274
				struct event_symbol *syms, unsigned max,
				bool name_only)
2275
{
2276
	unsigned int i, evt_i = 0, evt_num = 0;
2277
	char name[MAX_NAME_LEN];
2278 2279 2280 2281 2282 2283 2284 2285 2286 2287
	char **evt_list = NULL;
	bool evt_num_known = false;

restart:
	if (evt_num_known) {
		evt_list = zalloc(sizeof(char *) * evt_num);
		if (!evt_list)
			goto out_enomem;
		syms -= max;
	}
2288

2289
	for (i = 0; i < max; i++, syms++) {
2290

2291
		if (event_glob != NULL && syms->symbol != NULL &&
2292 2293 2294
		    !(strglobmatch(syms->symbol, event_glob) ||
		      (syms->alias && strglobmatch(syms->alias, event_glob))))
			continue;
2295

2296 2297 2298
		if (!is_event_supported(type, i))
			continue;

2299 2300
		if (!evt_num_known) {
			evt_num++;
2301 2302 2303
			continue;
		}

2304
		if (!name_only && strlen(syms->alias))
2305
			snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
2306
		else
2307
			strncpy(name, syms->symbol, MAX_NAME_LEN);
2308

2309 2310 2311 2312
		evt_list[evt_i] = strdup(name);
		if (evt_list[evt_i] == NULL)
			goto out_enomem;
		evt_i++;
2313 2314
	}

2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
	if (!evt_num_known) {
		evt_num_known = true;
		goto restart;
	}
	qsort(evt_list, evt_num, sizeof(char *), cmp_string);
	evt_i = 0;
	while (evt_i < evt_num) {
		if (name_only) {
			printf("%s ", evt_list[evt_i++]);
			continue;
		}
		printf("  %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]);
	}
2328
	if (evt_num && pager_in_use())
2329
		printf("\n");
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341

out_free:
	evt_num = evt_i;
	for (evt_i = 0; evt_i < evt_num; evt_i++)
		zfree(&evt_list[evt_i]);
	zfree(&evt_list);
	return;

out_enomem:
	printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]);
	if (evt_list)
		goto out_free;
2342 2343 2344 2345 2346
}

/*
 * Print the help text for the event symbols:
 */
2347
void print_events(const char *event_glob, bool name_only, bool quiet_flag,
2348
			bool long_desc, bool details_flag)
2349 2350
{
	print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
2351
			    event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
2352 2353

	print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
2354
			    event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
2355

2356
	print_hwcache_events(event_glob, name_only);
2357

2358 2359
	print_pmu_events(event_glob, name_only, quiet_flag, long_desc,
			details_flag);
2360

2361 2362
	if (event_glob != NULL)
		return;
2363

2364 2365 2366 2367 2368 2369 2370
	if (!name_only) {
		printf("  %-50s [%s]\n",
		       "rNNN",
		       event_type_descriptors[PERF_TYPE_RAW]);
		printf("  %-50s [%s]\n",
		       "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
		       event_type_descriptors[PERF_TYPE_RAW]);
2371 2372
		if (pager_in_use())
			printf("   (see 'man perf-list' on how to encode it)\n\n");
2373 2374

		printf("  %-50s [%s]\n",
2375
		       "mem:<addr>[/len][:access]",
2376
			event_type_descriptors[PERF_TYPE_BREAKPOINT]);
2377 2378
		if (pager_in_use())
			printf("\n");
2379
	}
2380

2381
	print_tracepoint_events(NULL, NULL, name_only);
2382 2383

	print_sdt_events(NULL, NULL, name_only);
2384 2385

	metricgroup__print(true, true, NULL, name_only);
2386
}
2387

2388
int parse_events__is_hardcoded_term(struct parse_events_term *term)
2389
{
2390
	return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
2391 2392
}

2393 2394 2395
static int new_term(struct parse_events_term **_term,
		    struct parse_events_term *temp,
		    char *str, u64 num)
2396
{
2397
	struct parse_events_term *term;
2398

2399
	term = malloc(sizeof(*term));
2400 2401 2402
	if (!term)
		return -ENOMEM;

2403
	*term = *temp;
2404 2405
	INIT_LIST_HEAD(&term->list);

2406
	switch (term->type_val) {
2407 2408 2409 2410 2411 2412 2413
	case PARSE_EVENTS__TERM_TYPE_NUM:
		term->val.num = num;
		break;
	case PARSE_EVENTS__TERM_TYPE_STR:
		term->val.str = str;
		break;
	default:
2414
		free(term);
2415 2416 2417 2418 2419 2420 2421
		return -EINVAL;
	}

	*_term = term;
	return 0;
}

2422
int parse_events_term__num(struct parse_events_term **term,
2423
			   int type_term, char *config, u64 num,
2424
			   bool no_value,
2425
			   void *loc_term_, void *loc_val_)
2426
{
2427 2428 2429
	YYLTYPE *loc_term = loc_term_;
	YYLTYPE *loc_val = loc_val_;

2430 2431 2432 2433
	struct parse_events_term temp = {
		.type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
		.type_term = type_term,
		.config    = config,
2434
		.no_value  = no_value,
2435 2436 2437 2438 2439
		.err_term  = loc_term ? loc_term->first_column : 0,
		.err_val   = loc_val  ? loc_val->first_column  : 0,
	};

	return new_term(term, &temp, NULL, num);
2440 2441
}

2442
int parse_events_term__str(struct parse_events_term **term,
2443
			   int type_term, char *config, char *str,
2444
			   void *loc_term_, void *loc_val_)
2445
{
2446 2447 2448
	YYLTYPE *loc_term = loc_term_;
	YYLTYPE *loc_val = loc_val_;

2449 2450 2451 2452 2453 2454 2455 2456 2457
	struct parse_events_term temp = {
		.type_val  = PARSE_EVENTS__TERM_TYPE_STR,
		.type_term = type_term,
		.config    = config,
		.err_term  = loc_term ? loc_term->first_column : 0,
		.err_val   = loc_val  ? loc_val->first_column  : 0,
	};

	return new_term(term, &temp, str, 0);
2458 2459
}

2460
int parse_events_term__sym_hw(struct parse_events_term **term,
2461 2462 2463
			      char *config, unsigned idx)
{
	struct event_symbol *sym;
2464 2465 2466 2467 2468
	struct parse_events_term temp = {
		.type_val  = PARSE_EVENTS__TERM_TYPE_STR,
		.type_term = PARSE_EVENTS__TERM_TYPE_USER,
		.config    = config ?: (char *) "event",
	};
2469 2470 2471 2472

	BUG_ON(idx >= PERF_COUNT_HW_MAX);
	sym = &event_symbols_hw[idx];

2473
	return new_term(term, &temp, (char *) sym->symbol, 0);
2474 2475
}

2476 2477
int parse_events_term__clone(struct parse_events_term **new,
			     struct parse_events_term *term)
2478
{
2479 2480 2481 2482 2483 2484 2485 2486 2487
	struct parse_events_term temp = {
		.type_val  = term->type_val,
		.type_term = term->type_term,
		.config    = term->config,
		.err_term  = term->err_term,
		.err_val   = term->err_val,
	};

	return new_term(new, &temp, term->val.str, term->val.num);
2488 2489
}

2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514
int parse_events_copy_term_list(struct list_head *old,
				 struct list_head **new)
{
	struct parse_events_term *term, *n;
	int ret;

	if (!old) {
		*new = NULL;
		return 0;
	}

	*new = malloc(sizeof(struct list_head));
	if (!*new)
		return -ENOMEM;
	INIT_LIST_HEAD(*new);

	list_for_each_entry (term, old, list) {
		ret = parse_events_term__clone(&n, term);
		if (ret)
			return ret;
		list_add_tail(&n->list, *new);
	}
	return 0;
}

2515
void parse_events_terms__purge(struct list_head *terms)
2516
{
2517
	struct parse_events_term *term, *h;
2518

2519
	list_for_each_entry_safe(term, h, terms, list) {
2520
		if (term->array.nr_ranges)
2521
			zfree(&term->array.ranges);
2522
		list_del_init(&term->list);
2523
		free(term);
2524
	}
2525
}
2526

2527
void parse_events_terms__delete(struct list_head *terms)
2528
{
2529 2530
	if (!terms)
		return;
2531
	parse_events_terms__purge(terms);
2532
	free(terms);
2533 2534
}

2535 2536
void parse_events__clear_array(struct parse_events_array *a)
{
2537
	zfree(&a->ranges);
2538 2539
}

2540
void parse_events_evlist_error(struct parse_events_state *parse_state,
2541 2542
			       int idx, const char *str)
{
2543
	struct parse_events_error *err = parse_state->error;
2544

2545 2546
	if (!err)
		return;
2547 2548 2549 2550
	err->idx = idx;
	err->str = strdup(str);
	WARN_ONCE(!err->str, "WARNING: failed to allocate error string");
}
2551

2552 2553 2554 2555 2556 2557 2558 2559 2560
static void config_terms_list(char *buf, size_t buf_sz)
{
	int i;
	bool first = true;

	buf[0] = '\0';
	for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
		const char *name = config_term_names[i];

2561 2562
		if (!config_term_avail(i, NULL))
			continue;
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578
		if (!name)
			continue;
		if (name[0] == '<')
			continue;

		if (strlen(buf) + strlen(name) + 2 >= buf_sz)
			return;

		if (!first)
			strcat(buf, ",");
		else
			first = false;
		strcat(buf, name);
	}
}

2579 2580 2581 2582 2583 2584 2585
/*
 * Return string contains valid config terms of an event.
 * @additional_terms: For terms such as PMU sysfs terms.
 */
char *parse_events_formats_error_string(char *additional_terms)
{
	char *str;
W
Wang Nan 已提交
2586
	/* "no-overwrite" is the longest name */
2587
	char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
W
Wang Nan 已提交
2588
			  (sizeof("no-overwrite") - 1)];
2589

2590
	config_terms_list(static_terms, sizeof(static_terms));
2591 2592
	/* valid terms */
	if (additional_terms) {
2593 2594
		if (asprintf(&str, "valid terms: %s,%s",
			     additional_terms, static_terms) < 0)
2595 2596
			goto fail;
	} else {
2597
		if (asprintf(&str, "valid terms: %s", static_terms) < 0)
2598 2599 2600 2601 2602 2603 2604
			goto fail;
	}
	return str;

fail:
	return NULL;
}