0001
0002 %option reentrant
0003 %option bison-bridge
0004 %option prefix="parse_events_"
0005 %option stack
0006 %option bison-locations
0007 %option yylineno
0008 %option reject
0009
0010 %{
0011 #include <errno.h>
0012 #include <sys/types.h>
0013 #include <sys/stat.h>
0014 #include <unistd.h>
0015 #include "parse-events.h"
0016 #include "parse-events-bison.h"
0017 #include "evsel.h"
0018
0019 char *parse_events_get_text(yyscan_t yyscanner);
0020 YYSTYPE *parse_events_get_lval(yyscan_t yyscanner);
0021
0022 static int __value(YYSTYPE *yylval, char *str, int base, int token)
0023 {
0024 u64 num;
0025
0026 errno = 0;
0027 num = strtoull(str, NULL, base);
0028 if (errno)
0029 return PE_ERROR;
0030
0031 yylval->num = num;
0032 return token;
0033 }
0034
0035 static int value(yyscan_t scanner, int base)
0036 {
0037 YYSTYPE *yylval = parse_events_get_lval(scanner);
0038 char *text = parse_events_get_text(scanner);
0039
0040 return __value(yylval, text, base, PE_VALUE);
0041 }
0042
0043 static int str(yyscan_t scanner, int token)
0044 {
0045 YYSTYPE *yylval = parse_events_get_lval(scanner);
0046 char *text = parse_events_get_text(scanner);
0047
0048 if (text[0] != '\'') {
0049 yylval->str = strdup(text);
0050 } else {
0051 /*
0052 * If a text tag specified on the command line
0053 * contains opening single quite ' then it is
0054 * expected that the tag ends with single quote
0055 * as well, like this:
0056 * name=\'CPU_CLK_UNHALTED.THREAD:cmask=1\'
0057 * quotes need to be escaped to bypass shell
0058 * processing.
0059 */
0060 yylval->str = strndup(&text[1], strlen(text) - 2);
0061 }
0062
0063 return token;
0064 }
0065
0066 static int raw(yyscan_t scanner)
0067 {
0068 YYSTYPE *yylval = parse_events_get_lval(scanner);
0069 char *text = parse_events_get_text(scanner);
0070
0071 if (perf_pmu__parse_check(text) == PMU_EVENT_SYMBOL)
0072 return str(scanner, PE_NAME);
0073
0074 return __value(yylval, text + 1, 16, PE_RAW);
0075 }
0076
0077 static bool isbpf_suffix(char *text)
0078 {
0079 int len = strlen(text);
0080
0081 if (len < 2)
0082 return false;
0083 if ((text[len - 1] == 'c' || text[len - 1] == 'o') &&
0084 text[len - 2] == '.')
0085 return true;
0086 if (len > 4 && !strcmp(text + len - 4, ".obj"))
0087 return true;
0088 return false;
0089 }
0090
0091 static bool isbpf(yyscan_t scanner)
0092 {
0093 char *text = parse_events_get_text(scanner);
0094 struct stat st;
0095
0096 if (!isbpf_suffix(text))
0097 return false;
0098
0099 return stat(text, &st) == 0;
0100 }
0101
0102 /*
0103 * This function is called when the parser gets two kind of input:
0104 *
0105 * @cfg1 or @cfg2=config
0106 *
0107 * The leading '@' is stripped off before 'cfg1' and 'cfg2=config' are given to
0108 * bison. In the latter case it is necessary to keep the string intact so that
0109 * the PMU kernel driver can determine what configurable is associated to
0110 * 'config'.
0111 */
0112 static int drv_str(yyscan_t scanner, int token)
0113 {
0114 YYSTYPE *yylval = parse_events_get_lval(scanner);
0115 char *text = parse_events_get_text(scanner);
0116
0117 /* Strip off the '@' */
0118 yylval->str = strdup(text + 1);
0119 return token;
0120 }
0121
0122 #define REWIND(__alloc) \
0123 do { \
0124 YYSTYPE *__yylval = parse_events_get_lval(yyscanner); \
0125 char *text = parse_events_get_text(yyscanner); \
0126 \
0127 if (__alloc) \
0128 __yylval->str = strdup(text); \
0129 \
0130 yycolumn -= strlen(text); \
0131 yyless(0); \
0132 } while (0)
0133
0134 static int pmu_str_check(yyscan_t scanner, struct parse_events_state *parse_state)
0135 {
0136 YYSTYPE *yylval = parse_events_get_lval(scanner);
0137 char *text = parse_events_get_text(scanner);
0138
0139 yylval->str = strdup(text);
0140
0141 /*
0142 * If we're not testing then parse check determines the PMU event type
0143 * which if it isn't a PMU returns PE_NAME. When testing the result of
0144 * parse check can't be trusted so we return PE_PMU_EVENT_FAKE unless
0145 * an '!' is present in which case the text can't be a PMU name.
0146 */
0147 switch (perf_pmu__parse_check(text)) {
0148 case PMU_EVENT_SYMBOL_PREFIX:
0149 return PE_PMU_EVENT_PRE;
0150 case PMU_EVENT_SYMBOL_SUFFIX:
0151 return PE_PMU_EVENT_SUF;
0152 case PMU_EVENT_SYMBOL_SUFFIX2:
0153 return PE_PMU_EVENT_SUF2;
0154 case PMU_EVENT_SYMBOL:
0155 return parse_state->fake_pmu
0156 ? PE_PMU_EVENT_FAKE : PE_KERNEL_PMU_EVENT;
0157 default:
0158 return parse_state->fake_pmu && !strchr(text,'!')
0159 ? PE_PMU_EVENT_FAKE : PE_NAME;
0160 }
0161 }
0162
0163 static int sym(yyscan_t scanner, int type, int config)
0164 {
0165 YYSTYPE *yylval = parse_events_get_lval(scanner);
0166
0167 yylval->num = (type << 16) + config;
0168 return type == PERF_TYPE_HARDWARE ? PE_VALUE_SYM_HW : PE_VALUE_SYM_SW;
0169 }
0170
0171 static int tool(yyscan_t scanner, enum perf_tool_event event)
0172 {
0173 YYSTYPE *yylval = parse_events_get_lval(scanner);
0174
0175 yylval->num = event;
0176 return PE_VALUE_SYM_TOOL;
0177 }
0178
0179 static int term(yyscan_t scanner, int type)
0180 {
0181 YYSTYPE *yylval = parse_events_get_lval(scanner);
0182
0183 yylval->num = type;
0184 return PE_TERM;
0185 }
0186
0187 #define YY_USER_ACTION \
0188 do { \
0189 yylloc->last_column = yylloc->first_column; \
0190 yylloc->first_column = yycolumn; \
0191 yycolumn += yyleng; \
0192 } while (0);
0193
0194 #define USER_REJECT \
0195 yycolumn -= yyleng; \
0196 REJECT
0197
0198 %}
0199
0200 %x mem
0201 %s config
0202 %x event
0203 %x array
0204
0205 group [^,{}/]*[{][^}]*[}][^,{}/]*
0206 event_pmu [^,{}/]+[/][^/]*[/][^,{}/]*
0207 event [^,{}/]+
0208 bpf_object [^,{}]+\.(o|bpf)[a-zA-Z0-9._]*
0209 bpf_source [^,{}]+\.c[a-zA-Z0-9._]*
0210
0211 num_dec [0-9]+
0212 num_hex 0x[a-fA-F0-9]+
0213 num_raw_hex [a-fA-F0-9]+
0214 name [a-zA-Z_*?\[\]][a-zA-Z0-9_*?.\[\]!]*
0215 name_tag [\'][a-zA-Z_*?\[\]][a-zA-Z0-9_*?\-,\.\[\]:=]*[\']
0216 name_minus [a-zA-Z_*?][a-zA-Z0-9\-_*?.:]*
0217 drv_cfg_term [a-zA-Z0-9_\.]+(=[a-zA-Z0-9_*?\.:]+)?
0218 /* If you add a modifier you need to update check_modifier() */
0219 modifier_event [ukhpPGHSDIWeb]+
0220 modifier_bp [rwx]{1,3}
0221
0222 %%
0223
0224 %{
0225 struct parse_events_state *_parse_state = parse_events_get_extra(yyscanner);
0226
0227 {
0228 int start_token = _parse_state->stoken;
0229
0230 if (start_token == PE_START_TERMS)
0231 BEGIN(config);
0232 else if (start_token == PE_START_EVENTS)
0233 BEGIN(event);
0234
0235 if (start_token) {
0236 _parse_state->stoken = 0;
0237 /*
0238 * The flex parser does not init locations variable
0239 * via the scan_string interface, so we need do the
0240 * init in here.
0241 */
0242 yycolumn = 0;
0243 return start_token;
0244 }
0245 }
0246 %}
0247
0248 <event>{
0249
0250 {group} {
0251 BEGIN(INITIAL);
0252 REWIND(0);
0253 }
0254
0255 {event_pmu} |
0256 {bpf_object} |
0257 {bpf_source} |
0258 {event} {
0259 BEGIN(INITIAL);
0260 REWIND(1);
0261 return PE_EVENT_NAME;
0262 }
0263
0264 <<EOF>> {
0265 BEGIN(INITIAL);
0266 REWIND(0);
0267 }
0268 , {
0269 return ',';
0270 }
0271 }
0272
0273 <array>{
0274 "]" { BEGIN(config); return ']'; }
0275 {num_dec} { return value(yyscanner, 10); }
0276 {num_hex} { return value(yyscanner, 16); }
0277 , { return ','; }
0278 "\.\.\." { return PE_ARRAY_RANGE; }
0279 }
0280
0281 <config>{
0282 /*
0283 * Please update config_term_names when new static term is added.
0284 */
0285 config { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); }
0286 config1 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); }
0287 config2 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); }
0288 name { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); }
0289 period { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
0290 freq { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ); }
0291 branch_type { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
0292 time { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_TIME); }
0293 call-graph { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CALLGRAPH); }
0294 stack-size { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_STACKSIZE); }
0295 max-stack { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_STACK); }
0296 nr { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_EVENTS); }
0297 inherit { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_INHERIT); }
0298 no-inherit { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOINHERIT); }
0299 overwrite { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_OVERWRITE); }
0300 no-overwrite { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOOVERWRITE); }
0301 percore { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_PERCORE); }
0302 aux-output { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT); }
0303 aux-sample-size { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE); }
0304 metric-id { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_METRIC_ID); }
0305 r{num_raw_hex} { return raw(yyscanner); }
0306 r0x{num_raw_hex} { return raw(yyscanner); }
0307 , { return ','; }
0308 "/" { BEGIN(INITIAL); return '/'; }
0309 {name_minus} { return str(yyscanner, PE_NAME); }
0310 \[all\] { return PE_ARRAY_ALL; }
0311 "[" { BEGIN(array); return '['; }
0312 @{drv_cfg_term} { return drv_str(yyscanner, PE_DRV_CFG_TERM); }
0313 }
0314
0315 <mem>{
0316 {modifier_bp} { return str(yyscanner, PE_MODIFIER_BP); }
0317 : { return ':'; }
0318 "/" { return '/'; }
0319 {num_dec} { return value(yyscanner, 10); }
0320 {num_hex} { return value(yyscanner, 16); }
0321 /*
0322 * We need to separate 'mem:' scanner part, in order to get specific
0323 * modifier bits parsed out. Otherwise we would need to handle PE_NAME
0324 * and we'd need to parse it manually. During the escape from <mem>
0325 * state we need to put the escaping char back, so we dont miss it.
0326 */
0327 . { unput(*yytext); BEGIN(INITIAL); }
0328 /*
0329 * We destroy the scanner after reaching EOF,
0330 * but anyway just to be sure get back to INIT state.
0331 */
0332 <<EOF>> { BEGIN(INITIAL); }
0333 }
0334
0335 cpu-cycles|cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
0336 stalled-cycles-frontend|idle-cycles-frontend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
0337 stalled-cycles-backend|idle-cycles-backend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
0338 instructions { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
0339 cache-references { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
0340 cache-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
0341 branch-instructions|branches { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
0342 branch-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
0343 bus-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
0344 ref-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); }
0345 cpu-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
0346 task-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
0347 page-faults|faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
0348 minor-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
0349 major-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
0350 context-switches|cs { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
0351 cpu-migrations|migrations { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
0352 alignment-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
0353 emulation-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
0354 dummy { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_DUMMY); }
0355 duration_time { return tool(yyscanner, PERF_TOOL_DURATION_TIME); }
0356 user_time { return tool(yyscanner, PERF_TOOL_USER_TIME); }
0357 system_time { return tool(yyscanner, PERF_TOOL_SYSTEM_TIME); }
0358 bpf-output { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_BPF_OUTPUT); }
0359 cgroup-switches { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CGROUP_SWITCHES); }
0360
0361 /*
0362 * We have to handle the kernel PMU event cycles-ct/cycles-t/mem-loads/mem-stores separately.
0363 * Because the prefix cycles is mixed up with cpu-cycles.
0364 * loads and stores are mixed up with cache event
0365 */
0366 cycles-ct |
0367 cycles-t |
0368 mem-loads |
0369 mem-loads-aux |
0370 mem-stores |
0371 topdown-[a-z-]+ |
0372 tx-capacity-[a-z-]+ |
0373 el-capacity-[a-z-]+ { return str(yyscanner, PE_KERNEL_PMU_EVENT); }
0374
0375 L1-dcache|l1-d|l1d|L1-data |
0376 L1-icache|l1-i|l1i|L1-instruction |
0377 LLC|L2 |
0378 dTLB|d-tlb|Data-TLB |
0379 iTLB|i-tlb|Instruction-TLB |
0380 branch|branches|bpu|btb|bpc |
0381 node { return str(yyscanner, PE_NAME_CACHE_TYPE); }
0382
0383 load|loads|read |
0384 store|stores|write |
0385 prefetch|prefetches |
0386 speculative-read|speculative-load |
0387 refs|Reference|ops|access |
0388 misses|miss { return str(yyscanner, PE_NAME_CACHE_OP_RESULT); }
0389
0390 mem: { BEGIN(mem); return PE_PREFIX_MEM; }
0391 r{num_raw_hex} { return raw(yyscanner); }
0392 {num_dec} { return value(yyscanner, 10); }
0393 {num_hex} { return value(yyscanner, 16); }
0394
0395 {modifier_event} { return str(yyscanner, PE_MODIFIER_EVENT); }
0396 {bpf_object} { if (!isbpf(yyscanner)) { USER_REJECT }; return str(yyscanner, PE_BPF_OBJECT); }
0397 {bpf_source} { if (!isbpf(yyscanner)) { USER_REJECT }; return str(yyscanner, PE_BPF_SOURCE); }
0398 {name} { return pmu_str_check(yyscanner, _parse_state); }
0399 {name_tag} { return str(yyscanner, PE_NAME); }
0400 "/" { BEGIN(config); return '/'; }
0401 - { return '-'; }
0402 , { BEGIN(event); return ','; }
0403 : { return ':'; }
0404 "{" { BEGIN(event); return '{'; }
0405 "}" { return '}'; }
0406 = { return '='; }
0407 \n { }
0408 . { }
0409
0410 %%
0411
0412 int parse_events_wrap(void *scanner __maybe_unused)
0413 {
0414 return 1;
0415 }
