tools/perf/util/parse-events.l at v4.14-rc4

tjh.dev / kernel
fork
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork
kernel / tools / perf / util / parse-events.l
at v4.14-rc4 343 lines 10 kB view raw
wrap content
  1
  2%option reentrant
  3%option bison-bridge
  4%option prefix="parse_events_"
  5%option stack
  6%option bison-locations
  7%option yylineno
  8
  9%{
 10#include <errno.h>
 11#include "../perf.h"
 12#include "parse-events.h"
 13#include "parse-events-bison.h"
 14
 15char *parse_events_get_text(yyscan_t yyscanner);
 16YYSTYPE *parse_events_get_lval(yyscan_t yyscanner);
 17
 18static int __value(YYSTYPE *yylval, char *str, int base, int token)
 19{
 20	u64 num;
 21
 22	errno = 0;
 23	num = strtoull(str, NULL, base);
 24	if (errno)
 25		return PE_ERROR;
 26
 27	yylval->num = num;
 28	return token;
 29}
 30
 31static int value(yyscan_t scanner, int base)
 32{
 33	YYSTYPE *yylval = parse_events_get_lval(scanner);
 34	char *text = parse_events_get_text(scanner);
 35
 36	return __value(yylval, text, base, PE_VALUE);
 37}
 38
 39static int raw(yyscan_t scanner)
 40{
 41	YYSTYPE *yylval = parse_events_get_lval(scanner);
 42	char *text = parse_events_get_text(scanner);
 43
 44	return __value(yylval, text + 1, 16, PE_RAW);
 45}
 46
 47static int str(yyscan_t scanner, int token)
 48{
 49	YYSTYPE *yylval = parse_events_get_lval(scanner);
 50	char *text = parse_events_get_text(scanner);
 51
 52	yylval->str = strdup(text);
 53	return token;
 54}
 55
 56static bool isbpf(yyscan_t scanner)
 57{
 58	char *text = parse_events_get_text(scanner);
 59	int len = strlen(text);
 60
 61	if (len < 2)
 62		return false;
 63	if ((text[len - 1] == 'c' || text[len - 1] == 'o') &&
 64	    text[len - 2] == '.')
 65		return true;
 66	if (len > 4 && !strcmp(text + len - 4, ".obj"))
 67		return true;
 68	return false;
 69}
 70
 71/*
 72 * This function is called when the parser gets two kind of input:
 73 *
 74 * 	@cfg1 or @cfg2=config
 75 *
 76 * The leading '@' is stripped off before 'cfg1' and 'cfg2=config' are given to
 77 * bison.  In the latter case it is necessary to keep the string intact so that
 78 * the PMU kernel driver can determine what configurable is associated to
 79 * 'config'.
 80 */
 81static int drv_str(yyscan_t scanner, int token)
 82{
 83	YYSTYPE *yylval = parse_events_get_lval(scanner);
 84	char *text = parse_events_get_text(scanner);
 85
 86	/* Strip off the '@' */
 87	yylval->str = strdup(text + 1);
 88	return token;
 89}
 90
 91#define REWIND(__alloc)				\
 92do {								\
 93	YYSTYPE *__yylval = parse_events_get_lval(yyscanner);	\
 94	char *text = parse_events_get_text(yyscanner);		\
 95								\
 96	if (__alloc)						\
 97		__yylval->str = strdup(text);			\
 98								\
 99	yycolumn -= strlen(text);				\
100	yyless(0);						\
101} while (0)
102
103static int pmu_str_check(yyscan_t scanner)
104{
105	YYSTYPE *yylval = parse_events_get_lval(scanner);
106	char *text = parse_events_get_text(scanner);
107
108	yylval->str = strdup(text);
109	switch (perf_pmu__parse_check(text)) {
110		case PMU_EVENT_SYMBOL_PREFIX:
111			return PE_PMU_EVENT_PRE;
112		case PMU_EVENT_SYMBOL_SUFFIX:
113			return PE_PMU_EVENT_SUF;
114		case PMU_EVENT_SYMBOL:
115			return PE_KERNEL_PMU_EVENT;
116		default:
117			return PE_NAME;
118	}
119}
120
121static int sym(yyscan_t scanner, int type, int config)
122{
123	YYSTYPE *yylval = parse_events_get_lval(scanner);
124
125	yylval->num = (type << 16) + config;
126	return type == PERF_TYPE_HARDWARE ? PE_VALUE_SYM_HW : PE_VALUE_SYM_SW;
127}
128
129static int term(yyscan_t scanner, int type)
130{
131	YYSTYPE *yylval = parse_events_get_lval(scanner);
132
133	yylval->num = type;
134	return PE_TERM;
135}
136
137#define YY_USER_ACTION					\
138do {							\
139	yylloc->last_column  = yylloc->first_column;	\
140	yylloc->first_column = yycolumn;		\
141	yycolumn += yyleng;				\
142} while (0);
143
144%}
145
146%x mem
147%s config
148%x event
149%x array
150
151group		[^,{}/]*[{][^}]*[}][^,{}/]*
152event_pmu	[^,{}/]+[/][^/]*[/][^,{}/]*
153event		[^,{}/]+
154bpf_object	[^,{}]+\.(o|bpf)[a-zA-Z0-9._]*
155bpf_source	[^,{}]+\.c[a-zA-Z0-9._]*
156
157num_dec		[0-9]+
158num_hex		0x[a-fA-F0-9]+
159num_raw_hex	[a-fA-F0-9]+
160name		[a-zA-Z_*?][a-zA-Z0-9_*?.]*
161name_minus	[a-zA-Z_*?][a-zA-Z0-9\-_*?.:]*
162drv_cfg_term	[a-zA-Z0-9_\.]+(=[a-zA-Z0-9_*?\.:]+)?
163/* If you add a modifier you need to update check_modifier() */
164modifier_event	[ukhpPGHSDI]+
165modifier_bp	[rwx]{1,3}
166
167%%
168
169%{
170	{
171		int start_token;
172
173		start_token = parse_events_get_extra(yyscanner);
174
175		if (start_token == PE_START_TERMS)
176			BEGIN(config);
177		else if (start_token == PE_START_EVENTS)
178			BEGIN(event);
179
180		if (start_token) {
181			parse_events_set_extra(NULL, yyscanner);
182			/*
183			 * The flex parser does not init locations variable
184			 * via the scan_string interface, so we need do the
185			 * init in here.
186			 */
187			yycolumn = 0;
188			return start_token;
189		}
190         }
191%}
192
193<event>{
194
195{group}		{
196			BEGIN(INITIAL);
197			REWIND(0);
198		}
199
200{event_pmu}	|
201{bpf_object}	|
202{bpf_source}	|
203{event}		{
204			BEGIN(INITIAL);
205			REWIND(1);
206			return PE_EVENT_NAME;
207		}
208
209<<EOF>>		{
210			BEGIN(INITIAL);
211			REWIND(0);
212		}
213
214}
215
216<array>{
217"]"			{ BEGIN(config); return ']'; }
218{num_dec}		{ return value(yyscanner, 10); }
219{num_hex}		{ return value(yyscanner, 16); }
220,			{ return ','; }
221"\.\.\."		{ return PE_ARRAY_RANGE; }
222}
223
224<config>{
225	/*
226	 * Please update config_term_names when new static term is added.
227	 */
228config			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); }
229config1			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); }
230config2			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); }
231name			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); }
232period			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
233freq			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ); }
234branch_type		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
235time			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_TIME); }
236call-graph		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CALLGRAPH); }
237stack-size		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_STACKSIZE); }
238max-stack		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_STACK); }
239inherit			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_INHERIT); }
240no-inherit		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOINHERIT); }
241overwrite		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_OVERWRITE); }
242no-overwrite		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOOVERWRITE); }
243,			{ return ','; }
244"/"			{ BEGIN(INITIAL); return '/'; }
245{name_minus}		{ return str(yyscanner, PE_NAME); }
246\[all\]			{ return PE_ARRAY_ALL; }
247"["			{ BEGIN(array); return '['; }
248@{drv_cfg_term}		{ return drv_str(yyscanner, PE_DRV_CFG_TERM); }
249}
250
251<mem>{
252{modifier_bp}		{ return str(yyscanner, PE_MODIFIER_BP); }
253:			{ return ':'; }
254"/"			{ return '/'; }
255{num_dec}		{ return value(yyscanner, 10); }
256{num_hex}		{ return value(yyscanner, 16); }
257	/*
258	 * We need to separate 'mem:' scanner part, in order to get specific
259	 * modifier bits parsed out. Otherwise we would need to handle PE_NAME
260	 * and we'd need to parse it manually. During the escape from <mem>
261	 * state we need to put the escaping char back, so we dont miss it.
262	 */
263.			{ unput(*yytext); BEGIN(INITIAL); }
264	/*
265	 * We destroy the scanner after reaching EOF,
266	 * but anyway just to be sure get back to INIT state.
267	 */
268<<EOF>>			{ BEGIN(INITIAL); }
269}
270
271cpu-cycles|cycles				{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
272stalled-cycles-frontend|idle-cycles-frontend	{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
273stalled-cycles-backend|idle-cycles-backend	{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
274instructions					{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
275cache-references				{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
276cache-misses					{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
277branch-instructions|branches			{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
278branch-misses					{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
279bus-cycles					{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
280ref-cycles					{ return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); }
281cpu-clock					{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
282task-clock					{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
283page-faults|faults				{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
284minor-faults					{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
285major-faults					{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
286context-switches|cs				{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
287cpu-migrations|migrations			{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
288alignment-faults				{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
289emulation-faults				{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
290dummy						{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_DUMMY); }
291bpf-output					{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_BPF_OUTPUT); }
292
293	/*
294	 * We have to handle the kernel PMU event cycles-ct/cycles-t/mem-loads/mem-stores separately.
295	 * Because the prefix cycles is mixed up with cpu-cycles.
296	 * loads and stores are mixed up with cache event
297	 */
298cycles-ct					{ return str(yyscanner, PE_KERNEL_PMU_EVENT); }
299cycles-t					{ return str(yyscanner, PE_KERNEL_PMU_EVENT); }
300mem-loads					{ return str(yyscanner, PE_KERNEL_PMU_EVENT); }
301mem-stores					{ return str(yyscanner, PE_KERNEL_PMU_EVENT); }
302topdown-[a-z-]+					{ return str(yyscanner, PE_KERNEL_PMU_EVENT); }
303
304L1-dcache|l1-d|l1d|L1-data		|
305L1-icache|l1-i|l1i|L1-instruction	|
306LLC|L2					|
307dTLB|d-tlb|Data-TLB			|
308iTLB|i-tlb|Instruction-TLB		|
309branch|branches|bpu|btb|bpc		|
310node					{ return str(yyscanner, PE_NAME_CACHE_TYPE); }
311
312load|loads|read				|
313store|stores|write			|
314prefetch|prefetches			|
315speculative-read|speculative-load	|
316refs|Reference|ops|access		|
317misses|miss				{ return str(yyscanner, PE_NAME_CACHE_OP_RESULT); }
318
319mem:			{ BEGIN(mem); return PE_PREFIX_MEM; }
320r{num_raw_hex}		{ return raw(yyscanner); }
321{num_dec}		{ return value(yyscanner, 10); }
322{num_hex}		{ return value(yyscanner, 16); }
323
324{modifier_event}	{ return str(yyscanner, PE_MODIFIER_EVENT); }
325{bpf_object}		{ if (!isbpf(yyscanner)) REJECT; return str(yyscanner, PE_BPF_OBJECT); }
326{bpf_source}		{ if (!isbpf(yyscanner)) REJECT; return str(yyscanner, PE_BPF_SOURCE); }
327{name}			{ return pmu_str_check(yyscanner); }
328"/"			{ BEGIN(config); return '/'; }
329-			{ return '-'; }
330,			{ BEGIN(event); return ','; }
331:			{ return ':'; }
332"{"			{ BEGIN(event); return '{'; }
333"}"			{ return '}'; }
334=			{ return '='; }
335\n			{ }
336.			{ }
337
338%%
339
340int parse_events_wrap(void *scanner __maybe_unused)
341{
342	return 1;
343}
Configure Feed

Configure Feed
