1 2 %option reentrant 3 %option bison-bridge 4 %option prefix="parse_events_" 5 %option stack 6 %option bison-locations 7 %option yylineno 8 %option reject 9 10 %{ 11 #include <errno.h> 12 #include <sys/types.h> 13 #include <sys/stat.h> 14 #include <unistd.h> 15 #include "parse-events.h" 16 #include "parse-events-bison.h" 17 #include "evsel.h" 18 19 char *parse_events_get_text(yyscan_t yyscanner); 20 YYSTYPE *parse_events_get_lval(yyscan_t yyscanner); 21 int parse_events_get_column(yyscan_t yyscanner); 22 int parse_events_get_leng(yyscan_t yyscanner); 23 24 static int get_column(yyscan_t scanner) 25 { 26 return parse_events_get_column(scanner) - parse_events_get_leng(scanner); 27 } 28 29 static int value(struct parse_events_state *parse_state, yyscan_t scanner, int base) 30 { 31 YYSTYPE *yylval = parse_events_get_lval(scanner); 32 char *text = parse_events_get_text(scanner); 33 u64 num; 34 35 errno = 0; 36 num = strtoull(text, NULL, base); 37 if (errno) { 38 struct parse_events_error *error = parse_state->error; 39 char *help = NULL; 40 41 if (asprintf(&help, "Bad base %d number \"%s\"", base, text) > 0) 42 parse_events_error__handle(error, get_column(scanner), help , NULL); 43 44 return PE_ERROR; 45 } 46 47 yylval->num = num; 48 return PE_VALUE; 49 } 50 51 static int str(yyscan_t scanner, int token) 52 { 53 YYSTYPE *yylval = parse_events_get_lval(scanner); 54 char *text = parse_events_get_text(scanner); 55 56 yylval->str = strdup(text); 57 return token; 58 } 59 60 static int quoted_str(yyscan_t scanner, int token) 61 { 62 YYSTYPE *yylval = parse_events_get_lval(scanner); 63 char *text = parse_events_get_text(scanner); 64 65 /* 66 * If a text tag specified on the command line 67 * contains opening single quite ' then it is 68 * expected that the tag ends with single quote 69 * as well, like this: 70 * name=\'CPU_CLK_UNHALTED.THREAD:cmask=1\' 71 * quotes need to be escaped to bypass shell 72 * processing. 73 */ 74 yylval->str = strndup(&text[1], strlen(text) - 2); 75 return token; 76 } 77 78 static int lc_str(yyscan_t scanner, const struct parse_events_state *state) 79 { 80 return str(scanner, state->match_legacy_cache_terms ? PE_LEGACY_CACHE : PE_NAME); 81 } 82 83 /* 84 * This function is called when the parser gets two kind of input: 85 * 86 * @cfg1 or @cfg2=config 87 * 88 * The leading '@' is stripped off before 'cfg1' and 'cfg2=config' are given to 89 * bison. In the latter case it is necessary to keep the string intact so that 90 * the PMU kernel driver can determine what configurable is associated to 91 * 'config'. 92 */ 93 static int drv_str(yyscan_t scanner, int token) 94 { 95 YYSTYPE *yylval = parse_events_get_lval(scanner); 96 char *text = parse_events_get_text(scanner); 97 98 /* Strip off the '@' */ 99 yylval->str = strdup(text + 1); 100 return token; 101 } 102 103 /* 104 * Use yyless to return all the characaters to the input. Update the column for 105 * location debugging. If __alloc is non-zero set yylval to the text for the 106 * returned token's value. 107 */ 108 #define REWIND(__alloc) \ 109 do { \ 110 YYSTYPE *__yylval = parse_events_get_lval(yyscanner); \ 111 char *text = parse_events_get_text(yyscanner); \ 112 \ 113 if (__alloc) \ 114 __yylval->str = strdup(text); \ 115 \ 116 yycolumn -= strlen(text); \ 117 yyless(0); \ 118 } while (0) 119 120 static int sym(yyscan_t scanner, int type, int config) 121 { 122 YYSTYPE *yylval = parse_events_get_lval(scanner); 123 124 yylval->num = (type << 16) + config; 125 return type == PERF_TYPE_HARDWARE ? PE_VALUE_SYM_HW : PE_VALUE_SYM_SW; 126 } 127 128 static int term(yyscan_t scanner, enum parse_events__term_type type) 129 { 130 YYSTYPE *yylval = parse_events_get_lval(scanner); 131 132 yylval->term_type = type; 133 return PE_TERM; 134 } 135 136 static int hw_term(yyscan_t scanner, int config) 137 { 138 YYSTYPE *yylval = parse_events_get_lval(scanner); 139 char *text = parse_events_get_text(scanner); 140 141 yylval->hardware_term.str = strdup(text); 142 yylval->hardware_term.num = PERF_TYPE_HARDWARE + config; 143 return PE_TERM_HW; 144 } 145 146 static void modifiers_error(struct parse_events_state *parse_state, yyscan_t scanner, 147 int pos, char mod_char, const char *mod_name) 148 { 149 struct parse_events_error *error = parse_state->error; 150 char *help = NULL; 151 152 if (asprintf(&help, "Duplicate modifier '%c' (%s)", mod_char, mod_name) > 0) 153 parse_events_error__handle(error, get_column(scanner) + pos, help , NULL); 154 } 155 156 static int modifiers(struct parse_events_state *parse_state, yyscan_t scanner) 157 { 158 YYSTYPE *yylval = parse_events_get_lval(scanner); 159 char *text = parse_events_get_text(scanner); 160 struct parse_events_modifier mod = { .precise = 0, }; 161 162 for (size_t i = 0, n = strlen(text); i < n; i++) { 163 #define CASE(c, field) \ 164 case c: \ 165 if (mod.field) { \ 166 modifiers_error(parse_state, scanner, i, c, #field); \ 167 return PE_ERROR; \ 168 } \ 169 mod.field = true; \ 170 break 171 172 switch (text[i]) { 173 CASE('u', user); 174 CASE('k', kernel); 175 CASE('h', hypervisor); 176 CASE('I', non_idle); 177 CASE('G', guest); 178 CASE('H', host); 179 case 'p': 180 mod.precise++; 181 /* 182 * precise ip: 183 * 184 * 0 - SAMPLE_IP can have arbitrary skid 185 * 1 - SAMPLE_IP must have constant skid 186 * 2 - SAMPLE_IP requested to have 0 skid 187 * 3 - SAMPLE_IP must have 0 skid 188 * 189 * See also PERF_RECORD_MISC_EXACT_IP 190 */ 191 if (mod.precise > 3) { 192 struct parse_events_error *error = parse_state->error; 193 char *help = strdup("Maximum precise value is 3"); 194 195 if (help) { 196 parse_events_error__handle(error, get_column(scanner) + i, 197 help , NULL); 198 } 199 return PE_ERROR; 200 } 201 break; 202 CASE('P', precise_max); 203 CASE('S', sample_read); 204 CASE('D', pinned); 205 CASE('W', weak); 206 CASE('e', exclusive); 207 CASE('b', bpf); 208 CASE('R', retire_lat); 209 default: 210 return PE_ERROR; 211 } 212 #undef CASE 213 } 214 yylval->mod = mod; 215 return PE_MODIFIER_EVENT; 216 } 217 218 #define YY_USER_ACTION \ 219 do { \ 220 yylloc->last_column = yylloc->first_column; \ 221 yylloc->first_column = yycolumn; \ 222 yycolumn += yyleng; \ 223 } while (0); 224 225 #define USER_REJECT \ 226 yycolumn -= yyleng; \ 227 REJECT 228 229 %} 230 231 %x mem 232 %s config 233 %x event 234 235 group [^,{}/]*[{][^}]*[}][^,{}/]* 236 event_pmu [^,{}/]+[/][^/]*[/][^,{}/]* 237 event [^,{}/]+ 238 239 num_dec [0-9]+ 240 num_hex 0x[a-fA-F0-9]{1,16} 241 num_raw_hex [a-fA-F0-9]{1,16} 242 /* Regular pattern to match the token PE_NAME. */ 243 name_start [a-zA-Z0-9_*?\[\]] 244 name {name_start}[a-zA-Z0-9_*?.\[\]!\-]* 245 /* PE_NAME token when inside a config term list, allows ':'. */ 246 term_name {name_start}[a-zA-Z0-9_*?.\[\]!\-:]* 247 /* 248 * PE_NAME token when quoted, allows ':,.='. 249 * Matches the RHS of terms like: name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks'. 250 */ 251 quoted_name [\']{name_start}[a-zA-Z0-9_*?.\[\]!\-:,\.=]*[\'] 252 drv_cfg_term [a-zA-Z0-9_\.]+(=[a-zA-Z0-9_*?\.:]+)? 253 /* 254 * If you add a modifier you need to update check_modifier(). 255 * Also, the letters in modifier_event must not be in modifier_bp. 256 */ 257 modifier_event [ukhpPGHSDIWebR]{1,16} 258 modifier_bp [rwx]{1,3} 259 lc_type (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|node) 260 lc_op_result (load|loads|read|store|stores|write|prefetch|prefetches|speculative-read|speculative-load|refs|Reference|ops|access|misses|miss) 261 digit [0-9] 262 non_digit [^0-9] 263 264 %% 265 266 %{ 267 struct parse_events_state *_parse_state = parse_events_get_extra(yyscanner); 268 { 269 int start_token = _parse_state->stoken; 270 271 if (start_token == PE_START_TERMS) 272 BEGIN(config); 273 else if (start_token == PE_START_EVENTS) 274 BEGIN(event); 275 276 if (start_token) { 277 _parse_state->stoken = 0; 278 /* 279 * The flex parser does not init locations variable 280 * via the scan_string interface, so we need do the 281 * init in here. 282 */ 283 yycolumn = 0; 284 return start_token; 285 } 286 } 287 %} 288 289 <event>{ 290 291 {group} { 292 BEGIN(INITIAL); 293 REWIND(0); 294 } 295 296 {event_pmu} | 297 {event} { 298 BEGIN(INITIAL); 299 REWIND(1); 300 return PE_EVENT_NAME; 301 } 302 303 <<EOF>> { 304 BEGIN(INITIAL); 305 REWIND(0); 306 } 307 , { 308 return ','; 309 } 310 } 311 312 <config>{ 313 /* 314 * Please update config_term_names when new static term is added. 315 */ 316 config { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); } 317 config1 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); } 318 config2 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); } 319 config3 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG3); } 320 name { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); } 321 period { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); } 322 freq { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ); } 323 branch_type { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); } 324 time { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_TIME); } 325 call-graph { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CALLGRAPH); } 326 stack-size { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_STACKSIZE); } 327 max-stack { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_STACK); } 328 nr { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_EVENTS); } 329 inherit { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_INHERIT); } 330 no-inherit { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOINHERIT); } 331 overwrite { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_OVERWRITE); } 332 no-overwrite { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOOVERWRITE); } 333 percore { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_PERCORE); } 334 aux-output { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT); } 335 aux-action { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_ACTION); } 336 aux-sample-size { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE); } 337 metric-id { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_METRIC_ID); } 338 cpu { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CPU); } 339 cpu-cycles|cycles { return hw_term(yyscanner, PERF_COUNT_HW_CPU_CYCLES); } 340 stalled-cycles-frontend|idle-cycles-frontend { return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); } 341 stalled-cycles-backend|idle-cycles-backend { return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); } 342 instructions { return hw_term(yyscanner, PERF_COUNT_HW_INSTRUCTIONS); } 343 cache-references { return hw_term(yyscanner, PERF_COUNT_HW_CACHE_REFERENCES); } 344 cache-misses { return hw_term(yyscanner, PERF_COUNT_HW_CACHE_MISSES); } 345 branch-instructions|branches { return hw_term(yyscanner, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); } 346 branch-misses { return hw_term(yyscanner, PERF_COUNT_HW_BRANCH_MISSES); } 347 bus-cycles { return hw_term(yyscanner, PERF_COUNT_HW_BUS_CYCLES); } 348 ref-cycles { return hw_term(yyscanner, PERF_COUNT_HW_REF_CPU_CYCLES); } 349 r{num_raw_hex} { return str(yyscanner, PE_RAW); } 350 r0x{num_raw_hex} { return str(yyscanner, PE_RAW); } 351 , { return ','; } 352 "/" { BEGIN(INITIAL); return '/'; } 353 {lc_type} { return lc_str(yyscanner, _parse_state); } 354 {lc_type}-{lc_op_result} { return lc_str(yyscanner, _parse_state); } 355 {lc_type}-{lc_op_result}-{lc_op_result} { return lc_str(yyscanner, _parse_state); } 356 {num_dec} { return value(_parse_state, yyscanner, 10); } 357 {num_hex} { return value(_parse_state, yyscanner, 16); } 358 {term_name} { return str(yyscanner, PE_NAME); } 359 @{drv_cfg_term} { return drv_str(yyscanner, PE_DRV_CFG_TERM); } 360 } 361 362 <mem>{ 363 {modifier_bp} { return str(yyscanner, PE_MODIFIER_BP); } 364 /* 365 * The colon before memory access modifiers can get mixed up with the 366 * colon before event modifiers. Fortunately none of the option letters 367 * are the same, so trailing context can be used disambiguate the two 368 * cases. 369 */ 370 ":"/{modifier_bp} { return PE_BP_COLON; } 371 /* 372 * The slash before memory length can get mixed up with the slash before 373 * config terms. Fortunately config terms do not start with a numeric 374 * digit, so trailing context can be used disambiguate the two cases. 375 */ 376 "/"/{digit} { return PE_BP_SLASH; } 377 "/"/{non_digit} { BEGIN(config); return '/'; } 378 {num_dec} { return value(_parse_state, yyscanner, 10); } 379 {num_hex} { return value(_parse_state, yyscanner, 16); } 380 /* 381 * We need to separate 'mem:' scanner part, in order to get specific 382 * modifier bits parsed out. Otherwise we would need to handle PE_NAME 383 * and we'd need to parse it manually. During the escape from <mem> 384 * state we need to put the escaping char back, so we dont miss it. 385 */ 386 . { unput(*yytext); BEGIN(INITIAL); } 387 /* 388 * We destroy the scanner after reaching EOF, 389 * but anyway just to be sure get back to INIT state. 390 */ 391 <<EOF>> { BEGIN(INITIAL); } 392 } 393 394 cpu-cycles|cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); } 395 stalled-cycles-frontend|idle-cycles-frontend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); } 396 stalled-cycles-backend|idle-cycles-backend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); } 397 instructions { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); } 398 cache-references { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); } 399 cache-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); } 400 branch-instructions|branches { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); } 401 branch-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); } 402 bus-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); } 403 ref-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); } 404 cpu-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); } 405 task-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); } 406 page-faults|faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); } 407 minor-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); } 408 major-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); } 409 context-switches|cs { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); } 410 cpu-migrations|migrations { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); } 411 alignment-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); } 412 emulation-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); } 413 dummy { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_DUMMY); } 414 bpf-output { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_BPF_OUTPUT); } 415 cgroup-switches { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CGROUP_SWITCHES); } 416 417 {lc_type} { return str(yyscanner, PE_LEGACY_CACHE); } 418 {lc_type}-{lc_op_result} { return str(yyscanner, PE_LEGACY_CACHE); } 419 {lc_type}-{lc_op_result}-{lc_op_result} { return str(yyscanner, PE_LEGACY_CACHE); } 420 mem: { BEGIN(mem); return PE_PREFIX_MEM; } 421 r{num_raw_hex} { return str(yyscanner, PE_RAW); } 422 {num_dec} { return value(_parse_state, yyscanner, 10); } 423 {num_hex} { return value(_parse_state, yyscanner, 16); } 424 425 {modifier_event} { return modifiers(_parse_state, yyscanner); } 426 {name} { return str(yyscanner, PE_NAME); } 427 {quoted_name} { return quoted_str(yyscanner, PE_NAME); } 428 "/" { BEGIN(config); return '/'; } 429 , { BEGIN(event); return ','; } 430 : { return ':'; } 431 "{" { BEGIN(event); return '{'; } 432 "}" { return '}'; } 433 = { return '='; } 434 \n { } 435 . { } 436 437 %% 438 439 int parse_events_wrap(void *scanner __maybe_unused) 440 { 441 return 1; 442 } 443