/* SPDX-License-Identifier: GPL-2.0 */#ifndef __LIBPERF_INTERNAL_EVSEL_H#define __LIBPERF_INTERNAL_EVSEL_H #include <linux/types.h>#include <linux/perf_event.h>#include <stdbool.h>#include <sys/types.h>#include <internal/cpumap.h> struct perf_thread_map;struct xyarray; /** * The per-thread accumulated period storage node. */struct perf_sample_id_period {	struct list_head	node;	struct hlist_node	hnode;	/* Holds total ID period value for PERF_SAMPLE_READ processing. */	u64			period;	/* The TID that the values belongs to */	u32			tid;}; /** * perf_evsel_for_each_per_thread_period_safe - safely iterate thru all the * per_stream_periods * @evlist:perf_evsel instance to iterate * @item: struct perf_sample_id_period iterator * @tmp: struct perf_sample_id_period temp iterator */#define perf_evsel_for_each_per_thread_period_safe(evsel, tmp, item) \	list_for_each_entry_safe(item, tmp, &(evsel)->per_stream_periods, node)  #define PERF_SAMPLE_ID__HLIST_BITS 4#define PERF_SAMPLE_ID__HLIST_SIZE (1 << PERF_SAMPLE_ID__HLIST_BITS) /* * Per fd, to map back from PERF_SAMPLE_ID to evsel, only used when there are * more than one entry in the evlist. */struct perf_sample_id {	struct hlist_node	 node;	u64			 id;	struct perf_evsel	*evsel;       /*	* 'idx' will be used for AUX area sampling. A sample will have AUX area	* data that will be queued for decoding, where there are separate	* queues for each CPU (per-cpu tracing) or task (per-thread tracing).	* The sample ID can be used to lookup 'idx' which is effectively the	* queue number.	*/	int			 idx;	struct perf_cpu		 cpu;	pid_t			 tid; 	/* Guest machine pid and VCPU, valid only if machine_pid is non-zero */	pid_t			 machine_pid;	struct perf_cpu		 vcpu; 	/*	 * Per-thread, and global event counts are mutually exclusive:	 * Whilst it is possible to combine events into a group with differing	 * values of PERF_SAMPLE_READ, it is not valid to have inconsistent	 * values for `inherit`. Therefore it is not possible to have a	 * situation where a per-thread event is sampled as a global event;	 * all !inherit groups are global, and all groups where the sampling	 * event is inherit + PERF_SAMPLE_READ will be per-thread. Any event	 * that is part of such a group that is inherit but not PERF_SAMPLE_READ	 * will be read as per-thread. If such an event can also trigger a	 * sample (such as with sample_period > 0) then it will not cause	 * `read_format` to be included in its PERF_RECORD_SAMPLE, and	 * therefore will not expose the per-thread group members as global.	 */	union {		/*		 * Holds total ID period value for PERF_SAMPLE_READ processing		 * (when period is not per-thread).		 */		u64			period;		/*		 * Holds total ID period value for PERF_SAMPLE_READ processing		 * (when period is per-thread).		 */		struct hlist_head	periods[PERF_SAMPLE_ID__HLIST_SIZE];	};}; struct perf_evsel {	struct list_head	 node;	struct perf_event_attr	 attr;	/** The commonly used cpu map of CPUs the event should be opened upon, etc. */	struct perf_cpu_map	*cpus;	/**	 * The cpu map read from the PMU. For core PMUs this is the list of all	 * CPUs the event can be opened upon. For other PMUs this is the default	 * cpu map for opening the event on, for example, the first CPU on a	 * socket for an uncore event.	 */	struct perf_cpu_map	*pmu_cpus;	struct perf_thread_map	*threads;	struct xyarray		*fd;	struct xyarray		*mmap;	struct xyarray		*sample_id;	u64			*id;	u32			 ids;	struct perf_evsel	*leader; 	/* For events where the read_format value is per-thread rather than	 * global, stores the per-thread cumulative period */	struct list_head	per_stream_periods; 	/* parse modifier helper */	int			 nr_members;	/*	 * system_wide is for events that need to be on every CPU, irrespective	 * of user requested CPUs or threads. Tha main example of this is the	 * dummy event. Map propagation will set cpus for this event to all CPUs	 * as software PMU events like dummy, have a CPU map that is empty.	 */	bool			 system_wide;	/*	 * Some events, for example uncore events, require a CPU.	 * i.e. it cannot be the 'any CPU' value of -1.	 */	bool			 requires_cpu;	/** Is the PMU for the event a core one? Effects the handling of own_cpus. */	bool			 is_pmu_core;	/** Does the evsel on read on the first CPU index such as tool time events? */	bool			 reads_only_on_cpu_idx0;	int			 idx;}; void perf_evsel__init(struct perf_evsel *evsel, struct perf_event_attr *attr,		      int idx);void perf_evsel__exit(struct perf_evsel *evsel);int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);void perf_evsel__close_fd(struct perf_evsel *evsel);void perf_evsel__free_fd(struct perf_evsel *evsel);int perf_evsel__read_size(struct perf_evsel *evsel);int perf_evsel__apply_filter(struct perf_evsel *evsel, const char *filter); int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads);void perf_evsel__free_id(struct perf_evsel *evsel); bool perf_evsel__attr_has_per_thread_sample_period(struct perf_evsel *evsel); u64 *perf_sample_id__get_period_storage(struct perf_sample_id *sid, u32 tid,					bool per_thread); #endif /* __LIBPERF_INTERNAL_EVSEL_H */