tools/perf/util/parse-events.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __PERF_PARSE_EVENTS_H
   3 #define __PERF_PARSE_EVENTS_H
   4 /*
   5  * Parse symbolic events/counts passed in as options:
   6  */
   7
   8 #include <linux/list.h>
   9 #include <stdbool.h>
  10 #include <linux/types.h>
  11 #include <linux/perf_event.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14
  15 struct evsel;
  16 struct evlist;
  17 struct parse_events_error;
  18
  19 struct option;
  20 struct perf_pmu;
  21 struct strbuf;
  22
  23 const char *event_type(int type);
  24
  25 /* Arguments encoded in opt->value. */
  26 struct parse_events_option_args {
  27         struct evlist **evlistp;
  28         const char *pmu_filter;
  29 };
  30 int parse_events_option(const struct option *opt, const char *str, int unset);
  31 int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset);
  32 __attribute__((nonnull(1, 2, 4)))
  33 int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter,
  34                    struct parse_events_error *error, bool fake_pmu,
  35                    bool warn_if_reordered, bool fake_tp);
  36
  37 __attribute__((nonnull(1, 2, 3)))
  38 static inline int parse_events(struct evlist *evlist, const char *str,
  39                                struct parse_events_error *err)
  40 {
  41         return __parse_events(evlist, str, /*pmu_filter=*/NULL, err, /*fake_pmu=*/false,
  42                               /*warn_if_reordered=*/true, /*fake_tp=*/false);
  43 }
  44
  45 int parse_event(struct evlist *evlist, const char *str);
  46
  47 int parse_filter(const struct option *opt, const char *str, int unset);
  48 int exclude_perf(const struct option *opt, const char *arg, int unset);
  49
  50 enum parse_events__term_val_type {
  51         PARSE_EVENTS__TERM_TYPE_NUM,
  52         PARSE_EVENTS__TERM_TYPE_STR,
  53 };
  54
  55 enum parse_events__term_type {
  56         PARSE_EVENTS__TERM_TYPE_USER,
  57         PARSE_EVENTS__TERM_TYPE_CONFIG,
  58         PARSE_EVENTS__TERM_TYPE_CONFIG1,
  59         PARSE_EVENTS__TERM_TYPE_CONFIG2,
  60         PARSE_EVENTS__TERM_TYPE_CONFIG3,
  61         PARSE_EVENTS__TERM_TYPE_NAME,
  62         PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
  63         PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ,
  64         PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
  65         PARSE_EVENTS__TERM_TYPE_TIME,
  66         PARSE_EVENTS__TERM_TYPE_CALLGRAPH,
  67         PARSE_EVENTS__TERM_TYPE_STACKSIZE,
  68         PARSE_EVENTS__TERM_TYPE_NOINHERIT,
  69         PARSE_EVENTS__TERM_TYPE_INHERIT,
  70         PARSE_EVENTS__TERM_TYPE_MAX_STACK,
  71         PARSE_EVENTS__TERM_TYPE_MAX_EVENTS,
  72         PARSE_EVENTS__TERM_TYPE_NOOVERWRITE,
  73         PARSE_EVENTS__TERM_TYPE_OVERWRITE,
  74         PARSE_EVENTS__TERM_TYPE_DRV_CFG,
  75         PARSE_EVENTS__TERM_TYPE_PERCORE,
  76         PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT,
  77         PARSE_EVENTS__TERM_TYPE_AUX_ACTION,
  78         PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE,
  79         PARSE_EVENTS__TERM_TYPE_METRIC_ID,
  80         PARSE_EVENTS__TERM_TYPE_RAW,
  81         PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE,
  82         PARSE_EVENTS__TERM_TYPE_HARDWARE,
  83         PARSE_EVENTS__TERM_TYPE_CPU,
  84 #define __PARSE_EVENTS__TERM_TYPE_NR (PARSE_EVENTS__TERM_TYPE_CPU + 1)
  85 };
  86
  87 struct parse_events_term {
  88         /** @list: The term list the term is a part of. */
  89         struct list_head list;
  90         /**
  91          * @config: The left-hand side of a term assignment, so the term
  92          * "event=8" would have the config be "event"
  93          */
  94         const char *config;
  95         /**
  96          * @val: The right-hand side of a term assignment that can either be a
  97          * string or a number depending on type_val.
  98          */
  99         union {
 100                 char *str;
 101                 u64  num;
 102         } val;
 103         /** @type_val: The union variable in val to be used for the term. */
 104         enum parse_events__term_val_type type_val;
 105         /**
 106          * @type_term: A predefined term type or PARSE_EVENTS__TERM_TYPE_USER
 107          * when not inbuilt.
 108          */
 109         enum parse_events__term_type type_term;
 110         /**
 111          * @err_term: The column index of the term from parsing, used during
 112          * error output.
 113          */
 114         int err_term;
 115         /**
 116          * @err_val: The column index of the val from parsing, used during error
 117          * output.
 118          */
 119         int err_val;
 120         /** @used: Was the term used during parameterized-eval. */
 121         bool used;
 122         /**
 123          * @weak: A term from the sysfs or json encoding of an event that
 124          * shouldn't override terms coming from the command line.
 125          */
 126         bool weak;
 127         /**
 128          * @no_value: Is there no value. If a numeric term has no value then the
 129          * value is assumed to be 1. An event name also has no value.
 130          */
 131         bool no_value;
 132         /**
 133          * @alternate_hw_config: config is the event name but num is an
 134          * alternate PERF_TYPE_HARDWARE config value which is often nice for the
 135          * sake of quick matching.
 136          */
 137         bool alternate_hw_config;
 138 };
 139
 140 struct parse_events_error {
 141         /** @list: The head of a list of errors. */
 142         struct list_head list;
 143 };
 144
 145 /* A wrapper around a list of terms for the sake of better type safety. */
 146 struct parse_events_terms {
 147         struct list_head terms;
 148 };
 149
 150 struct parse_events_state {
 151         /* The list parsed events are placed on. */
 152         struct list_head           list;
 153         /* The updated index used by entries as they are added. */
 154         int                        idx;
 155         /* Error information. */
 156         struct parse_events_error *error;
 157         /* Holds returned terms for term parsing. */
 158         struct parse_events_terms *terms;
 159         /* Start token. */
 160         int                        stoken;
 161         /* Use the fake PMU marker for testing. */
 162         bool                       fake_pmu;
 163         /* Skip actual tracepoint processing for testing. */
 164         bool                       fake_tp;
 165         /* If non-null, when wildcard matching only match the given PMU. */
 166         const char                *pmu_filter;
 167         /* Should PE_LEGACY_NAME tokens be generated for config terms? */
 168         bool                       match_legacy_cache_terms;
 169         /* Were multiple PMUs scanned to find events? */
 170         bool                       wild_card_pmus;
 171 };
 172
 173 const char *parse_events__term_type_str(enum parse_events__term_type term_type);
 174
 175 bool parse_events__filter_pmu(const struct parse_events_state *parse_state,
 176                               const struct perf_pmu *pmu);
 177 void parse_events__shrink_config_terms(void);
 178 int parse_events__is_hardcoded_term(struct parse_events_term *term);
 179 int parse_events_term__num(struct parse_events_term **term,
 180                            enum parse_events__term_type type_term,
 181                            const char *config, u64 num,
 182                            bool novalue,
 183                            void *loc_term, void *loc_val);
 184 int parse_events_term__str(struct parse_events_term **term,
 185                            enum parse_events__term_type type_term,
 186                            char *config, char *str,
 187                            void *loc_term, void *loc_val);
 188 int parse_events_term__term(struct parse_events_term **term,
 189                             enum parse_events__term_type term_lhs,
 190                             enum parse_events__term_type term_rhs,
 191                             void *loc_term, void *loc_val);
 192 int parse_events_term__clone(struct parse_events_term **new,
 193                              const struct parse_events_term *term);
 194 void parse_events_term__delete(struct parse_events_term *term);
 195
 196 void parse_events_terms__delete(struct parse_events_terms *terms);
 197 void parse_events_terms__init(struct parse_events_terms *terms);
 198 void parse_events_terms__exit(struct parse_events_terms *terms);
 199 int parse_events_terms(struct parse_events_terms *terms, const char *str, FILE *input);
 200 int parse_events_terms__to_strbuf(const struct parse_events_terms *terms, struct strbuf *sb);
 201
 202 struct parse_events_modifier {
 203         u8 precise;     /* Number of repeated 'p' for precision. */
 204         bool precise_max : 1;   /* 'P' */
 205         bool non_idle : 1;      /* 'I' */
 206         bool sample_read : 1;   /* 'S' */
 207         bool pinned : 1;        /* 'D' */
 208         bool exclusive : 1;     /* 'e' */
 209         bool weak : 1;          /* 'W' */
 210         bool bpf : 1;           /* 'b' */
 211         bool user : 1;          /* 'u' */
 212         bool kernel : 1;        /* 'k' */
 213         bool hypervisor : 1;    /* 'h' */
 214         bool guest : 1;         /* 'G' */
 215         bool host : 1;          /* 'H' */
 216         bool retire_lat : 1;    /* 'R' */
 217 };
 218
 219 int parse_events__modifier_event(struct parse_events_state *parse_state, void *loc,
 220                                  struct list_head *list, struct parse_events_modifier mod);
 221 int parse_events__modifier_group(struct parse_events_state *parse_state, void *loc,
 222                                  struct list_head *list, struct parse_events_modifier mod);
 223 int parse_events__set_default_name(struct list_head *list, char *name);
 224 int parse_events_add_tracepoint(struct parse_events_state *parse_state,
 225                                 struct list_head *list,
 226                                 const char *sys, const char *event,
 227                                 struct parse_events_error *error,
 228                                 struct parse_events_terms *head_config, void *loc);
 229 int parse_events_add_numeric(struct parse_events_state *parse_state,
 230                              struct list_head *list,
 231                              u32 type, u64 config,
 232                              const struct parse_events_terms *head_config,
 233                              bool wildcard);
 234 int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
 235                            struct parse_events_state *parse_state,
 236                            struct parse_events_terms *parsed_terms);
 237 int parse_events__decode_legacy_cache(const char *name, int pmu_type, __u64 *config);
 238 int parse_events_add_breakpoint(struct parse_events_state *parse_state,
 239                                 struct list_head *list,
 240                                 u64 addr, char *type, u64 len,
 241                                 struct parse_events_terms *head_config);
 242
 243 struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
 244                                       const char *name, const char *metric_id,
 245                                       struct perf_pmu *pmu);
 246
 247 int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
 248                                const char *event_name, u64 hw_config,
 249                                const struct parse_events_terms *const_parsed_terms,
 250                                struct list_head **listp, void *loc);
 251
 252 int parse_events_multi_pmu_add_or_add_pmu(struct parse_events_state *parse_state,
 253                                         const char *event_or_pmu,
 254                                         const struct parse_events_terms *const_parsed_terms,
 255                                         struct list_head **listp,
 256                                         void *loc_);
 257
 258 void parse_events__set_leader(char *name, struct list_head *list);
 259
 260 struct event_symbol {
 261         const char      *symbol;
 262         const char      *alias;
 263 };
 264 extern const struct event_symbol event_symbols_hw[];
 265 extern const struct event_symbol event_symbols_sw[];
 266
 267 char *parse_events_formats_error_string(char *additional_terms);
 268
 269 void parse_events_error__init(struct parse_events_error *err);
 270 void parse_events_error__exit(struct parse_events_error *err);
 271 void parse_events_error__handle(struct parse_events_error *err, int idx,
 272                                 char *str, char *help);
 273 void parse_events_error__print(const struct parse_events_error *err,
 274                                const char *event);
 275 bool parse_events_error__contains(const struct parse_events_error *err,
 276                                   const char *needle);
 277 #ifdef HAVE_LIBELF_SUPPORT
 278 /*
 279  * If the probe point starts with '%',
 280  * or starts with "sdt_" and has a ':' but no '=',
 281  * then it should be a SDT/cached probe point.
 282  */
 283 static inline bool is_sdt_event(char *str)
 284 {
 285         return (str[0] == '%' ||
 286                 (!strncmp(str, "sdt_", 4) &&
 287                  !!strchr(str, ':') && !strchr(str, '=')));
 288 }
 289 #else
 290 static inline bool is_sdt_event(char *str __maybe_unused)
 291 {
 292         return false;
 293 }
 294 #endif /* HAVE_LIBELF_SUPPORT */
 295
 296 size_t default_breakpoint_len(void);
 297
 298 #endif /* __PERF_PARSE_EVENTS_H */