[mirror_ubuntu-zesty-kernel.git] / tools / perf / util / parse-events.c


#include "../perf.h"
#include "util.h"
#include "parse-options.h"
#include "parse-events.h"
#include "exec_cmd.h"
#include "string.h"
#include "cache.h"

extern char *strcasestr(const char *haystack, const char *needle);

int					nr_counters;

struct perf_counter_attr		attrs[MAX_COUNTERS];

struct event_symbol {
	u8	type;
	u64	config;
	char	*symbol;
	char	*alias;
};

char debugfs_path[MAXPATHLEN];

#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x

static struct event_symbol event_symbols[] = {
  { CHW(CPU_CYCLES),		"cpu-cycles",		"cycles"	},
  { CHW(INSTRUCTIONS),		"instructions",		""		},
  { CHW(CACHE_REFERENCES),	"cache-references",	""		},
  { CHW(CACHE_MISSES),		"cache-misses",		""		},
  { CHW(BRANCH_INSTRUCTIONS),	"branch-instructions",	"branches"	},
  { CHW(BRANCH_MISSES),		"branch-misses",	""		},
  { CHW(BUS_CYCLES),		"bus-cycles",		""		},

  { CSW(CPU_CLOCK),		"cpu-clock",		""		},
  { CSW(TASK_CLOCK),		"task-clock",		""		},
  { CSW(PAGE_FAULTS),		"page-faults",		"faults"	},
  { CSW(PAGE_FAULTS_MIN),	"minor-faults",		""		},
  { CSW(PAGE_FAULTS_MAJ),	"major-faults",		""		},
  { CSW(CONTEXT_SWITCHES),	"context-switches",	"cs"		},
  { CSW(CPU_MIGRATIONS),	"cpu-migrations",	"migrations"	},
};

#define __PERF_COUNTER_FIELD(config, name) \
	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)

#define PERF_COUNTER_RAW(config)	__PERF_COUNTER_FIELD(config, RAW)
#define PERF_COUNTER_CONFIG(config)	__PERF_COUNTER_FIELD(config, CONFIG)
#define PERF_COUNTER_TYPE(config)	__PERF_COUNTER_FIELD(config, TYPE)
#define PERF_COUNTER_ID(config)		__PERF_COUNTER_FIELD(config, EVENT)

static char *hw_event_names[] = {
	"cycles",
	"instructions",
	"cache-references",
	"cache-misses",
	"branches",
	"branch-misses",
	"bus-cycles",
};

static char *sw_event_names[] = {
	"cpu-clock-msecs",
	"task-clock-msecs",
	"page-faults",
	"context-switches",
	"CPU-migrations",
	"minor-faults",
	"major-faults",
};

#define MAX_ALIASES 8

static char *hw_cache[][MAX_ALIASES] = {
 { "L1-dcache",	"l1-d",		"l1d",		"L1-data",		},
 { "L1-icache",	"l1-i",		"l1i",		"L1-instruction",	},
 { "LLC",	"L2"							},
 { "dTLB",	"d-tlb",	"Data-TLB",				},
 { "iTLB",	"i-tlb",	"Instruction-TLB",			},
 { "branch",	"branches",	"bpu",		"btb",		"bpc",	},
};

static char *hw_cache_op[][MAX_ALIASES] = {
 { "load",	"loads",	"read",					},
 { "store",	"stores",	"write",				},
 { "prefetch",	"prefetches",	"speculative-read", "speculative-load",	},
};

static char *hw_cache_result[][MAX_ALIASES] = {
 { "refs",	"Reference",	"ops",		"access",		},
 { "misses",	"miss",							},
};

#define C(x)		PERF_COUNT_HW_CACHE_##x
#define CACHE_READ	(1 << C(OP_READ))
#define CACHE_WRITE	(1 << C(OP_WRITE))
#define CACHE_PREFETCH	(1 << C(OP_PREFETCH))
#define COP(x)		(1 << x)

/*
 * cache operartion stat
 * L1I : Read and prefetch only
 * ITLB and BPU : Read-only
 */
static unsigned long hw_cache_stat[C(MAX)] = {
 [C(L1D)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 [C(L1I)]	= (CACHE_READ | CACHE_PREFETCH),
 [C(LL)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 [C(DTLB)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 [C(ITLB)]	= (CACHE_READ),
 [C(BPU)]	= (CACHE_READ),
};

#define for_each_subsystem(sys_dir, sys_dirent, sys_next, file, st)	       \
	while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)	       \
	if (snprintf(file, MAXPATHLEN, "%s/%s", debugfs_path,	       	       \
			sys_dirent.d_name) &&		       		       \
	   (!stat(file, &st)) && (S_ISDIR(st.st_mode)) &&		       \
	   (strcmp(sys_dirent.d_name, ".")) &&				       \
	   (strcmp(sys_dirent.d_name, "..")))

static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
{
	char evt_path[MAXPATHLEN];
	int fd;

	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
			sys_dir->d_name, evt_dir->d_name);
	fd = open(evt_path, O_RDONLY);
	if (fd < 0)
		return -EINVAL;
	close(fd);

	return 0;
}

#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next, file, st)    \
	while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
	if (snprintf(file, MAXPATHLEN, "%s/%s/%s", debugfs_path,	       \
		     sys_dirent.d_name, evt_dirent.d_name) &&		       \
	   (!stat(file, &st)) && (S_ISDIR(st.st_mode)) &&		       \
	   (strcmp(evt_dirent.d_name, ".")) &&				       \
	   (strcmp(evt_dirent.d_name, "..")) &&				       \
	   (!tp_event_has_id(&sys_dirent, &evt_dirent)))

#define MAX_EVENT_LENGTH 30

int valid_debugfs_mount(const char *debugfs)
{
	struct statfs st_fs;

	if (statfs(debugfs, &st_fs) < 0)
		return -ENOENT;
	else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
		return -ENOENT;
	return 0;
}

static char *tracepoint_id_to_name(u64 config)
{
	static char tracepoint_name[2 * MAX_EVENT_LENGTH];
	DIR *sys_dir, *evt_dir;
	struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
	struct stat st;
	char id_buf[4];
	int fd;
	u64 id;
	char evt_path[MAXPATHLEN];

	if (valid_debugfs_mount(debugfs_path))
		return "unkown";

	sys_dir = opendir(debugfs_path);
	if (!sys_dir)
		goto cleanup;

	for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
		evt_dir = opendir(evt_path);
		if (!evt_dir)
			goto cleanup;
		for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
								evt_path, st) {
			snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id",
				 debugfs_path, sys_dirent.d_name,
				 evt_dirent.d_name);
			fd = open(evt_path, O_RDONLY);
			if (fd < 0)
				continue;
			if (read(fd, id_buf, sizeof(id_buf)) < 0) {
				close(fd);
				continue;
			}
			close(fd);
			id = atoll(id_buf);
			if (id == config) {
				closedir(evt_dir);
				closedir(sys_dir);
				snprintf(tracepoint_name, 2 * MAX_EVENT_LENGTH,
					"%s:%s", sys_dirent.d_name,
					evt_dirent.d_name);
				return tracepoint_name;
			}
		}
		closedir(evt_dir);
	}

cleanup:
	closedir(sys_dir);
	return "unkown";
}

static int is_cache_op_valid(u8 cache_type, u8 cache_op)
{
	if (hw_cache_stat[cache_type] & COP(cache_op))
		return 1;	/* valid */
	else
		return 0;	/* invalid */
}

static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
{
	static char name[50];

	if (cache_result) {
		sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
			hw_cache_op[cache_op][0],
			hw_cache_result[cache_result][0]);
	} else {
		sprintf(name, "%s-%s", hw_cache[cache_type][0],
			hw_cache_op[cache_op][1]);
	}

	return name;
}

char *event_name(int counter)
{
	u64 config = attrs[counter].config;
	int type = attrs[counter].type;

	return __event_name(type, config);
}

char *__event_name(int type, u64 config)
{
	static char buf[32];

	if (type == PERF_TYPE_RAW) {
		sprintf(buf, "raw 0x%llx", config);
		return buf;
	}

	switch (type) {
	case PERF_TYPE_HARDWARE:
		if (config < PERF_COUNT_HW_MAX)
			return hw_event_names[config];
		return "unknown-hardware";

	case PERF_TYPE_HW_CACHE: {
		u8 cache_type, cache_op, cache_result;

		cache_type   = (config >>  0) & 0xff;
		if (cache_type > PERF_COUNT_HW_CACHE_MAX)
			return "unknown-ext-hardware-cache-type";

		cache_op     = (config >>  8) & 0xff;
		if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
			return "unknown-ext-hardware-cache-op";

		cache_result = (config >> 16) & 0xff;
		if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
			return "unknown-ext-hardware-cache-result";

		if (!is_cache_op_valid(cache_type, cache_op))
			return "invalid-cache";

		return event_cache_name(cache_type, cache_op, cache_result);
	}

	case PERF_TYPE_SOFTWARE:
		if (config < PERF_COUNT_SW_MAX)
			return sw_event_names[config];
		return "unknown-software";

	case PERF_TYPE_TRACEPOINT:
		return tracepoint_id_to_name(config);

	default:
		break;
	}

	return "unknown";
}

static int parse_aliases(const char **str, char *names[][MAX_ALIASES], int size)
{
	int i, j;
	int n, longest = -1;

	for (i = 0; i < size; i++) {
		for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
			n = strlen(names[i][j]);
			if (n > longest && !strncasecmp(*str, names[i][j], n))
				longest = n;
		}
		if (longest > 0) {
			*str += longest;
			return i;
		}
	}

	return -1;
}

static int
parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
{
	const char *s = *str;
	int cache_type = -1, cache_op = -1, cache_result = -1;

	cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
	/*
	 * No fallback - if we cannot get a clear cache type
	 * then bail out:
	 */
	if (cache_type == -1)
		return 0;

	while ((cache_op == -1 || cache_result == -1) && *s == '-') {
		++s;

		if (cache_op == -1) {
			cache_op = parse_aliases(&s, hw_cache_op,
						PERF_COUNT_HW_CACHE_OP_MAX);
			if (cache_op >= 0) {
				if (!is_cache_op_valid(cache_type, cache_op))
					return 0;
				continue;
			}
		}

		if (cache_result == -1) {
			cache_result = parse_aliases(&s, hw_cache_result,
						PERF_COUNT_HW_CACHE_RESULT_MAX);
			if (cache_result >= 0)
				continue;
		}

		/*
		 * Can't parse this as a cache op or result, so back up
		 * to the '-'.
		 */
		--s;
		break;
	}

	/*
	 * Fall back to reads:
	 */
	if (cache_op == -1)
		cache_op = PERF_COUNT_HW_CACHE_OP_READ;

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

	attr->config = cache_type | (cache_op << 8) | (cache_result << 16);
	attr->type = PERF_TYPE_HW_CACHE;

	*str = s;
	return 1;
}

static int parse_tracepoint_event(const char **strp,
				    struct perf_counter_attr *attr)
{
	const char *evt_name;
	char sys_name[MAX_EVENT_LENGTH];
	char id_buf[4];
	int fd;
	unsigned int sys_length, evt_length;
	u64 id;
	char evt_path[MAXPATHLEN];

	if (valid_debugfs_mount(debugfs_path))
		return 0;

	evt_name = strchr(*strp, ':');
	if (!evt_name)
		return 0;

	sys_length = evt_name - *strp;
	if (sys_length >= MAX_EVENT_LENGTH)
		return 0;

	strncpy(sys_name, *strp, sys_length);
	sys_name[sys_length] = '\0';
	evt_name = evt_name + 1;
	evt_length = strlen(evt_name);
	if (evt_length >= MAX_EVENT_LENGTH)
		return 0;

	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
		 sys_name, evt_name);
	fd = open(evt_path, O_RDONLY);
	if (fd < 0)
		return 0;

	if (read(fd, id_buf, sizeof(id_buf)) < 0) {
		close(fd);
		return 0;
	}
	close(fd);
	id = atoll(id_buf);
	attr->config = id;
	attr->type = PERF_TYPE_TRACEPOINT;
	*strp = evt_name + evt_length;
	return 1;
}

static int check_events(const char *str, unsigned int i)
{
	int n;

	n = strlen(event_symbols[i].symbol);
	if (!strncmp(str, event_symbols[i].symbol, n))
		return n;

	n = strlen(event_symbols[i].alias);
	if (n)
		if (!strncmp(str, event_symbols[i].alias, n))
			return n;
	return 0;
}

static int
parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
{
	const char *str = *strp;
	unsigned int i;
	int n;

	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
		n = check_events(str, i);
		if (n > 0) {
			attr->type = event_symbols[i].type;
			attr->config = event_symbols[i].config;
			*strp = str + n;
			return 1;
		}
	}
	return 0;
}

static int parse_raw_event(const char **strp, struct perf_counter_attr *attr)
{
	const char *str = *strp;
	u64 config;
	int n;

	if (*str != 'r')
		return 0;
	n = hex2u64(str + 1, &config);
	if (n > 0) {
		*strp = str + n + 1;
		attr->type = PERF_TYPE_RAW;
		attr->config = config;
		return 1;
	}
	return 0;
}

static int
parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
{
	const char *str = *strp;
	char *endp;
	unsigned long type;
	u64 config;

	type = strtoul(str, &endp, 0);
	if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
		str = endp + 1;
		config = strtoul(str, &endp, 0);
		if (endp > str) {
			attr->type = type;
			attr->config = config;
			*strp = endp;
			return 1;
		}
	}
	return 0;
}

static int
parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
{
	const char *str = *strp;
	int eu = 1, ek = 1, eh = 1;

	if (*str++ != ':')
		return 0;
	while (*str) {
		if (*str == 'u')
			eu = 0;
		else if (*str == 'k')
			ek = 0;
		else if (*str == 'h')
			eh = 0;
		else
			break;
		++str;
	}
	if (str >= *strp + 2) {
		*strp = str;
		attr->exclude_user   = eu;
		attr->exclude_kernel = ek;
		attr->exclude_hv     = eh;
		return 1;
	}
	return 0;
}

/*
 * Each event can have multiple symbolic names.
 * Symbolic names are (almost) exactly matched.
 */
static int parse_event_symbols(const char **str, struct perf_counter_attr *attr)
{
	if (!(parse_tracepoint_event(str, attr) ||
	      parse_raw_event(str, attr) ||
	      parse_numeric_event(str, attr) ||
	      parse_symbolic_event(str, attr) ||
	      parse_generic_hw_event(str, attr)))
		return 0;

	parse_event_modifier(str, attr);

	return 1;
}

int parse_events(const struct option *opt __used, const char *str, int unset __used)
{
	struct perf_counter_attr attr;

	for (;;) {
		if (nr_counters == MAX_COUNTERS)
			return -1;

		memset(&attr, 0, sizeof(attr));
		if (!parse_event_symbols(&str, &attr))
			return -1;

		if (!(*str == 0 || *str == ',' || isspace(*str)))
			return -1;

		attrs[nr_counters] = attr;
		nr_counters++;

		if (*str == 0)
			break;
		if (*str == ',')
			++str;
		while (isspace(*str))
			++str;
	}

	return 0;
}

static const char * const event_type_descriptors[] = {
	"",
	"Hardware event",
	"Software event",
	"Tracepoint event",
	"Hardware cache event",
};

/*
 * Print the events from <debugfs_mount_point>/tracing/events
 */

static void print_tracepoint_events(void)
{
	DIR *sys_dir, *evt_dir;
	struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
	struct stat st;
	char evt_path[MAXPATHLEN];

	if (valid_debugfs_mount(debugfs_path))
		return;

	sys_dir = opendir(debugfs_path);
	if (!sys_dir)
		goto cleanup;

	for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
		evt_dir = opendir(evt_path);
		if (!evt_dir)
			goto cleanup;
		for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
								evt_path, st) {
			snprintf(evt_path, MAXPATHLEN, "%s:%s",
				 sys_dirent.d_name, evt_dirent.d_name);
			fprintf(stderr, "  %-40s [%s]\n", evt_path,
				event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
		}
		closedir(evt_dir);
	}

cleanup:
	closedir(sys_dir);
}

/*
 * Print the help text for the event symbols:
 */
void print_events(void)
{
	struct event_symbol *syms = event_symbols;
	unsigned int i, type, op, prev_type = -1;
	char name[40];

	fprintf(stderr, "\n");
	fprintf(stderr, "List of pre-defined events (to be used in -e):\n");

	for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
		type = syms->type + 1;
		if (type >= ARRAY_SIZE(event_type_descriptors))
			type = 0;

		if (type != prev_type)
			fprintf(stderr, "\n");

		if (strlen(syms->alias))
			sprintf(name, "%s OR %s", syms->symbol, syms->alias);
		else
			strcpy(name, syms->symbol);
		fprintf(stderr, "  %-40s [%s]\n", name,
			event_type_descriptors[type]);

		prev_type = type;
	}

	fprintf(stderr, "\n");
	for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
		for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
			/* skip invalid cache type */
			if (!is_cache_op_valid(type, op))
				continue;

			for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
				fprintf(stderr, "  %-40s [%s]\n",
					event_cache_name(type, op, i),
					event_type_descriptors[4]);
			}
		}
	}

	fprintf(stderr, "\n");
	fprintf(stderr, "  %-40s [raw hardware event descriptor]\n",
		"rNNN");
	fprintf(stderr, "\n");

	print_tracepoint_events();

	exit(129);
}
Commit	Line	Data
8ad8db37 IM	1
	2	#include "../perf.h"
	3	#include "util.h"
	4	#include "parse-options.h"
	5	#include "parse-events.h"
	6	#include "exec_cmd.h"
a0055ae2	7	#include "string.h"
5beeded1	8	#include "cache.h"
8ad8db37	9
8326f44d IM	10	extern char strcasestr(const char haystack, const char *needle);
8326f44d IM	11
a21ca2ca	12	int nr_counters;
8ad8db37	13
a21ca2ca	14	struct perf_counter_attr attrs[MAX_COUNTERS];
8ad8db37 IM	15
8ad8db37 IM	16	struct event_symbol {
9cffa8d5 PM	17	u8 type;
9cffa8d5 PM	18	u64 config;
a21ca2ca	19	char *symbol;
74d5b588	20	char *alias;
8ad8db37 IM	21	};
8ad8db37 IM	22
5beeded1 JB	23	char debugfs_path[MAXPATHLEN];
5beeded1 JB	24
51e26842 JSR	25	#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
51e26842 JSR	26	#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
a21ca2ca	27
8ad8db37	28	static struct event_symbol event_symbols[] = {
74d5b588 JSR	29	{ CHW(CPU_CYCLES), "cpu-cycles", "cycles" },
	30	{ CHW(INSTRUCTIONS), "instructions", "" },
	31	{ CHW(CACHE_REFERENCES), "cache-references", "" },
	32	{ CHW(CACHE_MISSES), "cache-misses", "" },
	33	{ CHW(BRANCH_INSTRUCTIONS), "branch-instructions", "branches" },
	34	{ CHW(BRANCH_MISSES), "branch-misses", "" },
	35	{ CHW(BUS_CYCLES), "bus-cycles", "" },
	36
	37	{ CSW(CPU_CLOCK), "cpu-clock", "" },
	38	{ CSW(TASK_CLOCK), "task-clock", "" },
c0c22dbf	39	{ CSW(PAGE_FAULTS), "page-faults", "faults" },
74d5b588 JSR	40	{ CSW(PAGE_FAULTS_MIN), "minor-faults", "" },
	41	{ CSW(PAGE_FAULTS_MAJ), "major-faults", "" },
	42	{ CSW(CONTEXT_SWITCHES), "context-switches", "cs" },
	43	{ CSW(CPU_MIGRATIONS), "cpu-migrations", "migrations" },
8ad8db37 IM	44	};
8ad8db37 IM	45
5242519b IM	46	#define __PERF_COUNTER_FIELD(config, name) \
	47	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
	48
	49	#define PERF_COUNTER_RAW(config) __PERF_COUNTER_FIELD(config, RAW)
	50	#define PERF_COUNTER_CONFIG(config) __PERF_COUNTER_FIELD(config, CONFIG)
	51	#define PERF_COUNTER_TYPE(config) __PERF_COUNTER_FIELD(config, TYPE)
	52	#define PERF_COUNTER_ID(config) __PERF_COUNTER_FIELD(config, EVENT)
	53
	54	static char *hw_event_names[] = {
8faf3b54	55	"cycles",
5242519b	56	"instructions",
8faf3b54 IM	57	"cache-references",
8faf3b54 IM	58	"cache-misses",
5242519b	59	"branches",
8faf3b54 IM	60	"branch-misses",
8faf3b54 IM	61	"bus-cycles",
5242519b IM	62	};
	63
	64	static char *sw_event_names[] = {
44175b6f IM	65	"cpu-clock-msecs",
44175b6f IM	66	"task-clock-msecs",
8faf3b54 IM	67	"page-faults",
	68	"context-switches",
	69	"CPU-migrations",
	70	"minor-faults",
	71	"major-faults",
5242519b IM	72	};
5242519b IM	73
8326f44d IM	74	#define MAX_ALIASES 8
8326f44d IM	75
c0c22dbf	76	static char *hw_cache[][MAX_ALIASES] = {
9590b7ba AB	77	{ "L1-dcache", "l1-d", "l1d", "L1-data", },
9590b7ba AB	78	{ "L1-icache", "l1-i", "l1i", "L1-instruction", },
e5c59547 JSR	79	{ "LLC", "L2" },
	80	{ "dTLB", "d-tlb", "Data-TLB", },
	81	{ "iTLB", "i-tlb", "Instruction-TLB", },
	82	{ "branch", "branches", "bpu", "btb", "bpc", },
8326f44d IM	83	};
8326f44d IM	84
c0c22dbf	85	static char *hw_cache_op[][MAX_ALIASES] = {
e5c59547 JSR	86	{ "load", "loads", "read", },
	87	{ "store", "stores", "write", },
	88	{ "prefetch", "prefetches", "speculative-read", "speculative-load", },
8326f44d IM	89	};
8326f44d IM	90
c0c22dbf	91	static char *hw_cache_result[][MAX_ALIASES] = {
e5c59547 JSR	92	{ "refs", "Reference", "ops", "access", },
e5c59547 JSR	93	{ "misses", "miss", },
8326f44d IM	94	};
8326f44d IM	95
06813f6c JSR	96	#define C(x) PERF_COUNT_HW_CACHE_##x
	97	#define CACHE_READ (1 << C(OP_READ))
	98	#define CACHE_WRITE (1 << C(OP_WRITE))
	99	#define CACHE_PREFETCH (1 << C(OP_PREFETCH))
	100	#define COP(x) (1 << x)
	101
	102	/*
	103	* cache operartion stat
	104	* L1I : Read and prefetch only
	105	* ITLB and BPU : Read-only
	106	*/
	107	static unsigned long hw_cache_stat[C(MAX)] = {
	108	[C(L1D)] = (CACHE_READ \| CACHE_WRITE \| CACHE_PREFETCH),
	109	[C(L1I)] = (CACHE_READ \| CACHE_PREFETCH),
	110	[C(LL)] = (CACHE_READ \| CACHE_WRITE \| CACHE_PREFETCH),
	111	[C(DTLB)] = (CACHE_READ \| CACHE_WRITE \| CACHE_PREFETCH),
	112	[C(ITLB)] = (CACHE_READ),
	113	[C(BPU)] = (CACHE_READ),
	114	};
	115
f6bdafef JB	116	#define for_each_subsystem(sys_dir, sys_dirent, sys_next, file, st) \
f6bdafef JB	117	while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \
5beeded1 JB	118	if (snprintf(file, MAXPATHLEN, "%s/%s", debugfs_path, \
5beeded1 JB	119	sys_dirent.d_name) && \
f6bdafef JB	120	(!stat(file, &st)) && (S_ISDIR(st.st_mode)) && \
	121	(strcmp(sys_dirent.d_name, ".")) && \
	122	(strcmp(sys_dirent.d_name, "..")))
	123
ae07b63f PZ	124	static int tp_event_has_id(struct dirent sys_dir, struct dirent evt_dir)
	125	{
	126	char evt_path[MAXPATHLEN];
	127	int fd;
	128
	129	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
	130	sys_dir->d_name, evt_dir->d_name);
	131	fd = open(evt_path, O_RDONLY);
	132	if (fd < 0)
	133	return -EINVAL;
	134	close(fd);
	135
	136	return 0;
	137	}
	138
f6bdafef JB	139	#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next, file, st) \
f6bdafef JB	140	while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \
5beeded1 JB	141	if (snprintf(file, MAXPATHLEN, "%s/%s/%s", debugfs_path, \
5beeded1 JB	142	sys_dirent.d_name, evt_dirent.d_name) && \
f6bdafef JB	143	(!stat(file, &st)) && (S_ISDIR(st.st_mode)) && \
f6bdafef JB	144	(strcmp(evt_dirent.d_name, ".")) && \
ae07b63f PZ	145	(strcmp(evt_dirent.d_name, "..")) && \
ae07b63f PZ	146	(!tp_event_has_id(&sys_dirent, &evt_dirent)))
f6bdafef JB	147
	148	#define MAX_EVENT_LENGTH 30
	149
5beeded1	150	int valid_debugfs_mount(const char *debugfs)
f6bdafef JB	151	{
	152	struct statfs st_fs;
	153
5beeded1	154	if (statfs(debugfs, &st_fs) < 0)
f6bdafef JB	155	return -ENOENT;
	156	else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
	157	return -ENOENT;
	158	return 0;
	159	}
	160
	161	static char *tracepoint_id_to_name(u64 config)
	162	{
	163	static char tracepoint_name[2 * MAX_EVENT_LENGTH];
	164	DIR sys_dir, evt_dir;
	165	struct dirent sys_next, evt_next, sys_dirent, evt_dirent;
	166	struct stat st;
	167	char id_buf[4];
	168	int fd;
	169	u64 id;
	170	char evt_path[MAXPATHLEN];
	171
5beeded1	172	if (valid_debugfs_mount(debugfs_path))
f6bdafef JB	173	return "unkown";
f6bdafef JB	174
5beeded1	175	sys_dir = opendir(debugfs_path);
f6bdafef JB	176	if (!sys_dir)
	177	goto cleanup;
	178
	179	for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
	180	evt_dir = opendir(evt_path);
	181	if (!evt_dir)
	182	goto cleanup;
	183	for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
	184	evt_path, st) {
	185	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id",
5beeded1	186	debugfs_path, sys_dirent.d_name,
f6bdafef JB	187	evt_dirent.d_name);
	188	fd = open(evt_path, O_RDONLY);
	189	if (fd < 0)
	190	continue;
	191	if (read(fd, id_buf, sizeof(id_buf)) < 0) {
	192	close(fd);
	193	continue;
	194	}
	195	close(fd);
	196	id = atoll(id_buf);
	197	if (id == config) {
	198	closedir(evt_dir);
	199	closedir(sys_dir);
	200	snprintf(tracepoint_name, 2 * MAX_EVENT_LENGTH,
	201	"%s:%s", sys_dirent.d_name,
	202	evt_dirent.d_name);
	203	return tracepoint_name;
	204	}
	205	}
	206	closedir(evt_dir);
	207	}
	208
	209	cleanup:
	210	closedir(sys_dir);
	211	return "unkown";
	212	}
	213
06813f6c JSR	214	static int is_cache_op_valid(u8 cache_type, u8 cache_op)
	215	{
	216	if (hw_cache_stat[cache_type] & COP(cache_op))
	217	return 1; /* valid */
	218	else
	219	return 0; /* invalid */
	220	}
	221
e5c59547 JSR	222	static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
	223	{
	224	static char name[50];
	225
	226	if (cache_result) {
	227	sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
	228	hw_cache_op[cache_op][0],
	229	hw_cache_result[cache_result][0]);
	230	} else {
	231	sprintf(name, "%s-%s", hw_cache[cache_type][0],
	232	hw_cache_op[cache_op][1]);
	233	}
	234
	235	return name;
	236	}
	237
a21ca2ca	238	char *event_name(int counter)
5242519b	239	{
9cffa8d5	240	u64 config = attrs[counter].config;
a21ca2ca	241	int type = attrs[counter].type;
8f18aec5 PZ	242
	243	return __event_name(type, config);
	244	}
	245
	246	char *__event_name(int type, u64 config)
	247	{
5242519b IM	248	static char buf[32];
5242519b IM	249
8f18aec5	250	if (type == PERF_TYPE_RAW) {
a21ca2ca	251	sprintf(buf, "raw 0x%llx", config);
5242519b IM	252	return buf;
	253	}
	254
	255	switch (type) {
	256	case PERF_TYPE_HARDWARE:
f4dbfa8f	257	if (config < PERF_COUNT_HW_MAX)
a21ca2ca	258	return hw_event_names[config];
5242519b IM	259	return "unknown-hardware";
5242519b IM	260
8326f44d	261	case PERF_TYPE_HW_CACHE: {
9cffa8d5	262	u8 cache_type, cache_op, cache_result;
8326f44d IM	263
	264	cache_type = (config >> 0) & 0xff;
	265	if (cache_type > PERF_COUNT_HW_CACHE_MAX)
	266	return "unknown-ext-hardware-cache-type";
	267
	268	cache_op = (config >> 8) & 0xff;
8faf3b54 IM	269	if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
8faf3b54 IM	270	return "unknown-ext-hardware-cache-op";
8326f44d IM	271
8326f44d IM	272	cache_result = (config >> 16) & 0xff;
8faf3b54 IM	273	if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
8faf3b54 IM	274	return "unknown-ext-hardware-cache-result";
8326f44d	275
06813f6c JSR	276	if (!is_cache_op_valid(cache_type, cache_op))
06813f6c JSR	277	return "invalid-cache";
8326f44d	278
e5c59547	279	return event_cache_name(cache_type, cache_op, cache_result);
8326f44d IM	280	}
8326f44d IM	281
5242519b	282	case PERF_TYPE_SOFTWARE:
f4dbfa8f	283	if (config < PERF_COUNT_SW_MAX)
a21ca2ca	284	return sw_event_names[config];
5242519b IM	285	return "unknown-software";
5242519b IM	286
f6bdafef JB	287	case PERF_TYPE_TRACEPOINT:
	288	return tracepoint_id_to_name(config);
	289
5242519b IM	290	default:
	291	break;
	292	}
	293
	294	return "unknown";
	295	}
	296
61c45981	297	static int parse_aliases(const char *str, char names[][MAX_ALIASES], int size)
8326f44d IM	298	{
8326f44d IM	299	int i, j;
61c45981	300	int n, longest = -1;
8326f44d IM	301
8326f44d IM	302	for (i = 0; i < size; i++) {
61c45981 PM	303	for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
	304	n = strlen(names[i][j]);
	305	if (n > longest && !strncasecmp(*str, names[i][j], n))
	306	longest = n;
	307	}
	308	if (longest > 0) {
	309	*str += longest;
	310	return i;
8326f44d IM	311	}
	312	}
	313
8953645f	314	return -1;
8326f44d IM	315	}
8326f44d IM	316
c0c22dbf	317	static int
61c45981	318	parse_generic_hw_event(const char *str, struct perf_counter_attr attr)
8326f44d	319	{
61c45981 PM	320	const char s = str;
61c45981 PM	321	int cache_type = -1, cache_op = -1, cache_result = -1;
8326f44d	322
61c45981	323	cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
8326f44d IM	324	/*
	325	* No fallback - if we cannot get a clear cache type
	326	* then bail out:
	327	*/
	328	if (cache_type == -1)
61c45981 PM	329	return 0;
	330
	331	while ((cache_op == -1 \|\| cache_result == -1) && *s == '-') {
	332	++s;
	333
	334	if (cache_op == -1) {
	335	cache_op = parse_aliases(&s, hw_cache_op,
	336	PERF_COUNT_HW_CACHE_OP_MAX);
	337	if (cache_op >= 0) {
	338	if (!is_cache_op_valid(cache_type, cache_op))
	339	return 0;
	340	continue;
	341	}
	342	}
	343
	344	if (cache_result == -1) {
	345	cache_result = parse_aliases(&s, hw_cache_result,
	346	PERF_COUNT_HW_CACHE_RESULT_MAX);
	347	if (cache_result >= 0)
	348	continue;
	349	}
	350
	351	/*
	352	* Can't parse this as a cache op or result, so back up
	353	* to the '-'.
	354	*/
	355	--s;
	356	break;
	357	}
8326f44d	358
8326f44d IM	359	/*
	360	* Fall back to reads:
	361	*/
8953645f IM	362	if (cache_op == -1)
8953645f IM	363	cache_op = PERF_COUNT_HW_CACHE_OP_READ;
8326f44d	364
8326f44d IM	365	/*
	366	* Fall back to accesses:
	367	*/
	368	if (cache_result == -1)
	369	cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
	370
	371	attr->config = cache_type \| (cache_op << 8) \| (cache_result << 16);
	372	attr->type = PERF_TYPE_HW_CACHE;
	373
61c45981 PM	374	*str = s;
61c45981 PM	375	return 1;
8326f44d IM	376	}
8326f44d IM	377
f6bdafef JB	378	static int parse_tracepoint_event(const char **strp,
	379	struct perf_counter_attr *attr)
	380	{
	381	const char *evt_name;
	382	char sys_name[MAX_EVENT_LENGTH];
	383	char id_buf[4];
	384	int fd;
	385	unsigned int sys_length, evt_length;
	386	u64 id;
	387	char evt_path[MAXPATHLEN];
	388
5beeded1	389	if (valid_debugfs_mount(debugfs_path))
f6bdafef JB	390	return 0;
	391
	392	evt_name = strchr(*strp, ':');
	393	if (!evt_name)
	394	return 0;
	395
	396	sys_length = evt_name - *strp;
	397	if (sys_length >= MAX_EVENT_LENGTH)
	398	return 0;
	399
	400	strncpy(sys_name, *strp, sys_length);
	401	sys_name[sys_length] = '\0';
	402	evt_name = evt_name + 1;
	403	evt_length = strlen(evt_name);
	404	if (evt_length >= MAX_EVENT_LENGTH)
	405	return 0;
	406
5beeded1 JB	407	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
5beeded1 JB	408	sys_name, evt_name);
f6bdafef JB	409	fd = open(evt_path, O_RDONLY);
	410	if (fd < 0)
	411	return 0;
	412
	413	if (read(fd, id_buf, sizeof(id_buf)) < 0) {
	414	close(fd);
	415	return 0;
	416	}
	417	close(fd);
	418	id = atoll(id_buf);
	419	attr->config = id;
	420	attr->type = PERF_TYPE_TRACEPOINT;
	421	*strp = evt_name + evt_length;
	422	return 1;
	423	}
	424
74d5b588 JSR	425	static int check_events(const char *str, unsigned int i)
74d5b588 JSR	426	{
61c45981	427	int n;
74d5b588	428
61c45981 PM	429	n = strlen(event_symbols[i].symbol);
	430	if (!strncmp(str, event_symbols[i].symbol, n))
	431	return n;
	432
	433	n = strlen(event_symbols[i].alias);
	434	if (n)
	435	if (!strncmp(str, event_symbols[i].alias, n))
	436	return n;
74d5b588 JSR	437	return 0;
	438	}
	439
61c45981 PM	440	static int
61c45981 PM	441	parse_symbolic_event(const char *strp, struct perf_counter_attr attr)
8ad8db37	442	{
61c45981	443	const char str = strp;
8ad8db37	444	unsigned int i;
61c45981	445	int n;
8ad8db37	446
61c45981 PM	447	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
	448	n = check_events(str, i);
	449	if (n > 0) {
	450	attr->type = event_symbols[i].type;
	451	attr->config = event_symbols[i].config;
	452	*strp = str + n;
	453	return 1;
	454	}
	455	}
	456	return 0;
	457	}
	458
	459	static int parse_raw_event(const char *strp, struct perf_counter_attr attr)
	460	{
	461	const char str = strp;
	462	u64 config;
	463	int n;
a21ca2ca	464
61c45981	465	if (*str != 'r')
a21ca2ca	466	return 0;
61c45981 PM	467	n = hex2u64(str + 1, &config);
	468	if (n > 0) {
	469	*strp = str + n + 1;
	470	attr->type = PERF_TYPE_RAW;
	471	attr->config = config;
	472	return 1;
a21ca2ca	473	}
61c45981 PM	474	return 0;
61c45981 PM	475	}
8ad8db37	476
61c45981 PM	477	static int
	478	parse_numeric_event(const char *strp, struct perf_counter_attr attr)
	479	{
	480	const char str = strp;
	481	char *endp;
	482	unsigned long type;
	483	u64 config;
	484
	485	type = strtoul(str, &endp, 0);
	486	if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
	487	str = endp + 1;
	488	config = strtoul(str, &endp, 0);
	489	if (endp > str) {
	490	attr->type = type;
	491	attr->config = config;
	492	*strp = endp;
	493	return 1;
a0055ae2	494	}
61c45981 PM	495	}
	496	return 0;
	497	}
	498
	499	static int
	500	parse_event_modifier(const char *strp, struct perf_counter_attr attr)
	501	{
	502	const char str = strp;
	503	int eu = 1, ek = 1, eh = 1;
a21ca2ca	504
61c45981	505	if (*str++ != ':')
a21ca2ca	506	return 0;
61c45981 PM	507	while (*str) {
	508	if (*str == 'u')
	509	eu = 0;
	510	else if (*str == 'k')
	511	ek = 0;
	512	else if (*str == 'h')
	513	eh = 0;
	514	else
	515	break;
	516	++str;
5242519b	517	}
61c45981 PM	518	if (str >= *strp + 2) {
	519	*strp = str;
	520	attr->exclude_user = eu;
	521	attr->exclude_kernel = ek;
	522	attr->exclude_hv = eh;
	523	return 1;
	524	}
	525	return 0;
	526	}
8ad8db37	527
61c45981 PM	528	/*
	529	* Each event can have multiple symbolic names.
	530	* Symbolic names are (almost) exactly matched.
	531	*/
	532	static int parse_event_symbols(const char *str, struct perf_counter_attr attr)
	533	{
f6bdafef JB	534	if (!(parse_tracepoint_event(str, attr) \|\|
f6bdafef JB	535	parse_raw_event(str, attr) \|\|
61c45981 PM	536	parse_numeric_event(str, attr) \|\|
	537	parse_symbolic_event(str, attr) \|\|
	538	parse_generic_hw_event(str, attr)))
	539	return 0;
a21ca2ca	540
61c45981	541	parse_event_modifier(str, attr);
8ad8db37	542
61c45981	543	return 1;
8ad8db37 IM	544	}
8ad8db37 IM	545
f37a291c	546	int parse_events(const struct option opt __used, const char str, int unset __used)
8ad8db37	547	{
a21ca2ca	548	struct perf_counter_attr attr;
8ad8db37	549
61c45981 PM	550	for (;;) {
	551	if (nr_counters == MAX_COUNTERS)
	552	return -1;
	553
	554	memset(&attr, 0, sizeof(attr));
	555	if (!parse_event_symbols(&str, &attr))
	556	return -1;
8ad8db37	557
61c45981 PM	558	if (!(str == 0 \|\| str == ',' \|\| isspace(*str)))
61c45981 PM	559	return -1;
8ad8db37	560
61c45981 PM	561	attrs[nr_counters] = attr;
61c45981 PM	562	nr_counters++;
8ad8db37	563
61c45981 PM	564	if (*str == 0)
	565	break;
	566	if (*str == ',')
	567	++str;
	568	while (isspace(*str))
	569	++str;
8ad8db37 IM	570	}
	571
	572	return 0;
	573	}
	574
86847b62 TG	575	static const char * const event_type_descriptors[] = {
	576	"",
	577	"Hardware event",
	578	"Software event",
	579	"Tracepoint event",
	580	"Hardware cache event",
	581	};
	582
f6bdafef JB	583	/*
	584	* Print the events from <debugfs_mount_point>/tracing/events
	585	*/
	586
	587	static void print_tracepoint_events(void)
	588	{
	589	DIR sys_dir, evt_dir;
	590	struct dirent sys_next, evt_next, sys_dirent, evt_dirent;
	591	struct stat st;
	592	char evt_path[MAXPATHLEN];
	593
5beeded1	594	if (valid_debugfs_mount(debugfs_path))
f6bdafef JB	595	return;
f6bdafef JB	596
5beeded1	597	sys_dir = opendir(debugfs_path);
f6bdafef JB	598	if (!sys_dir)
	599	goto cleanup;
	600
	601	for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
	602	evt_dir = opendir(evt_path);
	603	if (!evt_dir)
	604	goto cleanup;
	605	for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
	606	evt_path, st) {
	607	snprintf(evt_path, MAXPATHLEN, "%s:%s",
	608	sys_dirent.d_name, evt_dirent.d_name);
	609	fprintf(stderr, " %-40s [%s]\n", evt_path,
	610	event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
	611	}
	612	closedir(evt_dir);
	613	}
	614
	615	cleanup:
	616	closedir(sys_dir);
	617	}
	618
8ad8db37	619	/*
86847b62	620	* Print the help text for the event symbols:
8ad8db37	621	*/
86847b62	622	void print_events(void)
8ad8db37	623	{
86847b62	624	struct event_symbol *syms = event_symbols;
73c24cb8	625	unsigned int i, type, op, prev_type = -1;
74d5b588	626	char name[40];
8ad8db37	627
86847b62 TG	628	fprintf(stderr, "\n");
86847b62 TG	629	fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
8ad8db37	630
86847b62 TG	631	for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
86847b62 TG	632	type = syms->type + 1;
23cdb5d5	633	if (type >= ARRAY_SIZE(event_type_descriptors))
86847b62	634	type = 0;
8ad8db37	635
86847b62 TG	636	if (type != prev_type)
86847b62 TG	637	fprintf(stderr, "\n");
8ad8db37	638
74d5b588 JSR	639	if (strlen(syms->alias))
	640	sprintf(name, "%s OR %s", syms->symbol, syms->alias);
	641	else
	642	strcpy(name, syms->symbol);
	643	fprintf(stderr, " %-40s [%s]\n", name,
86847b62	644	event_type_descriptors[type]);
8ad8db37	645
86847b62	646	prev_type = type;
8ad8db37 IM	647	}
8ad8db37 IM	648
73c24cb8 JSR	649	fprintf(stderr, "\n");
	650	for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
	651	for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
	652	/* skip invalid cache type */
	653	if (!is_cache_op_valid(type, op))
	654	continue;
	655
	656	for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
	657	fprintf(stderr, " %-40s [%s]\n",
	658	event_cache_name(type, op, i),
	659	event_type_descriptors[4]);
	660	}
	661	}
	662	}
	663
86847b62	664	fprintf(stderr, "\n");
74d5b588	665	fprintf(stderr, " %-40s [raw hardware event descriptor]\n",
86847b62 TG	666	"rNNN");
	667	fprintf(stderr, "\n");
	668
f6bdafef JB	669	print_tracepoint_events();
f6bdafef JB	670
86847b62	671	exit(129);
8ad8db37	672	}