[linux-2.6-block.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"

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

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

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;
	static char buf[32];

	if (attrs[counter].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";

	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 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_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 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");

	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"
8ad8db37	8
8326f44d IM	9	extern char strcasestr(const char haystack, const char *needle);
8326f44d IM	10
a21ca2ca	11	int nr_counters;
8ad8db37	12
a21ca2ca	13	struct perf_counter_attr attrs[MAX_COUNTERS];
8ad8db37 IM	14
8ad8db37 IM	15	struct event_symbol {
9cffa8d5 PM	16	u8 type;
9cffa8d5 PM	17	u64 config;
a21ca2ca	18	char *symbol;
74d5b588	19	char *alias;
8ad8db37 IM	20	};
8ad8db37 IM	21
51e26842 JSR	22	#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
51e26842 JSR	23	#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
a21ca2ca	24
8ad8db37	25	static struct event_symbol event_symbols[] = {
74d5b588 JSR	26	{ CHW(CPU_CYCLES), "cpu-cycles", "cycles" },
	27	{ CHW(INSTRUCTIONS), "instructions", "" },
	28	{ CHW(CACHE_REFERENCES), "cache-references", "" },
	29	{ CHW(CACHE_MISSES), "cache-misses", "" },
	30	{ CHW(BRANCH_INSTRUCTIONS), "branch-instructions", "branches" },
	31	{ CHW(BRANCH_MISSES), "branch-misses", "" },
	32	{ CHW(BUS_CYCLES), "bus-cycles", "" },
	33
	34	{ CSW(CPU_CLOCK), "cpu-clock", "" },
	35	{ CSW(TASK_CLOCK), "task-clock", "" },
c0c22dbf	36	{ CSW(PAGE_FAULTS), "page-faults", "faults" },
74d5b588 JSR	37	{ CSW(PAGE_FAULTS_MIN), "minor-faults", "" },
	38	{ CSW(PAGE_FAULTS_MAJ), "major-faults", "" },
	39	{ CSW(CONTEXT_SWITCHES), "context-switches", "cs" },
	40	{ CSW(CPU_MIGRATIONS), "cpu-migrations", "migrations" },
8ad8db37 IM	41	};
8ad8db37 IM	42
5242519b IM	43	#define __PERF_COUNTER_FIELD(config, name) \
	44	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
	45
	46	#define PERF_COUNTER_RAW(config) __PERF_COUNTER_FIELD(config, RAW)
	47	#define PERF_COUNTER_CONFIG(config) __PERF_COUNTER_FIELD(config, CONFIG)
	48	#define PERF_COUNTER_TYPE(config) __PERF_COUNTER_FIELD(config, TYPE)
	49	#define PERF_COUNTER_ID(config) __PERF_COUNTER_FIELD(config, EVENT)
	50
	51	static char *hw_event_names[] = {
8faf3b54	52	"cycles",
5242519b	53	"instructions",
8faf3b54 IM	54	"cache-references",
8faf3b54 IM	55	"cache-misses",
5242519b	56	"branches",
8faf3b54 IM	57	"branch-misses",
8faf3b54 IM	58	"bus-cycles",
5242519b IM	59	};
	60
	61	static char *sw_event_names[] = {
44175b6f IM	62	"cpu-clock-msecs",
44175b6f IM	63	"task-clock-msecs",
8faf3b54 IM	64	"page-faults",
	65	"context-switches",
	66	"CPU-migrations",
	67	"minor-faults",
	68	"major-faults",
5242519b IM	69	};
5242519b IM	70
8326f44d IM	71	#define MAX_ALIASES 8
8326f44d IM	72
c0c22dbf	73	static char *hw_cache[][MAX_ALIASES] = {
9590b7ba AB	74	{ "L1-dcache", "l1-d", "l1d", "L1-data", },
9590b7ba AB	75	{ "L1-icache", "l1-i", "l1i", "L1-instruction", },
e5c59547 JSR	76	{ "LLC", "L2" },
	77	{ "dTLB", "d-tlb", "Data-TLB", },
	78	{ "iTLB", "i-tlb", "Instruction-TLB", },
	79	{ "branch", "branches", "bpu", "btb", "bpc", },
8326f44d IM	80	};
8326f44d IM	81
c0c22dbf	82	static char *hw_cache_op[][MAX_ALIASES] = {
e5c59547 JSR	83	{ "load", "loads", "read", },
	84	{ "store", "stores", "write", },
	85	{ "prefetch", "prefetches", "speculative-read", "speculative-load", },
8326f44d IM	86	};
8326f44d IM	87
c0c22dbf	88	static char *hw_cache_result[][MAX_ALIASES] = {
e5c59547 JSR	89	{ "refs", "Reference", "ops", "access", },
e5c59547 JSR	90	{ "misses", "miss", },
8326f44d IM	91	};
8326f44d IM	92
06813f6c JSR	93	#define C(x) PERF_COUNT_HW_CACHE_##x
	94	#define CACHE_READ (1 << C(OP_READ))
	95	#define CACHE_WRITE (1 << C(OP_WRITE))
	96	#define CACHE_PREFETCH (1 << C(OP_PREFETCH))
	97	#define COP(x) (1 << x)
	98
	99	/*
	100	* cache operartion stat
	101	* L1I : Read and prefetch only
	102	* ITLB and BPU : Read-only
	103	*/
	104	static unsigned long hw_cache_stat[C(MAX)] = {
	105	[C(L1D)] = (CACHE_READ \| CACHE_WRITE \| CACHE_PREFETCH),
	106	[C(L1I)] = (CACHE_READ \| CACHE_PREFETCH),
	107	[C(LL)] = (CACHE_READ \| CACHE_WRITE \| CACHE_PREFETCH),
	108	[C(DTLB)] = (CACHE_READ \| CACHE_WRITE \| CACHE_PREFETCH),
	109	[C(ITLB)] = (CACHE_READ),
	110	[C(BPU)] = (CACHE_READ),
	111	};
	112
	113	static int is_cache_op_valid(u8 cache_type, u8 cache_op)
	114	{
	115	if (hw_cache_stat[cache_type] & COP(cache_op))
	116	return 1; /* valid */
	117	else
	118	return 0; /* invalid */
	119	}
	120
e5c59547 JSR	121	static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
	122	{
	123	static char name[50];
	124
	125	if (cache_result) {
	126	sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
	127	hw_cache_op[cache_op][0],
	128	hw_cache_result[cache_result][0]);
	129	} else {
	130	sprintf(name, "%s-%s", hw_cache[cache_type][0],
	131	hw_cache_op[cache_op][1]);
	132	}
	133
	134	return name;
	135	}
	136
a21ca2ca	137	char *event_name(int counter)
5242519b	138	{
9cffa8d5	139	u64 config = attrs[counter].config;
a21ca2ca	140	int type = attrs[counter].type;
5242519b IM	141	static char buf[32];
5242519b IM	142
a21ca2ca IM	143	if (attrs[counter].type == PERF_TYPE_RAW) {
a21ca2ca IM	144	sprintf(buf, "raw 0x%llx", config);
5242519b IM	145	return buf;
	146	}
	147
	148	switch (type) {
	149	case PERF_TYPE_HARDWARE:
f4dbfa8f	150	if (config < PERF_COUNT_HW_MAX)
a21ca2ca	151	return hw_event_names[config];
5242519b IM	152	return "unknown-hardware";
5242519b IM	153
8326f44d	154	case PERF_TYPE_HW_CACHE: {
9cffa8d5	155	u8 cache_type, cache_op, cache_result;
8326f44d IM	156
	157	cache_type = (config >> 0) & 0xff;
	158	if (cache_type > PERF_COUNT_HW_CACHE_MAX)
	159	return "unknown-ext-hardware-cache-type";
	160
	161	cache_op = (config >> 8) & 0xff;
8faf3b54 IM	162	if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
8faf3b54 IM	163	return "unknown-ext-hardware-cache-op";
8326f44d IM	164
8326f44d IM	165	cache_result = (config >> 16) & 0xff;
8faf3b54 IM	166	if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
8faf3b54 IM	167	return "unknown-ext-hardware-cache-result";
8326f44d	168
06813f6c JSR	169	if (!is_cache_op_valid(cache_type, cache_op))
06813f6c JSR	170	return "invalid-cache";
8326f44d	171
e5c59547	172	return event_cache_name(cache_type, cache_op, cache_result);
8326f44d IM	173	}
8326f44d IM	174
5242519b	175	case PERF_TYPE_SOFTWARE:
f4dbfa8f	176	if (config < PERF_COUNT_SW_MAX)
a21ca2ca	177	return sw_event_names[config];
5242519b IM	178	return "unknown-software";
	179
	180	default:
	181	break;
	182	}
	183
	184	return "unknown";
	185	}
	186
61c45981	187	static int parse_aliases(const char *str, char names[][MAX_ALIASES], int size)
8326f44d IM	188	{
8326f44d IM	189	int i, j;
61c45981	190	int n, longest = -1;
8326f44d IM	191
8326f44d IM	192	for (i = 0; i < size; i++) {
61c45981 PM	193	for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
	194	n = strlen(names[i][j]);
	195	if (n > longest && !strncasecmp(*str, names[i][j], n))
	196	longest = n;
	197	}
	198	if (longest > 0) {
	199	*str += longest;
	200	return i;
8326f44d IM	201	}
	202	}
	203
8953645f	204	return -1;
8326f44d IM	205	}
8326f44d IM	206
c0c22dbf	207	static int
61c45981	208	parse_generic_hw_event(const char *str, struct perf_counter_attr attr)
8326f44d	209	{
61c45981 PM	210	const char s = str;
61c45981 PM	211	int cache_type = -1, cache_op = -1, cache_result = -1;
8326f44d	212
61c45981	213	cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
8326f44d IM	214	/*
	215	* No fallback - if we cannot get a clear cache type
	216	* then bail out:
	217	*/
	218	if (cache_type == -1)
61c45981 PM	219	return 0;
	220
	221	while ((cache_op == -1 \|\| cache_result == -1) && *s == '-') {
	222	++s;
	223
	224	if (cache_op == -1) {
	225	cache_op = parse_aliases(&s, hw_cache_op,
	226	PERF_COUNT_HW_CACHE_OP_MAX);
	227	if (cache_op >= 0) {
	228	if (!is_cache_op_valid(cache_type, cache_op))
	229	return 0;
	230	continue;
	231	}
	232	}
	233
	234	if (cache_result == -1) {
	235	cache_result = parse_aliases(&s, hw_cache_result,
	236	PERF_COUNT_HW_CACHE_RESULT_MAX);
	237	if (cache_result >= 0)
	238	continue;
	239	}
	240
	241	/*
	242	* Can't parse this as a cache op or result, so back up
	243	* to the '-'.
	244	*/
	245	--s;
	246	break;
	247	}
8326f44d	248
8326f44d IM	249	/*
	250	* Fall back to reads:
	251	*/
8953645f IM	252	if (cache_op == -1)
8953645f IM	253	cache_op = PERF_COUNT_HW_CACHE_OP_READ;
8326f44d	254
8326f44d IM	255	/*
	256	* Fall back to accesses:
	257	*/
	258	if (cache_result == -1)
	259	cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
	260
	261	attr->config = cache_type \| (cache_op << 8) \| (cache_result << 16);
	262	attr->type = PERF_TYPE_HW_CACHE;
	263
61c45981 PM	264	*str = s;
61c45981 PM	265	return 1;
8326f44d IM	266	}
8326f44d IM	267
74d5b588 JSR	268	static int check_events(const char *str, unsigned int i)
74d5b588 JSR	269	{
61c45981	270	int n;
74d5b588	271
61c45981 PM	272	n = strlen(event_symbols[i].symbol);
	273	if (!strncmp(str, event_symbols[i].symbol, n))
	274	return n;
	275
	276	n = strlen(event_symbols[i].alias);
	277	if (n)
	278	if (!strncmp(str, event_symbols[i].alias, n))
	279	return n;
74d5b588 JSR	280	return 0;
	281	}
	282
61c45981 PM	283	static int
61c45981 PM	284	parse_symbolic_event(const char *strp, struct perf_counter_attr attr)
8ad8db37	285	{
61c45981	286	const char str = strp;
8ad8db37	287	unsigned int i;
61c45981	288	int n;
8ad8db37	289
61c45981 PM	290	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
	291	n = check_events(str, i);
	292	if (n > 0) {
	293	attr->type = event_symbols[i].type;
	294	attr->config = event_symbols[i].config;
	295	*strp = str + n;
	296	return 1;
	297	}
	298	}
	299	return 0;
	300	}
	301
	302	static int parse_raw_event(const char *strp, struct perf_counter_attr attr)
	303	{
	304	const char str = strp;
	305	u64 config;
	306	int n;
a21ca2ca	307
61c45981	308	if (*str != 'r')
a21ca2ca	309	return 0;
61c45981 PM	310	n = hex2u64(str + 1, &config);
	311	if (n > 0) {
	312	*strp = str + n + 1;
	313	attr->type = PERF_TYPE_RAW;
	314	attr->config = config;
	315	return 1;
a21ca2ca	316	}
61c45981 PM	317	return 0;
61c45981 PM	318	}
8ad8db37	319
61c45981 PM	320	static int
	321	parse_numeric_event(const char *strp, struct perf_counter_attr attr)
	322	{
	323	const char str = strp;
	324	char *endp;
	325	unsigned long type;
	326	u64 config;
	327
	328	type = strtoul(str, &endp, 0);
	329	if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
	330	str = endp + 1;
	331	config = strtoul(str, &endp, 0);
	332	if (endp > str) {
	333	attr->type = type;
	334	attr->config = config;
	335	*strp = endp;
	336	return 1;
a0055ae2	337	}
61c45981 PM	338	}
	339	return 0;
	340	}
	341
	342	static int
	343	parse_event_modifier(const char *strp, struct perf_counter_attr attr)
	344	{
	345	const char str = strp;
	346	int eu = 1, ek = 1, eh = 1;
a21ca2ca	347
61c45981	348	if (*str++ != ':')
a21ca2ca	349	return 0;
61c45981 PM	350	while (*str) {
	351	if (*str == 'u')
	352	eu = 0;
	353	else if (*str == 'k')
	354	ek = 0;
	355	else if (*str == 'h')
	356	eh = 0;
	357	else
	358	break;
	359	++str;
5242519b	360	}
61c45981 PM	361	if (str >= *strp + 2) {
	362	*strp = str;
	363	attr->exclude_user = eu;
	364	attr->exclude_kernel = ek;
	365	attr->exclude_hv = eh;
	366	return 1;
	367	}
	368	return 0;
	369	}
8ad8db37	370
61c45981 PM	371	/*
	372	* Each event can have multiple symbolic names.
	373	* Symbolic names are (almost) exactly matched.
	374	*/
	375	static int parse_event_symbols(const char *str, struct perf_counter_attr attr)
	376	{
	377	if (!(parse_raw_event(str, attr) \|\|
	378	parse_numeric_event(str, attr) \|\|
	379	parse_symbolic_event(str, attr) \|\|
	380	parse_generic_hw_event(str, attr)))
	381	return 0;
a21ca2ca	382
61c45981	383	parse_event_modifier(str, attr);
8ad8db37	384
61c45981	385	return 1;
8ad8db37 IM	386	}
8ad8db37 IM	387
f37a291c	388	int parse_events(const struct option opt __used, const char str, int unset __used)
8ad8db37	389	{
a21ca2ca	390	struct perf_counter_attr attr;
8ad8db37	391
61c45981 PM	392	for (;;) {
	393	if (nr_counters == MAX_COUNTERS)
	394	return -1;
	395
	396	memset(&attr, 0, sizeof(attr));
	397	if (!parse_event_symbols(&str, &attr))
	398	return -1;
8ad8db37	399
61c45981 PM	400	if (!(str == 0 \|\| str == ',' \|\| isspace(*str)))
61c45981 PM	401	return -1;
8ad8db37	402
61c45981 PM	403	attrs[nr_counters] = attr;
61c45981 PM	404	nr_counters++;
8ad8db37	405
61c45981 PM	406	if (*str == 0)
	407	break;
	408	if (*str == ',')
	409	++str;
	410	while (isspace(*str))
	411	++str;
8ad8db37 IM	412	}
	413
	414	return 0;
	415	}
	416
86847b62 TG	417	static const char * const event_type_descriptors[] = {
	418	"",
	419	"Hardware event",
	420	"Software event",
	421	"Tracepoint event",
	422	"Hardware cache event",
	423	};
	424
8ad8db37	425	/*
86847b62	426	* Print the help text for the event symbols:
8ad8db37	427	*/
86847b62	428	void print_events(void)
8ad8db37	429	{
86847b62	430	struct event_symbol *syms = event_symbols;
73c24cb8	431	unsigned int i, type, op, prev_type = -1;
74d5b588	432	char name[40];
8ad8db37	433
86847b62 TG	434	fprintf(stderr, "\n");
86847b62 TG	435	fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
8ad8db37	436
86847b62 TG	437	for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
86847b62 TG	438	type = syms->type + 1;
23cdb5d5	439	if (type >= ARRAY_SIZE(event_type_descriptors))
86847b62	440	type = 0;
8ad8db37	441
86847b62 TG	442	if (type != prev_type)
86847b62 TG	443	fprintf(stderr, "\n");
8ad8db37	444
74d5b588 JSR	445	if (strlen(syms->alias))
	446	sprintf(name, "%s OR %s", syms->symbol, syms->alias);
	447	else
	448	strcpy(name, syms->symbol);
	449	fprintf(stderr, " %-40s [%s]\n", name,
86847b62	450	event_type_descriptors[type]);
8ad8db37	451
86847b62	452	prev_type = type;
8ad8db37 IM	453	}
8ad8db37 IM	454
73c24cb8 JSR	455	fprintf(stderr, "\n");
	456	for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
	457	for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
	458	/* skip invalid cache type */
	459	if (!is_cache_op_valid(type, op))
	460	continue;
	461
	462	for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
	463	fprintf(stderr, " %-40s [%s]\n",
	464	event_cache_name(type, op, i),
	465	event_type_descriptors[4]);
	466	}
	467	}
	468	}
	469
86847b62	470	fprintf(stderr, "\n");
74d5b588	471	fprintf(stderr, " %-40s [raw hardware event descriptor]\n",
86847b62 TG	472	"rNNN");
	473	fprintf(stderr, "\n");
	474
	475	exit(129);
8ad8db37	476	}