1// SPDX-License-Identifier: GPL-2.0
   2#include <linux/list.h>
   3#include <linux/compiler.h>
   4#include <linux/string.h>
   5#include <linux/zalloc.h>
   6#include <linux/ctype.h>
   7#include <sys/types.h>
   8#include <fcntl.h>
   9#include <sys/stat.h>
  10#include <unistd.h>
  11#include <stdio.h>
  12#include <stdbool.h>
  13#include <dirent.h>
  14#include <api/fs/fs.h>
  15#include <locale.h>
  16#include <fnmatch.h>
  17#include <math.h>
  18#include "debug.h"
  19#include "evsel.h"
  20#include "pmu.h"
  21#include "pmus.h"
  22#include <util/pmu-bison.h>
  23#include <util/pmu-flex.h>
  24#include "parse-events.h"
  25#include "print-events.h"
  26#include "header.h"
  27#include "string2.h"
  28#include "strbuf.h"
  29#include "fncache.h"
  30#include "util/evsel_config.h"
  31#include <regex.h>
  32
  33struct perf_pmu perf_pmu__fake = {
  34	.name = "fake",
  35};
  36
  37#define UNIT_MAX_LEN	31 /* max length for event unit name */
  38
  39/**
  40 * struct perf_pmu_alias - An event either read from sysfs or builtin in
  41 * pmu-events.c, created by parsing the pmu-events json files.
  42 */
  43struct perf_pmu_alias {
  44	/** @name: Name of the event like "mem-loads". */
  45	char *name;
  46	/** @desc: Optional short description of the event. */
  47	char *desc;
  48	/** @long_desc: Optional long description. */
  49	char *long_desc;
  50	/**
  51	 * @topic: Optional topic such as cache or pipeline, particularly for
  52	 * json events.
  53	 */
  54	char *topic;
  55	/** @terms: Owned list of the original parsed parameters. */
  56	struct parse_events_terms terms;
  57	/** @list: List element of struct perf_pmu aliases. */
  58	struct list_head list;
  59	/**
  60	 * @pmu_name: The name copied from the json struct pmu_event. This can
  61	 * differ from the PMU name as it won't have suffixes.
  62	 */
  63	char *pmu_name;
  64	/** @unit: Units for the event, such as bytes or cache lines. */
  65	char unit[UNIT_MAX_LEN+1];
  66	/** @scale: Value to scale read counter values by. */
  67	double scale;
  68	/**
  69	 * @per_pkg: Does the file
  70	 * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.per-pkg or
  71	 * equivalent json value exist and have the value 1.
  72	 */
  73	bool per_pkg;
  74	/**
  75	 * @snapshot: Does the file
  76	 * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.snapshot
  77	 * exist and have the value 1.
  78	 */
  79	bool snapshot;
  80	/**
  81	 * @deprecated: Is the event hidden and so not shown in perf list by
  82	 * default.
  83	 */
  84	bool deprecated;
  85	/** @from_sysfs: Was the alias from sysfs or a json event? */
  86	bool from_sysfs;
  87	/** @info_loaded: Have the scale, unit and other values been read from disk? */
  88	bool info_loaded;
  89};
  90
  91/**
  92 * struct perf_pmu_format - Values from a format file read from
  93 * <sysfs>/devices/cpu/format/ held in struct perf_pmu.
  94 *
  95 * For example, the contents of <sysfs>/devices/cpu/format/event may be
  96 * "config:0-7" and will be represented here as name="event",
  97 * value=PERF_PMU_FORMAT_VALUE_CONFIG and bits 0 to 7 will be set.
  98 */
  99struct perf_pmu_format {
 100	/** @list: Element on list within struct perf_pmu. */
 101	struct list_head list;
 102	/** @bits: Which config bits are set by this format value. */
 103	DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
 104	/** @name: The modifier/file name. */
 105	char *name;
 106	/**
 107	 * @value : Which config value the format relates to. Supported values
 108	 * are from PERF_PMU_FORMAT_VALUE_CONFIG to
 109	 * PERF_PMU_FORMAT_VALUE_CONFIG_END.
 110	 */
 111	u16 value;
 112	/** @loaded: Has the contents been loaded/parsed. */
 113	bool loaded;
 114};
 115
 116static int pmu_aliases_parse(struct perf_pmu *pmu);
 117
 118static struct perf_pmu_format *perf_pmu__new_format(struct list_head *list, char *name)
 119{
 120	struct perf_pmu_format *format;
 121
 122	format = zalloc(sizeof(*format));
 123	if (!format)
 124		return NULL;
 125
 126	format->name = strdup(name);
 127	if (!format->name) {
 128		free(format);
 129		return NULL;
 130	}
 131	list_add_tail(&format->list, list);
 132	return format;
 133}
 134
 135/* Called at the end of parsing a format. */
 136void perf_pmu_format__set_value(void *vformat, int config, unsigned long *bits)
 137{
 138	struct perf_pmu_format *format = vformat;
 139
 140	format->value = config;
 141	memcpy(format->bits, bits, sizeof(format->bits));
 142}
 143
 144static void __perf_pmu_format__load(struct perf_pmu_format *format, FILE *file)
 145{
 146	void *scanner;
 147	int ret;
 148
 149	ret = perf_pmu_lex_init(&scanner);
 150	if (ret)
 151		return;
 152
 153	perf_pmu_set_in(file, scanner);
 154	ret = perf_pmu_parse(format, scanner);
 155	perf_pmu_lex_destroy(scanner);
 156	format->loaded = true;
 157}
 158
 159static void perf_pmu_format__load(const struct perf_pmu *pmu, struct perf_pmu_format *format)
 160{
 161	char path[PATH_MAX];
 162	FILE *file = NULL;
 163
 164	if (format->loaded)
 165		return;
 166
 167	if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, "format"))
 168		return;
 169
 170	assert(strlen(path) + strlen(format->name) + 2 < sizeof(path));
 171	strcat(path, "/");
 172	strcat(path, format->name);
 173
 174	file = fopen(path, "r");
 175	if (!file)
 176		return;
 177	__perf_pmu_format__load(format, file);
 178	fclose(file);
 179}
 180
 181/*
 182 * Parse & process all the sysfs attributes located under
 183 * the directory specified in 'dir' parameter.
 184 */
 185int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load)
 186{
 187	struct dirent *evt_ent;
 188	DIR *format_dir;
 189	int ret = 0;
 190
 191	format_dir = fdopendir(dirfd);
 192	if (!format_dir)
 193		return -EINVAL;
 194
 195	while ((evt_ent = readdir(format_dir)) != NULL) {
 196		struct perf_pmu_format *format;
 197		char *name = evt_ent->d_name;
 
 198
 199		if (!strcmp(name, ".") || !strcmp(name, ".."))
 200			continue;
 201
 202		format = perf_pmu__new_format(&pmu->format, name);
 203		if (!format) {
 204			ret = -ENOMEM;
 
 
 205			break;
 206		}
 207
 208		if (eager_load) {
 209			FILE *file;
 210			int fd = openat(dirfd, name, O_RDONLY);
 211
 212			if (fd < 0) {
 213				ret = -errno;
 214				break;
 215			}
 216			file = fdopen(fd, "r");
 217			if (!file) {
 218				close(fd);
 219				break;
 220			}
 221			__perf_pmu_format__load(format, file);
 222			fclose(file);
 223		}
 224	}
 225
 226	closedir(format_dir);
 227	return ret;
 228}
 229
 230/*
 231 * Reading/parsing the default pmu format definition, which should be
 232 * located at:
 233 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
 234 */
 235static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name)
 236{
 237	int fd;
 238
 239	fd = perf_pmu__pathname_fd(dirfd, name, "format", O_DIRECTORY);
 240	if (fd < 0)
 241		return 0;
 242
 243	/* it'll close the fd */
 244	if (perf_pmu__format_parse(pmu, fd, /*eager_load=*/false))
 245		return -1;
 246
 247	return 0;
 248}
 249
 250int perf_pmu__convert_scale(const char *scale, char **end, double *sval)
 251{
 252	char *lc;
 253	int ret = 0;
 254
 255	/*
 256	 * save current locale
 257	 */
 258	lc = setlocale(LC_NUMERIC, NULL);
 259
 260	/*
 261	 * The lc string may be allocated in static storage,
 262	 * so get a dynamic copy to make it survive setlocale
 263	 * call below.
 264	 */
 265	lc = strdup(lc);
 266	if (!lc) {
 267		ret = -ENOMEM;
 268		goto out;
 269	}
 270
 271	/*
 272	 * force to C locale to ensure kernel
 273	 * scale string is converted correctly.
 274	 * kernel uses default C locale.
 275	 */
 276	setlocale(LC_NUMERIC, "C");
 277
 278	*sval = strtod(scale, end);
 
 279
 280out:
 281	/* restore locale */
 282	setlocale(LC_NUMERIC, lc);
 283	free(lc);
 284	return ret;
 285}
 286
 287static int perf_pmu__parse_scale(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 288{
 289	struct stat st;
 290	ssize_t sret;
 291	size_t len;
 292	char scale[128];
 293	int fd, ret = -1;
 294	char path[PATH_MAX];
 
 295
 296	len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 297	if (!len)
 298		return 0;
 299	scnprintf(path + len, sizeof(path) - len, "%s/events/%s.scale", pmu->name, alias->name);
 300
 301	fd = open(path, O_RDONLY);
 302	if (fd == -1)
 303		return -1;
 304
 305	if (fstat(fd, &st) < 0)
 306		goto error;
 307
 308	sret = read(fd, scale, sizeof(scale)-1);
 309	if (sret < 0)
 310		goto error;
 311
 312	if (scale[sret - 1] == '\n')
 313		scale[sret - 1] = '\0';
 314	else
 315		scale[sret] = '\0';
 
 316
 317	ret = perf_pmu__convert_scale(scale, NULL, &alias->scale);
 
 
 
 
 
 
 
 
 
 
 
 
 318error:
 319	close(fd);
 320	return ret;
 321}
 322
 323static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 324{
 325	char path[PATH_MAX];
 326	size_t len;
 327	ssize_t sret;
 328	int fd;
 329
 330
 331	len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 332	if (!len)
 333		return 0;
 334	scnprintf(path + len, sizeof(path) - len, "%s/events/%s.unit", pmu->name, alias->name);
 335
 336	fd = open(path, O_RDONLY);
 337	if (fd == -1)
 338		return -1;
 339
 340	sret = read(fd, alias->unit, UNIT_MAX_LEN);
 341	if (sret < 0)
 342		goto error;
 343
 344	close(fd);
 345
 346	if (alias->unit[sret - 1] == '\n')
 347		alias->unit[sret - 1] = '\0';
 348	else
 349		alias->unit[sret] = '\0';
 350
 351	return 0;
 352error:
 353	close(fd);
 354	alias->unit[0] = '\0';
 355	return -1;
 356}
 357
 358static int
 359perf_pmu__parse_per_pkg(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 360{
 361	char path[PATH_MAX];
 362	size_t len;
 363	int fd;
 364
 365	len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 366	if (!len)
 367		return 0;
 368	scnprintf(path + len, sizeof(path) - len, "%s/events/%s.per-pkg", pmu->name, alias->name);
 369
 370	fd = open(path, O_RDONLY);
 371	if (fd == -1)
 372		return -1;
 373
 374	close(fd);
 375
 376	alias->per_pkg = true;
 377	return 0;
 378}
 379
 380static int perf_pmu__parse_snapshot(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 381{
 382	char path[PATH_MAX];
 383	size_t len;
 384	int fd;
 385
 386	len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 387	if (!len)
 388		return 0;
 389	scnprintf(path + len, sizeof(path) - len, "%s/events/%s.snapshot", pmu->name, alias->name);
 390
 391	fd = open(path, O_RDONLY);
 392	if (fd == -1)
 393		return -1;
 394
 395	alias->snapshot = true;
 396	close(fd);
 397	return 0;
 398}
 399
 400/* Delete an alias entry. */
 401static void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
 402{
 403	zfree(&newalias->name);
 404	zfree(&newalias->desc);
 405	zfree(&newalias->long_desc);
 406	zfree(&newalias->topic);
 407	zfree(&newalias->pmu_name);
 408	parse_events_terms__exit(&newalias->terms);
 409	free(newalias);
 410}
 411
 412static void perf_pmu__del_aliases(struct perf_pmu *pmu)
 413{
 414	struct perf_pmu_alias *alias, *tmp;
 415
 416	list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) {
 417		list_del(&alias->list);
 418		perf_pmu_free_alias(alias);
 419	}
 420}
 421
 422static struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu,
 423						   const char *name,
 424						   bool load)
 425{
 426	struct perf_pmu_alias *alias;
 427
 428	if (load && !pmu->sysfs_aliases_loaded)
 429		pmu_aliases_parse(pmu);
 430
 431	list_for_each_entry(alias, &pmu->aliases, list) {
 432		if (!strcasecmp(alias->name, name))
 433			return alias;
 434	}
 435	return NULL;
 436}
 437
 438static bool assign_str(const char *name, const char *field, char **old_str,
 439				const char *new_str)
 440{
 441	if (!*old_str && new_str) {
 442		*old_str = strdup(new_str);
 443		return true;
 444	}
 445
 446	if (!new_str || !strcasecmp(*old_str, new_str))
 447		return false; /* Nothing to update. */
 448
 449	pr_debug("alias %s differs in field '%s' ('%s' != '%s')\n",
 450		name, field, *old_str, new_str);
 451	zfree(old_str);
 452	*old_str = strdup(new_str);
 453	return true;
 454}
 455
 456static void read_alias_info(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 457{
 458	if (!alias->from_sysfs || alias->info_loaded)
 459		return;
 460
 461	/*
 462	 * load unit name and scale if available
 463	 */
 464	perf_pmu__parse_unit(pmu, alias);
 465	perf_pmu__parse_scale(pmu, alias);
 466	perf_pmu__parse_per_pkg(pmu, alias);
 467	perf_pmu__parse_snapshot(pmu, alias);
 468}
 469
 470struct update_alias_data {
 471	struct perf_pmu *pmu;
 472	struct perf_pmu_alias *alias;
 473};
 474
 475static int update_alias(const struct pmu_event *pe,
 476			const struct pmu_events_table *table __maybe_unused,
 477			void *vdata)
 478{
 479	struct update_alias_data *data = vdata;
 480	int ret = 0;
 481
 482	read_alias_info(data->pmu, data->alias);
 483	assign_str(pe->name, "desc", &data->alias->desc, pe->desc);
 484	assign_str(pe->name, "long_desc", &data->alias->long_desc, pe->long_desc);
 485	assign_str(pe->name, "topic", &data->alias->topic, pe->topic);
 486	data->alias->per_pkg = pe->perpkg;
 487	if (pe->event) {
 488		parse_events_terms__exit(&data->alias->terms);
 489		ret = parse_events_terms(&data->alias->terms, pe->event, /*input=*/NULL);
 490	}
 491	if (!ret && pe->unit) {
 492		char *unit;
 493
 494		ret = perf_pmu__convert_scale(pe->unit, &unit, &data->alias->scale);
 495		if (!ret)
 496			snprintf(data->alias->unit, sizeof(data->alias->unit), "%s", unit);
 497	}
 498	return ret;
 499}
 500
 501static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name,
 502				const char *desc, const char *val, FILE *val_fd,
 503				const struct pmu_event *pe)
 504{
 505	struct perf_pmu_alias *alias;
 
 506	int ret;
 507	const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL;
 508	bool deprecated = false, perpkg = false;
 509
 510	if (perf_pmu__find_alias(pmu, name, /*load=*/ false)) {
 511		/* Alias was already created/loaded. */
 512		return 0;
 513	}
 514
 515	if (pe) {
 516		long_desc = pe->long_desc;
 517		topic = pe->topic;
 518		unit = pe->unit;
 519		perpkg = pe->perpkg;
 520		deprecated = pe->deprecated;
 521		pmu_name = pe->pmu;
 522	}
 523
 524	alias = zalloc(sizeof(*alias));
 525	if (!alias)
 526		return -ENOMEM;
 527
 528	parse_events_terms__init(&alias->terms);
 529	alias->scale = 1.0;
 530	alias->unit[0] = '\0';
 531	alias->per_pkg = perpkg;
 532	alias->snapshot = false;
 533	alias->deprecated = deprecated;
 534
 535	ret = parse_events_terms(&alias->terms, val, val_fd);
 536	if (ret) {
 537		pr_err("Cannot parse alias %s: %d\n", val, ret);
 538		free(alias);
 539		return ret;
 540	}
 541
 542	alias->name = strdup(name);
 543	alias->desc = desc ? strdup(desc) : NULL;
 544	alias->long_desc = long_desc ? strdup(long_desc) :
 545				desc ? strdup(desc) : NULL;
 546	alias->topic = topic ? strdup(topic) : NULL;
 547	alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL;
 548	if (unit) {
 549		if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) {
 550			perf_pmu_free_alias(alias);
 551			return -1;
 552		}
 553		snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
 554	}
 555	if (!pe) {
 556		/* Update an event from sysfs with json data. */
 557		struct update_alias_data data = {
 558			.pmu = pmu,
 559			.alias = alias,
 560		};
 561
 562		alias->from_sysfs = true;
 563		if (pmu->events_table) {
 564			if (pmu_events_table__find_event(pmu->events_table, pmu, name,
 565							 update_alias, &data) == 0)
 566				pmu->loaded_json_aliases++;
 567		}
 568	}
 569
 570	if (!pe)
 571		pmu->sysfs_aliases++;
 572	else
 573		pmu->loaded_json_aliases++;
 574	list_add_tail(&alias->list, &pmu->aliases);
 575	return 0;
 576}
 577
 578static inline bool pmu_alias_info_file(const char *name)
 579{
 580	size_t len;
 581
 582	len = strlen(name);
 583	if (len > 5 && !strcmp(name + len - 5, ".unit"))
 584		return true;
 585	if (len > 6 && !strcmp(name + len - 6, ".scale"))
 586		return true;
 587	if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
 588		return true;
 589	if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
 590		return true;
 591
 592	return false;
 593}
 594
 595/*
 596 * Reading the pmu event aliases definition, which should be located at:
 597 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
 598 */
 599static int pmu_aliases_parse(struct perf_pmu *pmu)
 600{
 601	char path[PATH_MAX];
 602	struct dirent *evt_ent;
 603	DIR *event_dir;
 604	size_t len;
 605	int fd, dir_fd;
 606
 607	len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 608	if (!len)
 609		return 0;
 610	scnprintf(path + len, sizeof(path) - len, "%s/events", pmu->name);
 611
 612	dir_fd = open(path, O_DIRECTORY);
 613	if (dir_fd == -1) {
 614		pmu->sysfs_aliases_loaded = true;
 615		return 0;
 616	}
 617
 618	event_dir = fdopendir(dir_fd);
 619	if (!event_dir){
 620		close (dir_fd);
 621		return -EINVAL;
 622	}
 623
 624	while ((evt_ent = readdir(event_dir))) {
 
 625		char *name = evt_ent->d_name;
 626		FILE *file;
 627
 628		if (!strcmp(name, ".") || !strcmp(name, ".."))
 629			continue;
 630
 631		/*
 632		 * skip info files parsed in perf_pmu__new_alias()
 
 633		 */
 634		if (pmu_alias_info_file(name))
 
 635			continue;
 636
 637		fd = openat(dir_fd, name, O_RDONLY);
 638		if (fd == -1) {
 639			pr_debug("Cannot open %s\n", name);
 640			continue;
 641		}
 642		file = fdopen(fd, "r");
 643		if (!file) {
 644			close(fd);
 645			continue;
 646		}
 647
 648		if (perf_pmu__new_alias(pmu, name, /*desc=*/ NULL,
 649					/*val=*/ NULL, file, /*pe=*/ NULL) < 0)
 650			pr_debug("Cannot set up %s\n", name);
 651		fclose(file);
 652	}
 653
 654	closedir(event_dir);
 655	close (dir_fd);
 656	pmu->sysfs_aliases_loaded = true;
 657	return 0;
 658}
 659
 660static int pmu_alias_terms(struct perf_pmu_alias *alias, struct list_head *terms)
 661{
 662	struct parse_events_term *term, *cloned;
 663	struct parse_events_terms clone_terms;
 664
 665	parse_events_terms__init(&clone_terms);
 666	list_for_each_entry(term, &alias->terms.terms, list) {
 667		int ret = parse_events_term__clone(&cloned, term);
 668
 669		if (ret) {
 670			parse_events_terms__exit(&clone_terms);
 671			return ret;
 672		}
 673		/*
 674		 * Weak terms don't override command line options,
 675		 * which we don't want for implicit terms in aliases.
 676		 */
 677		cloned->weak = true;
 678		list_add_tail(&cloned->list, &clone_terms.terms);
 679	}
 680	list_splice_init(&clone_terms.terms, terms);
 681	parse_events_terms__exit(&clone_terms);
 682	return 0;
 683}
 684
 685/*
 686 * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64)
 687 * may have a "cpus" file.
 688 */
 689static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core)
 690{
 691	struct perf_cpu_map *cpus;
 692	const char *templates[] = {
 693		"cpumask",
 694		"cpus",
 695		NULL
 696	};
 697	const char **template;
 698	char pmu_name[PATH_MAX];
 699	struct perf_pmu pmu = {.name = pmu_name};
 700	FILE *file;
 701
 702	strlcpy(pmu_name, name, sizeof(pmu_name));
 703	for (template = templates; *template; template++) {
 704		file = perf_pmu__open_file_at(&pmu, dirfd, *template);
 705		if (!file)
 706			continue;
 707		cpus = perf_cpu_map__read(file);
 
 708		fclose(file);
 709		if (cpus)
 710			return cpus;
 711	}
 712
 713	/* Nothing found, for core PMUs assume this means all CPUs. */
 714	return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL;
 715}
 716
 717static bool pmu_is_uncore(int dirfd, const char *name)
 718{
 719	int fd;
 720
 721	fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH);
 722	if (fd < 0)
 723		return false;
 724
 725	close(fd);
 726	return true;
 727}
 728
 729static char *pmu_id(const char *name)
 730{
 731	char path[PATH_MAX], *str;
 732	size_t len;
 733
 734	perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier");
 735
 736	if (filename__read_str(path, &str, &len) < 0)
 737		return NULL;
 738
 739	str[len - 1] = 0; /* remove line feed */
 740
 741	return str;
 742}
 743
 744/**
 745 * is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in
 746 *         sysfs on some platforms like ARM or Intel hybrid. Looking for
 747 *         possible the cpus file in sysfs files to identify whether this is a
 748 *         core device.
 749 * @name: The PMU name such as "cpu_atom".
 750 */
 751static int is_sysfs_pmu_core(const char *name)
 752{
 
 753	char path[PATH_MAX];
 
 754
 755	if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus"))
 756		return 0;
 757	return file_available(path);
 758}
 759
 760char *perf_pmu__getcpuid(struct perf_pmu *pmu)
 761{
 762	char *cpuid;
 763	static bool printed;
 764
 765	cpuid = getenv("PERF_CPUID");
 766	if (cpuid)
 767		cpuid = strdup(cpuid);
 768	if (!cpuid)
 769		cpuid = get_cpuid_str(pmu);
 770	if (!cpuid)
 771		return NULL;
 772
 773	if (!printed) {
 774		pr_debug("Using CPUID %s\n", cpuid);
 775		printed = true;
 776	}
 777	return cpuid;
 778}
 779
 780__weak const struct pmu_metrics_table *pmu_metrics_table__find(void)
 781{
 782	return perf_pmu__find_metrics_table(NULL);
 783}
 784
 785/**
 786 * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any
 787 *                                   trailing suffix? The Suffix must be in form
 788 *                                   tok_{digits}, or tok{digits}.
 789 * @pmu_name: The pmu_name with possible suffix.
 790 * @tok: The possible match to pmu_name without suffix.
 791 */
 792static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok)
 793{
 794	const char *p;
 795
 796	if (strncmp(pmu_name, tok, strlen(tok)))
 797		return false;
 798
 799	p = pmu_name + strlen(tok);
 800	if (*p == 0)
 801		return true;
 802
 803	if (*p == '_')
 804		++p;
 805
 806	/* Ensure we end in a number */
 807	while (1) {
 808		if (!isdigit(*p))
 809			return false;
 810		if (*(++p) == 0)
 811			break;
 
 812	}
 813
 814	return true;
 815}
 816
 817/**
 818 * pmu_uncore_alias_match - does name match the PMU name?
 819 * @pmu_name: the json struct pmu_event name. This may lack a suffix (which
 820 *            matches) or be of the form "socket,pmuname" which will match
 821 *            "socketX_pmunameY".
 822 * @name: a real full PMU name as from sysfs.
 823 */
 824static bool pmu_uncore_alias_match(const char *pmu_name, const char *name)
 825{
 826	char *tmp = NULL, *tok, *str;
 827	bool res;
 828
 829	if (strchr(pmu_name, ',') == NULL)
 830		return perf_pmu__match_ignoring_suffix(name, pmu_name);
 831
 832	str = strdup(pmu_name);
 833	if (!str)
 834		return false;
 835
 836	/*
 837	 * uncore alias may be from different PMU with common prefix
 838	 */
 839	tok = strtok_r(str, ",", &tmp);
 840	if (strncmp(pmu_name, tok, strlen(tok))) {
 841		res = false;
 842		goto out;
 843	}
 844
 845	/*
 846	 * Match more complex aliases where the alias name is a comma-delimited
 847	 * list of tokens, orderly contained in the matching PMU name.
 848	 *
 849	 * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we
 850	 *	    match "socket" in "socketX_pmunameY" and then "pmuname" in
 851	 *	    "pmunameY".
 852	 */
 853	while (1) {
 854		char *next_tok = strtok_r(NULL, ",", &tmp);
 855
 856		name = strstr(name, tok);
 857		if (!name ||
 858		    (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) {
 859			res = false;
 860			goto out;
 861		}
 862		if (!next_tok)
 863			break;
 864		tok = next_tok;
 865		name += strlen(tok);
 866	}
 867
 868	res = true;
 869out:
 870	free(str);
 871	return res;
 872}
 873
 874bool pmu_uncore_identifier_match(const char *compat, const char *id)
 875{
 876	regex_t re;
 877	regmatch_t pmatch[1];
 878	int match;
 879
 880	if (regcomp(&re, compat, REG_EXTENDED) != 0) {
 881		/* Warn unable to generate match particular string. */
 882		pr_info("Invalid regular expression %s\n", compat);
 883		return false;
 884	}
 885
 886	match = !regexec(&re, id, 1, pmatch, 0);
 887	if (match) {
 888		/* Ensure a full match. */
 889		match = pmatch[0].rm_so == 0 && (size_t)pmatch[0].rm_eo == strlen(id);
 890	}
 891	regfree(&re);
 892
 893	return match;
 894}
 895
 896static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe,
 897					const struct pmu_events_table *table __maybe_unused,
 898					void *vdata)
 899{
 900	struct perf_pmu *pmu = vdata;
 901
 902	perf_pmu__new_alias(pmu, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, pe);
 903	return 0;
 904}
 905
 906/*
 907 * From the pmu_events_table, find the events that correspond to the given
 908 * PMU and add them to the list 'head'.
 909 */
 910void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table)
 911{
 912	pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu);
 913}
 914
 915static void pmu_add_cpu_aliases(struct perf_pmu *pmu)
 
 916{
 917	if (!pmu->events_table)
 918		return;
 
 
 919
 920	if (pmu->cpu_aliases_added)
 921		return;
 922
 923	pmu_add_cpu_aliases_table(pmu, pmu->events_table);
 924	pmu->cpu_aliases_added = true;
 925}
 926
 927static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe,
 928				       const struct pmu_events_table *table __maybe_unused,
 929				       void *vdata)
 930{
 931	struct perf_pmu *pmu = vdata;
 932
 933	if (!pe->compat || !pe->pmu)
 934		return 0;
 
 935
 936	if (pmu_uncore_alias_match(pe->pmu, pmu->name) &&
 937			pmu_uncore_identifier_match(pe->compat, pmu->id)) {
 938		perf_pmu__new_alias(pmu,
 939				pe->name,
 940				pe->desc,
 941				pe->event,
 942				/*val_fd=*/ NULL,
 943				pe);
 944	}
 945
 946	return 0;
 947}
 948
 949void pmu_add_sys_aliases(struct perf_pmu *pmu)
 950{
 951	if (!pmu->id)
 952		return;
 
 
 
 953
 954	pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu);
 955}
 956
 957static char *pmu_find_alias_name(struct perf_pmu *pmu, int dirfd)
 958{
 959	FILE *file = perf_pmu__open_file_at(pmu, dirfd, "alias");
 960	char *line = NULL;
 961	size_t line_len = 0;
 962	ssize_t ret;
 963
 964	if (!file)
 965		return NULL;
 966
 967	ret = getline(&line, &line_len, file);
 968	if (ret < 0) {
 969		fclose(file);
 970		return NULL;
 971	}
 972	/* Remove trailing newline. */
 973	if (ret > 0 && line[ret - 1] == '\n')
 974		line[--ret] = '\0';
 975
 
 976	fclose(file);
 977	return line;
 978}
 979
 980static int pmu_max_precise(int dirfd, struct perf_pmu *pmu)
 981{
 982	int max_precise = -1;
 983
 984	perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise);
 985	return max_precise;
 986}
 987
 988void __weak
 989perf_pmu__arch_init(struct perf_pmu *pmu __maybe_unused)
 990{
 991}
 992
 993struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *name)
 994{
 995	struct perf_pmu *pmu;
 
 
 996	__u32 type;
 997
 998	pmu = zalloc(sizeof(*pmu));
 999	if (!pmu)
1000		return NULL;
1001
1002	pmu->name = strdup(name);
1003	if (!pmu->name)
1004		goto err;
1005
1006	/*
1007	 * Read type early to fail fast if a lookup name isn't a PMU. Ensure
1008	 * that type value is successfully assigned (return 1).
1009	 */
1010	if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1)
1011		goto err;
1012
1013	INIT_LIST_HEAD(&pmu->format);
1014	INIT_LIST_HEAD(&pmu->aliases);
1015	INIT_LIST_HEAD(&pmu->caps);
1016
1017	/*
1018	 * The pmu data we store & need consists of the pmu
1019	 * type value and format definitions. Load both right
1020	 * now.
1021	 */
1022	if (pmu_format(pmu, dirfd, name)) {
1023		free(pmu);
1024		return NULL;
1025	}
1026	pmu->is_core = is_pmu_core(name);
1027	pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core);
1028
1029	pmu->type = type;
1030	pmu->is_uncore = pmu_is_uncore(dirfd, name);
1031	if (pmu->is_uncore)
1032		pmu->id = pmu_id(name);
1033	pmu->max_precise = pmu_max_precise(dirfd, pmu);
1034	pmu->alias_name = pmu_find_alias_name(pmu, dirfd);
1035	pmu->events_table = perf_pmu__find_events_table(pmu);
1036	pmu_add_sys_aliases(pmu);
1037	list_add_tail(&pmu->list, pmus);
1038
1039	perf_pmu__arch_init(pmu);
1040
1041	return pmu;
1042err:
1043	zfree(&pmu->name);
1044	free(pmu);
1045	return NULL;
1046}
1047
1048/* Creates the PMU when sysfs scanning fails. */
1049struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus)
1050{
1051	struct perf_pmu *pmu = zalloc(sizeof(*pmu));
1052
1053	if (!pmu)
1054		return NULL;
1055
1056	pmu->name = strdup("cpu");
1057	if (!pmu->name) {
1058		free(pmu);
1059		return NULL;
1060	}
1061
1062	pmu->is_core = true;
1063	pmu->type = PERF_TYPE_RAW;
1064	pmu->cpus = cpu_map__online();
1065
1066	INIT_LIST_HEAD(&pmu->format);
1067	INIT_LIST_HEAD(&pmu->aliases);
1068	INIT_LIST_HEAD(&pmu->caps);
1069	list_add_tail(&pmu->list, core_pmus);
 
 
 
1070	return pmu;
1071}
1072
1073void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu)
1074{
1075	struct perf_pmu_format *format;
1076
1077	if (pmu->formats_checked)
1078		return;
1079
1080	pmu->formats_checked = true;
1081
1082	/* fake pmu doesn't have format list */
1083	if (pmu == &perf_pmu__fake)
1084		return;
1085
1086	list_for_each_entry(format, &pmu->format, list) {
1087		perf_pmu_format__load(pmu, format);
1088		if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) {
1089			pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'"
1090				   "which is not supported by this version of perf!\n",
1091				   pmu->name, format->name, format->value);
1092			return;
1093		}
1094	}
1095}
1096
1097bool evsel__is_aux_event(const struct evsel *evsel)
1098{
1099	struct perf_pmu *pmu = evsel__find_pmu(evsel);
1100
1101	return pmu && pmu->auxtrace;
 
 
 
 
 
 
 
 
1102}
1103
1104/*
1105 * Set @config_name to @val as long as the user hasn't already set or cleared it
1106 * by passing a config term on the command line.
1107 *
1108 * @val is the value to put into the bits specified by @config_name rather than
1109 * the bit pattern. It is shifted into position by this function, so to set
1110 * something to true, pass 1 for val rather than a pre shifted value.
1111 */
1112#define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask))
1113void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel,
1114				const char *config_name, u64 val)
1115{
1116	u64 user_bits = 0, bits;
1117	struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG);
1118
1119	if (term)
1120		user_bits = term->val.cfg_chg;
1121
1122	bits = perf_pmu__format_bits(pmu, config_name);
1123
1124	/* Do nothing if the user changed the value */
1125	if (bits & user_bits)
1126		return;
 
 
 
 
 
1127
1128	/* Otherwise replace it */
1129	evsel->core.attr.config &= ~bits;
1130	evsel->core.attr.config |= field_prep(bits, val);
1131}
1132
1133static struct perf_pmu_format *
1134pmu_find_format(const struct list_head *formats, const char *name)
1135{
1136	struct perf_pmu_format *format;
1137
1138	list_for_each_entry(format, formats, list)
1139		if (!strcmp(format->name, name))
1140			return format;
1141
1142	return NULL;
1143}
1144
1145__u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name)
1146{
1147	struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);
1148	__u64 bits = 0;
1149	int fbit;
1150
1151	if (!format)
1152		return 0;
1153
1154	for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
1155		bits |= 1ULL << fbit;
1156
1157	return bits;
1158}
1159
1160int perf_pmu__format_type(struct perf_pmu *pmu, const char *name)
1161{
1162	struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);
1163
1164	if (!format)
1165		return -1;
1166
1167	perf_pmu_format__load(pmu, format);
1168	return format->value;
1169}
1170
1171/*
1172 * Sets value based on the format definition (format parameter)
1173 * and unformatted value (value parameter).
 
 
1174 */
1175static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
1176			     bool zero)
1177{
1178	unsigned long fbit, vbit;
 
1179
1180	for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
1181
1182		if (!test_bit(fbit, format))
1183			continue;
1184
1185		if (value & (1llu << vbit++))
1186			*v |= (1llu << fbit);
1187		else if (zero)
1188			*v &= ~(1llu << fbit);
1189	}
1190}
1191
1192static __u64 pmu_format_max_value(const unsigned long *format)
1193{
1194	int w;
1195
1196	w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
1197	if (!w)
1198		return 0;
1199	if (w < 64)
1200		return (1ULL << w) - 1;
1201	return -1;
1202}
1203
1204/*
1205 * Term is a string term, and might be a param-term. Try to look up it's value
1206 * in the remaining terms.
1207 * - We have a term like "base-or-format-term=param-term",
1208 * - We need to find the value supplied for "param-term" (with param-term named
1209 *   in a config string) later on in the term list.
1210 */
1211static int pmu_resolve_param_term(struct parse_events_term *term,
1212				  struct parse_events_terms *head_terms,
1213				  __u64 *value)
1214{
1215	struct parse_events_term *t;
1216
1217	list_for_each_entry(t, &head_terms->terms, list) {
1218		if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM &&
1219		    t->config && !strcmp(t->config, term->config)) {
1220			t->used = true;
1221			*value = t->val.num;
1222			return 0;
1223		}
1224	}
1225
1226	if (verbose > 0)
1227		printf("Required parameter '%s' not specified\n", term->config);
1228
1229	return -1;
1230}
1231
1232static char *pmu_formats_string(const struct list_head *formats)
1233{
1234	struct perf_pmu_format *format;
1235	char *str = NULL;
1236	struct strbuf buf = STRBUF_INIT;
1237	unsigned int i = 0;
1238
1239	if (!formats)
1240		return NULL;
1241
1242	/* sysfs exported terms */
1243	list_for_each_entry(format, formats, list)
1244		if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
1245			goto error;
1246
1247	str = strbuf_detach(&buf, NULL);
1248error:
1249	strbuf_release(&buf);
1250
1251	return str;
1252}
1253
1254/*
1255 * Setup one of config[12] attr members based on the
1256 * user input data - term parameter.
1257 */
1258static int pmu_config_term(const struct perf_pmu *pmu,
1259			   struct perf_event_attr *attr,
1260			   struct parse_events_term *term,
1261			   struct parse_events_terms *head_terms,
1262			   bool zero, struct parse_events_error *err)
1263{
1264	struct perf_pmu_format *format;
1265	__u64 *vp;
1266	__u64 val, max_val;
1267
1268	/*
1269	 * If this is a parameter we've already used for parameterized-eval,
1270	 * skip it in normal eval.
1271	 */
1272	if (term->used)
1273		return 0;
1274
1275	/*
 
1276	 * Hardcoded terms should be already in, so nothing
1277	 * to be done for them.
1278	 */
1279	if (parse_events__is_hardcoded_term(term))
1280		return 0;
1281
1282	format = pmu_find_format(&pmu->format, term->config);
1283	if (!format) {
1284		char *pmu_term = pmu_formats_string(&pmu->format);
1285		char *unknown_term;
1286		char *help_msg;
1287
1288		if (asprintf(&unknown_term,
1289				"unknown term '%s' for pmu '%s'",
1290				term->config, pmu->name) < 0)
1291			unknown_term = NULL;
1292		help_msg = parse_events_formats_error_string(pmu_term);
1293		if (err) {
1294			parse_events_error__handle(err, term->err_term,
1295						   unknown_term,
1296						   help_msg);
1297		} else {
1298			pr_debug("%s (%s)\n", unknown_term, help_msg);
1299			free(unknown_term);
1300		}
1301		free(pmu_term);
1302		return -EINVAL;
1303	}
1304	perf_pmu_format__load(pmu, format);
 
 
 
1305	switch (format->value) {
1306	case PERF_PMU_FORMAT_VALUE_CONFIG:
1307		vp = &attr->config;
1308		break;
1309	case PERF_PMU_FORMAT_VALUE_CONFIG1:
1310		vp = &attr->config1;
1311		break;
1312	case PERF_PMU_FORMAT_VALUE_CONFIG2:
1313		vp = &attr->config2;
1314		break;
1315	case PERF_PMU_FORMAT_VALUE_CONFIG3:
1316		vp = &attr->config3;
1317		break;
1318	default:
1319		return -EINVAL;
1320	}
1321
1322	/*
1323	 * Either directly use a numeric term, or try to translate string terms
1324	 * using event parameters.
 
1325	 */
1326	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1327		if (term->no_value &&
1328		    bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
1329			if (err) {
1330				parse_events_error__handle(err, term->err_val,
1331					   strdup("no value assigned for term"),
1332					   NULL);
1333			}
1334			return -EINVAL;
1335		}
1336
1337		val = term->val.num;
1338	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1339		if (strcmp(term->val.str, "?")) {
1340			if (verbose > 0) {
1341				pr_info("Invalid sysfs entry %s=%s\n",
1342						term->config, term->val.str);
1343			}
1344			if (err) {
1345				parse_events_error__handle(err, term->err_val,
1346					strdup("expected numeric value"),
1347					NULL);
1348			}
1349			return -EINVAL;
1350		}
1351
1352		if (pmu_resolve_param_term(term, head_terms, &val))
1353			return -EINVAL;
1354	} else
1355		return -EINVAL;
1356
1357	max_val = pmu_format_max_value(format->bits);
1358	if (val > max_val) {
1359		if (err) {
1360			char *err_str;
1361
1362			parse_events_error__handle(err, term->err_val,
1363				asprintf(&err_str,
1364				    "value too big for format, maximum is %llu",
1365				    (unsigned long long)max_val) < 0
1366				    ? strdup("value too big for format")
1367				    : err_str,
1368				    NULL);
1369			return -EINVAL;
1370		}
1371		/*
1372		 * Assume we don't care if !err, in which case the value will be
1373		 * silently truncated.
1374		 */
1375	}
1376
1377	pmu_format_value(format->bits, val, vp, zero);
1378	return 0;
1379}
1380
1381int perf_pmu__config_terms(const struct perf_pmu *pmu,
1382			   struct perf_event_attr *attr,
1383			   struct parse_events_terms *terms,
1384			   bool zero, struct parse_events_error *err)
1385{
1386	struct parse_events_term *term;
1387
1388	list_for_each_entry(term, &terms->terms, list) {
1389		if (pmu_config_term(pmu, attr, term, terms, zero, err))
1390			return -EINVAL;
1391	}
1392
1393	return 0;
1394}
1395
1396/*
1397 * Configures event's 'attr' parameter based on the:
1398 * 1) users input - specified in terms parameter
1399 * 2) pmu format definitions - specified by pmu parameter
1400 */
1401int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1402		     struct parse_events_terms *head_terms,
1403		     struct parse_events_error *err)
1404{
1405	bool zero = !!pmu->perf_event_attr_init_default;
1406
1407	return perf_pmu__config_terms(pmu, attr, head_terms, zero, err);
1408}
1409
1410static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1411					     struct parse_events_term *term)
1412{
1413	struct perf_pmu_alias *alias;
1414	const char *name;
1415
1416	if (parse_events__is_hardcoded_term(term))
1417		return NULL;
1418
1419	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1420		if (!term->no_value)
1421			return NULL;
1422		if (pmu_find_format(&pmu->format, term->config))
1423			return NULL;
1424		name = term->config;
1425
1426	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1427		if (strcasecmp(term->config, "event"))
1428			return NULL;
1429		name = term->val.str;
1430	} else {
1431		return NULL;
1432	}
1433
1434	alias = perf_pmu__find_alias(pmu, name, /*load=*/ true);
1435	if (alias || pmu->cpu_aliases_added)
1436		return alias;
1437
1438	/* Alias doesn't exist, try to get it from the json events. */
1439	if (pmu->events_table &&
1440	    pmu_events_table__find_event(pmu->events_table, pmu, name,
1441				         pmu_add_cpu_aliases_map_callback,
1442				         pmu) == 0) {
1443		alias = perf_pmu__find_alias(pmu, name, /*load=*/ false);
1444	}
1445	return alias;
1446}
1447
1448
1449static int check_info_data(struct perf_pmu *pmu,
1450			   struct perf_pmu_alias *alias,
1451			   struct perf_pmu_info *info,
1452			   struct parse_events_error *err,
1453			   int column)
1454{
1455	read_alias_info(pmu, alias);
1456	/*
1457	 * Only one term in event definition can
1458	 * define unit, scale and snapshot, fail
1459	 * if there's more than one.
1460	 */
1461	if (info->unit && alias->unit[0]) {
1462		parse_events_error__handle(err, column,
1463					strdup("Attempt to set event's unit twice"),
1464					NULL);
1465		return -EINVAL;
1466	}
1467	if (info->scale && alias->scale) {
1468		parse_events_error__handle(err, column,
1469					strdup("Attempt to set event's scale twice"),
1470					NULL);
1471		return -EINVAL;
1472	}
1473	if (info->snapshot && alias->snapshot) {
1474		parse_events_error__handle(err, column,
1475					strdup("Attempt to set event snapshot twice"),
1476					NULL);
1477		return -EINVAL;
1478	}
1479
1480	if (alias->unit[0])
1481		info->unit = alias->unit;
1482
1483	if (alias->scale)
1484		info->scale = alias->scale;
1485
1486	if (alias->snapshot)
1487		info->snapshot = alias->snapshot;
1488
1489	return 0;
1490}
1491
1492/*
1493 * Find alias in the terms list and replace it with the terms
1494 * defined for the alias
1495 */
1496int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms,
1497			  struct perf_pmu_info *info, bool *rewrote_terms,
1498			  struct parse_events_error *err)
1499{
1500	struct parse_events_term *term, *h;
1501	struct perf_pmu_alias *alias;
1502	int ret;
1503
1504	*rewrote_terms = false;
1505	info->per_pkg = false;
1506
1507	/*
1508	 * Mark unit and scale as not set
1509	 * (different from default values, see below)
1510	 */
1511	info->unit     = NULL;
1512	info->scale    = 0.0;
1513	info->snapshot = false;
1514
1515	list_for_each_entry_safe(term, h, &head_terms->terms, list) {
1516		alias = pmu_find_alias(pmu, term);
1517		if (!alias)
1518			continue;
1519		ret = pmu_alias_terms(alias, &term->list);
1520		if (ret) {
1521			parse_events_error__handle(err, term->err_term,
1522						strdup("Failure to duplicate terms"),
1523						NULL);
1524			return ret;
1525		}
1526		*rewrote_terms = true;
1527		ret = check_info_data(pmu, alias, info, err, term->err_term);
1528		if (ret)
1529			return ret;
1530
1531		if (alias->per_pkg)
1532			info->per_pkg = true;
 
1533
1534		list_del_init(&term->list);
1535		parse_events_term__delete(term);
1536	}
1537
1538	/*
1539	 * if no unit or scale found in aliases, then
1540	 * set defaults as for evsel
1541	 * unit cannot left to NULL
1542	 */
1543	if (info->unit == NULL)
1544		info->unit   = "";
1545
1546	if (info->scale == 0.0)
1547		info->scale  = 1.0;
1548
1549	return 0;
1550}
1551
1552struct find_event_args {
1553	const char *event;
1554	void *state;
1555	pmu_event_callback cb;
1556};
1557
1558static int find_event_callback(void *state, struct pmu_event_info *info)
1559{
1560	struct find_event_args *args = state;
1561
1562	if (!strcmp(args->event, info->name))
1563		return args->cb(args->state, info);
1564
1565	return 0;
1566}
1567
1568int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb)
1569{
1570	struct find_event_args args = {
1571		.event = event,
1572		.state = state,
1573		.cb = cb,
1574	};
1575
1576	/* Sub-optimal, but function is only used by tests. */
1577	return perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ false,
1578					&args, find_event_callback);
1579}
1580
1581static void perf_pmu__del_formats(struct list_head *formats)
1582{
1583	struct perf_pmu_format *fmt, *tmp;
1584
1585	list_for_each_entry_safe(fmt, tmp, formats, list) {
1586		list_del(&fmt->list);
1587		zfree(&fmt->name);
1588		free(fmt);
1589	}
1590}
1591
1592bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name)
1593{
1594	struct perf_pmu_format *format;
1595
1596	list_for_each_entry(format, &pmu->format, list) {
1597		if (!strcmp(format->name, name))
1598			return true;
1599	}
1600	return false;
1601}
1602
1603bool is_pmu_core(const char *name)
1604{
1605	return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name);
1606}
1607
1608bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu)
1609{
1610	return pmu->is_core;
1611}
1612
1613bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu)
1614{
1615	return !pmu->is_core || perf_pmus__num_core_pmus() == 1;
1616}
1617
1618bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)
1619{
1620	if (!name)
1621		return false;
1622	if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL)
1623		return true;
1624	if (pmu->cpu_aliases_added || !pmu->events_table)
1625		return false;
1626	return pmu_events_table__find_event(pmu->events_table, pmu, name, NULL, NULL) == 0;
1627}
1628
1629size_t perf_pmu__num_events(struct perf_pmu *pmu)
1630{
1631	size_t nr;
1632
1633	if (!pmu->sysfs_aliases_loaded)
1634		pmu_aliases_parse(pmu);
1635
1636	nr = pmu->sysfs_aliases;
1637
1638	if (pmu->cpu_aliases_added)
1639		 nr += pmu->loaded_json_aliases;
1640	else if (pmu->events_table)
1641		nr += pmu_events_table__num_events(pmu->events_table, pmu) - pmu->loaded_json_aliases;
1642
1643	return pmu->selectable ? nr + 1 : nr;
 
 
1644}
1645
1646static int sub_non_neg(int a, int b)
 
1647{
1648	if (b > a)
1649		return 0;
1650	return a - b;
1651}
1652
1653static char *format_alias(char *buf, int len, const struct perf_pmu *pmu,
1654			  const struct perf_pmu_alias *alias, bool skip_duplicate_pmus)
1655{
1656	struct parse_events_term *term;
1657	int pmu_name_len = skip_duplicate_pmus
1658		? pmu_name_len_no_suffix(pmu->name, /*num=*/NULL)
1659		: (int)strlen(pmu->name);
1660	int used = snprintf(buf, len, "%.*s/%s", pmu_name_len, pmu->name, alias->name);
1661
1662	list_for_each_entry(term, &alias->terms.terms, list) {
1663		if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1664			used += snprintf(buf + used, sub_non_neg(len, used),
1665					",%s=%s", term->config,
1666					term->val.str);
1667	}
1668
1669	if (sub_non_neg(len, used) > 0) {
1670		buf[used] = '/';
1671		used++;
1672	}
1673	if (sub_non_neg(len, used) > 0) {
1674		buf[used] = '\0';
1675		used++;
1676	} else
1677		buf[len - 1] = '\0';
1678
1679	return buf;
1680}
1681
1682int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus,
1683			     void *state, pmu_event_callback cb)
1684{
1685	char buf[1024];
1686	struct perf_pmu_alias *event;
1687	struct pmu_event_info info = {
1688		.pmu = pmu,
1689	};
1690	int ret = 0;
1691	struct strbuf sb;
1692
1693	strbuf_init(&sb, /*hint=*/ 0);
1694	pmu_add_cpu_aliases(pmu);
1695	list_for_each_entry(event, &pmu->aliases, list) {
1696		size_t buf_used;
1697
1698		info.pmu_name = event->pmu_name ?: pmu->name;
1699		info.alias = NULL;
1700		if (event->desc) {
1701			info.name = event->name;
1702			buf_used = 0;
1703		} else {
1704			info.name = format_alias(buf, sizeof(buf), pmu, event,
1705						 skip_duplicate_pmus);
1706			if (pmu->is_core) {
1707				info.alias = info.name;
1708				info.name = event->name;
1709			}
1710			buf_used = strlen(buf) + 1;
1711		}
1712		info.scale_unit = NULL;
1713		if (strlen(event->unit) || event->scale != 1.0) {
1714			info.scale_unit = buf + buf_used;
1715			buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used,
1716					"%G%s", event->scale, event->unit) + 1;
1717		}
1718		info.desc = event->desc;
1719		info.long_desc = event->long_desc;
1720		info.encoding_desc = buf + buf_used;
1721		parse_events_terms__to_strbuf(&event->terms, &sb);
1722		buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used,
1723				"%s/%s/", info.pmu_name, sb.buf) + 1;
1724		info.topic = event->topic;
1725		info.str = sb.buf;
1726		info.deprecated = event->deprecated;
1727		ret = cb(state, &info);
1728		if (ret)
1729			goto out;
1730		strbuf_setlen(&sb, /*len=*/ 0);
1731	}
1732	if (pmu->selectable) {
1733		info.name = buf;
1734		snprintf(buf, sizeof(buf), "%s//", pmu->name);
1735		info.alias = NULL;
1736		info.scale_unit = NULL;
1737		info.desc = NULL;
1738		info.long_desc = NULL;
1739		info.encoding_desc = NULL;
1740		info.topic = NULL;
1741		info.pmu_name = pmu->name;
1742		info.deprecated = false;
1743		ret = cb(state, &info);
1744	}
1745out:
1746	strbuf_release(&sb);
1747	return ret;
1748}
1749
1750bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name)
1751{
1752	return !strcmp(pmu->name, pmu_name) ||
1753		(pmu->is_uncore && pmu_uncore_alias_match(pmu_name, pmu->name)) ||
1754		/*
1755		 * jevents and tests use default_core as a marker for any core
1756		 * PMU as the PMU name varies across architectures.
1757		 */
1758	        (pmu->is_core && !strcmp(pmu_name, "default_core"));
1759}
1760
1761bool perf_pmu__is_software(const struct perf_pmu *pmu)
1762{
1763	if (pmu->is_core || pmu->is_uncore || pmu->auxtrace)
1764		return false;
1765	switch (pmu->type) {
1766	case PERF_TYPE_HARDWARE:	return false;
1767	case PERF_TYPE_SOFTWARE:	return true;
1768	case PERF_TYPE_TRACEPOINT:	return true;
1769	case PERF_TYPE_HW_CACHE:	return false;
1770	case PERF_TYPE_RAW:		return false;
1771	case PERF_TYPE_BREAKPOINT:	return true;
1772	default: break;
1773	}
1774	return !strcmp(pmu->name, "kprobe") || !strcmp(pmu->name, "uprobe");
1775}
1776
1777FILE *perf_pmu__open_file(const struct perf_pmu *pmu, const char *name)
1778{
1779	char path[PATH_MAX];
1780
1781	if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) ||
1782	    !file_available(path))
1783		return NULL;
1784
1785	return fopen(path, "r");
1786}
1787
1788FILE *perf_pmu__open_file_at(const struct perf_pmu *pmu, int dirfd, const char *name)
1789{
1790	int fd;
1791
1792	fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY);
1793	if (fd < 0)
1794		return NULL;
1795
1796	return fdopen(fd, "r");
1797}
1798
1799int perf_pmu__scan_file(const struct perf_pmu *pmu, const char *name, const char *fmt,
1800			...)
1801{
1802	va_list args;
1803	FILE *file;
1804	int ret = EOF;
1805
1806	va_start(args, fmt);
1807	file = perf_pmu__open_file(pmu, name);
1808	if (file) {
1809		ret = vfscanf(file, fmt, args);
1810		fclose(file);
1811	}
1812	va_end(args);
1813	return ret;
1814}
1815
1816int perf_pmu__scan_file_at(const struct perf_pmu *pmu, int dirfd, const char *name,
1817			   const char *fmt, ...)
1818{
1819	va_list args;
1820	FILE *file;
1821	int ret = EOF;
1822
1823	va_start(args, fmt);
1824	file = perf_pmu__open_file_at(pmu, dirfd, name);
1825	if (file) {
1826		ret = vfscanf(file, fmt, args);
1827		fclose(file);
1828	}
1829	va_end(args);
1830	return ret;
1831}
1832
1833bool perf_pmu__file_exists(const struct perf_pmu *pmu, const char *name)
1834{
1835	char path[PATH_MAX];
1836
1837	if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name))
1838		return false;
1839
1840	return file_available(path);
1841}
1842
1843static int perf_pmu__new_caps(struct list_head *list, char *name, char *value)
1844{
1845	struct perf_pmu_caps *caps = zalloc(sizeof(*caps));
1846
1847	if (!caps)
1848		return -ENOMEM;
1849
1850	caps->name = strdup(name);
1851	if (!caps->name)
1852		goto free_caps;
1853	caps->value = strndup(value, strlen(value) - 1);
1854	if (!caps->value)
1855		goto free_name;
1856	list_add_tail(&caps->list, list);
1857	return 0;
1858
1859free_name:
1860	zfree(&caps->name);
1861free_caps:
1862	free(caps);
1863
1864	return -ENOMEM;
1865}
1866
1867static void perf_pmu__del_caps(struct perf_pmu *pmu)
1868{
1869	struct perf_pmu_caps *caps, *tmp;
1870
1871	list_for_each_entry_safe(caps, tmp, &pmu->caps, list) {
1872		list_del(&caps->list);
1873		zfree(&caps->name);
1874		zfree(&caps->value);
1875		free(caps);
1876	}
1877}
1878
1879/*
1880 * Reading/parsing the given pmu capabilities, which should be located at:
1881 * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes.
1882 * Return the number of capabilities
1883 */
1884int perf_pmu__caps_parse(struct perf_pmu *pmu)
1885{
1886	struct stat st;
1887	char caps_path[PATH_MAX];
1888	DIR *caps_dir;
1889	struct dirent *evt_ent;
1890	int caps_fd;
1891
1892	if (pmu->caps_initialized)
1893		return pmu->nr_caps;
1894
1895	pmu->nr_caps = 0;
1896
1897	if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps"))
1898		return -1;
1899
1900	if (stat(caps_path, &st) < 0) {
1901		pmu->caps_initialized = true;
1902		return 0;	/* no error if caps does not exist */
1903	}
1904
1905	caps_dir = opendir(caps_path);
1906	if (!caps_dir)
1907		return -EINVAL;
1908
1909	caps_fd = dirfd(caps_dir);
1910
1911	while ((evt_ent = readdir(caps_dir)) != NULL) {
1912		char *name = evt_ent->d_name;
1913		char value[128];
1914		FILE *file;
1915		int fd;
1916
1917		if (!strcmp(name, ".") || !strcmp(name, ".."))
1918			continue;
1919
1920		fd = openat(caps_fd, name, O_RDONLY);
1921		if (fd == -1)
1922			continue;
1923		file = fdopen(fd, "r");
1924		if (!file) {
1925			close(fd);
1926			continue;
1927		}
1928
1929		if (!fgets(value, sizeof(value), file) ||
1930		    (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) {
1931			fclose(file);
1932			continue;
1933		}
1934
1935		pmu->nr_caps++;
1936		fclose(file);
1937	}
1938
1939	closedir(caps_dir);
1940
1941	pmu->caps_initialized = true;
1942	return pmu->nr_caps;
1943}
1944
1945static void perf_pmu__compute_config_masks(struct perf_pmu *pmu)
1946{
1947	struct perf_pmu_format *format;
1948
1949	if (pmu->config_masks_computed)
1950		return;
1951
1952	list_for_each_entry(format, &pmu->format, list)	{
1953		unsigned int i;
1954		__u64 *mask;
1955
1956		if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END)
1957			continue;
1958
1959		pmu->config_masks_present = true;
1960		mask = &pmu->config_masks[format->value];
1961
1962		for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS)
1963			*mask |= 1ULL << i;
 
 
 
 
 
1964	}
1965	pmu->config_masks_computed = true;
1966}
1967
1968void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
1969				   const char *name, int config_num,
1970				   const char *config_name)
1971{
1972	__u64 bits;
1973	char buf[100];
1974
1975	perf_pmu__compute_config_masks(pmu);
1976
1977	/*
1978	 * Kernel doesn't export any valid format bits.
1979	 */
1980	if (!pmu->config_masks_present)
1981		return;
1982
1983	bits = config & ~pmu->config_masks[config_num];
1984	if (bits == 0)
1985		return;
1986
1987	bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf));
1988
1989	pr_warning("WARNING: event '%s' not valid (bits %s of %s "
1990		   "'%llx' not supported by kernel)!\n",
1991		   name ?: "N/A", buf, config_name, config);
1992}
1993
1994int perf_pmu__match(const char *pattern, const char *name, const char *tok)
1995{
1996	if (!name)
1997		return -1;
1998
1999	if (fnmatch(pattern, name, 0))
2000		return -1;
2001
2002	if (tok && !perf_pmu__match_ignoring_suffix(name, tok))
2003		return -1;
2004
2005	return 0;
2006}
2007
2008double __weak perf_pmu__cpu_slots_per_cycle(void)
2009{
2010	return NAN;
2011}
2012
2013int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size)
2014{
2015	const char *sysfs = sysfs__mountpoint();
2016
2017	if (!sysfs)
2018		return 0;
2019	return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs);
2020}
2021
2022int perf_pmu__event_source_devices_fd(void)
2023{
2024	char path[PATH_MAX];
2025	const char *sysfs = sysfs__mountpoint();
2026
2027	if (!sysfs)
2028		return -1;
2029
2030	scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs);
2031	return open(path, O_DIRECTORY);
2032}
2033
2034/*
2035 * Fill 'buf' with the path to a file or folder in 'pmu_name' in
2036 * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format"
2037 * then pathname will be filled with
2038 * "/sys/bus/event_source/devices/cs_etm/format"
2039 *
2040 * Return 0 if the sysfs mountpoint couldn't be found, if no characters were
2041 * written or if the buffer size is exceeded.
2042 */
2043int perf_pmu__pathname_scnprintf(char *buf, size_t size,
2044				 const char *pmu_name, const char *filename)
2045{
2046	size_t len;
2047
2048	len = perf_pmu__event_source_devices_scnprintf(buf, size);
2049	if (!len || (len + strlen(pmu_name) + strlen(filename) + 1)  >= size)
2050		return 0;
2051
2052	return scnprintf(buf + len, size - len, "%s/%s", pmu_name, filename);
2053}
2054
2055int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags)
2056{
2057	char path[PATH_MAX];
2058
2059	scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename);
2060	return openat(dirfd, path, flags);
2061}
2062
2063void perf_pmu__delete(struct perf_pmu *pmu)
2064{
2065	perf_pmu__del_formats(&pmu->format);
2066	perf_pmu__del_aliases(pmu);
2067	perf_pmu__del_caps(pmu);
2068
2069	perf_cpu_map__put(pmu->cpus);
2070
2071	zfree(&pmu->name);
2072	zfree(&pmu->alias_name);
2073	zfree(&pmu->id);
2074	free(pmu);
2075}