diff options
Diffstat (limited to 'tools/perf/util/parse-events.y')
| -rw-r--r-- | tools/perf/util/parse-events.y | 579 |
1 files changed, 401 insertions, 178 deletions
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y index afc44c18dfe1..c194de5ec1ec 100644 --- a/tools/perf/util/parse-events.y +++ b/tools/perf/util/parse-events.y @@ -1,84 +1,120 @@ -%pure-parser -%parse-param {void *_data} +%define api.pure full +%parse-param {void *_parse_state} %parse-param {void *scanner} %lex-param {void* scanner} +%locations %{ +#ifndef NDEBUG #define YYDEBUG 1 +#endif +#include <errno.h> #include <linux/compiler.h> -#include <linux/list.h> -#include "types.h" -#include "util.h" +#include <linux/types.h> +#include "pmu.h" +#include "pmus.h" +#include "evsel.h" #include "parse-events.h" #include "parse-events-bison.h" -extern int parse_events_lex (YYSTYPE* lvalp, void* scanner); +int parse_events_lex(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void *yyscanner); +void parse_events_error(YYLTYPE *loc, void *parse_state, void *scanner, char const *msg); -#define ABORT_ON(val) \ +#define PE_ABORT(val) \ do { \ - if (val) \ - YYABORT; \ + if (val == -ENOMEM) \ + YYNOMEM; \ + YYABORT; \ } while (0) -static inc_group_count(struct list_head *list, - struct parse_events_evlist *data) +static struct list_head* alloc_list(void) { - /* Count groups only have more than 1 members */ - if (!list_is_last(list->next, list)) - data->nr_groups++; + struct list_head *list; + + list = malloc(sizeof(*list)); + if (!list) + return NULL; + + INIT_LIST_HEAD(list); + return list; +} + +static void free_list_evsel(struct list_head* list_evsel) +{ + struct evsel *evsel, *tmp; + + list_for_each_entry_safe(evsel, tmp, list_evsel, core.node) { + list_del_init(&evsel->core.node); + evsel__delete(evsel); + } + free(list_evsel); } %} %token PE_START_EVENTS PE_START_TERMS -%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM +%token PE_VALUE PE_TERM %token PE_EVENT_NAME -%token PE_NAME -%token PE_MODIFIER_EVENT PE_MODIFIER_BP -%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT -%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP +%token PE_RAW PE_NAME +%token PE_MODIFIER_EVENT PE_MODIFIER_BP PE_BP_COLON PE_BP_SLASH +%token PE_PREFIX_MEM %token PE_ERROR +%token PE_DRV_CFG_TERM %type <num> PE_VALUE -%type <num> PE_VALUE_SYM_HW -%type <num> PE_VALUE_SYM_SW -%type <num> PE_RAW -%type <num> PE_TERM +%type <mod> PE_MODIFIER_EVENT +%type <term_type> PE_TERM +%type <str> PE_RAW %type <str> PE_NAME -%type <str> PE_NAME_CACHE_TYPE -%type <str> PE_NAME_CACHE_OP_RESULT -%type <str> PE_MODIFIER_EVENT %type <str> PE_MODIFIER_BP %type <str> PE_EVENT_NAME -%type <num> value_sym -%type <head> event_config +%type <str> PE_DRV_CFG_TERM +%type <str> name_or_raw +%destructor { free ($$); } <str> %type <term> event_term -%type <head> event_pmu -%type <head> event_legacy_symbol -%type <head> event_legacy_cache -%type <head> event_legacy_mem -%type <head> event_legacy_tracepoint -%type <head> event_legacy_numeric -%type <head> event_legacy_raw -%type <head> event_def -%type <head> event_mod -%type <head> event_name -%type <head> event -%type <head> events -%type <head> group_def -%type <head> group -%type <head> groups +%destructor { parse_events_term__delete ($$); } <term> +%type <list_terms> event_config +%type <list_terms> opt_event_config +%type <list_terms> opt_pmu_config +%destructor { parse_events_terms__delete ($$); } <list_terms> +%type <list_evsel> event_pmu +%type <list_evsel> event_legacy_mem +%type <list_evsel> event_legacy_tracepoint +%type <list_evsel> event_legacy_numeric +%type <list_evsel> event_legacy_raw +%type <list_evsel> event_def +%type <list_evsel> event_mod +%type <list_evsel> event_name +%type <list_evsel> event +%type <list_evsel> events +%type <list_evsel> group_def +%type <list_evsel> group +%type <list_evsel> groups +%destructor { free_list_evsel ($$); } <list_evsel> +%type <tracepoint_name> tracepoint_name +%destructor { free ($$.sys); free ($$.event); } <tracepoint_name> %union { char *str; u64 num; - struct list_head *head; + struct parse_events_modifier mod; + enum parse_events__term_type term_type; + struct list_head *list_evsel; + struct parse_events_terms *list_terms; struct parse_events_term *term; + struct tracepoint_name { + char *sys; + char *event; + } tracepoint_name; } %% + /* + * Entry points. We are either parsing events or terminals. Just terminal + * parsing is used for parsing events in sysfs. + */ start: PE_START_EVENTS start_events | @@ -86,28 +122,36 @@ PE_START_TERMS start_terms start_events: groups { - struct parse_events_evlist *data = _data; + /* Take the parsed events, groups.. and place into parse_state. */ + struct list_head *groups = $1; + struct parse_events_state *parse_state = _parse_state; - parse_events_update_lists($1, &data->list); + list_splice_tail(groups, &parse_state->list); + free(groups); } -groups: +groups: /* A list of groups or events. */ groups ',' group { - struct list_head *list = $1; - struct list_head *group = $3; + /* Merge group into the list of events/groups. */ + struct list_head *groups = $1; + struct list_head *group = $3; - parse_events_update_lists(group, list); - $$ = list; + list_splice_tail(group, groups); + free(group); + $$ = groups; } | groups ',' event { - struct list_head *list = $1; + /* Merge event into the list of events/groups. */ + struct list_head *groups = $1; struct list_head *event = $3; - parse_events_update_lists(event, list); - $$ = list; + + list_splice_tail(event, groups); + free(event); + $$ = groups; } | group @@ -117,9 +161,13 @@ event group: group_def ':' PE_MODIFIER_EVENT { + /* Apply the modifier to the events in the group_def. */ struct list_head *list = $1; + int err; - ABORT_ON(parse_events__modifier_group(list, $3)); + err = parse_events__modifier_group(_parse_state, &@3, list, $3); + if (err) + YYABORT; $$ = list; } | @@ -130,7 +178,10 @@ PE_NAME '{' events '}' { struct list_head *list = $3; - inc_group_count(list, _data); + /* + * Set the first entry of list to be the leader. Set the group name on + * the leader to $1 taking ownership. + */ parse_events__set_leader($1, list); $$ = list; } @@ -139,7 +190,7 @@ PE_NAME '{' events '}' { struct list_head *list = $2; - inc_group_count(list, _data); + /* Set the first entry of list to be the leader clearing the group name. */ parse_events__set_leader(NULL, list); $$ = list; } @@ -147,11 +198,12 @@ PE_NAME '{' events '}' events: events ',' event { + struct list_head *events = $1; struct list_head *event = $3; - struct list_head *list = $1; - parse_events_update_lists(event, list); - $$ = list; + list_splice_tail(event, events); + free(event); + $$ = events; } | event @@ -162,13 +214,16 @@ event_mod: event_name PE_MODIFIER_EVENT { struct list_head *list = $1; + int err; /* * Apply modifier on all events added by single event definition * (there could be more events added for multiple tracepoint * definitions via '*?'. */ - ABORT_ON(parse_events__modifier_event(list, $2, false)); + err = parse_events__modifier_event(_parse_state, &@2, list, $2); + if (err) + YYABORT; $$ = list; } | @@ -177,248 +232,416 @@ event_name event_name: PE_EVENT_NAME event_def { - ABORT_ON(parse_events_name($2, $1)); - free($1); + /* + * When an event is parsed the text is rewound and the entire text of + * the event is set to the str of PE_EVENT_NAME token matched here. If + * no name was on an event via a term, set the name to the entire text + * taking ownership of the allocation. + */ + int err = parse_events__set_default_name($2, $1); + + if (err) { + free_list_evsel($2); + YYNOMEM; + } $$ = $2; } | event_def event_def: event_pmu | - event_legacy_symbol | - event_legacy_cache sep_dc | - event_legacy_mem | + event_legacy_mem sep_dc | event_legacy_tracepoint sep_dc | event_legacy_numeric sep_dc | event_legacy_raw sep_dc event_pmu: -PE_NAME '/' event_config '/' +PE_NAME opt_pmu_config { - struct parse_events_evlist *data = _data; + /* List of created evsels. */ struct list_head *list = NULL; + int err = parse_events_multi_pmu_add_or_add_pmu(_parse_state, $1, $2, &list, &@1); - ABORT_ON(parse_events_add_pmu(&list, &data->idx, $1, $3)); - parse_events__free_terms($3); + parse_events_terms__delete($2); + free($1); + if (err) + PE_ABORT(err); $$ = list; } - -value_sym: -PE_VALUE_SYM_HW | -PE_VALUE_SYM_SW - -event_legacy_symbol: -value_sym '/' event_config '/' -{ - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; - int type = $1 >> 16; - int config = $1 & 255; - - ABORT_ON(parse_events_add_numeric(&list, &data->idx, - type, config, $3)); - parse_events__free_terms($3); +PE_NAME sep_dc +{ + struct list_head *list; + int err; + + err = parse_events_multi_pmu_add(_parse_state, $1, /*const_parsed_terms*/NULL, &list, &@1); + if (err < 0) { + struct parse_events_state *parse_state = _parse_state; + struct parse_events_error *error = parse_state->error; + char *help; + + if (asprintf(&help, "Unable to find event on a PMU of '%s'", $1) < 0) + help = NULL; + parse_events_error__handle(error, @1.first_column, strdup("Bad event name"), help); + free($1); + PE_ABORT(err); + } + free($1); $$ = list; } -| -value_sym sep_slash_dc -{ - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; - int type = $1 >> 16; - int config = $1 & 255; - ABORT_ON(parse_events_add_numeric(&list, &data->idx, - type, config, NULL)); +event_legacy_mem: +PE_PREFIX_MEM PE_VALUE PE_BP_SLASH PE_VALUE PE_BP_COLON PE_MODIFIER_BP opt_event_config +{ + struct list_head *list; + int err; + + list = alloc_list(); + if (!list) + YYNOMEM; + + err = parse_events_add_breakpoint(_parse_state, list, + $2, $6, $4, $7); + parse_events_terms__delete($7); + free($6); + if (err) { + free(list); + PE_ABORT(err); + } $$ = list; } - -event_legacy_cache: -PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT -{ - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; - - ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, $5)); +| +PE_PREFIX_MEM PE_VALUE PE_BP_SLASH PE_VALUE opt_event_config +{ + struct list_head *list; + int err; + + list = alloc_list(); + if (!list) + YYNOMEM; + + err = parse_events_add_breakpoint(_parse_state, list, + $2, NULL, $4, $5); + parse_events_terms__delete($5); + if (err) { + free(list); + PE_ABORT(err); + } $$ = list; } | -PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT -{ - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; - - ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, NULL)); +PE_PREFIX_MEM PE_VALUE PE_BP_COLON PE_MODIFIER_BP opt_event_config +{ + struct list_head *list; + int err; + + list = alloc_list(); + if (!list) + YYNOMEM; + + err = parse_events_add_breakpoint(_parse_state, list, + $2, $4, 0, $5); + parse_events_terms__delete($5); + free($4); + if (err) { + free(list); + PE_ABORT(err); + } $$ = list; } | -PE_NAME_CACHE_TYPE -{ - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; +PE_PREFIX_MEM PE_VALUE opt_event_config +{ + struct list_head *list; + int err; + + list = alloc_list(); + if (!list) + YYNOMEM; + err = parse_events_add_breakpoint(_parse_state, list, + $2, NULL, 0, $3); + parse_events_terms__delete($3); + if (err) { + free(list); + PE_ABORT(err); + } + $$ = list; +} - ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, NULL, NULL)); +event_legacy_tracepoint: +tracepoint_name opt_event_config +{ + struct parse_events_state *parse_state = _parse_state; + struct parse_events_error *error = parse_state->error; + struct list_head *list; + int err; + + list = alloc_list(); + if (!list) + YYNOMEM; + + err = parse_events_add_tracepoint(parse_state, list, $1.sys, $1.event, + error, $2, &@1); + + parse_events_terms__delete($2); + free($1.sys); + free($1.event); + if (err) { + free(list); + PE_ABORT(err); + } $$ = list; } -event_legacy_mem: -PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc +tracepoint_name: +PE_NAME ':' PE_NAME { - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; + struct tracepoint_name tracepoint = {$1, $3}; - ABORT_ON(parse_events_add_breakpoint(&list, &data->idx, - (void *) $2, $4)); - $$ = list; + $$ = tracepoint; } -| -PE_PREFIX_MEM PE_VALUE sep_dc -{ - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; - ABORT_ON(parse_events_add_breakpoint(&list, &data->idx, - (void *) $2, NULL)); +event_legacy_numeric: +PE_VALUE ':' PE_VALUE opt_event_config +{ + struct list_head *list; + int err; + + list = alloc_list(); + if (!list) + YYNOMEM; + err = parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4, + /*wildcard=*/false); + parse_events_terms__delete($4); + if (err) { + free(list); + PE_ABORT(err); + } $$ = list; } -event_legacy_tracepoint: -PE_NAME ':' PE_NAME +event_legacy_raw: +PE_RAW opt_event_config { - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; + struct list_head *list; + int err; + u64 num; - ABORT_ON(parse_events_add_tracepoint(&list, &data->idx, $1, $3)); + list = alloc_list(); + if (!list) + YYNOMEM; + errno = 0; + num = strtoull($1 + 1, NULL, 16); + /* Given the lexer will only give [a-fA-F0-9]+ a failure here should be impossible. */ + if (errno) + YYABORT; + free($1); + err = parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, num, $2, + /*wildcard=*/false); + parse_events_terms__delete($2); + if (err) { + free(list); + PE_ABORT(err); + } $$ = list; } -event_legacy_numeric: -PE_VALUE ':' PE_VALUE +opt_event_config: +'/' event_config '/' { - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; - - ABORT_ON(parse_events_add_numeric(&list, &data->idx, (u32)$1, $3, NULL)); - $$ = list; + $$ = $2; } - -event_legacy_raw: -PE_RAW +| +'/' '/' { - struct parse_events_evlist *data = _data; - struct list_head *list = NULL; + $$ = NULL; +} +| +{ + $$ = NULL; +} - ABORT_ON(parse_events_add_numeric(&list, &data->idx, - PERF_TYPE_RAW, $1, NULL)); - $$ = list; +opt_pmu_config: +'/' event_config '/' +{ + $$ = $2; +} +| +'/' '/' +{ + $$ = NULL; } start_terms: event_config { - struct parse_events_terms *data = _data; - data->terms = $1; + struct parse_events_state *parse_state = _parse_state; + if (parse_state->terms) { + parse_events_terms__delete ($1); + YYABORT; + } + parse_state->terms = $1; } event_config: event_config ',' event_term { - struct list_head *head = $1; + struct parse_events_terms *head = $1; struct parse_events_term *term = $3; - ABORT_ON(!head); - list_add_tail(&term->list, head); + if (!head) { + parse_events_term__delete(term); + YYABORT; + } + list_add_tail(&term->list, &head->terms); $$ = $1; } | event_term { - struct list_head *head = malloc(sizeof(*head)); + struct parse_events_terms *head = malloc(sizeof(*head)); struct parse_events_term *term = $1; - ABORT_ON(!head); - INIT_LIST_HEAD(head); - list_add_tail(&term->list, head); + if (!head) + YYNOMEM; + parse_events_terms__init(head); + list_add_tail(&term->list, &head->terms); $$ = head; } +name_or_raw: PE_RAW | PE_NAME + event_term: -PE_NAME '=' PE_NAME +PE_RAW { struct parse_events_term *term; + int err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_RAW, + strdup("raw"), $1, &@1, &@1); - ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER, - $1, $3)); + if (err) { + free($1); + PE_ABORT(err); + } $$ = term; } | -PE_NAME '=' PE_VALUE +name_or_raw '=' name_or_raw { struct parse_events_term *term; + int err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER, $1, $3, &@1, &@3); - ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, - $1, $3)); + if (err) { + free($1); + free($3); + PE_ABORT(err); + } $$ = term; } | -PE_NAME '=' PE_VALUE_SYM_HW +name_or_raw '=' PE_VALUE { struct parse_events_term *term; - int config = $3 & 255; + int err = parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, + $1, $3, /*novalue=*/false, &@1, &@3); - ABORT_ON(parse_events_term__sym_hw(&term, $1, config)); + if (err) { + free($1); + PE_ABORT(err); + } $$ = term; } | PE_NAME { struct parse_events_term *term; + int err = parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, + $1, /*num=*/1, /*novalue=*/true, &@1, /*loc_val=*/NULL); - ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, - $1, 1)); + if (err) { + free($1); + PE_ABORT(err); + } $$ = term; } | -PE_VALUE_SYM_HW +PE_TERM '=' name_or_raw { struct parse_events_term *term; - int config = $1 & 255; + int err = parse_events_term__str(&term, $1, /*config=*/NULL, $3, &@1, &@3); - ABORT_ON(parse_events_term__sym_hw(&term, NULL, config)); + if (err) { + free($3); + PE_ABORT(err); + } $$ = term; } | -PE_TERM '=' PE_NAME +PE_TERM '=' PE_TERM { struct parse_events_term *term; + int err = parse_events_term__term(&term, $1, $3, &@1, &@3); + + if (err) + PE_ABORT(err); - ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3)); $$ = term; } | PE_TERM '=' PE_VALUE { struct parse_events_term *term; + int err = parse_events_term__num(&term, $1, + /*config=*/NULL, $3, /*novalue=*/false, + &@1, &@3); + + if (err) + PE_ABORT(err); - ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3)); $$ = term; } | PE_TERM { struct parse_events_term *term; + int err = parse_events_term__num(&term, $1, + /*config=*/NULL, /*num=*/1, /*novalue=*/true, + &@1, /*loc_val=*/NULL); + + if (err) + PE_ABORT(err); - ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1)); + $$ = term; +} +| +PE_DRV_CFG_TERM +{ + struct parse_events_term *term; + char *config = strdup($1); + int err; + + if (!config) + YYNOMEM; + err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG, config, $1, &@1, NULL); + if (err) { + free($1); + free(config); + PE_ABORT(err); + } $$ = term; } sep_dc: ':' | -sep_slash_dc: '/' | ':' | - %% -void parse_events_error(void *data __maybe_unused, void *scanner __maybe_unused, +void parse_events_error(YYLTYPE *loc, void *_parse_state, + void *scanner __maybe_unused, char const *msg __maybe_unused) { + struct parse_events_state *parse_state = _parse_state; + + if (!parse_state->error || !list_empty(&parse_state->error->list)) + return; + + parse_events_error__handle(parse_state->error, loc->last_column, + strdup("Unrecognized input"), NULL); } |