pmu.c 27.4 KB
Newer Older
1
#include <linux/list.h>
2
#include <linux/compiler.h>
3 4 5
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
6
#include <stdbool.h>
7
#include <stdarg.h>
8
#include <dirent.h>
9
#include <api/fs/fs.h>
10
#include <locale.h>
11 12 13
#include "util.h"
#include "pmu.h"
#include "parse-events.h"
Y
Yan, Zheng 已提交
14
#include "cpumap.h"
15 16
#include "header.h"
#include "pmu-events/pmu-events.h"
17
#include "cache.h"
18

19 20 21 22 23 24 25
struct perf_pmu_format {
	char *name;
	int value;
	DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
	struct list_head list;
};

26 27
#define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/"

28 29 30 31 32 33 34 35 36
int perf_pmu_parse(struct list_head *list, char *name);
extern FILE *perf_pmu_in;

static LIST_HEAD(pmus);

/*
 * Parse & process all the sysfs attributes located under
 * the directory specified in 'dir' parameter.
 */
37
int perf_pmu__format_parse(char *dir, struct list_head *head)
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
{
	struct dirent *evt_ent;
	DIR *format_dir;
	int ret = 0;

	format_dir = opendir(dir);
	if (!format_dir)
		return -EINVAL;

	while (!ret && (evt_ent = readdir(format_dir))) {
		char path[PATH_MAX];
		char *name = evt_ent->d_name;
		FILE *file;

		if (!strcmp(name, ".") || !strcmp(name, ".."))
			continue;

		snprintf(path, PATH_MAX, "%s/%s", dir, name);

		ret = -EINVAL;
		file = fopen(path, "r");
		if (!file)
			break;

		perf_pmu_in = file;
		ret = perf_pmu_parse(head, name);
		fclose(file);
	}

	closedir(format_dir);
	return ret;
}

/*
 * Reading/parsing the default pmu format definition, which should be
 * located at:
 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
 */
76
static int pmu_format(const char *name, struct list_head *format)
77 78 79
{
	struct stat st;
	char path[PATH_MAX];
80
	const char *sysfs = sysfs__mountpoint();
81 82 83 84 85

	if (!sysfs)
		return -1;

	snprintf(path, PATH_MAX,
86
		 "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name);
87 88

	if (stat(path, &st) < 0)
89
		return 0;	/* no error if format does not exist */
90

91
	if (perf_pmu__format_parse(path, format))
92 93 94 95 96
		return -1;

	return 0;
}

97
static int convert_scale(const char *scale, char **end, double *sval)
98
{
99
	char *lc;
100
	int ret = 0;
101

102 103 104 105 106
	/*
	 * save current locale
	 */
	lc = setlocale(LC_NUMERIC, NULL);

107 108 109 110 111 112 113 114
	/*
	 * The lc string may be allocated in static storage,
	 * so get a dynamic copy to make it survive setlocale
	 * call below.
	 */
	lc = strdup(lc);
	if (!lc) {
		ret = -ENOMEM;
115
		goto out;
116 117
	}

118 119 120 121 122 123 124
	/*
	 * force to C locale to ensure kernel
	 * scale string is converted correctly.
	 * kernel uses default C locale.
	 */
	setlocale(LC_NUMERIC, "C");

125
	*sval = strtod(scale, end);
126

127
out:
128 129
	/* restore locale */
	setlocale(LC_NUMERIC, lc);
130
	free(lc);
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
	return ret;
}

static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name)
{
	struct stat st;
	ssize_t sret;
	char scale[128];
	int fd, ret = -1;
	char path[PATH_MAX];

	snprintf(path, PATH_MAX, "%s/%s.scale", dir, name);

	fd = open(path, O_RDONLY);
	if (fd == -1)
		return -1;

	if (fstat(fd, &st) < 0)
		goto error;

	sret = read(fd, scale, sizeof(scale)-1);
	if (sret < 0)
		goto error;

	if (scale[sret - 1] == '\n')
		scale[sret - 1] = '\0';
	else
		scale[sret] = '\0';
159

160
	ret = convert_scale(scale, NULL, &alias->scale);
161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
error:
	close(fd);
	return ret;
}

static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name)
{
	char path[PATH_MAX];
	ssize_t sret;
	int fd;

	snprintf(path, PATH_MAX, "%s/%s.unit", dir, name);

	fd = open(path, O_RDONLY);
	if (fd == -1)
		return -1;

178
	sret = read(fd, alias->unit, UNIT_MAX_LEN);
179 180 181 182 183
	if (sret < 0)
		goto error;

	close(fd);

184 185 186 187
	if (alias->unit[sret - 1] == '\n')
		alias->unit[sret - 1] = '\0';
	else
		alias->unit[sret] = '\0';
188 189 190 191 192 193 194 195

	return 0;
error:
	close(fd);
	alias->unit[0] = '\0';
	return -1;
}

196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
static int
perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name)
{
	char path[PATH_MAX];
	int fd;

	snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name);

	fd = open(path, O_RDONLY);
	if (fd == -1)
		return -1;

	close(fd);

	alias->per_pkg = true;
	return 0;
}

214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
				    char *dir, char *name)
{
	char path[PATH_MAX];
	int fd;

	snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name);

	fd = open(path, O_RDONLY);
	if (fd == -1)
		return -1;

	alias->snapshot = true;
	close(fd);
	return 0;
}

231
static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
232 233
				 char *desc, char *val,
				 char *long_desc, char *topic,
234
				 char *unit, char *perpkg,
235 236
				 char *metric_expr,
				 char *metric_name)
237
{
238
	struct perf_pmu_alias *alias;
239
	int ret;
240
	int num;
241 242 243 244 245 246

	alias = malloc(sizeof(*alias));
	if (!alias)
		return -ENOMEM;

	INIT_LIST_HEAD(&alias->terms);
247 248
	alias->scale = 1.0;
	alias->unit[0] = '\0';
249
	alias->per_pkg = false;
250
	alias->snapshot = false;
251

252
	ret = parse_events_terms(&alias->terms, val);
253
	if (ret) {
254
		pr_err("Cannot parse alias %s: %d\n", val, ret);
255 256 257 258 259
		free(alias);
		return ret;
	}

	alias->name = strdup(name);
260 261 262 263 264 265 266 267 268
	if (dir) {
		/*
		 * load unit name and scale if available
		 */
		perf_pmu__parse_unit(alias, dir, name);
		perf_pmu__parse_scale(alias, dir, name);
		perf_pmu__parse_per_pkg(alias, dir, name);
		perf_pmu__parse_snapshot(alias, dir, name);
	}
269

270
	alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL;
271
	alias->metric_name = metric_name ? strdup(metric_name): NULL;
A
Andi Kleen 已提交
272
	alias->desc = desc ? strdup(desc) : NULL;
273 274
	alias->long_desc = long_desc ? strdup(long_desc) :
				desc ? strdup(desc) : NULL;
275
	alias->topic = topic ? strdup(topic) : NULL;
276 277 278 279 280 281
	if (unit) {
		if (convert_scale(unit, &unit, &alias->scale) < 0)
			return -1;
		snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
	}
	alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
282 283
	alias->str = strdup(val);

284
	list_add_tail(&alias->list, list);
285

286 287 288
	return 0;
}

289 290 291 292 293 294 295 296 297 298 299
static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file)
{
	char buf[256];
	int ret;

	ret = fread(buf, 1, sizeof(buf), file);
	if (ret == 0)
		return -EINVAL;

	buf[ret] = 0;

300
	return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
301
				     NULL, NULL, NULL);
302 303
}

304 305 306 307 308 309 310 311 312
static inline bool pmu_alias_info_file(char *name)
{
	size_t len;

	len = strlen(name);
	if (len > 5 && !strcmp(name + len - 5, ".unit"))
		return true;
	if (len > 6 && !strcmp(name + len - 6, ".scale"))
		return true;
313 314
	if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
		return true;
315 316
	if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
		return true;
317 318 319 320

	return false;
}

321 322 323 324 325 326 327 328 329 330 331 332 333
/*
 * Process all the sysfs attributes located under the directory
 * specified in 'dir' parameter.
 */
static int pmu_aliases_parse(char *dir, struct list_head *head)
{
	struct dirent *evt_ent;
	DIR *event_dir;

	event_dir = opendir(dir);
	if (!event_dir)
		return -EINVAL;

334
	while ((evt_ent = readdir(event_dir))) {
335 336 337 338 339 340 341
		char path[PATH_MAX];
		char *name = evt_ent->d_name;
		FILE *file;

		if (!strcmp(name, ".") || !strcmp(name, ".."))
			continue;

342
		/*
343
		 * skip info files parsed in perf_pmu__new_alias()
344
		 */
345
		if (pmu_alias_info_file(name))
346 347
			continue;

348 349 350
		snprintf(path, PATH_MAX, "%s/%s", dir, name);

		file = fopen(path, "r");
351 352 353 354
		if (!file) {
			pr_debug("Cannot open %s\n", path);
			continue;
		}
355

356 357
		if (perf_pmu__new_alias(head, dir, name, file) < 0)
			pr_debug("Cannot set up %s\n", name);
358 359 360 361
		fclose(file);
	}

	closedir(event_dir);
362
	return 0;
363 364 365 366 367 368
}

/*
 * Reading the pmu event aliases definition, which should be located at:
 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
 */
369
static int pmu_aliases(const char *name, struct list_head *head)
370 371 372
{
	struct stat st;
	char path[PATH_MAX];
373
	const char *sysfs = sysfs__mountpoint();
374 375 376 377 378 379 380 381

	if (!sysfs)
		return -1;

	snprintf(path, PATH_MAX,
		 "%s/bus/event_source/devices/%s/events", sysfs, name);

	if (stat(path, &st) < 0)
382
		return 0;	 /* no error if 'events' does not exist */
383 384 385 386 387 388 389

	if (pmu_aliases_parse(path, head))
		return -1;

	return 0;
}

390
static int pmu_alias_terms(struct perf_pmu_alias *alias,
391 392
			   struct list_head *terms)
{
393
	struct parse_events_term *term, *cloned;
394 395 396 397
	LIST_HEAD(list);
	int ret;

	list_for_each_entry(term, &alias->terms, list) {
398
		ret = parse_events_term__clone(&cloned, term);
399
		if (ret) {
400
			parse_events_terms__purge(&list);
401 402
			return ret;
		}
403
		list_add_tail(&cloned->list, &list);
404 405 406 407 408
	}
	list_splice(&list, terms);
	return 0;
}

409 410 411 412 413
/*
 * Reading/parsing the default pmu type value, which should be
 * located at:
 * /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
 */
414
static int pmu_type(const char *name, __u32 *type)
415 416 417 418 419
{
	struct stat st;
	char path[PATH_MAX];
	FILE *file;
	int ret = 0;
420
	const char *sysfs = sysfs__mountpoint();
421 422 423 424 425

	if (!sysfs)
		return -1;

	snprintf(path, PATH_MAX,
426
		 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441

	if (stat(path, &st) < 0)
		return -1;

	file = fopen(path, "r");
	if (!file)
		return -EINVAL;

	if (1 != fscanf(file, "%u", type))
		ret = -1;

	fclose(file);
	return ret;
}

442 443 444 445 446 447
/* Add all pmus in sysfs to pmu list: */
static void pmu_read_sysfs(void)
{
	char path[PATH_MAX];
	DIR *dir;
	struct dirent *dent;
448
	const char *sysfs = sysfs__mountpoint();
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469

	if (!sysfs)
		return;

	snprintf(path, PATH_MAX,
		 "%s" EVENT_SOURCE_DEVICE_PATH, sysfs);

	dir = opendir(path);
	if (!dir)
		return;

	while ((dent = readdir(dir))) {
		if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
			continue;
		/* add to static LIST_HEAD(pmus): */
		perf_pmu__find(dent->d_name);
	}

	closedir(dir);
}

470
static struct cpu_map *pmu_cpumask(const char *name)
Y
Yan, Zheng 已提交
471 472 473 474 475
{
	struct stat st;
	char path[PATH_MAX];
	FILE *file;
	struct cpu_map *cpus;
476
	const char *sysfs = sysfs__mountpoint();
477 478 479 480 481 482
	const char *templates[] = {
		 "%s/bus/event_source/devices/%s/cpumask",
		 "%s/bus/event_source/devices/%s/cpus",
		 NULL
	};
	const char **template;
Y
Yan, Zheng 已提交
483 484 485 486

	if (!sysfs)
		return NULL;

487 488 489 490 491
	for (template = templates; *template; template++) {
		snprintf(path, PATH_MAX, *template, sysfs, name);
		if (stat(path, &st) == 0)
			break;
	}
Y
Yan, Zheng 已提交
492

493
	if (!*template)
Y
Yan, Zheng 已提交
494 495 496 497 498 499 500 501 502 503 504
		return NULL;

	file = fopen(path, "r");
	if (!file)
		return NULL;

	cpus = cpu_map__read(file);
	fclose(file);
	return cpus;
}

505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
/*
 * Return the CPU id as a raw string.
 *
 * Each architecture should provide a more precise id string that
 * can be use to match the architecture's "mapfile".
 */
char * __weak get_cpuid_str(void)
{
	return NULL;
}

/*
 * From the pmu_events_map, find the table of PMU events that corresponds
 * to the current running CPU. Then, add all PMU events from that table
 * as aliases.
 */
521
static void pmu_add_cpu_aliases(struct list_head *head, const char *name)
522 523 524 525 526
{
	int i;
	struct pmu_events_map *map;
	struct pmu_event *pe;
	char *cpuid;
527
	static bool printed;
528

529 530 531 532 533
	cpuid = getenv("PERF_CPUID");
	if (cpuid)
		cpuid = strdup(cpuid);
	if (!cpuid)
		cpuid = get_cpuid_str();
534 535 536
	if (!cpuid)
		return;

537 538 539 540
	if (!printed) {
		pr_debug("Using CPUID %s\n", cpuid);
		printed = true;
	}
541

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
	i = 0;
	while (1) {
		map = &pmu_events_map[i++];
		if (!map->table)
			goto out;

		if (!strcmp(map->cpuid, cpuid))
			break;
	}

	/*
	 * Found a matching PMU events table. Create aliases
	 */
	i = 0;
	while (1) {
557 558
		const char *pname;

559 560 561 562
		pe = &map->table[i++];
		if (!pe->name)
			break;

563 564 565 566
		pname = pe->pmu ? pe->pmu : "cpu";
		if (strncmp(pname, name, strlen(pname)))
			continue;

567 568
		/* need type casts to override 'const' */
		__perf_pmu__new_alias(head, NULL, (char *)pe->name,
569
				(char *)pe->desc, (char *)pe->event,
570
				(char *)pe->long_desc, (char *)pe->topic,
571
				(char *)pe->unit, (char *)pe->perpkg,
572 573
				(char *)pe->metric_expr,
				(char *)pe->metric_name);
574 575 576 577 578 579
	}

out:
	free(cpuid);
}

580
struct perf_event_attr * __weak
581 582 583 584 585
perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
{
	return NULL;
}

586
static struct perf_pmu *pmu_lookup(const char *name)
587 588 589
{
	struct perf_pmu *pmu;
	LIST_HEAD(format);
590
	LIST_HEAD(aliases);
591 592 593 594 595 596 597 598 599 600
	__u32 type;

	/*
	 * The pmu data we store & need consists of the pmu
	 * type value and format definitions. Load both right
	 * now.
	 */
	if (pmu_format(name, &format))
		return NULL;

601 602 603 604
	/*
	 * Check the type first to avoid unnecessary work.
	 */
	if (pmu_type(name, &type))
605 606
		return NULL;

607
	if (pmu_aliases(name, &aliases))
608 609
		return NULL;

610
	pmu_add_cpu_aliases(&aliases, name);
611 612 613 614
	pmu = zalloc(sizeof(*pmu));
	if (!pmu)
		return NULL;

Y
Yan, Zheng 已提交
615 616
	pmu->cpus = pmu_cpumask(name);

617
	INIT_LIST_HEAD(&pmu->format);
618
	INIT_LIST_HEAD(&pmu->aliases);
619
	list_splice(&format, &pmu->format);
620
	list_splice(&aliases, &pmu->aliases);
621 622
	pmu->name = strdup(name);
	pmu->type = type;
623
	list_add_tail(&pmu->list, &pmus);
624 625 626

	pmu->default_config = perf_pmu__get_default_config(pmu);

627 628 629
	return pmu;
}

630
static struct perf_pmu *pmu_find(const char *name)
631 632 633 634 635 636 637 638 639 640
{
	struct perf_pmu *pmu;

	list_for_each_entry(pmu, &pmus, list)
		if (!strcmp(pmu->name, name))
			return pmu;

	return NULL;
}

641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
{
	/*
	 * pmu iterator: If pmu is NULL, we start at the begin,
	 * otherwise return the next pmu. Returns NULL on end.
	 */
	if (!pmu) {
		pmu_read_sysfs();
		pmu = list_prepare_entry(pmu, &pmus, list);
	}
	list_for_each_entry_continue(pmu, &pmus, list)
		return pmu;
	return NULL;
}

656
struct perf_pmu *perf_pmu__find(const char *name)
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
{
	struct perf_pmu *pmu;

	/*
	 * Once PMU is loaded it stays in the list,
	 * so we keep us from multiple reading/parsing
	 * the pmu format definitions.
	 */
	pmu = pmu_find(name);
	if (pmu)
		return pmu;

	return pmu_lookup(name);
}

672
static struct perf_pmu_format *
673
pmu_find_format(struct list_head *formats, const char *name)
674
{
675
	struct perf_pmu_format *format;
676 677 678 679 680 681 682 683

	list_for_each_entry(format, formats, list)
		if (!strcmp(format->name, name))
			return format;

	return NULL;
}

684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
__u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
{
	struct perf_pmu_format *format = pmu_find_format(formats, name);
	__u64 bits = 0;
	int fbit;

	if (!format)
		return 0;

	for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
		bits |= 1ULL << fbit;

	return bits;
}

699
/*
700
 * Sets value based on the format definition (format parameter)
701 702
 * and unformated value (value parameter).
 */
703 704
static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
			     bool zero)
705 706 707 708 709 710 711 712
{
	unsigned long fbit, vbit;

	for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {

		if (!test_bit(fbit, format))
			continue;

713 714 715 716
		if (value & (1llu << vbit++))
			*v |= (1llu << fbit);
		else if (zero)
			*v &= ~(1llu << fbit);
717 718 719
	}
}

720 721
static __u64 pmu_format_max_value(const unsigned long *format)
{
722 723
	__u64 w = 0;
	int fbit;
724

725 726 727 728
	for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS)
		w |= (1ULL << fbit);

	return w;
729 730
}

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
/*
 * Term is a string term, and might be a param-term. Try to look up it's value
 * in the remaining terms.
 * - We have a term like "base-or-format-term=param-term",
 * - We need to find the value supplied for "param-term" (with param-term named
 *   in a config string) later on in the term list.
 */
static int pmu_resolve_param_term(struct parse_events_term *term,
				  struct list_head *head_terms,
				  __u64 *value)
{
	struct parse_events_term *t;

	list_for_each_entry(t, head_terms, list) {
		if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
			if (!strcmp(t->config, term->config)) {
				t->used = true;
				*value = t->val.num;
				return 0;
			}
		}
	}

754
	if (verbose > 0)
755 756 757 758 759
		printf("Required parameter '%s' not specified\n", term->config);

	return -1;
}

760
static char *pmu_formats_string(struct list_head *formats)
761 762
{
	struct perf_pmu_format *format;
763 764
	char *str = NULL;
	struct strbuf buf = STRBUF_INIT;
765 766
	unsigned i = 0;

767
	if (!formats)
768 769 770
		return NULL;

	/* sysfs exported terms */
771
	list_for_each_entry(format, formats, list)
772 773
		if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
			goto error;
774

775
	str = strbuf_detach(&buf, NULL);
776
error:
777
	strbuf_release(&buf);
778 779 780 781

	return str;
}

782 783
/*
 * Setup one of config[12] attr members based on the
C
Cody P Schafer 已提交
784
 * user input data - term parameter.
785 786 787
 */
static int pmu_config_term(struct list_head *formats,
			   struct perf_event_attr *attr,
788
			   struct parse_events_term *term,
789
			   struct list_head *head_terms,
790
			   bool zero, struct parse_events_error *err)
791
{
792
	struct perf_pmu_format *format;
793
	__u64 *vp;
794
	__u64 val, max_val;
795 796 797 798 799 800 801

	/*
	 * If this is a parameter we've already used for parameterized-eval,
	 * skip it in normal eval.
	 */
	if (term->used)
		return 0;
802 803 804 805 806 807 808 809 810

	/*
	 * Hardcoded terms should be already in, so nothing
	 * to be done for them.
	 */
	if (parse_events__is_hardcoded_term(term))
		return 0;

	format = pmu_find_format(formats, term->config);
811
	if (!format) {
812
		if (verbose > 0)
813
			printf("Invalid event/parameter '%s'\n", term->config);
814
		if (err) {
815 816
			char *pmu_term = pmu_formats_string(formats);

817 818
			err->idx  = term->err_term;
			err->str  = strdup("unknown term");
819 820
			err->help = parse_events_formats_error_string(pmu_term);
			free(pmu_term);
821
		}
822
		return -EINVAL;
823
	}
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838

	switch (format->value) {
	case PERF_PMU_FORMAT_VALUE_CONFIG:
		vp = &attr->config;
		break;
	case PERF_PMU_FORMAT_VALUE_CONFIG1:
		vp = &attr->config1;
		break;
	case PERF_PMU_FORMAT_VALUE_CONFIG2:
		vp = &attr->config2;
		break;
	default:
		return -EINVAL;
	}

839
	/*
840 841
	 * Either directly use a numeric term, or try to translate string terms
	 * using event parameters.
842
	 */
843 844 845 846 847 848 849 850 851 852
	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
		if (term->no_value &&
		    bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
			if (err) {
				err->idx = term->err_val;
				err->str = strdup("no value assigned for term");
			}
			return -EINVAL;
		}

853
		val = term->val.num;
854
	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
855
		if (strcmp(term->val.str, "?")) {
856
			if (verbose > 0) {
857 858
				pr_info("Invalid sysfs entry %s=%s\n",
						term->config, term->val.str);
859 860 861 862 863
			}
			if (err) {
				err->idx = term->err_val;
				err->str = strdup("expected numeric value");
			}
864 865 866 867 868 869 870 871
			return -EINVAL;
		}

		if (pmu_resolve_param_term(term, head_terms, &val))
			return -EINVAL;
	} else
		return -EINVAL;

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
	max_val = pmu_format_max_value(format->bits);
	if (val > max_val) {
		if (err) {
			err->idx = term->err_val;
			if (asprintf(&err->str,
				     "value too big for format, maximum is %llu",
				     (unsigned long long)max_val) < 0)
				err->str = strdup("value too big for format");
			return -EINVAL;
		}
		/*
		 * Assume we don't care if !err, in which case the value will be
		 * silently truncated.
		 */
	}

888
	pmu_format_value(format->bits, val, vp, zero);
889 890 891
	return 0;
}

892 893
int perf_pmu__config_terms(struct list_head *formats,
			   struct perf_event_attr *attr,
894
			   struct list_head *head_terms,
895
			   bool zero, struct parse_events_error *err)
896
{
897
	struct parse_events_term *term;
898

899
	list_for_each_entry(term, head_terms, list) {
900 901
		if (pmu_config_term(formats, attr, term, head_terms,
				    zero, err))
902
			return -EINVAL;
903
	}
904 905 906 907 908 909 910 911 912 913

	return 0;
}

/*
 * Configures event's 'attr' parameter based on the:
 * 1) users input - specified in terms parameter
 * 2) pmu format definitions - specified by pmu parameter
 */
int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
914 915
		     struct list_head *head_terms,
		     struct parse_events_error *err)
916
{
917 918
	bool zero = !!pmu->default_config;

919
	attr->type = pmu->type;
920 921
	return perf_pmu__config_terms(&pmu->format, attr, head_terms,
				      zero, err);
922 923
}

924 925
static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
					     struct parse_events_term *term)
926
{
927
	struct perf_pmu_alias *alias;
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
	char *name;

	if (parse_events__is_hardcoded_term(term))
		return NULL;

	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
		if (term->val.num != 1)
			return NULL;
		if (pmu_find_format(&pmu->format, term->config))
			return NULL;
		name = term->config;
	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
		if (strcasecmp(term->config, "event"))
			return NULL;
		name = term->val.str;
	} else {
		return NULL;
	}

	list_for_each_entry(alias, &pmu->aliases, list) {
		if (!strcasecmp(alias->name, name))
			return alias;
	}
	return NULL;
}

954

955 956
static int check_info_data(struct perf_pmu_alias *alias,
			   struct perf_pmu_info *info)
957 958 959
{
	/*
	 * Only one term in event definition can
960 961
	 * define unit, scale and snapshot, fail
	 * if there's more than one.
962
	 */
963
	if ((info->unit && alias->unit[0]) ||
964 965
	    (info->scale && alias->scale) ||
	    (info->snapshot && alias->snapshot))
966 967
		return -EINVAL;

968
	if (alias->unit[0])
969
		info->unit = alias->unit;
970 971

	if (alias->scale)
972 973 974 975
		info->scale = alias->scale;

	if (alias->snapshot)
		info->snapshot = alias->snapshot;
976 977 978 979

	return 0;
}

980 981 982 983
/*
 * Find alias in the terms list and replace it with the terms
 * defined for the alias
 */
984
int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
985
			  struct perf_pmu_info *info)
986
{
987
	struct parse_events_term *term, *h;
988
	struct perf_pmu_alias *alias;
989 990
	int ret;

991 992
	info->per_pkg = false;

993 994 995 996
	/*
	 * Mark unit and scale as not set
	 * (different from default values, see below)
	 */
997 998 999
	info->unit     = NULL;
	info->scale    = 0.0;
	info->snapshot = false;
1000
	info->metric_expr = NULL;
1001
	info->metric_name = NULL;
1002

1003 1004 1005 1006 1007 1008 1009
	list_for_each_entry_safe(term, h, head_terms, list) {
		alias = pmu_find_alias(pmu, term);
		if (!alias)
			continue;
		ret = pmu_alias_terms(alias, &term->list);
		if (ret)
			return ret;
1010

1011
		ret = check_info_data(alias, info);
1012 1013 1014
		if (ret)
			return ret;

1015 1016
		if (alias->per_pkg)
			info->per_pkg = true;
1017
		info->metric_expr = alias->metric_expr;
1018
		info->metric_name = alias->metric_name;
1019

1020 1021 1022
		list_del(&term->list);
		free(term);
	}
1023 1024 1025 1026 1027 1028

	/*
	 * if no unit or scale foundin aliases, then
	 * set defaults as for evsel
	 * unit cannot left to NULL
	 */
1029 1030
	if (info->unit == NULL)
		info->unit   = "";
1031

1032 1033
	if (info->scale == 0.0)
		info->scale  = 1.0;
1034

1035 1036 1037
	return 0;
}

1038 1039 1040
int perf_pmu__new_format(struct list_head *list, char *name,
			 int config, unsigned long *bits)
{
1041
	struct perf_pmu_format *format;
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061

	format = zalloc(sizeof(*format));
	if (!format)
		return -ENOMEM;

	format->name = strdup(name);
	format->value = config;
	memcpy(format->bits, bits, sizeof(format->bits));

	list_add_tail(&format->list, list);
	return 0;
}

void perf_pmu__set_format(unsigned long *bits, long from, long to)
{
	long b;

	if (!to)
		to = from;

1062
	memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1063 1064 1065
	for (b = from; b <= to; b++)
		set_bit(b, bits);
}
1066

1067 1068 1069 1070 1071 1072 1073
static int sub_non_neg(int a, int b)
{
	if (b > a)
		return 0;
	return a - b;
}

1074 1075 1076
static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
			  struct perf_pmu_alias *alias)
{
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
	struct parse_events_term *term;
	int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);

	list_for_each_entry(term, &alias->terms, list) {
		if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
			used += snprintf(buf + used, sub_non_neg(len, used),
					",%s=%s", term->config,
					term->val.str);
	}

	if (sub_non_neg(len, used) > 0) {
		buf[used] = '/';
		used++;
	}
	if (sub_non_neg(len, used) > 0) {
		buf[used] = '\0';
		used++;
	} else
		buf[len - 1] = '\0';

1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
	return buf;
}

static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
			     struct perf_pmu_alias *alias)
{
	snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
	return buf;
}

1107
struct sevent {
A
Andi Kleen 已提交
1108 1109
	char *name;
	char *desc;
1110
	char *topic;
1111 1112
	char *str;
	char *pmu;
1113
	char *metric_expr;
1114
	char *metric_name;
A
Andi Kleen 已提交
1115 1116
};

1117
static int cmp_sevent(const void *a, const void *b)
A
Andi Kleen 已提交
1118
{
1119 1120
	const struct sevent *as = a;
	const struct sevent *bs = b;
A
Andi Kleen 已提交
1121 1122 1123 1124

	/* Put extra events last */
	if (!!as->desc != !!bs->desc)
		return !!as->desc - !!bs->desc;
1125 1126 1127 1128 1129 1130
	if (as->topic && bs->topic) {
		int n = strcmp(as->topic, bs->topic);

		if (n)
			return n;
	}
A
Andi Kleen 已提交
1131 1132 1133 1134
	return strcmp(as->name, bs->name);
}

static void wordwrap(char *s, int start, int max, int corr)
1135
{
A
Andi Kleen 已提交
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
	int column = start;
	int n;

	while (*s) {
		int wlen = strcspn(s, " \t");

		if (column + wlen >= max && column > start) {
			printf("\n%*s", start, "");
			column = start + corr;
		}
		n = printf("%s%.*s", column > start ? " " : "", wlen, s);
		if (n <= 0)
			break;
		s += wlen;
		column += n;
		while (isspace(*s))
			s++;
	}
1154 1155
}

1156 1157
void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
			bool long_desc)
1158 1159 1160 1161 1162 1163
{
	struct perf_pmu *pmu;
	struct perf_pmu_alias *alias;
	char buf[1024];
	int printed = 0;
	int len, j;
1164
	struct sevent *aliases;
A
Andi Kleen 已提交
1165
	int numdesc = 0;
1166
	int columns = pager_get_columns();
1167
	char *topic = NULL;
1168 1169 1170

	pmu = NULL;
	len = 0;
1171
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1172 1173
		list_for_each_entry(alias, &pmu->aliases, list)
			len++;
1174 1175 1176
		if (pmu->selectable)
			len++;
	}
1177
	aliases = zalloc(sizeof(struct sevent) * len);
1178
	if (!aliases)
1179
		goto out_enomem;
1180 1181
	pmu = NULL;
	j = 0;
1182
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1183
		list_for_each_entry(alias, &pmu->aliases, list) {
A
Andi Kleen 已提交
1184 1185
			char *name = alias->desc ? alias->name :
				format_alias(buf, sizeof(buf), pmu, alias);
1186 1187 1188
			bool is_cpu = !strcmp(pmu->name, "cpu");

			if (event_glob != NULL &&
1189 1190
			    !(strglobmatch_nocase(name, event_glob) ||
			      (!is_cpu && strglobmatch_nocase(alias->name,
A
Andi Kleen 已提交
1191 1192 1193
						       event_glob)) ||
			      (alias->topic &&
			       strglobmatch_nocase(alias->topic, event_glob))))
1194
				continue;
1195

A
Andi Kleen 已提交
1196
			if (is_cpu && !name_only && !alias->desc)
1197 1198
				name = format_alias_or(buf, sizeof(buf), pmu, alias);

A
Andi Kleen 已提交
1199 1200 1201 1202 1203 1204 1205
			aliases[j].name = name;
			if (is_cpu && !name_only && !alias->desc)
				aliases[j].name = format_alias_or(buf,
								  sizeof(buf),
								  pmu, alias);
			aliases[j].name = strdup(aliases[j].name);
			if (!aliases[j].name)
1206
				goto out_enomem;
A
Andi Kleen 已提交
1207

1208 1209
			aliases[j].desc = long_desc ? alias->long_desc :
						alias->desc;
1210
			aliases[j].topic = alias->topic;
1211 1212
			aliases[j].str = alias->str;
			aliases[j].pmu = pmu->name;
1213
			aliases[j].metric_expr = alias->metric_expr;
1214
			aliases[j].metric_name = alias->metric_name;
1215 1216
			j++;
		}
1217 1218
		if (pmu->selectable &&
		    (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1219 1220 1221
			char *s;
			if (asprintf(&s, "%s//", pmu->name) < 0)
				goto out_enomem;
A
Andi Kleen 已提交
1222
			aliases[j].name = s;
1223 1224 1225
			j++;
		}
	}
1226
	len = j;
1227
	qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1228
	for (j = 0; j < len; j++) {
1229 1230 1231
		/* Skip duplicates */
		if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name))
			continue;
1232
		if (name_only) {
A
Andi Kleen 已提交
1233
			printf("%s ", aliases[j].name);
1234 1235
			continue;
		}
A
Andi Kleen 已提交
1236
		if (aliases[j].desc && !quiet_flag) {
A
Andi Kleen 已提交
1237 1238
			if (numdesc++ == 0)
				printf("\n");
1239 1240 1241 1242 1243 1244
			if (aliases[j].topic && (!topic ||
					strcmp(topic, aliases[j].topic))) {
				printf("%s%s:\n", topic ? "\n" : "",
						aliases[j].topic);
				topic = aliases[j].topic;
			}
A
Andi Kleen 已提交
1245 1246 1247 1248
			printf("  %-50s\n", aliases[j].name);
			printf("%*s", 8, "[");
			wordwrap(aliases[j].desc, 8, columns, 0);
			printf("]\n");
1249 1250
			if (verbose > 0) {
				printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
1251 1252
				if (aliases[j].metric_name)
					printf(" MetricName: %s", aliases[j].metric_name);
1253 1254 1255 1256
				if (aliases[j].metric_expr)
					printf(" MetricExpr: %s", aliases[j].metric_expr);
				putchar('\n');
			}
A
Andi Kleen 已提交
1257 1258
		} else
			printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
1259 1260
		printed++;
	}
1261
	if (printed && pager_in_use())
1262
		printf("\n");
1263 1264
out_free:
	for (j = 0; j < len; j++)
A
Andi Kleen 已提交
1265
		zfree(&aliases[j].name);
1266 1267 1268 1269 1270 1271 1272
	zfree(&aliases);
	return;

out_enomem:
	printf("FATAL: not enough memory to print PMU events\n");
	if (aliases)
		goto out_free;
1273
}
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289

bool pmu_have_event(const char *pname, const char *name)
{
	struct perf_pmu *pmu;
	struct perf_pmu_alias *alias;

	pmu = NULL;
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
		if (strcmp(pname, pmu->name))
			continue;
		list_for_each_entry(alias, &pmu->aliases, list)
			if (!strcmp(alias->name, name))
				return true;
	}
	return false;
}
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325

static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
{
	struct stat st;
	char path[PATH_MAX];
	const char *sysfs;

	sysfs = sysfs__mountpoint();
	if (!sysfs)
		return NULL;

	snprintf(path, PATH_MAX,
		 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);

	if (stat(path, &st) < 0)
		return NULL;

	return fopen(path, "r");
}

int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
			...)
{
	va_list args;
	FILE *file;
	int ret = EOF;

	va_start(args, fmt);
	file = perf_pmu__open_file(pmu, name);
	if (file) {
		ret = vfscanf(file, fmt, args);
		fclose(file);
	}
	va_end(args);
	return ret;
}