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