1 files changed, 274 insertions, 43 deletions

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 4f7b0efdde2f..4c19d5e79d8c 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -279,7 +279,24 @@ const char *event_type(int type)
         return "unknown";
 }
 
+static int parse_events__is_name_term(struct parse_events_term *term)
+{
+        return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
+}
+
+static char *get_config_name(struct list_head *head_terms)
+{
+        struct parse_events_term *term;
+
+        if (!head_terms)
+                return NULL;
 
+        list_for_each_entry(term, head_terms, list)
+                if (parse_events__is_name_term(term))
+                        return term->val.str;
+
+        return NULL;
+}
 
 static struct perf_evsel *
 __add_event(struct list_head *list, int *idx,
@@ -333,11 +350,25 @@ static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES]
         return -1;
 }
 
+typedef int config_term_func_t(struct perf_event_attr *attr,
+                               struct parse_events_term *term,
+                               struct parse_events_error *err);
+static int config_term_common(struct perf_event_attr *attr,
+                              struct parse_events_term *term,
+                              struct parse_events_error *err);
+static int config_attr(struct perf_event_attr *attr,
+                       struct list_head *head,
+                       struct parse_events_error *err,
+                       config_term_func_t config_term);
+
 int parse_events_add_cache(struct list_head *list, int *idx,
-                           char *type, char *op_result1, char *op_result2)
+                           char *type, char *op_result1, char *op_result2,
+                           struct parse_events_error *err,
+                           struct list_head *head_config)
 {
         struct perf_event_attr attr;
-        char name[MAX_NAME_LEN];
+        LIST_HEAD(config_terms);
+        char name[MAX_NAME_LEN], *config_name;
         int cache_type = -1, cache_op = -1, cache_result = -1;
         char *op_result[2] = { op_result1, op_result2 };
         int i, n;
@@ -351,6 +382,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
         if (cache_type == -1)
                 return -EINVAL;
 
+        config_name = get_config_name(head_config);
         n = snprintf(name, MAX_NAME_LEN, "%s", type);
 
         for (i = 0; (i < 2) && (op_result[i]); i++) {
@@ -391,7 +423,16 @@ int parse_events_add_cache(struct list_head *list, int *idx,
         memset(&attr, 0, sizeof(attr));
         attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
         attr.type = PERF_TYPE_HW_CACHE;
-        return add_event(list, idx, &attr, name, NULL);
+
+        if (head_config) {
+                if (config_attr(&attr, head_config, err,
+                                config_term_common))
+                        return -EINVAL;
+
+                if (get_config_terms(head_config, &config_terms))
+                        return -ENOMEM;
+        }
+        return add_event(list, idx, &attr, config_name ? : name, &config_terms);
 }
 
 static void tracepoint_error(struct parse_events_error *e, int err,
@@ -399,6 +440,9 @@ static void tracepoint_error(struct parse_events_error *e, int err,
 {
         char help[BUFSIZ];
 
+        if (!e)
+                return;
+
         /*
          * We get error directly from syscall errno ( > 0),
          * or from encoded pointer's error ( < 0).
@@ -537,6 +581,7 @@ static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 struct __add_bpf_event_param {
         struct parse_events_evlist *data;
         struct list_head *list;
+        struct list_head *head_config;
 };
 
 static int add_bpf_event(struct probe_trace_event *tev, int fd,
@@ -553,7 +598,8 @@ static int add_bpf_event(struct probe_trace_event *tev, int fd,
                  tev->group, tev->event, fd);
 
         err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, tev->group,
-                                          tev->event, evlist->error, NULL);
+                                          tev->event, evlist->error,
+                                          param->head_config);
         if (err) {
                 struct perf_evsel *evsel, *tmp;
 
@@ -578,11 +624,12 @@ static int add_bpf_event(struct probe_trace_event *tev, int fd,
 
 int parse_events_load_bpf_obj(struct parse_events_evlist *data,
                               struct list_head *list,
-                              struct bpf_object *obj)
+                              struct bpf_object *obj,
+                              struct list_head *head_config)
 {
         int err;
         char errbuf[BUFSIZ];
-        struct __add_bpf_event_param param = {data, list};
+        struct __add_bpf_event_param param = {data, list, head_config};
         static bool registered_unprobe_atexit = false;
 
         if (IS_ERR(obj) || !obj) {
@@ -628,17 +675,99 @@ errout:
         return err;
 }
 
+static int
+parse_events_config_bpf(struct parse_events_evlist *data,
+                        struct bpf_object *obj,
+                        struct list_head *head_config)
+{
+        struct parse_events_term *term;
+        int error_pos;
+
+        if (!head_config || list_empty(head_config))
+                return 0;
+
+        list_for_each_entry(term, head_config, list) {
+                char errbuf[BUFSIZ];
+                int err;
+
+                if (term->type_term != PARSE_EVENTS__TERM_TYPE_USER) {
+                        snprintf(errbuf, sizeof(errbuf),
+                                 "Invalid config term for BPF object");
+                        errbuf[BUFSIZ - 1] = '\0';
+
+                        data->error->idx = term->err_term;
+                        data->error->str = strdup(errbuf);
+                        return -EINVAL;
+                }
+
+                err = bpf__config_obj(obj, term, data->evlist, &error_pos);
+                if (err) {
+                        bpf__strerror_config_obj(obj, term, data->evlist,
+                                                 &error_pos, err, errbuf,
+                                                 sizeof(errbuf));
+                        data->error->help = strdup(
+"Hint:\tValid config terms:\n"
+"     \tmap:[<arraymap>].value<indices>=[value]\n"
+"     \tmap:[<eventmap>].event<indices>=[event]\n"
+"\n"
+"     \twhere <indices> is something like [0,3...5] or [all]\n"
+"     \t(add -v to see detail)");
+                        data->error->str = strdup(errbuf);
+                        if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE)
+                                data->error->idx = term->err_val;
+                        else
+                                data->error->idx = term->err_term + error_pos;
+                        return err;
+                }
+        }
+        return 0;
+}
+
+/*
+ * Split config terms:
+ * perf record -e bpf.c/call-graph=fp,map:array.value[0]=1/ ...
+ *  'call-graph=fp' is 'evt config', should be applied to each
+ *  events in bpf.c.
+ * 'map:array.value[0]=1' is 'obj config', should be processed
+ * with parse_events_config_bpf.
+ *
+ * Move object config terms from the first list to obj_head_config.
+ */
+static void
+split_bpf_config_terms(struct list_head *evt_head_config,
+                       struct list_head *obj_head_config)
+{
+        struct parse_events_term *term, *temp;
+
+        /*
+         * Currectly, all possible user config term
+         * belong to bpf object. parse_events__is_hardcoded_term()
+         * happends to be a good flag.
+         *
+         * See parse_events_config_bpf() and
+         * config_term_tracepoint().
+         */
+        list_for_each_entry_safe(term, temp, evt_head_config, list)
+                if (!parse_events__is_hardcoded_term(term))
+                        list_move_tail(&term->list, obj_head_config);
+}
+
 int parse_events_load_bpf(struct parse_events_evlist *data,
                           struct list_head *list,
                           char *bpf_file_name,
-                          bool source)
+                          bool source,
+                          struct list_head *head_config)
 {
+        int err;
         struct bpf_object *obj;
+        LIST_HEAD(obj_head_config);
+
+        if (head_config)
+                split_bpf_config_terms(head_config, &obj_head_config);
 
         obj = bpf__prepare_load(bpf_file_name, source);
         if (IS_ERR(obj)) {
                 char errbuf[BUFSIZ];
-                int err;
 
                 err = PTR_ERR(obj);
 
@@ -656,7 +785,18 @@ int parse_events_load_bpf(struct parse_events_evlist *data,
                 return err;
         }
 
-        return parse_events_load_bpf_obj(data, list, obj);
+        err = parse_events_load_bpf_obj(data, list, obj, head_config);
+        if (err)
+                return err;
+        err = parse_events_config_bpf(data, obj, &obj_head_config);
+
+        /*
+         * Caller doesn't know anything about obj_head_config,
+         * so combine them together again before returnning.
+         */
+        if (head_config)
+                list_splice_tail(&obj_head_config, head_config);
+        return err;
 }
 
 static int
@@ -743,9 +883,59 @@ static int check_type_val(struct parse_events_term *term,
         return -EINVAL;
 }
 
-typedef int config_term_func_t(struct perf_event_attr *attr,
-                               struct parse_events_term *term,
-                               struct parse_events_error *err);
+/*
+ * Update according to parse-events.l
+ */
+static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
+        [PARSE_EVENTS__TERM_TYPE_USER]                  = "<sysfs term>",
+        [PARSE_EVENTS__TERM_TYPE_CONFIG]                = "config",
+        [PARSE_EVENTS__TERM_TYPE_CONFIG1]               = "config1",
+        [PARSE_EVENTS__TERM_TYPE_CONFIG2]               = "config2",
+        [PARSE_EVENTS__TERM_TYPE_NAME]                  = "name",
+        [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD]         = "period",
+        [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ]           = "freq",
+        [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE]    = "branch_type",
+        [PARSE_EVENTS__TERM_TYPE_TIME]                  = "time",
+        [PARSE_EVENTS__TERM_TYPE_CALLGRAPH]             = "call-graph",
+        [PARSE_EVENTS__TERM_TYPE_STACKSIZE]             = "stack-size",
+        [PARSE_EVENTS__TERM_TYPE_NOINHERIT]             = "no-inherit",
+        [PARSE_EVENTS__TERM_TYPE_INHERIT]               = "inherit",
+};
+
+static bool config_term_shrinked;
+
+static bool
+config_term_avail(int term_type, struct parse_events_error *err)
+{
+        if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
+                err->str = strdup("Invalid term_type");
+                return false;
+        }
+        if (!config_term_shrinked)
+                return true;
+
+        switch (term_type) {
+        case PARSE_EVENTS__TERM_TYPE_CONFIG:
+        case PARSE_EVENTS__TERM_TYPE_CONFIG1:
+        case PARSE_EVENTS__TERM_TYPE_CONFIG2:
+        case PARSE_EVENTS__TERM_TYPE_NAME:
+                return true;
+        default:
+                if (!err)
+                        return false;
+
+                /* term_type is validated so indexing is safe */
+                if (asprintf(&err->str, "'%s' is not usable in 'perf stat'",
+                             config_term_names[term_type]) < 0)
+                        err->str = NULL;
+                return false;
+        }
+}
+
+void parse_events__shrink_config_terms(void)
+{
+        config_term_shrinked = true;
+}
 
 static int config_term_common(struct perf_event_attr *attr,
                               struct parse_events_term *term,
@@ -812,6 +1002,17 @@ do {									   \
                 return -EINVAL;
         }
 
+        /*
+         * Check term availbility after basic checking so
+         * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered.
+         *
+         * If check availbility at the entry of this function,
+         * user will see "'<sysfs term>' is not usable in 'perf stat'"
+         * if an invalid config term is provided for legacy events
+         * (for example, instructions/badterm/...), which is confusing.
+         */
+        if (!config_term_avail(term->type_term, err))
+                return -EINVAL;
         return 0;
 #undef CHECK_TYPE_VAL
 }
@@ -958,23 +1159,8 @@ int parse_events_add_numeric(struct parse_events_evlist *data,
                         return -ENOMEM;
         }
 
-        return add_event(list, &data->idx, &attr, NULL, &config_terms);
-}
-
-static int parse_events__is_name_term(struct parse_events_term *term)
-{
-        return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
-}
-
-static char *pmu_event_name(struct list_head *head_terms)
-{
-        struct parse_events_term *term;
-
-        list_for_each_entry(term, head_terms, list)
-                if (parse_events__is_name_term(term))
-                        return term->val.str;
-
-        return NULL;
+        return add_event(list, &data->idx, &attr,
+                         get_config_name(head_config), &config_terms);
 }
 
 int parse_events_add_pmu(struct parse_events_evlist *data,
@@ -1021,7 +1207,7 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
                 return -EINVAL;
 
         evsel = __add_event(list, &data->idx, &attr,
-                            pmu_event_name(head_config), pmu->cpus,
+                            get_config_name(head_config), pmu->cpus,
                             &config_terms);
         if (evsel) {
                 evsel->unit = info.unit;
@@ -1383,8 +1569,7 @@ int parse_events_terms(struct list_head *terms, const char *str)
                 return 0;
         }
 
-        if (data.terms)
-                parse_events__free_terms(data.terms);
+        parse_events_terms__delete(data.terms);
         return ret;
 }
 
@@ -1392,9 +1577,10 @@ int parse_events(struct perf_evlist *evlist, const char *str,
                  struct parse_events_error *err)
 {
         struct parse_events_evlist data = {
-                .list  = LIST_HEAD_INIT(data.list),
-                .idx   = evlist->nr_entries,
-                .error = err,
+                .list   = LIST_HEAD_INIT(data.list),
+                .idx    = evlist->nr_entries,
+                .error  = err,
+                .evlist = evlist,
         };
         int ret;
 
@@ -2065,12 +2251,29 @@ int parse_events_term__clone(struct parse_events_term **new,
                         term->err_term, term->err_val);
 }
 
-void parse_events__free_terms(struct list_head *terms)
+void parse_events_terms__purge(struct list_head *terms)
 {
         struct parse_events_term *term, *h;
 
-        list_for_each_entry_safe(term, h, terms, list)
+        list_for_each_entry_safe(term, h, terms, list) {
+                if (term->array.nr_ranges)
+                        free(term->array.ranges);
+                list_del_init(&term->list);
                 free(term);
+        }
+}
+
+void parse_events_terms__delete(struct list_head *terms)
+{
+        if (!terms)
+                return;
+        parse_events_terms__purge(terms);
+        free(terms);
+}
+
+void parse_events__clear_array(struct parse_events_array *a)
+{
+        free(a->ranges);
 }
 
 void parse_events_evlist_error(struct parse_events_evlist *data,
@@ -2085,6 +2288,33 @@ void parse_events_evlist_error(struct parse_events_evlist *data,
         WARN_ONCE(!err->str, "WARNING: failed to allocate error string");
 }
 
+static void config_terms_list(char *buf, size_t buf_sz)
+{
+        int i;
+        bool first = true;
+
+        buf[0] = '\0';
+        for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
+                const char *name = config_term_names[i];
+
+                if (!config_term_avail(i, NULL))
+                        continue;
+                if (!name)
+                        continue;
+                if (name[0] == '<')
+                        continue;
+
+                if (strlen(buf) + strlen(name) + 2 >= buf_sz)
+                        return;
+
+                if (!first)
+                        strcat(buf, ",");
+                else
+                        first = false;
+                strcat(buf, name);
+        }
+}
+
 /*
  * Return string contains valid config terms of an event.
  * @additional_terms: For terms such as PMU sysfs terms.
@@ -2092,17 +2322,18 @@ void parse_events_evlist_error(struct parse_events_evlist *data,
 char *parse_events_formats_error_string(char *additional_terms)
 {
         char *str;
-        static const char *static_terms = "config,config1,config2,name,"
-                                          "period,freq,branch_type,time,"
-                                          "call-graph,stack-size\n";
+        /* "branch_type" is the longest name */
+        char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
+                          (sizeof("branch_type") - 1)];
 
+        config_terms_list(static_terms, sizeof(static_terms));
         /* valid terms */
         if (additional_terms) {
-                if (!asprintf(&str, "valid terms: %s,%s",
-                              additional_terms, static_terms))
+                if (asprintf(&str, "valid terms: %s,%s",
+                             additional_terms, static_terms) < 0)
                         goto fail;
         } else {
-                if (!asprintf(&str, "valid terms: %s", static_terms))
+                if (asprintf(&str, "valid terms: %s", static_terms) < 0)
                         goto fail;
         }
         return str;