[linux-block.git] / tools / perf / util / evsel.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __PERF_EVSEL_H
#define __PERF_EVSEL_H 1

#include <linux/list.h>
#include <stdbool.h>
#include <sys/types.h>
#include <linux/perf_event.h>
#include <linux/types.h>
#include <internal/evsel.h>
#include <perf/evsel.h>
#include "symbol_conf.h"

struct bpf_object;
struct cgroup;
struct perf_counts;
struct perf_stat_evsel;
union perf_event;
struct bpf_counter_ops;
struct target;
struct hashmap;
struct bperf_leader_bpf;
struct bperf_follower_bpf;
struct perf_pmu;

typedef int (evsel__sb_cb_t)(union perf_event *event, void *data);

enum perf_tool_event {
	PERF_TOOL_NONE		= 0,
	PERF_TOOL_DURATION_TIME = 1,
	PERF_TOOL_USER_TIME = 2,
	PERF_TOOL_SYSTEM_TIME = 3,

	PERF_TOOL_MAX,
};

const char *perf_tool_event__to_str(enum perf_tool_event ev);
enum perf_tool_event perf_tool_event__from_str(const char *str);

#define perf_tool_event__for_each_event(ev)		\
	for ((ev) = PERF_TOOL_DURATION_TIME; (ev) < PERF_TOOL_MAX; ev++)

/** struct evsel - event selector
 *
 * @evlist - evlist this evsel is in, if it is in one.
 * @core - libperf evsel object
 * @name - Can be set to retain the original event name passed by the user,
 *         so that when showing results in tools such as 'perf stat', we
 *         show the name used, not some alias.
 * @id_pos: the position of the event id (PERF_SAMPLE_ID or
 *          PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of
 *          struct perf_record_sample
 * @is_pos: the position (counting backwards) of the event id (PERF_SAMPLE_ID or
 *          PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if sample_id_all
 *          is used there is an id sample appended to non-sample events
 * @priv:   And what is in its containing unnamed union are tool specific
 */
struct evsel {
	struct perf_evsel	core;
	struct evlist		*evlist;
	off_t			id_offset;
	int			id_pos;
	int			is_pos;
	unsigned int		sample_size;

	/*
	 * These fields can be set in the parse-events code or similar.
	 * Please check evsel__clone() to copy them properly so that
	 * they can be released properly.
	 */
	struct {
		char			*name;
		char			*group_name;
		const char		*pmu_name;
#ifdef HAVE_LIBTRACEEVENT
		struct tep_event	*tp_format;
#endif
		char			*filter;
		unsigned long		max_events;
		double			scale;
		const char		*unit;
		struct cgroup		*cgrp;
		const char		*metric_id;
		enum perf_tool_event	tool_event;
		/* parse modifier helper */
		int			exclude_GH;
		int			sample_read;
		bool			snapshot;
		bool			per_pkg;
		bool			percore;
		bool			precise_max;
		bool			use_uncore_alias;
		bool			is_libpfm_event;
		bool			auto_merge_stats;
		bool			collect_stat;
		bool			weak_group;
		bool			bpf_counter;
		bool			use_config_name;
		int			bpf_fd;
		struct bpf_object	*bpf_obj;
		struct list_head	config_terms;
	};

	/*
	 * metric fields are similar, but needs more care as they can have
	 * references to other metric (evsel).
	 */
	const char *		metric_expr;
	const char *		metric_name;
	struct evsel		**metric_events;
	struct evsel		*metric_leader;

	void			*handler;
	struct perf_counts	*counts;
	struct perf_counts	*prev_raw_counts;
	unsigned long		nr_events_printed;
	struct perf_stat_evsel  *stats;
	void			*priv;
	u64			db_id;
	bool			uniquified_name;
	bool 			supported;
	bool 			needs_swap;
	bool 			disabled;
	bool			no_aux_samples;
	bool			immediate;
	bool			tracking;
	bool			ignore_missing_thread;
	bool			forced_leader;
	bool			cmdline_group_boundary;
	bool			merged_stat;
	bool			reset_group;
	bool			errored;
	bool			needs_auxtrace_mmap;
	struct hashmap		*per_pkg_mask;
	int			err;
	struct {
		evsel__sb_cb_t	*cb;
		void		*data;
	} side_band;
	/*
	 * For reporting purposes, an evsel sample can have a callchain
	 * synthesized from AUX area data. Keep track of synthesized sample
	 * types here. Note, the recorded sample_type cannot be changed because
	 * it is needed to continue to parse events.
	 * See also evsel__has_callchain().
	 */
	__u64			synth_sample_type;

	/*
	 * bpf_counter_ops serves two use cases:
	 *   1. perf-stat -b          counting events used byBPF programs
	 *   2. perf-stat --use-bpf   use BPF programs to aggregate counts
	 */
	struct bpf_counter_ops	*bpf_counter_ops;

	/* for perf-stat -b */
	struct list_head	bpf_counter_list;

	/* for perf-stat --use-bpf */
	int			bperf_leader_prog_fd;
	int			bperf_leader_link_fd;
	union {
		struct bperf_leader_bpf *leader_skel;
		struct bperf_follower_bpf *follower_skel;
	};
	unsigned long		open_flags;
	int			precise_ip_original;

	/* for missing_features */
	struct perf_pmu		*pmu;
};

struct perf_missing_features {
	bool sample_id_all;
	bool exclude_guest;
	bool mmap2;
	bool cloexec;
	bool clockid;
	bool clockid_wrong;
	bool lbr_flags;
	bool write_backward;
	bool group_read;
	bool ksymbol;
	bool bpf;
	bool aux_output;
	bool branch_hw_idx;
	bool cgroup;
	bool data_page_size;
	bool code_page_size;
	bool weight_struct;
	bool read_lost;
};

extern struct perf_missing_features perf_missing_features;

struct perf_cpu_map;
struct thread_map;
struct record_opts;

static inline struct perf_cpu_map *evsel__cpus(struct evsel *evsel)
{
	return perf_evsel__cpus(&evsel->core);
}

static inline int evsel__nr_cpus(struct evsel *evsel)
{
	return perf_cpu_map__nr(evsel__cpus(evsel));
}

void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
			   struct perf_counts_values *count);

int evsel__object_config(size_t object_size,
			 int (*init)(struct evsel *evsel),
			 void (*fini)(struct evsel *evsel));

struct perf_pmu *evsel__find_pmu(struct evsel *evsel);
bool evsel__is_aux_event(struct evsel *evsel);

struct evsel *evsel__new_idx(struct perf_event_attr *attr, int idx);

static inline struct evsel *evsel__new(struct perf_event_attr *attr)
{
	return evsel__new_idx(attr, 0);
}

struct evsel *evsel__clone(struct evsel *orig);

int copy_config_terms(struct list_head *dst, struct list_head *src);
void free_config_terms(struct list_head *config_terms);


#ifdef HAVE_LIBTRACEEVENT
struct evsel *evsel__newtp_idx(const char *sys, const char *name, int idx);

/*
 * Returns pointer with encoded error via <linux/err.h> interface.
 */
static inline struct evsel *evsel__newtp(const char *sys, const char *name)
{
	return evsel__newtp_idx(sys, name, 0);
}
#endif

struct evsel *evsel__new_cycles(bool precise, __u32 type, __u64 config);

#ifdef HAVE_LIBTRACEEVENT
struct tep_event *event_format__new(const char *sys, const char *name);
#endif

void evsel__init(struct evsel *evsel, struct perf_event_attr *attr, int idx);
void evsel__exit(struct evsel *evsel);
void evsel__delete(struct evsel *evsel);

struct callchain_param;

void evsel__config(struct evsel *evsel, struct record_opts *opts,
		   struct callchain_param *callchain);
void evsel__config_callchain(struct evsel *evsel, struct record_opts *opts,
			     struct callchain_param *callchain);

int __evsel__sample_size(u64 sample_type);
void evsel__calc_id_pos(struct evsel *evsel);

bool evsel__is_cache_op_valid(u8 type, u8 op);

static inline bool evsel__is_bpf(struct evsel *evsel)
{
	return evsel->bpf_counter_ops != NULL;
}

#define EVSEL__MAX_ALIASES 8

extern const char *const evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX][EVSEL__MAX_ALIASES];
extern const char *const evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][EVSEL__MAX_ALIASES];
extern const char *const evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX][EVSEL__MAX_ALIASES];
extern const char *const evsel__hw_names[PERF_COUNT_HW_MAX];
extern const char *const evsel__sw_names[PERF_COUNT_SW_MAX];
extern char *evsel__bpf_counter_events;
bool evsel__match_bpf_counter_events(const char *name);
int arch_evsel__hw_name(struct evsel *evsel, char *bf, size_t size);

int __evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result, char *bf, size_t size);
const char *evsel__name(struct evsel *evsel);
const char *evsel__metric_id(const struct evsel *evsel);

static inline bool evsel__is_tool(const struct evsel *evsel)
{
	return evsel->tool_event != PERF_TOOL_NONE;
}

const char *evsel__group_name(struct evsel *evsel);
int evsel__group_desc(struct evsel *evsel, char *buf, size_t size);

void __evsel__set_sample_bit(struct evsel *evsel, enum perf_event_sample_format bit);
void __evsel__reset_sample_bit(struct evsel *evsel, enum perf_event_sample_format bit);

#define evsel__set_sample_bit(evsel, bit) \
	__evsel__set_sample_bit(evsel, PERF_SAMPLE_##bit)

#define evsel__reset_sample_bit(evsel, bit) \
	__evsel__reset_sample_bit(evsel, PERF_SAMPLE_##bit)

void evsel__set_sample_id(struct evsel *evsel, bool use_sample_identifier);

void arch_evsel__set_sample_weight(struct evsel *evsel);
void arch_evsel__fixup_new_cycles(struct perf_event_attr *attr);
void arch__post_evsel_config(struct evsel *evsel, struct perf_event_attr *attr);

int evsel__set_filter(struct evsel *evsel, const char *filter);
int evsel__append_tp_filter(struct evsel *evsel, const char *filter);
int evsel__append_addr_filter(struct evsel *evsel, const char *filter);
int evsel__enable_cpu(struct evsel *evsel, int cpu_map_idx);
int evsel__enable(struct evsel *evsel);
int evsel__disable(struct evsel *evsel);
int evsel__disable_cpu(struct evsel *evsel, int cpu_map_idx);

int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu_map_idx);
int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads);
int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,
		struct perf_thread_map *threads);
void evsel__close(struct evsel *evsel);
int evsel__prepare_open(struct evsel *evsel, struct perf_cpu_map *cpus,
		struct perf_thread_map *threads);
bool evsel__detect_missing_features(struct evsel *evsel);

enum rlimit_action { NO_CHANGE, SET_TO_MAX, INCREASED_MAX };
bool evsel__increase_rlimit(enum rlimit_action *set_rlimit);

bool evsel__precise_ip_fallback(struct evsel *evsel);

struct perf_sample;

#ifdef HAVE_LIBTRACEEVENT
void *evsel__rawptr(struct evsel *evsel, struct perf_sample *sample, const char *name);
u64 evsel__intval(struct evsel *evsel, struct perf_sample *sample, const char *name);

static inline char *evsel__strval(struct evsel *evsel, struct perf_sample *sample, const char *name)
{
	return evsel__rawptr(evsel, sample, name);
}
#endif

struct tep_format_field;

u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample, bool needs_swap);

struct tep_format_field *evsel__field(struct evsel *evsel, const char *name);

#define evsel__match(evsel, t, c)		\
	(evsel->core.attr.type == PERF_TYPE_##t &&	\
	 evsel->core.attr.config == PERF_COUNT_##c)

static inline bool evsel__match2(struct evsel *e1, struct evsel *e2)
{
	return (e1->core.attr.type == e2->core.attr.type) &&
	       (e1->core.attr.config == e2->core.attr.config);
}

int evsel__read_counter(struct evsel *evsel, int cpu_map_idx, int thread);

int __evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread, bool scale);

/**
 * evsel__read_on_cpu - Read out the results on a CPU and thread
 *
 * @evsel - event selector to read value
 * @cpu_map_idx - CPU of interest
 * @thread - thread of interest
 */
static inline int evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread)
{
	return __evsel__read_on_cpu(evsel, cpu_map_idx, thread, false);
}

/**
 * evsel__read_on_cpu_scaled - Read out the results on a CPU and thread, scaled
 *
 * @evsel - event selector to read value
 * @cpu_map_idx - CPU of interest
 * @thread - thread of interest
 */
static inline int evsel__read_on_cpu_scaled(struct evsel *evsel, int cpu_map_idx, int thread)
{
	return __evsel__read_on_cpu(evsel, cpu_map_idx, thread, true);
}

int evsel__parse_sample(struct evsel *evsel, union perf_event *event,
			struct perf_sample *sample);

int evsel__parse_sample_timestamp(struct evsel *evsel, union perf_event *event,
				  u64 *timestamp);

u16 evsel__id_hdr_size(struct evsel *evsel);

static inline struct evsel *evsel__next(struct evsel *evsel)
{
	return list_entry(evsel->core.node.next, struct evsel, core.node);
}

static inline struct evsel *evsel__prev(struct evsel *evsel)
{
	return list_entry(evsel->core.node.prev, struct evsel, core.node);
}

/**
 * evsel__is_group_leader - Return whether given evsel is a leader event
 *
 * @evsel - evsel selector to be tested
 *
 * Return %true if @evsel is a group leader or a stand-alone event
 */
static inline bool evsel__is_group_leader(const struct evsel *evsel)
{
	return evsel->core.leader == &evsel->core;
}

/**
 * evsel__is_group_event - Return whether given evsel is a group event
 *
 * @evsel - evsel selector to be tested
 *
 * Return %true iff event group view is enabled and @evsel is a actual group
 * leader which has other members in the group
 */
static inline bool evsel__is_group_event(struct evsel *evsel)
{
	if (!symbol_conf.event_group)
		return false;

	return evsel__is_group_leader(evsel) && evsel->core.nr_members > 1;
}

bool evsel__is_function_event(struct evsel *evsel);

static inline bool evsel__is_bpf_output(struct evsel *evsel)
{
	return evsel__match(evsel, SOFTWARE, SW_BPF_OUTPUT);
}

static inline bool evsel__is_clock(struct evsel *evsel)
{
	return evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
	       evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK);
}

bool evsel__fallback(struct evsel *evsel, int err, char *msg, size_t msgsize);
int evsel__open_strerror(struct evsel *evsel, struct target *target,
			 int err, char *msg, size_t size);

static inline int evsel__group_idx(struct evsel *evsel)
{
	return evsel->core.idx - evsel->core.leader->idx;
}

/* Iterates group WITHOUT the leader. */
#define for_each_group_member(_evsel, _leader) 					\
for ((_evsel) = list_entry((_leader)->core.node.next, struct evsel, core.node); \
     (_evsel) && (_evsel)->core.leader == (&_leader->core);					\
     (_evsel) = list_entry((_evsel)->core.node.next, struct evsel, core.node))

/* Iterates group WITH the leader. */
#define for_each_group_evsel(_evsel, _leader) 					\
for ((_evsel) = _leader; 							\
     (_evsel) && (_evsel)->core.leader == (&_leader->core);					\
     (_evsel) = list_entry((_evsel)->core.node.next, struct evsel, core.node))

static inline bool evsel__has_branch_callstack(const struct evsel *evsel)
{
	return evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_CALL_STACK;
}

static inline bool evsel__has_branch_hw_idx(const struct evsel *evsel)
{
	return evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX;
}

static inline bool evsel__has_callchain(const struct evsel *evsel)
{
	/*
	 * For reporting purposes, an evsel sample can have a recorded callchain
	 * or a callchain synthesized from AUX area data.
	 */
	return evsel->core.attr.sample_type & PERF_SAMPLE_CALLCHAIN ||
	       evsel->synth_sample_type & PERF_SAMPLE_CALLCHAIN;
}

static inline bool evsel__has_br_stack(const struct evsel *evsel)
{
	/*
	 * For reporting purposes, an evsel sample can have a recorded branch
	 * stack or a branch stack synthesized from AUX area data.
	 */
	return evsel->core.attr.sample_type & PERF_SAMPLE_BRANCH_STACK ||
	       evsel->synth_sample_type & PERF_SAMPLE_BRANCH_STACK;
}

static inline bool evsel__is_dummy_event(struct evsel *evsel)
{
	return (evsel->core.attr.type == PERF_TYPE_SOFTWARE) &&
	       (evsel->core.attr.config == PERF_COUNT_SW_DUMMY);
}

struct perf_env *evsel__env(struct evsel *evsel);

int evsel__store_ids(struct evsel *evsel, struct evlist *evlist);

void evsel__zero_per_pkg(struct evsel *evsel);
bool evsel__is_hybrid(const struct evsel *evsel);
struct evsel *evsel__leader(struct evsel *evsel);
bool evsel__has_leader(struct evsel *evsel, struct evsel *leader);
bool evsel__is_leader(struct evsel *evsel);
void evsel__set_leader(struct evsel *evsel, struct evsel *leader);
int evsel__source_count(const struct evsel *evsel);
void evsel__remove_from_group(struct evsel *evsel, struct evsel *leader);

bool arch_evsel__must_be_in_group(const struct evsel *evsel);

/*
 * Macro to swap the bit-field postition and size.
 * Used when,
 * - dont need to swap the entire u64 &&
 * - when u64 has variable bit-field sizes &&
 * - when presented in a host endian which is different
 *   than the source endian of the perf.data file
 */
#define bitfield_swap(src, pos, size)	\
	((((src) >> (pos)) & ((1ull << (size)) - 1)) << (63 - ((pos) + (size) - 1)))

u64 evsel__bitfield_swap_branch_flags(u64 value);
#endif /* __PERF_EVSEL_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
69aad6f1 ACM	2	#ifndef __PERF_EVSEL_H
	3	#define __PERF_EVSEL_H 1
	4
	5	#include <linux/list.h>
c52b12ed	6	#include <stdbool.h>
f7004f59	7	#include <sys/types.h>
d2709c7c	8	#include <linux/perf_event.h>
d944c4ee	9	#include <linux/types.h>
b27c4ece	10	#include <internal/evsel.h>
69714a4e	11	#include <perf/evsel.h>
9cd997f8	12	#include "symbol_conf.h"
69aad6f1	13
ca125277 ACM	14	struct bpf_object;
	15	struct cgroup;
	16	struct perf_counts;
e669e833	17	struct perf_stat_evsel;
ca125277	18	union perf_event;
fa853c4b SL	19	struct bpf_counter_ops;
fa853c4b SL	20	struct target;
034f7ee1	21	struct hashmap;
7fac83aa SL	22	struct bperf_leader_bpf;
7fac83aa SL	23	struct bperf_follower_bpf;
3500eeeb	24	struct perf_pmu;
e669e833	25
65ddce3f	26	typedef int (evsel__sb_cb_t)(union perf_event event, void data);
657ee553	27
f0fbb114 AK	28	enum perf_tool_event {
	29	PERF_TOOL_NONE = 0,
	30	PERF_TOOL_DURATION_TIME = 1,
b03b89b3 FF	31	PERF_TOOL_USER_TIME = 2,
	32	PERF_TOOL_SYSTEM_TIME = 3,
	33
	34	PERF_TOOL_MAX,
f0fbb114 AK	35	};
f0fbb114 AK	36
79932d16 IR	37	const char *perf_tool_event__to_str(enum perf_tool_event ev);
	38	enum perf_tool_event perf_tool_event__from_str(const char *str);
	39
	40	#define perf_tool_event__for_each_event(ev) \
	41	for ((ev) = PERF_TOOL_DURATION_TIME; (ev) < PERF_TOOL_MAX; ev++)
	42
32dcd021	43	/** struct evsel - event selector
f0c55bcf	44	*
d49e4695	45	* @evlist - evlist this evsel is in, if it is in one.
b27c4ece	46	* @core - libperf evsel object
f0c55bcf SE	47	* @name - Can be set to retain the original event name passed by the user,
	48	* so that when showing results in tools such as 'perf stat', we
	49	* show the name used, not some alias.
75562573 AH	50	* @id_pos: the position of the event id (PERF_SAMPLE_ID or
75562573 AH	51	* PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of
69d81f09	52	* struct perf_record_sample
75562573 AH	53	* @is_pos: the position (counting backwards) of the event id (PERF_SAMPLE_ID or
	54	* PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if sample_id_all
	55	* is used there is an id sample appended to non-sample events
0db15b1e	56	* @priv: And what is in its containing unnamed union are tool specific
f0c55bcf	57	*/
32dcd021	58	struct evsel {
b27c4ece	59	struct perf_evsel core;
7fedd9b8 NK	60	struct evlist *evlist;
7fedd9b8 NK	61	off_t id_offset;
7fedd9b8 NK	62	int id_pos;
	63	int is_pos;
	64	unsigned int sample_size;
	65
	66	/*
	67	* These fields can be set in the parse-events code or similar.
	68	* Please check evsel__clone() to copy them properly so that
	69	* they can be released properly.
	70	*/
	71	struct {
	72	char *name;
	73	char *group_name;
	74	const char *pmu_name;
378ef0f5	75	#ifdef HAVE_LIBTRACEEVENT
7fedd9b8	76	struct tep_event *tp_format;
378ef0f5	77	#endif
7fedd9b8 NK	78	char *filter;
	79	unsigned long max_events;
	80	double scale;
	81	const char *unit;
	82	struct cgroup *cgrp;
2b62b3a6	83	const char *metric_id;
7fedd9b8 NK	84	enum perf_tool_event tool_event;
	85	/* parse modifier helper */
	86	int exclude_GH;
	87	int sample_read;
	88	bool snapshot;
	89	bool per_pkg;
	90	bool percore;
	91	bool precise_max;
	92	bool use_uncore_alias;
	93	bool is_libpfm_event;
	94	bool auto_merge_stats;
	95	bool collect_stat;
	96	bool weak_group;
01bd8efc	97	bool bpf_counter;
2dc065ea	98	bool use_config_name;
7fedd9b8 NK	99	int bpf_fd;
7fedd9b8 NK	100	struct bpf_object *bpf_obj;
2dc065ea	101	struct list_head config_terms;
7fedd9b8 NK	102	};
	103
	104	/*
	105	* metric fields are similar, but needs more care as they can have
	106	* references to other metric (evsel).
	107	*/
	108	const char * metric_expr;
	109	const char * metric_name;
	110	struct evsel **metric_events;
	111	struct evsel *metric_leader;
	112
	113	void *handler;
c52b12ed	114	struct perf_counts *counts;
c7a79c47	115	struct perf_counts *prev_raw_counts;
a9c5e6c1	116	unsigned long nr_events_printed;
e669e833	117	struct perf_stat_evsel *stats;
616df645 CP	118	void *priv;
616df645 CP	119	u64 db_id;
80ee8c58	120	bool uniquified_name;
2cee77c4	121	bool supported;
0807d2d8	122	bool needs_swap;
b7e8452b	123	bool disabled;
6ff1ce76	124	bool no_aux_samples;
2afd2bcf	125	bool immediate;
60b0896c	126	bool tracking;
a359c17a	127	bool ignore_missing_thread;
8ef278bb	128	bool forced_leader;
15bfd2cc	129	bool cmdline_group_boundary;
430daf2d	130	bool merged_stat;
4804e011 AK	131	bool reset_group;
4804e011 AK	132	bool errored;
7df319e5	133	bool needs_auxtrace_mmap;
034f7ee1	134	struct hashmap *per_pkg_mask;
7fedd9b8	135	int err;
657ee553	136	struct {
65ddce3f ACM	137	evsel__sb_cb_t *cb;
65ddce3f ACM	138	void *data;
657ee553	139	} side_band;
e11869a0 AH	140	/*
	141	* For reporting purposes, an evsel sample can have a callchain
	142	* synthesized from AUX area data. Keep track of synthesized sample
	143	* types here. Note, the recorded sample_type cannot be changed because
	144	* it is needed to continue to parse events.
	145	* See also evsel__has_callchain().
	146	*/
	147	__u64 synth_sample_type;
7fac83aa SL	148
	149	/*
	150	* bpf_counter_ops serves two use cases:
	151	* 1. perf-stat -b counting events used byBPF programs
	152	* 2. perf-stat --use-bpf use BPF programs to aggregate counts
	153	*/
fa853c4b	154	struct bpf_counter_ops *bpf_counter_ops;
7fac83aa SL	155
	156	/* for perf-stat -b */
	157	struct list_head bpf_counter_list;
	158
	159	/* for perf-stat --use-bpf */
	160	int bperf_leader_prog_fd;
	161	int bperf_leader_link_fd;
	162	union {
	163	struct bperf_leader_bpf *leader_skel;
	164	struct bperf_follower_bpf *follower_skel;
	165	};
46def08f	166	unsigned long open_flags;
28667a52	167	int precise_ip_original;
3500eeeb NK	168
	169	/* for missing_features */
	170	struct perf_pmu *pmu;
69aad6f1 ACM	171	};
69aad6f1 ACM	172
9a831b3a ACM	173	struct perf_missing_features {
	174	bool sample_id_all;
	175	bool exclude_guest;
	176	bool mmap2;
	177	bool cloexec;
	178	bool clockid;
	179	bool clockid_wrong;
	180	bool lbr_flags;
	181	bool write_backward;
	182	bool group_read;
9aa0bfa3	183	bool ksymbol;
74a1e863	184	bool bpf;
acb9f2d4	185	bool aux_output;
d3f85437	186	bool branch_hw_idx;
8fb4b679	187	bool cgroup;
456ef4c1	188	bool data_page_size;
c1de7f3d	189	bool code_page_size;
ea8d0ed6	190	bool weight_struct;
e17f343c	191	bool read_lost;
9a831b3a ACM	192	};
	193
	194	extern struct perf_missing_features perf_missing_features;
	195
f854839b	196	struct perf_cpu_map;
86bd5e86	197	struct thread_map;
b4006796	198	struct record_opts;
86bd5e86	199
b49aca3e	200	static inline struct perf_cpu_map evsel__cpus(struct evsel evsel)
a22e99cd	201	{
0ff1a0fd	202	return perf_evsel__cpus(&evsel->core);
a22e99cd JO	203	}
a22e99cd JO	204
5eb88f04	205	static inline int evsel__nr_cpus(struct evsel *evsel)
a22e99cd	206	{
44028699	207	return perf_cpu_map__nr(evsel__cpus(evsel));
a22e99cd JO	208	}
a22e99cd JO	209
12f5261d ACM	210	void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
12f5261d ACM	211	struct perf_counts_values *count);
857a94a2	212
4c703828 ACM	213	int evsel__object_config(size_t object_size,
	214	int (init)(struct evsel evsel),
	215	void (fini)(struct evsel evsel));
ce8ccff5	216
e76026bd	217	struct perf_pmu evsel__find_pmu(struct evsel evsel);
39453ed5	218	bool evsel__is_aux_event(struct evsel *evsel);
e12ee9f7	219
8f6725a2	220	struct evsel evsel__new_idx(struct perf_event_attr attr, int idx);
ef503831	221
365c3ae7	222	static inline struct evsel evsel__new(struct perf_event_attr attr)
ef503831	223	{
8f6725a2	224	return evsel__new_idx(attr, 0);
ef503831 ACM	225	}
ef503831 ACM	226
7fedd9b8	227	struct evsel evsel__clone(struct evsel orig);
ef503831	228
a7d212fc AH	229	int copy_config_terms(struct list_head dst, struct list_head src);
	230	void free_config_terms(struct list_head *config_terms);
	231
378ef0f5 IR	232
	233	#ifdef HAVE_LIBTRACEEVENT
	234	struct evsel evsel__newtp_idx(const char sys, const char *name, int idx);
	235
8dd2a131 JO	236	/*
	237	* Returns pointer with encoded error via <linux/err.h> interface.
	238	*/
8f6725a2	239	static inline struct evsel evsel__newtp(const char sys, const char *name)
ef503831	240	{
8f6725a2	241	return evsel__newtp_idx(sys, name, 0);
ef503831	242	}
378ef0f5	243	#endif
201b7334	244
b53a0755	245	struct evsel *evsel__new_cycles(bool precise, __u32 type, __u64 config);
7c48dcfd	246
378ef0f5	247	#ifdef HAVE_LIBTRACEEVENT
97fbf3f0	248	struct tep_event event_format__new(const char sys, const char *name);
378ef0f5	249	#endif
201b7334	250
b4b62ee6	251	void evsel__init(struct evsel evsel, struct perf_event_attr attr, int idx);
30f7c591	252	void evsel__exit(struct evsel *evsel);
5eb2dd2a	253	void evsel__delete(struct evsel *evsel);
69aad6f1	254
e68ae9cf ACM	255	struct callchain_param;
e68ae9cf ACM	256
6ec17b4e ACM	257	void evsel__config(struct evsel evsel, struct record_opts opts,
	258	struct callchain_param *callchain);
	259	void evsel__config_callchain(struct evsel evsel, struct record_opts opts,
	260	struct callchain_param *callchain);
0f82ebc4	261
2aaefde4	262	int __evsel__sample_size(u64 sample_type);
4b5e87b7	263	void evsel__calc_id_pos(struct evsel *evsel);
75562573	264
c754c382	265	bool evsel__is_cache_op_valid(u8 type, u8 op);
0b668bc9	266
112cb561 SL	267	static inline bool evsel__is_bpf(struct evsel *evsel)
	268	{
	269	return evsel->bpf_counter_ops != NULL;
	270	}
	271
c64e85e1 ACM	272	#define EVSEL__MAX_ALIASES 8
c64e85e1 ACM	273
545a96c9 IR	274	extern const char *const evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX][EVSEL__MAX_ALIASES];
	275	extern const char *const evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][EVSEL__MAX_ALIASES];
	276	extern const char *const evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX][EVSEL__MAX_ALIASES];
	277	extern const char *const evsel__hw_names[PERF_COUNT_HW_MAX];
	278	extern const char *const evsel__sw_names[PERF_COUNT_SW_MAX];
112cb561 SL	279	extern char *evsel__bpf_counter_events;
112cb561 SL	280	bool evsel__match_bpf_counter_events(const char *name);
ff4207f7	281	int arch_evsel__hw_name(struct evsel evsel, char bf, size_t size);
112cb561	282
8ab2e96d ACM	283	int __evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result, char *bf, size_t size);
8ab2e96d ACM	284	const char evsel__name(struct evsel evsel);
2b62b3a6	285	const char evsel__metric_id(const struct evsel evsel);
410136f5	286
79932d16 IR	287	static inline bool evsel__is_tool(const struct evsel *evsel)
	288	{
	289	return evsel->tool_event != PERF_TOOL_NONE;
	290	}
	291
8ab2e96d	292	const char evsel__group_name(struct evsel evsel);
347c751a	293	int evsel__group_desc(struct evsel evsel, char buf, size_t size);
c410431c	294
862b2f8f ACM	295	void __evsel__set_sample_bit(struct evsel *evsel, enum perf_event_sample_format bit);
862b2f8f ACM	296	void __evsel__reset_sample_bit(struct evsel *evsel, enum perf_event_sample_format bit);
7be5ebe8	297
862b2f8f ACM	298	#define evsel__set_sample_bit(evsel, bit) \
862b2f8f ACM	299	__evsel__set_sample_bit(evsel, PERF_SAMPLE_##bit)
7be5ebe8	300
862b2f8f ACM	301	#define evsel__reset_sample_bit(evsel, bit) \
862b2f8f ACM	302	__evsel__reset_sample_bit(evsel, PERF_SAMPLE_##bit)
7be5ebe8	303
862b2f8f	304	void evsel__set_sample_id(struct evsel *evsel, bool use_sample_identifier);
7a5a5ca5	305
ea8d0ed6	306	void arch_evsel__set_sample_weight(struct evsel *evsel);
eb39bf32	307	void arch_evsel__fixup_new_cycles(struct perf_event_attr *attr);
9ab95b0b	308	void arch__post_evsel_config(struct evsel evsel, struct perf_event_attr attr);
ea8d0ed6	309
ad681adf ACM	310	int evsel__set_filter(struct evsel evsel, const char filter);
	311	int evsel__append_tp_filter(struct evsel evsel, const char filter);
	312	int evsel__append_addr_filter(struct evsel evsel, const char filter);
6f844b1f	313	int evsel__enable_cpu(struct evsel *evsel, int cpu_map_idx);
ec7f24ef	314	int evsel__enable(struct evsel *evsel);
9a10bb22	315	int evsel__disable(struct evsel *evsel);
6f844b1f	316	int evsel__disable_cpu(struct evsel *evsel, int cpu_map_idx);
745cefc5	317
6f844b1f	318	int evsel__open_per_cpu(struct evsel evsel, struct perf_cpu_map cpus, int cpu_map_idx);
aa8c406b	319	int evsel__open_per_thread(struct evsel evsel, struct perf_thread_map threads);
5972d1e0 JO	320	int evsel__open(struct evsel evsel, struct perf_cpu_map cpus,
5972d1e0 JO	321	struct perf_thread_map *threads);
88761fa1	322	void evsel__close(struct evsel *evsel);
6efd06e3 RM	323	int evsel__prepare_open(struct evsel evsel, struct perf_cpu_map cpus,
6efd06e3 RM	324	struct perf_thread_map *threads);
d21fc5f0	325	bool evsel__detect_missing_features(struct evsel *evsel);
48290609	326
71efc48a RM	327	enum rlimit_action { NO_CHANGE, SET_TO_MAX, INCREASED_MAX };
	328	bool evsel__increase_rlimit(enum rlimit_action *set_rlimit);
	329
28667a52	330	bool evsel__precise_ip_fallback(struct evsel *evsel);
da7c3b46	331
5555ded4 ACM	332	struct perf_sample;
5555ded4 ACM	333
378ef0f5	334	#ifdef HAVE_LIBTRACEEVENT
efc0cdc9 ACM	335	void evsel__rawptr(struct evsel evsel, struct perf_sample sample, const char name);
	336	u64 evsel__intval(struct evsel evsel, struct perf_sample sample, const char *name);
	337
	338	static inline char evsel__strval(struct evsel evsel, struct perf_sample sample, const char name)
5d2074ea	339	{
efc0cdc9	340	return evsel__rawptr(evsel, sample, name);
5d2074ea	341	}
378ef0f5	342	#endif
5d2074ea	343
2c92f982	344	struct tep_format_field;
efd2b924	345
2c92f982	346	u64 format_field__intval(struct tep_format_field field, struct perf_sample sample, bool needs_swap);
90525176	347
efc0cdc9	348	struct tep_format_field evsel__field(struct evsel evsel, const char *name);
efd2b924	349
c754c382	350	#define evsel__match(evsel, t, c) \
1fc632ce JO	351	(evsel->core.attr.type == PERF_TYPE_##t && \
1fc632ce JO	352	evsel->core.attr.config == PERF_COUNT_##c)
daec78a0	353
c754c382	354	static inline bool evsel__match2(struct evsel e1, struct evsel e2)
863e451f	355	{
1fc632ce JO	356	return (e1->core.attr.type == e2->core.attr.type) &&
1fc632ce JO	357	(e1->core.attr.config == e2->core.attr.config);
863e451f JO	358	}
863e451f JO	359
da8c94c0	360	int evsel__read_counter(struct evsel *evsel, int cpu_map_idx, int thread);
f7794d52	361
da8c94c0	362	int __evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread, bool scale);
c52b12ed ACM	363
c52b12ed ACM	364	/**
ea089692	365	* evsel__read_on_cpu - Read out the results on a CPU and thread
c52b12ed ACM	366	*
c52b12ed ACM	367	* @evsel - event selector to read value
da8c94c0	368	* @cpu_map_idx - CPU of interest
c52b12ed ACM	369	* @thread - thread of interest
c52b12ed ACM	370	*/
da8c94c0	371	static inline int evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread)
c52b12ed	372	{
da8c94c0	373	return __evsel__read_on_cpu(evsel, cpu_map_idx, thread, false);
c52b12ed ACM	374	}
	375
	376	/**
ea089692	377	* evsel__read_on_cpu_scaled - Read out the results on a CPU and thread, scaled
c52b12ed ACM	378	*
c52b12ed ACM	379	* @evsel - event selector to read value
da8c94c0	380	* @cpu_map_idx - CPU of interest
c52b12ed ACM	381	* @thread - thread of interest
c52b12ed ACM	382	*/
da8c94c0	383	static inline int evsel__read_on_cpu_scaled(struct evsel *evsel, int cpu_map_idx, int thread)
c52b12ed	384	{
da8c94c0	385	return __evsel__read_on_cpu(evsel, cpu_map_idx, thread, true);
c52b12ed ACM	386	}
c52b12ed ACM	387
6b6017a2 ACM	388	int evsel__parse_sample(struct evsel evsel, union perf_event event,
6b6017a2 ACM	389	struct perf_sample *sample);
0c21f736	390
6b6017a2 ACM	391	int evsel__parse_sample_timestamp(struct evsel evsel, union perf_event event,
6b6017a2 ACM	392	u64 *timestamp);
01468120	393
0a64de04 AH	394	u16 evsel__id_hdr_size(struct evsel *evsel);
0a64de04 AH	395
e470daea	396	static inline struct evsel evsel__next(struct evsel evsel)
0c21f736	397	{
b27c4ece	398	return list_entry(evsel->core.node.next, struct evsel, core.node);
0c21f736	399	}
07ac002f	400
e470daea	401	static inline struct evsel evsel__prev(struct evsel evsel)
d87fcb4a	402	{
b27c4ece	403	return list_entry(evsel->core.node.prev, struct evsel, core.node);
d87fcb4a ACM	404	}
d87fcb4a ACM	405
759ff497	406	/**
c754c382	407	* evsel__is_group_leader - Return whether given evsel is a leader event
759ff497 NK	408	*
	409	* @evsel - evsel selector to be tested
	410	*
	411	* Return %true if @evsel is a group leader or a stand-alone event
	412	*/
c754c382	413	static inline bool evsel__is_group_leader(const struct evsel *evsel)
07ac002f	414	{
fba7c866	415	return evsel->core.leader == &evsel->core;
07ac002f	416	}
0698aedd	417
759ff497	418	/**
c754c382	419	* evsel__is_group_event - Return whether given evsel is a group event
759ff497 NK	420	*
	421	* @evsel - evsel selector to be tested
	422	*
	423	* Return %true iff event group view is enabled and @evsel is a actual group
	424	* leader which has other members in the group
	425	*/
c754c382	426	static inline bool evsel__is_group_event(struct evsel *evsel)
759ff497 NK	427	{
	428	if (!symbol_conf.event_group)
	429	return false;
	430
c754c382	431	return evsel__is_group_leader(evsel) && evsel->core.nr_members > 1;
759ff497 NK	432	}
759ff497 NK	433
c754c382	434	bool evsel__is_function_event(struct evsel *evsel);
6bedfab6	435
c754c382	436	static inline bool evsel__is_bpf_output(struct evsel *evsel)
03e0a7df	437	{
c754c382	438	return evsel__match(evsel, SOFTWARE, SW_BPF_OUTPUT);
03e0a7df WN	439	}
03e0a7df WN	440
c754c382	441	static inline bool evsel__is_clock(struct evsel *evsel)
0aa802a7	442	{
c754c382 ACM	443	return evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) \|\|
c754c382 ACM	444	evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK);
0aa802a7 JO	445	}
0aa802a7 JO	446
ae430892	447	bool evsel__fallback(struct evsel evsel, int err, char msg, size_t msgsize);
2bb72dbb ACM	448	int evsel__open_strerror(struct evsel evsel, struct target target,
2bb72dbb ACM	449	int err, char *msg, size_t size);
97f63e4a	450
2bb72dbb	451	static inline int evsel__group_idx(struct evsel *evsel)
97f63e4a	452	{
fba7c866	453	return evsel->core.idx - evsel->core.leader->idx;
97f63e4a	454	}
717e263f	455
2bcf7306	456	/* Iterates group WITHOUT the leader. */
717e263f	457	#define for_each_group_member(_evsel, _leader) \
b27c4ece	458	for ((_evsel) = list_entry((_leader)->core.node.next, struct evsel, core.node); \
fba7c866	459	(_evsel) && (_evsel)->core.leader == (&_leader->core); \
b27c4ece	460	(_evsel) = list_entry((_evsel)->core.node.next, struct evsel, core.node))
717e263f	461
2bcf7306 JO	462	/* Iterates group WITH the leader. */
	463	#define for_each_group_evsel(_evsel, _leader) \
	464	for ((_evsel) = _leader; \
fba7c866	465	(_evsel) && (_evsel)->core.leader == (&_leader->core); \
b27c4ece	466	(_evsel) = list_entry((_evsel)->core.node.next, struct evsel, core.node))
2bcf7306	467
4f138a9e	468	static inline bool evsel__has_branch_callstack(const struct evsel *evsel)
384b6055	469	{
1fc632ce	470	return evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_CALL_STACK;
384b6055	471	}
2c5e8c52	472
4f138a9e	473	static inline bool evsel__has_branch_hw_idx(const struct evsel *evsel)
42bbabed KL	474	{
	475	return evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX;
	476	}
	477
32dcd021	478	static inline bool evsel__has_callchain(const struct evsel *evsel)
27de9b2b	479	{
e11869a0 AH	480	/*
	481	* For reporting purposes, an evsel sample can have a recorded callchain
	482	* or a callchain synthesized from AUX area data.
	483	*/
	484	return evsel->core.attr.sample_type & PERF_SAMPLE_CALLCHAIN \|\|
	485	evsel->synth_sample_type & PERF_SAMPLE_CALLCHAIN;
27de9b2b ACM	486	}
27de9b2b ACM	487
6cd2cbfc AH	488	static inline bool evsel__has_br_stack(const struct evsel *evsel)
	489	{
	490	/*
	491	* For reporting purposes, an evsel sample can have a recorded branch
	492	* stack or a branch stack synthesized from AUX area data.
	493	*/
	494	return evsel->core.attr.sample_type & PERF_SAMPLE_BRANCH_STACK \|\|
	495	evsel->synth_sample_type & PERF_SAMPLE_BRANCH_STACK;
	496	}
	497
442ad225 AH	498	static inline bool evsel__is_dummy_event(struct evsel *evsel)
	499	{
	500	return (evsel->core.attr.type == PERF_TYPE_SOFTWARE) &&
	501	(evsel->core.attr.config == PERF_COUNT_SW_DUMMY);
	502	}
	503
6e6d1d65	504	struct perf_env evsel__env(struct evsel evsel);
f4e47f9f	505
34397753	506	int evsel__store_ids(struct evsel evsel, struct evlist evlist);
fa853c4b	507
034f7ee1	508	void evsel__zero_per_pkg(struct evsel *evsel);
e5f4afbe	509	bool evsel__is_hybrid(const struct evsel *evsel);
fba7c866 JO	510	struct evsel evsel__leader(struct evsel evsel);
	511	bool evsel__has_leader(struct evsel evsel, struct evsel leader);
	512	bool evsel__is_leader(struct evsel *evsel);
	513	void evsel__set_leader(struct evsel evsel, struct evsel leader);
9aba0ada	514	int evsel__source_count(const struct evsel *evsel);
e8f4f794	515	void evsel__remove_from_group(struct evsel evsel, struct evsel leader);
d98079c0 IR	516
d98079c0 IR	517	bool arch_evsel__must_be_in_group(const struct evsel *evsel);
63c12ae2 MS	518
	519	/*
	520	* Macro to swap the bit-field postition and size.
	521	* Used when,
	522	* - dont need to swap the entire u64 &&
	523	* - when u64 has variable bit-field sizes &&
	524	* - when presented in a host endian which is different
	525	* than the source endian of the perf.data file
	526	*/
	527	#define bitfield_swap(src, pos, size) \
	528	((((src) >> (pos)) & ((1ull << (size)) - 1)) << (63 - ((pos) + (size) - 1)))
	529
	530	u64 evsel__bitfield_swap_branch_flags(u64 value);
69aad6f1	531	#endif /* __PERF_EVSEL_H */