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

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

#include <linux/stddef.h>
#include <linux/perf_event.h>
#include <sys/types.h>
#include <stdio.h> // FILE
#include <stdbool.h>
#include <linux/bitmap.h>
#include <linux/types.h>
#include "env.h"
#include "pmu.h"

enum {
	HEADER_RESERVED		= 0,	/* always cleared */
	HEADER_FIRST_FEATURE	= 1,
	HEADER_TRACING_DATA	= 1,
	HEADER_BUILD_ID,

	HEADER_HOSTNAME,
	HEADER_OSRELEASE,
	HEADER_VERSION,
	HEADER_ARCH,
	HEADER_NRCPUS,
	HEADER_CPUDESC,
	HEADER_CPUID,
	HEADER_TOTAL_MEM,
	HEADER_CMDLINE,
	HEADER_EVENT_DESC,
	HEADER_CPU_TOPOLOGY,
	HEADER_NUMA_TOPOLOGY,
	HEADER_BRANCH_STACK,
	HEADER_PMU_MAPPINGS,
	HEADER_GROUP_DESC,
	HEADER_AUXTRACE,
	HEADER_STAT,
	HEADER_CACHE,
	HEADER_SAMPLE_TIME,
	HEADER_MEM_TOPOLOGY,
	HEADER_CLOCKID,
	HEADER_DIR_FORMAT,
	HEADER_BPF_PROG_INFO,
	HEADER_BPF_BTF,
	HEADER_COMPRESSED,
	HEADER_CPU_PMU_CAPS,
	HEADER_CLOCK_DATA,
	HEADER_HYBRID_TOPOLOGY,
	HEADER_PMU_CAPS,
	HEADER_LAST_FEATURE,
	HEADER_FEAT_BITS	= 256,
};

enum perf_header_version {
	PERF_HEADER_VERSION_1,
	PERF_HEADER_VERSION_2,
};

struct perf_file_section {
	u64 offset;
	u64 size;
};

struct perf_file_header {
	u64				magic;
	u64				size;
	u64				attr_size;
	struct perf_file_section	attrs;
	struct perf_file_section	data;
	/* event_types is ignored */
	struct perf_file_section	event_types;
	DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
};

struct perf_pipe_file_header {
	u64				magic;
	u64				size;
};

struct perf_header;

int perf_file_header__read(struct perf_file_header *header,
			   struct perf_header *ph, int fd);

struct perf_header {
	enum perf_header_version	version;
	bool				needs_swap;
	u64				data_offset;
	u64				data_size;
	u64				feat_offset;
	DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
	struct perf_env 	env;
};

struct feat_fd {
	struct perf_header *ph;
	int		   fd;
	void		   *buf;	/* Either buf != NULL or fd >= 0 */
	ssize_t		   offset;
	size_t		   size;
	struct evsel	   *events;
};

struct perf_header_feature_ops {
	int	   (*write)(struct feat_fd *ff, struct evlist *evlist);
	void	   (*print)(struct feat_fd *ff, FILE *fp);
	int	   (*process)(struct feat_fd *ff, void *data);
	const char *name;
	bool	   full_only;
	bool	   synthesize;
};

struct evlist;
struct perf_session;
struct perf_tool;
union perf_event;

extern const char perf_version_string[];

int perf_session__read_header(struct perf_session *session, int repipe_fd);
int perf_session__write_header(struct perf_session *session,
			       struct evlist *evlist,
			       int fd, bool at_exit);
int perf_header__write_pipe(int fd);

/* feat_writer writes a feature section to output */
struct feat_writer {
	int (*write)(struct feat_writer *fw, void *buf, size_t sz);
};

/* feat_copier copies a feature section using feat_writer to output */
struct feat_copier {
	int (*copy)(struct feat_copier *fc, int feat, struct feat_writer *fw);
};

int perf_session__inject_header(struct perf_session *session,
				struct evlist *evlist,
				int fd,
				struct feat_copier *fc);

size_t perf_session__data_offset(const struct evlist *evlist);

void perf_header__set_feat(struct perf_header *header, int feat);
void perf_header__clear_feat(struct perf_header *header, int feat);
bool perf_header__has_feat(const struct perf_header *header, int feat);

int perf_header__set_cmdline(int argc, const char **argv);

int perf_header__process_sections(struct perf_header *header, int fd,
				  void *data,
				  int (*process)(struct perf_file_section *section,
				  struct perf_header *ph,
				  int feat, int fd, void *data));

int perf_header__fprintf_info(struct perf_session *s, FILE *fp, bool full);

int perf_event__process_feature(struct perf_session *session,
				union perf_event *event);
int perf_event__process_attr(struct perf_tool *tool, union perf_event *event,
			     struct evlist **pevlist);
int perf_event__process_event_update(struct perf_tool *tool,
				     union perf_event *event,
				     struct evlist **pevlist);
size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp);
#ifdef HAVE_LIBTRACEEVENT
int perf_event__process_tracing_data(struct perf_session *session,
				     union perf_event *event);
#endif
int perf_event__process_build_id(struct perf_session *session,
				 union perf_event *event);
bool is_perf_magic(u64 magic);

#define NAME_ALIGN 64

struct feat_fd;

int do_write(struct feat_fd *fd, const void *buf, size_t size);

int write_padded(struct feat_fd *fd, const void *bf,
		 size_t count, size_t count_aligned);

#define MAX_CACHE_LVL 4

int is_cpu_online(unsigned int cpu);
int build_caches_for_cpu(u32 cpu, struct cpu_cache_level caches[], u32 *cntp);

/*
 * arch specific callback
 */
int get_cpuid(char *buffer, size_t sz);

char *get_cpuid_str(struct perf_pmu *pmu __maybe_unused);
int strcmp_cpuid_str(const char *s1, const char *s2);
#endif /* __PERF_HEADER_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
8b40f521 JK	2	#ifndef __PERF_HEADER_H
8b40f521 JK	3	#define __PERF_HEADER_H
7c6a1c65	4
44fe619b	5	#include <linux/stddef.h>
d2709c7c	6	#include <linux/perf_event.h>
7c6a1c65	7	#include <sys/types.h>
27830616	8	#include <stdio.h> // FILE
8d06367f	9	#include <stdbool.h>
d944c4ee BP	10	#include <linux/bitmap.h>
d944c4ee BP	11	#include <linux/types.h>
f0ce888c	12	#include "env.h"
54e32dc0	13	#include "pmu.h"
db9f11e3	14
37562eac	15	enum {
b1e5a9be	16	HEADER_RESERVED = 0, /* always cleared */
781ba9d2	17	HEADER_FIRST_FEATURE = 1,
2eeaaa09	18	HEADER_TRACING_DATA = 1,
37562eac	19	HEADER_BUILD_ID,
fbe96f29 SE	20
	21	HEADER_HOSTNAME,
	22	HEADER_OSRELEASE,
	23	HEADER_VERSION,
	24	HEADER_ARCH,
	25	HEADER_NRCPUS,
	26	HEADER_CPUDESC,
	27	HEADER_CPUID,
	28	HEADER_TOTAL_MEM,
	29	HEADER_CMDLINE,
	30	HEADER_EVENT_DESC,
	31	HEADER_CPU_TOPOLOGY,
	32	HEADER_NUMA_TOPOLOGY,
330aa675	33	HEADER_BRANCH_STACK,
50a9667c	34	HEADER_PMU_MAPPINGS,
a8bb559b	35	HEADER_GROUP_DESC,
4025ea40	36	HEADER_AUXTRACE,
ffa517ad	37	HEADER_STAT,
720e98b5	38	HEADER_CACHE,
6011518d	39	HEADER_SAMPLE_TIME,
e2091ced	40	HEADER_MEM_TOPOLOGY,
cf790516	41	HEADER_CLOCKID,
258031c0	42	HEADER_DIR_FORMAT,
606f972b	43	HEADER_BPF_PROG_INFO,
a70a1123	44	HEADER_BPF_BTF,
42e1fd80	45	HEADER_COMPRESSED,
6f91ea28	46	HEADER_CPU_PMU_CAPS,
d1e325cf	47	HEADER_CLOCK_DATA,
f7d74ce3	48	HEADER_HYBRID_TOPOLOGY,
2139f742	49	HEADER_PMU_CAPS,
37562eac	50	HEADER_LAST_FEATURE,
b1e5a9be	51	HEADER_FEAT_BITS = 256,
37562eac	52	};
2ba08250	53
2a08c3ec JO	54	enum perf_header_version {
	55	PERF_HEADER_VERSION_1,
	56	PERF_HEADER_VERSION_2,
	57	};
	58
37562eac ACM	59	struct perf_file_section {
	60	u64 offset;
	61	u64 size;
	62	};
	63
	64	struct perf_file_header {
	65	u64 magic;
	66	u64 size;
	67	u64 attr_size;
	68	struct perf_file_section attrs;
	69	struct perf_file_section data;
44b3c578	70	/* event_types is ignored */
37562eac ACM	71	struct perf_file_section event_types;
	72	DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
	73	};
	74
8dc58101 TZ	75	struct perf_pipe_file_header {
	76	u64 magic;
	77	u64 size;
	78	};
	79
37562eac ACM	80	struct perf_header;
37562eac ACM	81
1c0b04d1	82	int perf_file_header__read(struct perf_file_header *header,
37562eac ACM	83	struct perf_header *ph, int fd);
37562eac ACM	84
7c6a1c65	85	struct perf_header {
2a08c3ec JO	86	enum perf_header_version version;
	87	bool needs_swap;
	88	u64 data_offset;
	89	u64 data_size;
	90	u64 feat_offset;
db9f11e3	91	DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
ce80d3be	92	struct perf_env env;
7c6a1c65 PZ	93	};
7c6a1c65 PZ	94
055c67ed ACM	95	struct feat_fd {
	96	struct perf_header *ph;
	97	int fd;
	98	void buf; / Either buf != NULL or fd >= 0 */
	99	ssize_t offset;
	100	size_t size;
	101	struct evsel *events;
	102	};
	103
	104	struct perf_header_feature_ops {
	105	int (write)(struct feat_fd ff, struct evlist *evlist);
	106	void (print)(struct feat_fd ff, FILE *fp);
	107	int (process)(struct feat_fd ff, void *data);
	108	const char *name;
	109	bool full_only;
	110	bool synthesize;
	111	};
	112
63503dba	113	struct evlist;
d20deb64	114	struct perf_session;
27830616 ACM	115	struct perf_tool;
27830616 ACM	116	union perf_event;
361c99a6	117
8641661c IR	118	extern const char perf_version_string[];
8641661c IR	119
0ae03893	120	int perf_session__read_header(struct perf_session *session, int repipe_fd);
a91e5431	121	int perf_session__write_header(struct perf_session *session,
63503dba	122	struct evlist *evlist,
a91e5431	123	int fd, bool at_exit);
8dc58101	124	int perf_header__write_pipe(int fd);
7c6a1c65	125
237c96b8 AH	126	/* feat_writer writes a feature section to output */
	127	struct feat_writer {
	128	int (write)(struct feat_writer fw, void *buf, size_t sz);
	129	};
	130
	131	/* feat_copier copies a feature section using feat_writer to output */
	132	struct feat_copier {
	133	int (copy)(struct feat_copier fc, int feat, struct feat_writer *fw);
	134	};
	135
180b3d06 AH	136	int perf_session__inject_header(struct perf_session *session,
	137	struct evlist *evlist,
	138	int fd,
	139	struct feat_copier *fc);
	140
37ed2cdd RS	141	size_t perf_session__data_offset(const struct evlist *evlist);
37ed2cdd RS	142
1c0b04d1 ACM	143	void perf_header__set_feat(struct perf_header *header, int feat);
	144	void perf_header__clear_feat(struct perf_header *header, int feat);
	145	bool perf_header__has_feat(const struct perf_header *header, int feat);
7c6a1c65	146
fbe96f29 SE	147	int perf_header__set_cmdline(int argc, const char **argv);
fbe96f29 SE	148
1c0b04d1	149	int perf_header__process_sections(struct perf_header *header, int fd,
fbe96f29	150	void *data,
1c0b04d1	151	int (process)(struct perf_file_section section,
fbe96f29 SE	152	struct perf_header *ph,
	153	int feat, int fd, void *data));
	154
	155	int perf_header__fprintf_info(struct perf_session s, FILE fp, bool full);
37562eac	156
89f1688a JO	157	int perf_event__process_feature(struct perf_session *session,
89f1688a JO	158	union perf_event *event);
47c3d109	159	int perf_event__process_attr(struct perf_tool tool, union perf_event event,
63503dba	160	struct evlist **pevlist);
b8f8eb84	161	int perf_event__process_event_update(struct perf_tool *tool,
ffe77725	162	union perf_event *event,
63503dba	163	struct evlist **pevlist);
c853f939	164	size_t perf_event__fprintf_event_update(union perf_event event, FILE fp);
378ef0f5	165	#ifdef HAVE_LIBTRACEEVENT
89f1688a JO	166	int perf_event__process_tracing_data(struct perf_session *session,
89f1688a JO	167	union perf_event *event);
378ef0f5	168	#endif
89f1688a JO	169	int perf_event__process_build_id(struct perf_session *session,
89f1688a JO	170	union perf_event *event);
e84ba4e2	171	bool is_perf_magic(u64 magic);
fbe96f29	172
e195fac8 NK	173	#define NAME_ALIGN 64
e195fac8 NK	174
ccebbeb6	175	struct feat_fd;
3b8f51a6	176
ccebbeb6 DCC	177	int do_write(struct feat_fd fd, const void buf, size_t size);
	178
	179	int write_padded(struct feat_fd fd, const void bf,
	180	size_t count, size_t count_aligned);
1f625b0b	181
2b72cec9 PN	182	#define MAX_CACHE_LVL 4
2b72cec9 PN	183
8cb7a188	184	int is_cpu_online(unsigned int cpu);
2b72cec9 PN	185	int build_caches_for_cpu(u32 cpu, struct cpu_cache_level caches[], u32 *cntp);
2b72cec9 PN	186
fbe96f29 SE	187	/*
	188	* arch specific callback
	189	*/
	190	int get_cpuid(char *buffer, size_t sz);
	191
54e32dc0	192	char get_cpuid_str(struct perf_pmu pmu __maybe_unused);
4cb7d3ec	193	int strcmp_cpuid_str(const char s1, const char s2);
8b40f521	194	#endif /* __PERF_HEADER_H */