parse-events.h 7.87 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
2 3
#ifndef __PERF_PARSE_EVENTS_H
#define __PERF_PARSE_EVENTS_H
4 5 6 7
/*
 * Parse symbolic events/counts passed in as options:
 */

8
#include <linux/list.h>
9
#include <stdbool.h>
Borislav Petkov's avatar
Borislav Petkov committed
10
#include <linux/types.h>
11
#include <linux/perf_event.h>
12
#include <string.h>
13 14

struct list_head;
15
struct evsel;
16
struct evlist;
17
struct parse_events_error;
18

19 20
struct option;

21 22 23 24 25 26
struct tracepoint_path {
	char *system;
	char *name;
	struct tracepoint_path *next;
};

27 28 29
struct tracepoint_path *tracepoint_id_to_path(u64 config);
struct tracepoint_path *tracepoint_name_to_path(const char *name);
bool have_tracepoints(struct list_head *evlist);
30

31
const char *event_type(int type);
32

33
int parse_events_option(const struct option *opt, const char *str, int unset);
34
int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset);
35
int parse_events(struct evlist *evlist, const char *str,
36 37 38 39
		 struct parse_events_error *error);
int parse_events_terms(struct list_head *terms, const char *str);
int parse_filter(const struct option *opt, const char *str, int unset);
int exclude_perf(const struct option *opt, const char *arg, int unset);
40 41 42

#define EVENTS_HELP_MAX (128*1024)

43 44 45 46 47 48 49 50 51 52 53 54
enum perf_pmu_event_symbol_type {
	PMU_EVENT_SYMBOL_ERR,		/* not a PMU EVENT */
	PMU_EVENT_SYMBOL,		/* normal style PMU event */
	PMU_EVENT_SYMBOL_PREFIX,	/* prefix of pre-suf style event */
	PMU_EVENT_SYMBOL_SUFFIX,	/* suffix of pre-suf style event */
};

struct perf_pmu_event_symbol {
	char	*symbol;
	enum perf_pmu_event_symbol_type	type;
};

55
enum {
56 57 58 59 60 61
	PARSE_EVENTS__TERM_TYPE_NUM,
	PARSE_EVENTS__TERM_TYPE_STR,
};

enum {
	PARSE_EVENTS__TERM_TYPE_USER,
62 63 64
	PARSE_EVENTS__TERM_TYPE_CONFIG,
	PARSE_EVENTS__TERM_TYPE_CONFIG1,
	PARSE_EVENTS__TERM_TYPE_CONFIG2,
65
	PARSE_EVENTS__TERM_TYPE_NAME,
66
	PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
67
	PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ,
68
	PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
69
	PARSE_EVENTS__TERM_TYPE_TIME,
70 71
	PARSE_EVENTS__TERM_TYPE_CALLGRAPH,
	PARSE_EVENTS__TERM_TYPE_STACKSIZE,
72
	PARSE_EVENTS__TERM_TYPE_NOINHERIT,
73
	PARSE_EVENTS__TERM_TYPE_INHERIT,
74
	PARSE_EVENTS__TERM_TYPE_MAX_STACK,
75
	PARSE_EVENTS__TERM_TYPE_MAX_EVENTS,
76 77
	PARSE_EVENTS__TERM_TYPE_NOOVERWRITE,
	PARSE_EVENTS__TERM_TYPE_OVERWRITE,
78
	PARSE_EVENTS__TERM_TYPE_DRV_CFG,
79
	PARSE_EVENTS__TERM_TYPE_PERCORE,
80
	PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT,
81
	PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE,
82
	__PARSE_EVENTS__TERM_TYPE_NR,
83 84
};

85 86 87 88 89 90 91 92
struct parse_events_array {
	size_t nr_ranges;
	struct {
		unsigned int start;
		size_t length;
	} *ranges;
};

93
struct parse_events_term {
94
	char *config;
95
	struct parse_events_array array;
96 97
	union {
		char *str;
98
		u64  num;
99
	} val;
100 101
	int type_val;
	int type_term;
102
	struct list_head list;
103
	bool used;
104
	bool no_value;
105 106 107 108

	/* error string indexes for within parsed string */
	int err_term;
	int err_val;
109 110 111

	/* Coming from implicit alias */
	bool weak;
112 113
};

114
struct parse_events_error {
115
	int   num_errors;       /* number of errors encountered */
116 117 118
	int   idx;	/* index in the parsed string */
	char *str;      /* string to display at the index */
	char *help;	/* optional help string */
119 120 121
	int   first_idx;/* as above, but for the first encountered error */
	char *first_str;
	char *first_help;
122 123
};

124
struct parse_events_state {
125 126 127 128
	struct list_head	   list;
	int			   idx;
	int			   nr_groups;
	struct parse_events_error *error;
129
	struct evlist	  *evlist;
130
	struct list_head	  *terms;
131
	int			   stoken;
132 133
};

134 135
void parse_events__handle_error(struct parse_events_error *err, int idx,
				char *str, char *help);
136
void parse_events__shrink_config_terms(void);
137
int parse_events__is_hardcoded_term(struct parse_events_term *term);
138 139
int parse_events_term__num(struct parse_events_term **term,
			   int type_term, char *config, u64 num,
140
			   bool novalue,
141 142 143 144
			   void *loc_term, void *loc_val);
int parse_events_term__str(struct parse_events_term **term,
			   int type_term, char *config, char *str,
			   void *loc_term, void *loc_val);
145
int parse_events_term__sym_hw(struct parse_events_term **term,
146
			      char *config, unsigned idx);
147 148
int parse_events_term__clone(struct parse_events_term **new,
			     struct parse_events_term *term);
149
void parse_events_term__delete(struct parse_events_term *term);
150
void parse_events_terms__delete(struct list_head *terms);
151
void parse_events_terms__purge(struct list_head *terms);
152
void parse_events__clear_array(struct parse_events_array *a);
153
int parse_events__modifier_event(struct list_head *list, char *str, bool add);
154
int parse_events__modifier_group(struct list_head *list, char *event_mod);
155
int parse_events_name(struct list_head *list, char *name);
156
int parse_events_add_tracepoint(struct list_head *list, int *idx,
157
				const char *sys, const char *event,
158 159
				struct parse_events_error *error,
				struct list_head *head_config);
160
int parse_events_load_bpf(struct parse_events_state *parse_state,
161
			  struct list_head *list,
162
			  char *bpf_file_name,
163 164
			  bool source,
			  struct list_head *head_config);
165 166
/* Provide this function for perf test */
struct bpf_object;
167
int parse_events_load_bpf_obj(struct parse_events_state *parse_state,
168
			      struct list_head *list,
169 170
			      struct bpf_object *obj,
			      struct list_head *head_config);
171
int parse_events_add_numeric(struct parse_events_state *parse_state,
172
			     struct list_head *list,
173
			     u32 type, u64 config,
174
			     struct list_head *head_config);
175 176 177 178
enum perf_tool_event;
int parse_events_add_tool(struct parse_events_state *parse_state,
			  struct list_head *list,
			  enum perf_tool_event tool_event);
179
int parse_events_add_cache(struct list_head *list, int *idx,
180 181 182
			   char *type, char *op_result1, char *op_result2,
			   struct parse_events_error *error,
			   struct list_head *head_config);
183
int parse_events_add_breakpoint(struct list_head *list, int *idx,
184
				void *ptr, char *type, u64 len);
185
int parse_events_add_pmu(struct parse_events_state *parse_state,
186
			 struct list_head *list, char *name,
187 188 189
			 struct list_head *head_config,
			 bool auto_merge_stats,
			 bool use_alias);
190

191
int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
192 193 194
			       char *str,
			       struct list_head **listp);

195 196 197
int parse_events_copy_term_list(struct list_head *old,
				 struct list_head **new);

198 199
enum perf_pmu_event_symbol_type
perf_pmu__parse_check(const char *name);
200 201
void parse_events__set_leader(char *name, struct list_head *list,
			      struct parse_events_state *parse_state);
202 203
void parse_events_update_lists(struct list_head *list_event,
			       struct list_head *list_all);
204
void parse_events_evlist_error(struct parse_events_state *parse_state,
205
			       int idx, const char *str);
206

207
void print_events(const char *event_glob, bool name_only, bool quiet,
208
		  bool long_desc, bool details_flag, bool deprecated);
209 210 211 212 213 214 215 216 217 218

struct event_symbol {
	const char	*symbol;
	const char	*alias;
};
extern struct event_symbol event_symbols_hw[];
extern struct event_symbol event_symbols_sw[];
void print_symbol_events(const char *event_glob, unsigned type,
				struct event_symbol *syms, unsigned max,
				bool name_only);
Andi Kleen's avatar
Andi Kleen committed
219
void print_tool_events(const char *event_glob, bool name_only);
220 221 222
void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
			     bool name_only);
int print_hwcache_events(const char *event_glob, bool name_only);
223 224
void print_sdt_events(const char *subsys_glob, const char *event_glob,
		      bool name_only);
225
int is_valid_tracepoint(const char *event_string);
226

227
int valid_event_mount(const char *eventfs);
228
char *parse_events_formats_error_string(char *additional_terms);
229

230 231 232
void parse_events_print_error(struct parse_events_error *err,
			      const char *event);

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
#ifdef HAVE_LIBELF_SUPPORT
/*
 * If the probe point starts with '%',
 * or starts with "sdt_" and has a ':' but no '=',
 * then it should be a SDT/cached probe point.
 */
static inline bool is_sdt_event(char *str)
{
	return (str[0] == '%' ||
		(!strncmp(str, "sdt_", 4) &&
		 !!strchr(str, ':') && !strchr(str, '=')));
}
#else
static inline bool is_sdt_event(char *str __maybe_unused)
{
	return false;
}
#endif /* HAVE_LIBELF_SUPPORT */

252
#endif /* __PERF_PARSE_EVENTS_H */