pmu.c 25.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 98 99 100 101 102 103
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];
104
	char *lc;
105 106 107 108 109 110 111 112 113 114 115 116 117 118

	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;

119 120 121 122 123
	if (scale[sret - 1] == '\n')
		scale[sret - 1] = '\0';
	else
		scale[sret] = '\0';

124 125 126 127 128
	/*
	 * save current locale
	 */
	lc = setlocale(LC_NUMERIC, NULL);

129 130 131 132 133 134 135 136 137 138 139
	/*
	 * 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;
		goto error;
	}

140 141 142 143 144 145 146 147 148 149 150 151
	/*
	 * force to C locale to ensure kernel
	 * scale string is converted correctly.
	 * kernel uses default C locale.
	 */
	setlocale(LC_NUMERIC, "C");

	alias->scale = strtod(scale, NULL);

	/* restore locale */
	setlocale(LC_NUMERIC, lc);

152
	free(lc);
153

154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
	ret = 0;
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;

172
	sret = read(fd, alias->unit, UNIT_MAX_LEN);
173 174 175 176 177
	if (sret < 0)
		goto error;

	close(fd);

178 179 180 181
	if (alias->unit[sret - 1] == '\n')
		alias->unit[sret - 1] = '\0';
	else
		alias->unit[sret] = '\0';
182 183 184 185 186 187 188 189

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

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
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;
}

208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
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;
}

225
static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
226 227
				 char *desc, char *val, char *long_desc,
				 char *topic)
228
{
229
	struct perf_pmu_alias *alias;
230 231 232 233 234 235 236
	int ret;

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

	INIT_LIST_HEAD(&alias->terms);
237 238
	alias->scale = 1.0;
	alias->unit[0] = '\0';
239
	alias->per_pkg = false;
240
	alias->snapshot = false;
241

242
	ret = parse_events_terms(&alias->terms, val);
243
	if (ret) {
244
		pr_err("Cannot parse alias %s: %d\n", val, ret);
245 246 247 248 249
		free(alias);
		return ret;
	}

	alias->name = strdup(name);
250 251 252 253 254 255 256 257 258
	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);
	}
259

A
Andi Kleen 已提交
260
	alias->desc = desc ? strdup(desc) : NULL;
261 262
	alias->long_desc = long_desc ? strdup(long_desc) :
				desc ? strdup(desc) : NULL;
263
	alias->topic = topic ? strdup(topic) : NULL;
A
Andi Kleen 已提交
264

265
	list_add_tail(&alias->list, list);
266

267 268 269
	return 0;
}

270 271 272 273 274 275 276 277 278 279 280
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;

281
	return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL);
282 283
}

284 285 286 287 288 289 290 291 292
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;
293 294
	if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
		return true;
295 296
	if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
		return true;
297 298 299 300

	return false;
}

301 302 303 304 305 306 307 308 309 310 311 312 313
/*
 * 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;

314
	while ((evt_ent = readdir(event_dir))) {
315 316 317 318 319 320 321
		char path[PATH_MAX];
		char *name = evt_ent->d_name;
		FILE *file;

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

322
		/*
323
		 * skip info files parsed in perf_pmu__new_alias()
324
		 */
325
		if (pmu_alias_info_file(name))
326 327
			continue;

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

		file = fopen(path, "r");
331 332 333 334
		if (!file) {
			pr_debug("Cannot open %s\n", path);
			continue;
		}
335

336 337
		if (perf_pmu__new_alias(head, dir, name, file) < 0)
			pr_debug("Cannot set up %s\n", name);
338 339 340 341
		fclose(file);
	}

	closedir(event_dir);
342
	return 0;
343 344 345 346 347 348
}

/*
 * Reading the pmu event aliases definition, which should be located at:
 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
 */
349
static int pmu_aliases(const char *name, struct list_head *head)
350 351 352
{
	struct stat st;
	char path[PATH_MAX];
353
	const char *sysfs = sysfs__mountpoint();
354 355 356 357 358 359 360 361

	if (!sysfs)
		return -1;

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

	if (stat(path, &st) < 0)
362
		return 0;	 /* no error if 'events' does not exist */
363 364 365 366 367 368 369

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

	return 0;
}

370
static int pmu_alias_terms(struct perf_pmu_alias *alias,
371 372
			   struct list_head *terms)
{
373
	struct parse_events_term *term, *cloned;
374 375 376 377
	LIST_HEAD(list);
	int ret;

	list_for_each_entry(term, &alias->terms, list) {
378
		ret = parse_events_term__clone(&cloned, term);
379
		if (ret) {
380
			parse_events_terms__purge(&list);
381 382
			return ret;
		}
383
		list_add_tail(&cloned->list, &list);
384 385 386 387 388
	}
	list_splice(&list, terms);
	return 0;
}

389 390 391 392 393
/*
 * Reading/parsing the default pmu type value, which should be
 * located at:
 * /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
 */
394
static int pmu_type(const char *name, __u32 *type)
395 396 397 398 399
{
	struct stat st;
	char path[PATH_MAX];
	FILE *file;
	int ret = 0;
400
	const char *sysfs = sysfs__mountpoint();
401 402 403 404 405

	if (!sysfs)
		return -1;

	snprintf(path, PATH_MAX,
406
		 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421

	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;
}

422 423 424 425 426 427
/* Add all pmus in sysfs to pmu list: */
static void pmu_read_sysfs(void)
{
	char path[PATH_MAX];
	DIR *dir;
	struct dirent *dent;
428
	const char *sysfs = sysfs__mountpoint();
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449

	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);
}

450
static struct cpu_map *pmu_cpumask(const char *name)
Y
Yan, Zheng 已提交
451 452 453 454 455
{
	struct stat st;
	char path[PATH_MAX];
	FILE *file;
	struct cpu_map *cpus;
456
	const char *sysfs = sysfs__mountpoint();
457 458 459 460 461 462
	const char *templates[] = {
		 "%s/bus/event_source/devices/%s/cpumask",
		 "%s/bus/event_source/devices/%s/cpus",
		 NULL
	};
	const char **template;
Y
Yan, Zheng 已提交
463 464 465 466

	if (!sysfs)
		return NULL;

467 468 469 470 471
	for (template = templates; *template; template++) {
		snprintf(path, PATH_MAX, *template, sysfs, name);
		if (stat(path, &st) == 0)
			break;
	}
Y
Yan, Zheng 已提交
472

473
	if (!*template)
Y
Yan, Zheng 已提交
474 475 476 477 478 479 480 481 482 483 484
		return NULL;

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

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

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
/*
 * 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.
 */
static void pmu_add_cpu_aliases(struct list_head *head)
{
	int i;
	struct pmu_events_map *map;
	struct pmu_event *pe;
	char *cpuid;
507
	static bool printed;
508

509 510 511 512 513
	cpuid = getenv("PERF_CPUID");
	if (cpuid)
		cpuid = strdup(cpuid);
	if (!cpuid)
		cpuid = get_cpuid_str();
514 515 516
	if (!cpuid)
		return;

517 518 519 520
	if (!printed) {
		pr_debug("Using CPUID %s\n", cpuid);
		printed = true;
	}
521

522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
	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) {
		pe = &map->table[i++];
		if (!pe->name)
			break;

		/* need type casts to override 'const' */
		__perf_pmu__new_alias(head, NULL, (char *)pe->name,
543
				(char *)pe->desc, (char *)pe->event,
544
				(char *)pe->long_desc, (char *)pe->topic);
545 546 547 548 549 550
	}

out:
	free(cpuid);
}

551
struct perf_event_attr * __weak
552 553 554 555 556
perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
{
	return NULL;
}

557
static struct perf_pmu *pmu_lookup(const char *name)
558 559 560
{
	struct perf_pmu *pmu;
	LIST_HEAD(format);
561
	LIST_HEAD(aliases);
562 563 564 565 566 567 568 569 570 571
	__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;

572 573 574
	if (pmu_aliases(name, &aliases))
		return NULL;

575 576 577
	if (!strcmp(name, "cpu"))
		pmu_add_cpu_aliases(&aliases);

578 579 580 581 582 583 584
	if (pmu_type(name, &type))
		return NULL;

	pmu = zalloc(sizeof(*pmu));
	if (!pmu)
		return NULL;

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

587
	INIT_LIST_HEAD(&pmu->format);
588
	INIT_LIST_HEAD(&pmu->aliases);
589
	list_splice(&format, &pmu->format);
590
	list_splice(&aliases, &pmu->aliases);
591 592
	pmu->name = strdup(name);
	pmu->type = type;
593
	list_add_tail(&pmu->list, &pmus);
594 595 596

	pmu->default_config = perf_pmu__get_default_config(pmu);

597 598 599
	return pmu;
}

600
static struct perf_pmu *pmu_find(const char *name)
601 602 603 604 605 606 607 608 609 610
{
	struct perf_pmu *pmu;

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

	return NULL;
}

611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
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;
}

626
struct perf_pmu *perf_pmu__find(const char *name)
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
{
	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);
}

642
static struct perf_pmu_format *
643
pmu_find_format(struct list_head *formats, const char *name)
644
{
645
	struct perf_pmu_format *format;
646 647 648 649 650 651 652 653

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

	return NULL;
}

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
__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;
}

669
/*
670
 * Sets value based on the format definition (format parameter)
671 672
 * and unformated value (value parameter).
 */
673 674
static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
			     bool zero)
675 676 677 678 679 680 681 682
{
	unsigned long fbit, vbit;

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

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

683 684 685 686
		if (value & (1llu << vbit++))
			*v |= (1llu << fbit);
		else if (zero)
			*v &= ~(1llu << fbit);
687 688 689
	}
}

690 691
static __u64 pmu_format_max_value(const unsigned long *format)
{
692 693
	__u64 w = 0;
	int fbit;
694

695 696 697 698
	for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS)
		w |= (1ULL << fbit);

	return w;
699 700
}

701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
/*
 * 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;
			}
		}
	}

	if (verbose)
		printf("Required parameter '%s' not specified\n", term->config);

	return -1;
}

730
static char *pmu_formats_string(struct list_head *formats)
731 732
{
	struct perf_pmu_format *format;
733 734
	char *str = NULL;
	struct strbuf buf = STRBUF_INIT;
735 736
	unsigned i = 0;

737
	if (!formats)
738 739 740
		return NULL;

	/* sysfs exported terms */
741
	list_for_each_entry(format, formats, list)
742 743
		if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
			goto error;
744

745
	str = strbuf_detach(&buf, NULL);
746
error:
747
	strbuf_release(&buf);
748 749 750 751

	return str;
}

752 753
/*
 * Setup one of config[12] attr members based on the
C
Cody P Schafer 已提交
754
 * user input data - term parameter.
755 756 757
 */
static int pmu_config_term(struct list_head *formats,
			   struct perf_event_attr *attr,
758
			   struct parse_events_term *term,
759
			   struct list_head *head_terms,
760
			   bool zero, struct parse_events_error *err)
761
{
762
	struct perf_pmu_format *format;
763
	__u64 *vp;
764
	__u64 val, max_val;
765 766 767 768 769 770 771

	/*
	 * If this is a parameter we've already used for parameterized-eval,
	 * skip it in normal eval.
	 */
	if (term->used)
		return 0;
772 773 774 775 776 777 778 779 780

	/*
	 * 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);
781 782 783
	if (!format) {
		if (verbose)
			printf("Invalid event/parameter '%s'\n", term->config);
784
		if (err) {
785 786
			char *pmu_term = pmu_formats_string(formats);

787 788
			err->idx  = term->err_term;
			err->str  = strdup("unknown term");
789 790
			err->help = parse_events_formats_error_string(pmu_term);
			free(pmu_term);
791
		}
792
		return -EINVAL;
793
	}
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808

	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;
	}

809
	/*
810 811
	 * Either directly use a numeric term, or try to translate string terms
	 * using event parameters.
812
	 */
813 814 815 816
	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
		val = term->val.num;
	else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
		if (strcmp(term->val.str, "?")) {
817
			if (verbose) {
818 819
				pr_info("Invalid sysfs entry %s=%s\n",
						term->config, term->val.str);
820 821 822 823 824
			}
			if (err) {
				err->idx = term->err_val;
				err->str = strdup("expected numeric value");
			}
825 826 827 828 829 830 831 832
			return -EINVAL;
		}

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

833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
	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.
		 */
	}

849
	pmu_format_value(format->bits, val, vp, zero);
850 851 852
	return 0;
}

853 854
int perf_pmu__config_terms(struct list_head *formats,
			   struct perf_event_attr *attr,
855
			   struct list_head *head_terms,
856
			   bool zero, struct parse_events_error *err)
857
{
858
	struct parse_events_term *term;
859

860
	list_for_each_entry(term, head_terms, list) {
861 862
		if (pmu_config_term(formats, attr, term, head_terms,
				    zero, err))
863
			return -EINVAL;
864
	}
865 866 867 868 869 870 871 872 873 874

	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,
875 876
		     struct list_head *head_terms,
		     struct parse_events_error *err)
877
{
878 879
	bool zero = !!pmu->default_config;

880
	attr->type = pmu->type;
881 882
	return perf_pmu__config_terms(&pmu->format, attr, head_terms,
				      zero, err);
883 884
}

885 886
static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
					     struct parse_events_term *term)
887
{
888
	struct perf_pmu_alias *alias;
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
	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;
}

915

916 917
static int check_info_data(struct perf_pmu_alias *alias,
			   struct perf_pmu_info *info)
918 919 920
{
	/*
	 * Only one term in event definition can
921 922
	 * define unit, scale and snapshot, fail
	 * if there's more than one.
923
	 */
924 925 926
	if ((info->unit && alias->unit) ||
	    (info->scale && alias->scale) ||
	    (info->snapshot && alias->snapshot))
927 928 929
		return -EINVAL;

	if (alias->unit)
930
		info->unit = alias->unit;
931 932

	if (alias->scale)
933 934 935 936
		info->scale = alias->scale;

	if (alias->snapshot)
		info->snapshot = alias->snapshot;
937 938 939 940

	return 0;
}

941 942 943 944
/*
 * Find alias in the terms list and replace it with the terms
 * defined for the alias
 */
945
int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
946
			  struct perf_pmu_info *info)
947
{
948
	struct parse_events_term *term, *h;
949
	struct perf_pmu_alias *alias;
950 951
	int ret;

952 953
	info->per_pkg = false;

954 955 956 957
	/*
	 * Mark unit and scale as not set
	 * (different from default values, see below)
	 */
958 959 960
	info->unit     = NULL;
	info->scale    = 0.0;
	info->snapshot = false;
961

962 963 964 965 966 967 968
	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;
969

970
		ret = check_info_data(alias, info);
971 972 973
		if (ret)
			return ret;

974 975 976
		if (alias->per_pkg)
			info->per_pkg = true;

977 978 979
		list_del(&term->list);
		free(term);
	}
980 981 982 983 984 985

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

989 990
	if (info->scale == 0.0)
		info->scale  = 1.0;
991

992 993 994
	return 0;
}

995 996 997
int perf_pmu__new_format(struct list_head *list, char *name,
			 int config, unsigned long *bits)
{
998
	struct perf_pmu_format *format;
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018

	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;

1019
	memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1020 1021 1022
	for (b = from; b <= to; b++)
		set_bit(b, bits);
}
1023

1024 1025 1026 1027 1028 1029 1030
static int sub_non_neg(int a, int b)
{
	if (b > a)
		return 0;
	return a - b;
}

1031 1032 1033
static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
			  struct perf_pmu_alias *alias)
{
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
	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';

1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
	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;
}

1064
struct sevent {
A
Andi Kleen 已提交
1065 1066
	char *name;
	char *desc;
1067
	char *topic;
A
Andi Kleen 已提交
1068 1069
};

1070
static int cmp_sevent(const void *a, const void *b)
A
Andi Kleen 已提交
1071
{
1072 1073
	const struct sevent *as = a;
	const struct sevent *bs = b;
A
Andi Kleen 已提交
1074 1075 1076 1077

	/* Put extra events last */
	if (!!as->desc != !!bs->desc)
		return !!as->desc - !!bs->desc;
1078 1079 1080 1081 1082 1083
	if (as->topic && bs->topic) {
		int n = strcmp(as->topic, bs->topic);

		if (n)
			return n;
	}
A
Andi Kleen 已提交
1084 1085 1086 1087
	return strcmp(as->name, bs->name);
}

static void wordwrap(char *s, int start, int max, int corr)
1088
{
A
Andi Kleen 已提交
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
	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++;
	}
1107 1108
}

1109 1110
void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
			bool long_desc)
1111 1112 1113 1114 1115 1116
{
	struct perf_pmu *pmu;
	struct perf_pmu_alias *alias;
	char buf[1024];
	int printed = 0;
	int len, j;
1117
	struct sevent *aliases;
A
Andi Kleen 已提交
1118
	int numdesc = 0;
1119
	int columns = pager_get_columns();
1120
	char *topic = NULL;
1121 1122 1123

	pmu = NULL;
	len = 0;
1124
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1125 1126
		list_for_each_entry(alias, &pmu->aliases, list)
			len++;
1127 1128 1129
		if (pmu->selectable)
			len++;
	}
1130
	aliases = zalloc(sizeof(struct sevent) * len);
1131
	if (!aliases)
1132
		goto out_enomem;
1133 1134
	pmu = NULL;
	j = 0;
1135
	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1136
		list_for_each_entry(alias, &pmu->aliases, list) {
A
Andi Kleen 已提交
1137 1138
			char *name = alias->desc ? alias->name :
				format_alias(buf, sizeof(buf), pmu, alias);
1139 1140 1141 1142 1143 1144 1145
			bool is_cpu = !strcmp(pmu->name, "cpu");

			if (event_glob != NULL &&
			    !(strglobmatch(name, event_glob) ||
			      (!is_cpu && strglobmatch(alias->name,
						       event_glob))))
				continue;
1146

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

A
Andi Kleen 已提交
1150 1151 1152 1153 1154 1155 1156
			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)
1157
				goto out_enomem;
A
Andi Kleen 已提交
1158

1159 1160
			aliases[j].desc = long_desc ? alias->long_desc :
						alias->desc;
1161
			aliases[j].topic = alias->topic;
1162 1163
			j++;
		}
1164 1165
		if (pmu->selectable &&
		    (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1166 1167 1168
			char *s;
			if (asprintf(&s, "%s//", pmu->name) < 0)
				goto out_enomem;
A
Andi Kleen 已提交
1169
			aliases[j].name = s;
1170 1171 1172
			j++;
		}
	}
1173
	len = j;
1174
	qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1175 1176
	for (j = 0; j < len; j++) {
		if (name_only) {
A
Andi Kleen 已提交
1177
			printf("%s ", aliases[j].name);
1178 1179
			continue;
		}
A
Andi Kleen 已提交
1180
		if (aliases[j].desc && !quiet_flag) {
A
Andi Kleen 已提交
1181 1182
			if (numdesc++ == 0)
				printf("\n");
1183 1184 1185 1186 1187 1188
			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 已提交
1189 1190 1191 1192 1193 1194
			printf("  %-50s\n", aliases[j].name);
			printf("%*s", 8, "[");
			wordwrap(aliases[j].desc, 8, columns, 0);
			printf("]\n");
		} else
			printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
1195 1196
		printed++;
	}
1197
	if (printed && pager_in_use())
1198
		printf("\n");
1199 1200
out_free:
	for (j = 0; j < len; j++)
A
Andi Kleen 已提交
1201
		zfree(&aliases[j].name);
1202 1203 1204 1205 1206 1207 1208
	zfree(&aliases);
	return;

out_enomem:
	printf("FATAL: not enough memory to print PMU events\n");
	if (aliases)
		goto out_free;
1209
}
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225

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;
}
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261

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;
}