parse-events.l 12 KB

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