[linux-2.6-block.git] / tools / perf / util / parse-events.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __PERF_PARSE_EVENTS_H
#define __PERF_PARSE_EVENTS_H
/*
 * Parse symbolic events/counts passed in as options:
 */

#include <linux/list.h>
#include <stdbool.h>
#include <linux/types.h>
#include <linux/perf_event.h>
#include <string.h>

struct evsel;
struct evlist;
struct parse_events_error;

struct option;
struct perf_pmu;

bool have_tracepoints(struct list_head *evlist);

const char *event_type(int type);

int parse_events_option(const struct option *opt, const char *str, int unset);
int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset);
int __parse_events(struct evlist *evlist, const char *str, struct parse_events_error *error,
		   struct perf_pmu *fake_pmu);

static inline int parse_events(struct evlist *evlist, const char *str,
			       struct parse_events_error *err)
{
	return __parse_events(evlist, str, err, NULL);
}

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);

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 */
	PMU_EVENT_SYMBOL_SUFFIX2,	/* suffix of pre-suf2 style event */
};

enum {
	PARSE_EVENTS__TERM_TYPE_NUM,
	PARSE_EVENTS__TERM_TYPE_STR,
};

enum {
	PARSE_EVENTS__TERM_TYPE_USER,
	PARSE_EVENTS__TERM_TYPE_CONFIG,
	PARSE_EVENTS__TERM_TYPE_CONFIG1,
	PARSE_EVENTS__TERM_TYPE_CONFIG2,
	PARSE_EVENTS__TERM_TYPE_NAME,
	PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
	PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ,
	PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
	PARSE_EVENTS__TERM_TYPE_TIME,
	PARSE_EVENTS__TERM_TYPE_CALLGRAPH,
	PARSE_EVENTS__TERM_TYPE_STACKSIZE,
	PARSE_EVENTS__TERM_TYPE_NOINHERIT,
	PARSE_EVENTS__TERM_TYPE_INHERIT,
	PARSE_EVENTS__TERM_TYPE_MAX_STACK,
	PARSE_EVENTS__TERM_TYPE_MAX_EVENTS,
	PARSE_EVENTS__TERM_TYPE_NOOVERWRITE,
	PARSE_EVENTS__TERM_TYPE_OVERWRITE,
	PARSE_EVENTS__TERM_TYPE_DRV_CFG,
	PARSE_EVENTS__TERM_TYPE_PERCORE,
	PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT,
	PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE,
	PARSE_EVENTS__TERM_TYPE_METRIC_ID,
	__PARSE_EVENTS__TERM_TYPE_NR,
};

struct parse_events_array {
	size_t nr_ranges;
	struct {
		unsigned int start;
		size_t length;
	} *ranges;
};

struct parse_events_term {
	char *config;
	struct parse_events_array array;
	union {
		char *str;
		u64  num;
	} val;
	int type_val;
	int type_term;
	struct list_head list;
	bool used;
	bool no_value;

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

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

struct parse_events_error {
	int   num_errors;       /* number of errors encountered */
	int   idx;	/* index in the parsed string */
	char *str;      /* string to display at the index */
	char *help;	/* optional help string */
	int   first_idx;/* as above, but for the first encountered error */
	char *first_str;
	char *first_help;
};

struct parse_events_state {
	struct list_head	   list;
	int			   idx;
	int			   nr_groups;
	struct parse_events_error *error;
	struct evlist		  *evlist;
	struct list_head	  *terms;
	int			   stoken;
	struct perf_pmu		  *fake_pmu;
	char			  *hybrid_pmu_name;
};

void parse_events__shrink_config_terms(void);
int parse_events__is_hardcoded_term(struct parse_events_term *term);
int parse_events_term__num(struct parse_events_term **term,
			   int type_term, char *config, u64 num,
			   bool novalue,
			   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);
int parse_events_term__sym_hw(struct parse_events_term **term,
			      char *config, unsigned idx);
int parse_events_term__clone(struct parse_events_term **new,
			     struct parse_events_term *term);
void parse_events_term__delete(struct parse_events_term *term);
void parse_events_terms__delete(struct list_head *terms);
void parse_events_terms__purge(struct list_head *terms);
void parse_events__clear_array(struct parse_events_array *a);
int parse_events__modifier_event(struct list_head *list, char *str, bool add);
int parse_events__modifier_group(struct list_head *list, char *event_mod);
int parse_events_name(struct list_head *list, const char *name);
int parse_events_add_tracepoint(struct list_head *list, int *idx,
				const char *sys, const char *event,
				struct parse_events_error *error,
				struct list_head *head_config);
int parse_events_load_bpf(struct parse_events_state *parse_state,
			  struct list_head *list,
			  char *bpf_file_name,
			  bool source,
			  struct list_head *head_config);
/* Provide this function for perf test */
struct bpf_object;
int parse_events_load_bpf_obj(struct parse_events_state *parse_state,
			      struct list_head *list,
			      struct bpf_object *obj,
			      struct list_head *head_config);
int parse_events_add_numeric(struct parse_events_state *parse_state,
			     struct list_head *list,
			     u32 type, u64 config,
			     struct list_head *head_config);
int parse_events_add_tool(struct parse_events_state *parse_state,
			  struct list_head *list,
			  int tool_event);
int parse_events_add_cache(struct list_head *list, int *idx,
			   char *type, char *op_result1, char *op_result2,
			   struct parse_events_error *error,
			   struct list_head *head_config,
			   struct parse_events_state *parse_state);
int parse_events_add_breakpoint(struct list_head *list, int *idx,
				u64 addr, char *type, u64 len);
int parse_events_add_pmu(struct parse_events_state *parse_state,
			 struct list_head *list, char *name,
			 struct list_head *head_config,
			 bool auto_merge_stats,
			 bool use_alias);

struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
				      const char *name, const char *metric_id,
				      struct perf_pmu *pmu);

int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
			       char *str,
			       struct list_head *head_config,
			       struct list_head **listp);

int parse_events_copy_term_list(struct list_head *old,
				 struct list_head **new);

enum perf_pmu_event_symbol_type
perf_pmu__parse_check(const char *name);
void parse_events__set_leader(char *name, struct list_head *list,
			      struct parse_events_state *parse_state);
void parse_events_update_lists(struct list_head *list_event,
			       struct list_head *list_all);
void parse_events_evlist_error(struct parse_events_state *parse_state,
			       int idx, const char *str);

struct event_symbol {
	const char	*symbol;
	const char	*alias;
};
extern struct event_symbol event_symbols_hw[];
extern struct event_symbol event_symbols_sw[];

char *parse_events_formats_error_string(char *additional_terms);

void parse_events_error__init(struct parse_events_error *err);
void parse_events_error__exit(struct parse_events_error *err);
void parse_events_error__handle(struct parse_events_error *err, int idx,
				char *str, char *help);
void parse_events_error__print(struct parse_events_error *err,
			       const char *event);

#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 */

int perf_pmu__test_parse_init(void);

struct evsel *parse_events__add_event_hybrid(struct list_head *list, int *idx,
					     struct perf_event_attr *attr,
					     const char *name,
					     const char *metric_id,
					     struct perf_pmu *pmu,
					     struct list_head *config_terms);

#endif /* __PERF_PARSE_EVENTS_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
8b40f521 JK	2	#ifndef __PERF_PARSE_EVENTS_H
8b40f521 JK	3	#define __PERF_PARSE_EVENTS_H
5242519b IM	4	/*
	5	* Parse symbolic events/counts passed in as options:
	6	*/
	7
f50246e2	8	#include <linux/list.h>
c651214e	9	#include <stdbool.h>
d944c4ee	10	#include <linux/types.h>
d2709c7c	11	#include <linux/perf_event.h>
af9100ad	12	#include <string.h>
69aad6f1	13
32dcd021	14	struct evsel;
63503dba	15	struct evlist;
b39b8393	16	struct parse_events_error;
69aad6f1	17
5beeded1	18	struct option;
70943490	19	struct perf_pmu;
5beeded1	20
3938bad4	21	bool have_tracepoints(struct list_head *evlist);
1ef2ed10	22
1424dc96	23	const char *event_type(int type);
8ad8db37	24
3938bad4	25	int parse_events_option(const struct option opt, const char str, int unset);
d0abbc3c	26	int parse_events_option_new_evlist(const struct option opt, const char str, int unset);
3bf91aa5 ACM	27	int __parse_events(struct evlist evlist, const char str, struct parse_events_error *error,
	28	struct perf_pmu *fake_pmu);
	29
	30	static inline int parse_events(struct evlist evlist, const char str,
	31	struct parse_events_error *err)
	32	{
	33	return __parse_events(evlist, str, err, NULL);
	34	}
	35
3938bad4 ACM	36	int parse_events_terms(struct list_head terms, const char str);
	37	int parse_filter(const struct option opt, const char str, int unset);
	38	int exclude_perf(const struct option opt, const char arg, int unset);
8ad8db37	39
dcb4e102 KL	40	enum perf_pmu_event_symbol_type {
	41	PMU_EVENT_SYMBOL_ERR, /* not a PMU EVENT */
	42	PMU_EVENT_SYMBOL, /* normal style PMU event */
	43	PMU_EVENT_SYMBOL_PREFIX, /* prefix of pre-suf style event */
	44	PMU_EVENT_SYMBOL_SUFFIX, /* suffix of pre-suf style event */
864bc8c9	45	PMU_EVENT_SYMBOL_SUFFIX2, /* suffix of pre-suf2 style event */
dcb4e102 KL	46	};
dcb4e102 KL	47
8f707d84	48	enum {
16fa7e82 JO	49	PARSE_EVENTS__TERM_TYPE_NUM,
	50	PARSE_EVENTS__TERM_TYPE_STR,
	51	};
	52
	53	enum {
	54	PARSE_EVENTS__TERM_TYPE_USER,
8f707d84 JO	55	PARSE_EVENTS__TERM_TYPE_CONFIG,
	56	PARSE_EVENTS__TERM_TYPE_CONFIG1,
	57	PARSE_EVENTS__TERM_TYPE_CONFIG2,
6b5fc39b	58	PARSE_EVENTS__TERM_TYPE_NAME,
8f707d84	59	PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
09af2a55	60	PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ,
8f707d84	61	PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
32067712	62	PARSE_EVENTS__TERM_TYPE_TIME,
d457c963 KL	63	PARSE_EVENTS__TERM_TYPE_CALLGRAPH,
d457c963 KL	64	PARSE_EVENTS__TERM_TYPE_STACKSIZE,
374ce938	65	PARSE_EVENTS__TERM_TYPE_NOINHERIT,
17cb5f84	66	PARSE_EVENTS__TERM_TYPE_INHERIT,
792d48b4	67	PARSE_EVENTS__TERM_TYPE_MAX_STACK,
2fda5ada	68	PARSE_EVENTS__TERM_TYPE_MAX_EVENTS,
626a6b78 WN	69	PARSE_EVENTS__TERM_TYPE_NOOVERWRITE,
626a6b78 WN	70	PARSE_EVENTS__TERM_TYPE_OVERWRITE,
dd60fba7	71	PARSE_EVENTS__TERM_TYPE_DRV_CFG,
064b4e82	72	PARSE_EVENTS__TERM_TYPE_PERCORE,
1b992154	73	PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT,
eb7a52d4	74	PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE,
2b62b3a6	75	PARSE_EVENTS__TERM_TYPE_METRIC_ID,
17cb5f84	76	__PARSE_EVENTS__TERM_TYPE_NR,
8f707d84 JO	77	};
8f707d84 JO	78
2d055bf2 WN	79	struct parse_events_array {
	80	size_t nr_ranges;
	81	struct {
	82	unsigned int start;
	83	size_t length;
	84	} *ranges;
	85	};
	86
6cee6cd3	87	struct parse_events_term {
8f707d84	88	char *config;
2d055bf2	89	struct parse_events_array array;
8f707d84 JO	90	union {
8f707d84 JO	91	char *str;
b527bab5	92	u64 num;
8f707d84	93	} val;
16fa7e82 JO	94	int type_val;
16fa7e82 JO	95	int type_term;
8f707d84	96	struct list_head list;
688d4dfc	97	bool used;
99e7138e	98	bool no_value;
cecf3a2e JO	99
	100	/* error string indexes for within parsed string */
	101	int err_term;
	102	int err_val;
59622fd4 AK	103
	104	/* Coming from implicit alias */
	105	bool weak;
8f707d84 JO	106	};
8f707d84 JO	107
b39b8393	108	struct parse_events_error {
a910e466	109	int num_errors; /* number of errors encountered */
b39b8393 JO	110	int idx; /* index in the parsed string */
	111	char str; / string to display at the index */
	112	char help; / optional help string */
a910e466 IR	113	int first_idx;/* as above, but for the first encountered error */
	114	char *first_str;
	115	char *first_help;
b39b8393 JO	116	};
b39b8393 JO	117
5d369a75	118	struct parse_events_state {
b39b8393 JO	119	struct list_head list;
	120	int idx;
	121	int nr_groups;
	122	struct parse_events_error *error;
387ad33f	123	struct evlist *evlist;
d17d0878	124	struct list_head *terms;
1244a327	125	int stoken;
387ad33f	126	struct perf_pmu *fake_pmu;
c93afadc	127	char *hybrid_pmu_name;
90e2b22d JO	128	};
90e2b22d JO	129
1669e509	130	void parse_events__shrink_config_terms(void);
6cee6cd3	131	int parse_events__is_hardcoded_term(struct parse_events_term *term);
bb78ce7d AH	132	int parse_events_term__num(struct parse_events_term **term,
bb78ce7d AH	133	int type_term, char *config, u64 num,
99e7138e	134	bool novalue,
bb78ce7d AH	135	void loc_term, void loc_val);
	136	int parse_events_term__str(struct parse_events_term **term,
	137	int type_term, char config, char str,
	138	void loc_term, void loc_val);
6cee6cd3	139	int parse_events_term__sym_hw(struct parse_events_term **term,
1d33d6dc	140	char *config, unsigned idx);
6cee6cd3 ACM	141	int parse_events_term__clone(struct parse_events_term **new,
6cee6cd3 ACM	142	struct parse_events_term *term);
1dc92556	143	void parse_events_term__delete(struct parse_events_term *term);
2146afc6	144	void parse_events_terms__delete(struct list_head *terms);
fc0a2c1d	145	void parse_events_terms__purge(struct list_head *terms);
2d055bf2	146	void parse_events__clear_array(struct parse_events_array *a);
f5b1135b	147	int parse_events__modifier_event(struct list_head list, char str, bool add);
89efb029	148	int parse_events__modifier_group(struct list_head list, char event_mod);
8e8bbfb3	149	int parse_events_name(struct list_head list, const char name);
c5cd8ac0	150	int parse_events_add_tracepoint(struct list_head list, int idx,
8c619d6a	151	const char sys, const char event,
e637d177 HK	152	struct parse_events_error *error,
e637d177 HK	153	struct list_head *head_config);
5d9cdc11	154	int parse_events_load_bpf(struct parse_events_state *parse_state,
84c86ca1	155	struct list_head *list,
d509db04	156	char *bpf_file_name,
a34f3be7 WN	157	bool source,
a34f3be7 WN	158	struct list_head *head_config);
84c86ca1 WN	159	/* Provide this function for perf test */
84c86ca1 WN	160	struct bpf_object;
5d9cdc11	161	int parse_events_load_bpf_obj(struct parse_events_state *parse_state,
84c86ca1	162	struct list_head *list,
95088a59 WN	163	struct bpf_object *obj,
95088a59 WN	164	struct list_head *head_config);
5d9cdc11	165	int parse_events_add_numeric(struct parse_events_state *parse_state,
87d650be	166	struct list_head *list,
b527bab5	167	u32 type, u64 config,
8f707d84	168	struct list_head *head_config);
f0fbb114 AK	169	int parse_events_add_tool(struct parse_events_state *parse_state,
f0fbb114 AK	170	struct list_head *list,
8228e936	171	int tool_event);
c5cd8ac0	172	int parse_events_add_cache(struct list_head list, int idx,
43d0b978 WN	173	char type, char op_result1, char *op_result2,
43d0b978 WN	174	struct parse_events_error *error,
c93afadc JY	175	struct list_head *head_config,
c93afadc JY	176	struct parse_events_state *parse_state);
c5cd8ac0	177	int parse_events_add_breakpoint(struct list_head list, int idx,
aa98d848	178	u64 addr, char *type, u64 len);
5d9cdc11	179	int parse_events_add_pmu(struct parse_events_state *parse_state,
36adec85	180	struct list_head list, char name,
369b2308 KL	181	struct list_head *head_config,
	182	bool auto_merge_stats,
	183	bool use_alias);
2073ad33	184
70943490	185	struct evsel parse_events__add_event(int idx, struct perf_event_attr attr,
2b62b3a6 IR	186	const char name, const char metric_id,
2b62b3a6 IR	187	struct perf_pmu *pmu);
70943490	188
5d9cdc11	189	int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
2073ad33	190	char *str,
fb081153	191	struct list_head *head_config,
2073ad33 AK	192	struct list_head **listp);
2073ad33 AK	193
8255718f AK	194	int parse_events_copy_term_list(struct list_head *old,
	195	struct list_head **new);
	196
dcb4e102 KL	197	enum perf_pmu_event_symbol_type
dcb4e102 KL	198	perf_pmu__parse_check(const char *name);
369b2308 KL	199	void parse_events__set_leader(char name, struct list_head list,
369b2308 KL	200	struct parse_events_state *parse_state);
5d7be90e JO	201	void parse_events_update_lists(struct list_head *list_event,
5d7be90e JO	202	struct list_head *list_all);
5d9cdc11	203	void parse_events_evlist_error(struct parse_events_state *parse_state,
b39b8393	204	int idx, const char *str);
89812fc8	205
705750f2 YS	206	struct event_symbol {
	207	const char *symbol;
	208	const char *alias;
	209	};
	210	extern struct event_symbol event_symbols_hw[];
	211	extern struct event_symbol event_symbols_sw[];
9b7c7728	212
ffeb883e	213	char parse_events_formats_error_string(char additional_terms);
5beeded1	214
07eafd4e IR	215	void parse_events_error__init(struct parse_events_error *err);
07eafd4e IR	216	void parse_events_error__exit(struct parse_events_error *err);
6c191289 IR	217	void parse_events_error__handle(struct parse_events_error *err, int idx,
	218	char str, char help);
	219	void parse_events_error__print(struct parse_events_error *err,
	220	const char *event);
333b5665	221
af9100ad RB	222	#ifdef HAVE_LIBELF_SUPPORT
	223	/*
	224	* If the probe point starts with '%',
	225	* or starts with "sdt_" and has a ':' but no '=',
	226	* then it should be a SDT/cached probe point.
	227	*/
	228	static inline bool is_sdt_event(char *str)
	229	{
	230	return (str[0] == '%' \|\|
	231	(!strncmp(str, "sdt_", 4) &&
	232	!!strchr(str, ':') && !strchr(str, '=')));
	233	}
	234	#else
	235	static inline bool is_sdt_event(char *str __maybe_unused)
	236	{
	237	return false;
	238	}
	239	#endif /* HAVE_LIBELF_SUPPORT */
	240
4929e95a JO	241	int perf_pmu__test_parse_init(void);
4929e95a JO	242
9cbfa2f6 JY	243	struct evsel parse_events__add_event_hybrid(struct list_head list, int *idx,
9cbfa2f6 JY	244	struct perf_event_attr *attr,
8e8bbfb3	245	const char *name,
2b62b3a6	246	const char *metric_id,
8e8bbfb3	247	struct perf_pmu *pmu,
9cbfa2f6 JY	248	struct list_head *config_terms);
9cbfa2f6 JY	249
8b40f521	250	#endif /* __PERF_PARSE_EVENTS_H */