[mirror_ubuntu-artful-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;
	const char	*symbol;
	const 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 const char *hw_event_names[] = {
	"cycles",
	"instructions",
	"cache-references",
	"cache-misses",
	"branches",
	"branch-misses",
	"bus-cycles",
};

static const 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 const 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 const char *hw_cache_op[][MAX_ALIASES] = {
 { "load",	"loads",	"read",					},
 { "store",	"stores",	"write",				},
 { "prefetch",	"prefetches",	"speculative-read", "speculative-load",	},
};

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

struct tracepoint_path *tracepoint_id_to_path(u64 config)
{
	struct tracepoint_path *path = NULL;
	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 NULL;

	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);
				path = calloc(1, sizeof(path));
				path->system = malloc(MAX_EVENT_LENGTH);
				if (!path->system) {
					free(path);
					return NULL;
				}
				path->name = malloc(MAX_EVENT_LENGTH);
				if (!path->name) {
					free(path->system);
					free(path);
					return NULL;
				}
				strncpy(path->system, sys_dirent.d_name,
					MAX_EVENT_LENGTH);
				strncpy(path->name, evt_dirent.d_name,
					MAX_EVENT_LENGTH);
				return path;
			}
		}
		closedir(evt_dir);
	}

cleanup:
	closedir(sys_dir);
	return NULL;
}

#define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1)
static const char *tracepoint_id_to_name(u64 config)
{
	static char buf[TP_PATH_LEN];
	struct tracepoint_path *path;

	path = tracepoint_id_to_path(config);
	if (path) {
		snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name);
		free(path->name);
		free(path->system);
		free(path);
	} else
		snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown");

	return buf;
}

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

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

	return __event_name(type, config);
}

const 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, const 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 *flags;
	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;

	flags = strchr(evt_name, ':');
	if (flags) {
		*flags = '\0';
		flags++;
		if (!strncmp(flags, "record", strlen(flags)))
			attr->sample_type |= PERF_SAMPLE_RAW;
	}

	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 {
83a0944f IM	17	u8 type;
	18	u64 config;
	19	const char *symbol;
	20	const 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
83a0944f	54	static const 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	};
5242519b IM	63
83a0944f	64	static const 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
83a0944f	76	static const 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
83a0944f	85	static const 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
83a0944f	91	static const 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
1ef2ed10	161	struct tracepoint_path *tracepoint_id_to_path(u64 config)
f6bdafef	162	{
1ef2ed10	163	struct tracepoint_path *path = NULL;
f6bdafef JB	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))
1ef2ed10	173	return NULL;
f6bdafef	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);
1ef2ed10 FW	200	path = calloc(1, sizeof(path));
	201	path->system = malloc(MAX_EVENT_LENGTH);
	202	if (!path->system) {
	203	free(path);
	204	return NULL;
	205	}
	206	path->name = malloc(MAX_EVENT_LENGTH);
	207	if (!path->name) {
	208	free(path->system);
	209	free(path);
	210	return NULL;
	211	}
	212	strncpy(path->system, sys_dirent.d_name,
	213	MAX_EVENT_LENGTH);
	214	strncpy(path->name, evt_dirent.d_name,
	215	MAX_EVENT_LENGTH);
	216	return path;
f6bdafef JB	217	}
	218	}
	219	closedir(evt_dir);
	220	}
	221
	222	cleanup:
	223	closedir(sys_dir);
1ef2ed10 FW	224	return NULL;
	225	}
	226
	227	#define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1)
	228	static const char *tracepoint_id_to_name(u64 config)
	229	{
	230	static char buf[TP_PATH_LEN];
	231	struct tracepoint_path *path;
	232
	233	path = tracepoint_id_to_path(config);
	234	if (path) {
	235	snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name);
	236	free(path->name);
	237	free(path->system);
	238	free(path);
	239	} else
	240	snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown");
	241
	242	return buf;
f6bdafef JB	243	}
f6bdafef JB	244
06813f6c JSR	245	static int is_cache_op_valid(u8 cache_type, u8 cache_op)
	246	{
	247	if (hw_cache_stat[cache_type] & COP(cache_op))
	248	return 1; /* valid */
	249	else
	250	return 0; /* invalid */
	251	}
	252
e5c59547 JSR	253	static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
	254	{
	255	static char name[50];
	256
	257	if (cache_result) {
	258	sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
	259	hw_cache_op[cache_op][0],
	260	hw_cache_result[cache_result][0]);
	261	} else {
	262	sprintf(name, "%s-%s", hw_cache[cache_type][0],
	263	hw_cache_op[cache_op][1]);
	264	}
	265
	266	return name;
	267	}
	268
83a0944f	269	const char *event_name(int counter)
5242519b	270	{
9cffa8d5	271	u64 config = attrs[counter].config;
a21ca2ca	272	int type = attrs[counter].type;
8f18aec5 PZ	273
	274	return __event_name(type, config);
	275	}
	276
83a0944f	277	const char *__event_name(int type, u64 config)
8f18aec5	278	{
5242519b IM	279	static char buf[32];
5242519b IM	280
8f18aec5	281	if (type == PERF_TYPE_RAW) {
a21ca2ca	282	sprintf(buf, "raw 0x%llx", config);
5242519b IM	283	return buf;
	284	}
	285
	286	switch (type) {
	287	case PERF_TYPE_HARDWARE:
f4dbfa8f	288	if (config < PERF_COUNT_HW_MAX)
a21ca2ca	289	return hw_event_names[config];
5242519b IM	290	return "unknown-hardware";
5242519b IM	291
8326f44d	292	case PERF_TYPE_HW_CACHE: {
9cffa8d5	293	u8 cache_type, cache_op, cache_result;
8326f44d IM	294
	295	cache_type = (config >> 0) & 0xff;
	296	if (cache_type > PERF_COUNT_HW_CACHE_MAX)
	297	return "unknown-ext-hardware-cache-type";
	298
	299	cache_op = (config >> 8) & 0xff;
8faf3b54 IM	300	if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
8faf3b54 IM	301	return "unknown-ext-hardware-cache-op";
8326f44d IM	302
8326f44d IM	303	cache_result = (config >> 16) & 0xff;
8faf3b54 IM	304	if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
8faf3b54 IM	305	return "unknown-ext-hardware-cache-result";
8326f44d	306
06813f6c JSR	307	if (!is_cache_op_valid(cache_type, cache_op))
06813f6c JSR	308	return "invalid-cache";
8326f44d	309
e5c59547	310	return event_cache_name(cache_type, cache_op, cache_result);
8326f44d IM	311	}
8326f44d IM	312
5242519b	313	case PERF_TYPE_SOFTWARE:
f4dbfa8f	314	if (config < PERF_COUNT_SW_MAX)
a21ca2ca	315	return sw_event_names[config];
5242519b IM	316	return "unknown-software";
5242519b IM	317
f6bdafef JB	318	case PERF_TYPE_TRACEPOINT:
	319	return tracepoint_id_to_name(config);
	320
5242519b IM	321	default:
	322	break;
	323	}
	324
	325	return "unknown";
	326	}
	327
83a0944f	328	static int parse_aliases(const char *str, const char names[][MAX_ALIASES], int size)
8326f44d IM	329	{
8326f44d IM	330	int i, j;
61c45981	331	int n, longest = -1;
8326f44d IM	332
8326f44d IM	333	for (i = 0; i < size; i++) {
61c45981 PM	334	for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
	335	n = strlen(names[i][j]);
	336	if (n > longest && !strncasecmp(*str, names[i][j], n))
	337	longest = n;
	338	}
	339	if (longest > 0) {
	340	*str += longest;
	341	return i;
8326f44d IM	342	}
	343	}
	344
8953645f	345	return -1;
8326f44d IM	346	}
8326f44d IM	347
c0c22dbf	348	static int
61c45981	349	parse_generic_hw_event(const char *str, struct perf_counter_attr attr)
8326f44d	350	{
61c45981 PM	351	const char s = str;
61c45981 PM	352	int cache_type = -1, cache_op = -1, cache_result = -1;
8326f44d	353
61c45981	354	cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
8326f44d IM	355	/*
	356	* No fallback - if we cannot get a clear cache type
	357	* then bail out:
	358	*/
	359	if (cache_type == -1)
61c45981 PM	360	return 0;
	361
	362	while ((cache_op == -1 \|\| cache_result == -1) && *s == '-') {
	363	++s;
	364
	365	if (cache_op == -1) {
	366	cache_op = parse_aliases(&s, hw_cache_op,
	367	PERF_COUNT_HW_CACHE_OP_MAX);
	368	if (cache_op >= 0) {
	369	if (!is_cache_op_valid(cache_type, cache_op))
	370	return 0;
	371	continue;
	372	}
	373	}
	374
	375	if (cache_result == -1) {
	376	cache_result = parse_aliases(&s, hw_cache_result,
	377	PERF_COUNT_HW_CACHE_RESULT_MAX);
	378	if (cache_result >= 0)
	379	continue;
	380	}
	381
	382	/*
	383	* Can't parse this as a cache op or result, so back up
	384	* to the '-'.
	385	*/
	386	--s;
	387	break;
	388	}
8326f44d	389
8326f44d IM	390	/*
	391	* Fall back to reads:
	392	*/
8953645f IM	393	if (cache_op == -1)
8953645f IM	394	cache_op = PERF_COUNT_HW_CACHE_OP_READ;
8326f44d	395
8326f44d IM	396	/*
	397	* Fall back to accesses:
	398	*/
	399	if (cache_result == -1)
	400	cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
	401
	402	attr->config = cache_type \| (cache_op << 8) \| (cache_result << 16);
	403	attr->type = PERF_TYPE_HW_CACHE;
	404
61c45981 PM	405	*str = s;
61c45981 PM	406	return 1;
8326f44d IM	407	}
8326f44d IM	408
f6bdafef JB	409	static int parse_tracepoint_event(const char **strp,
	410	struct perf_counter_attr *attr)
	411	{
	412	const char *evt_name;
3a9f131f	413	char *flags;
f6bdafef JB	414	char sys_name[MAX_EVENT_LENGTH];
	415	char id_buf[4];
	416	int fd;
	417	unsigned int sys_length, evt_length;
	418	u64 id;
	419	char evt_path[MAXPATHLEN];
	420
5beeded1	421	if (valid_debugfs_mount(debugfs_path))
f6bdafef JB	422	return 0;
	423
	424	evt_name = strchr(*strp, ':');
	425	if (!evt_name)
	426	return 0;
	427
	428	sys_length = evt_name - *strp;
	429	if (sys_length >= MAX_EVENT_LENGTH)
	430	return 0;
	431
	432	strncpy(sys_name, *strp, sys_length);
	433	sys_name[sys_length] = '\0';
	434	evt_name = evt_name + 1;
3a9f131f FW	435
	436	flags = strchr(evt_name, ':');
	437	if (flags) {
	438	*flags = '\0';
	439	flags++;
	440	if (!strncmp(flags, "record", strlen(flags)))
	441	attr->sample_type \|= PERF_SAMPLE_RAW;
	442	}
	443
f6bdafef JB	444	evt_length = strlen(evt_name);
	445	if (evt_length >= MAX_EVENT_LENGTH)
	446	return 0;
	447
5beeded1 JB	448	snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
5beeded1 JB	449	sys_name, evt_name);
f6bdafef JB	450	fd = open(evt_path, O_RDONLY);
	451	if (fd < 0)
	452	return 0;
	453
	454	if (read(fd, id_buf, sizeof(id_buf)) < 0) {
	455	close(fd);
	456	return 0;
	457	}
	458	close(fd);
	459	id = atoll(id_buf);
	460	attr->config = id;
	461	attr->type = PERF_TYPE_TRACEPOINT;
	462	*strp = evt_name + evt_length;
	463	return 1;
	464	}
	465
74d5b588 JSR	466	static int check_events(const char *str, unsigned int i)
74d5b588 JSR	467	{
61c45981	468	int n;
74d5b588	469
61c45981 PM	470	n = strlen(event_symbols[i].symbol);
	471	if (!strncmp(str, event_symbols[i].symbol, n))
	472	return n;
	473
	474	n = strlen(event_symbols[i].alias);
	475	if (n)
	476	if (!strncmp(str, event_symbols[i].alias, n))
	477	return n;
74d5b588 JSR	478	return 0;
	479	}
	480
61c45981 PM	481	static int
61c45981 PM	482	parse_symbolic_event(const char *strp, struct perf_counter_attr attr)
8ad8db37	483	{
61c45981	484	const char str = strp;
8ad8db37	485	unsigned int i;
61c45981	486	int n;
8ad8db37	487
61c45981 PM	488	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
	489	n = check_events(str, i);
	490	if (n > 0) {
	491	attr->type = event_symbols[i].type;
	492	attr->config = event_symbols[i].config;
	493	*strp = str + n;
	494	return 1;
	495	}
	496	}
	497	return 0;
	498	}
	499
	500	static int parse_raw_event(const char *strp, struct perf_counter_attr attr)
	501	{
	502	const char str = strp;
	503	u64 config;
	504	int n;
a21ca2ca	505
61c45981	506	if (*str != 'r')
a21ca2ca	507	return 0;
61c45981 PM	508	n = hex2u64(str + 1, &config);
	509	if (n > 0) {
	510	*strp = str + n + 1;
	511	attr->type = PERF_TYPE_RAW;
	512	attr->config = config;
	513	return 1;
a21ca2ca	514	}
61c45981 PM	515	return 0;
61c45981 PM	516	}
8ad8db37	517
61c45981 PM	518	static int
	519	parse_numeric_event(const char *strp, struct perf_counter_attr attr)
	520	{
	521	const char str = strp;
	522	char *endp;
	523	unsigned long type;
	524	u64 config;
	525
	526	type = strtoul(str, &endp, 0);
	527	if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
	528	str = endp + 1;
	529	config = strtoul(str, &endp, 0);
	530	if (endp > str) {
	531	attr->type = type;
	532	attr->config = config;
	533	*strp = endp;
	534	return 1;
a0055ae2	535	}
61c45981 PM	536	}
	537	return 0;
	538	}
	539
	540	static int
	541	parse_event_modifier(const char *strp, struct perf_counter_attr attr)
	542	{
	543	const char str = strp;
	544	int eu = 1, ek = 1, eh = 1;
a21ca2ca	545
61c45981	546	if (*str++ != ':')
a21ca2ca	547	return 0;
61c45981 PM	548	while (*str) {
	549	if (*str == 'u')
	550	eu = 0;
	551	else if (*str == 'k')
	552	ek = 0;
	553	else if (*str == 'h')
	554	eh = 0;
	555	else
	556	break;
	557	++str;
5242519b	558	}
61c45981 PM	559	if (str >= *strp + 2) {
	560	*strp = str;
	561	attr->exclude_user = eu;
	562	attr->exclude_kernel = ek;
	563	attr->exclude_hv = eh;
	564	return 1;
	565	}
	566	return 0;
	567	}
8ad8db37	568
61c45981 PM	569	/*
	570	* Each event can have multiple symbolic names.
	571	* Symbolic names are (almost) exactly matched.
	572	*/
	573	static int parse_event_symbols(const char *str, struct perf_counter_attr attr)
	574	{
f6bdafef JB	575	if (!(parse_tracepoint_event(str, attr) \|\|
f6bdafef JB	576	parse_raw_event(str, attr) \|\|
61c45981 PM	577	parse_numeric_event(str, attr) \|\|
	578	parse_symbolic_event(str, attr) \|\|
	579	parse_generic_hw_event(str, attr)))
	580	return 0;
a21ca2ca	581
61c45981	582	parse_event_modifier(str, attr);
8ad8db37	583
61c45981	584	return 1;
8ad8db37 IM	585	}
8ad8db37 IM	586
f37a291c	587	int parse_events(const struct option opt __used, const char str, int unset __used)
8ad8db37	588	{
a21ca2ca	589	struct perf_counter_attr attr;
8ad8db37	590
61c45981 PM	591	for (;;) {
	592	if (nr_counters == MAX_COUNTERS)
	593	return -1;
	594
	595	memset(&attr, 0, sizeof(attr));
	596	if (!parse_event_symbols(&str, &attr))
	597	return -1;
8ad8db37	598
61c45981 PM	599	if (!(str == 0 \|\| str == ',' \|\| isspace(*str)))
61c45981 PM	600	return -1;
8ad8db37	601
61c45981 PM	602	attrs[nr_counters] = attr;
61c45981 PM	603	nr_counters++;
8ad8db37	604
61c45981 PM	605	if (*str == 0)
	606	break;
	607	if (*str == ',')
	608	++str;
	609	while (isspace(*str))
	610	++str;
8ad8db37 IM	611	}
	612
	613	return 0;
	614	}
	615
86847b62 TG	616	static const char * const event_type_descriptors[] = {
	617	"",
	618	"Hardware event",
	619	"Software event",
	620	"Tracepoint event",
	621	"Hardware cache event",
	622	};
	623
f6bdafef JB	624	/*
	625	* Print the events from <debugfs_mount_point>/tracing/events
	626	*/
	627
	628	static void print_tracepoint_events(void)
	629	{
	630	DIR sys_dir, evt_dir;
	631	struct dirent sys_next, evt_next, sys_dirent, evt_dirent;
	632	struct stat st;
	633	char evt_path[MAXPATHLEN];
	634
5beeded1	635	if (valid_debugfs_mount(debugfs_path))
f6bdafef JB	636	return;
f6bdafef JB	637
5beeded1	638	sys_dir = opendir(debugfs_path);
f6bdafef JB	639	if (!sys_dir)
	640	goto cleanup;
	641
	642	for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
	643	evt_dir = opendir(evt_path);
	644	if (!evt_dir)
	645	goto cleanup;
	646	for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
	647	evt_path, st) {
	648	snprintf(evt_path, MAXPATHLEN, "%s:%s",
	649	sys_dirent.d_name, evt_dirent.d_name);
	650	fprintf(stderr, " %-40s [%s]\n", evt_path,
	651	event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
	652	}
	653	closedir(evt_dir);
	654	}
	655
	656	cleanup:
	657	closedir(sys_dir);
	658	}
	659
8ad8db37	660	/*
86847b62	661	* Print the help text for the event symbols:
8ad8db37	662	*/
86847b62	663	void print_events(void)
8ad8db37	664	{
86847b62	665	struct event_symbol *syms = event_symbols;
73c24cb8	666	unsigned int i, type, op, prev_type = -1;
74d5b588	667	char name[40];
8ad8db37	668
86847b62 TG	669	fprintf(stderr, "\n");
86847b62 TG	670	fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
8ad8db37	671
86847b62 TG	672	for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
86847b62 TG	673	type = syms->type + 1;
23cdb5d5	674	if (type >= ARRAY_SIZE(event_type_descriptors))
86847b62	675	type = 0;
8ad8db37	676
86847b62 TG	677	if (type != prev_type)
86847b62 TG	678	fprintf(stderr, "\n");
8ad8db37	679
74d5b588 JSR	680	if (strlen(syms->alias))
	681	sprintf(name, "%s OR %s", syms->symbol, syms->alias);
	682	else
	683	strcpy(name, syms->symbol);
	684	fprintf(stderr, " %-40s [%s]\n", name,
86847b62	685	event_type_descriptors[type]);
8ad8db37	686
86847b62	687	prev_type = type;
8ad8db37 IM	688	}
8ad8db37 IM	689
73c24cb8 JSR	690	fprintf(stderr, "\n");
	691	for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
	692	for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
	693	/* skip invalid cache type */
	694	if (!is_cache_op_valid(type, op))
	695	continue;
	696
	697	for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
	698	fprintf(stderr, " %-40s [%s]\n",
	699	event_cache_name(type, op, i),
	700	event_type_descriptors[4]);
	701	}
	702	}
	703	}
	704
86847b62	705	fprintf(stderr, "\n");
74d5b588	706	fprintf(stderr, " %-40s [raw hardware event descriptor]\n",
86847b62 TG	707	"rNNN");
	708	fprintf(stderr, "\n");
	709
f6bdafef JB	710	print_tracepoint_events();
f6bdafef JB	711
86847b62	712	exit(129);
8ad8db37	713	}