event.h 16.8 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
2 3
#ifndef __PERF_RECORD_H
#define __PERF_RECORD_H
4

5
#include <limits.h>
6
#include <stdio.h>
7
#include <linux/kernel.h>
8
#include <linux/bpf.h>
9
#include <linux/perf_event.h>
10
#include <perf/event.h>
11

12
#include "../perf.h"
13
#include "build-id.h"
14
#include "perf_regs.h"
15

16 17 18 19 20 21 22 23 24
#ifdef __LP64__
/*
 * /usr/include/inttypes.h uses just 'lu' for PRIu64, but we end up defining
 * __u64 as long long unsigned int, and then -Werror=format= kicks in and
 * complains of the mismatched types, so use these two special extra PRI
 * macros to overcome that.
 */
#define PRI_lu64 "l" PRIu64
#define PRI_lx64 "l" PRIx64
25
#define PRI_ld64 "l" PRId64
26 27 28
#else
#define PRI_lu64 PRIu64
#define PRI_lx64 PRIx64
29
#define PRI_ld64 PRId64
30
#endif
31

32 33 34 35
#define PERF_SAMPLE_MASK				\
	(PERF_SAMPLE_IP | PERF_SAMPLE_TID |		\
	 PERF_SAMPLE_TIME | PERF_SAMPLE_ADDR |		\
	PERF_SAMPLE_ID | PERF_SAMPLE_STREAM_ID |	\
36 37
	 PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD |		\
	 PERF_SAMPLE_IDENTIFIER)
38

39 40 41
/* perf sample has 16 bits size limit */
#define PERF_SAMPLE_MAX_SIZE (1 << 16)

42
struct regs_dump {
43
	u64 abi;
44
	u64 mask;
45
	u64 *regs;
46 47 48 49

	/* Cached values/mask filled by first register access. */
	u64 cache_regs[PERF_REGS_MAX];
	u64 cache_mask;
50 51 52 53 54 55 56 57
};

struct stack_dump {
	u16 offset;
	u64 size;
	char *data;
};

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
struct sample_read_value {
	u64 value;
	u64 id;
};

struct sample_read {
	u64 time_enabled;
	u64 time_running;
	union {
		struct {
			u64 nr;
			struct sample_read_value *values;
		} group;
		struct sample_read_value one;
	};
};

75 76 77 78 79
struct ip_callchain {
	u64 nr;
	u64 ips[0];
};

80
struct branch_stack;
81

82 83 84 85 86 87 88 89 90 91 92 93 94 95
enum {
	PERF_IP_FLAG_BRANCH		= 1ULL << 0,
	PERF_IP_FLAG_CALL		= 1ULL << 1,
	PERF_IP_FLAG_RETURN		= 1ULL << 2,
	PERF_IP_FLAG_CONDITIONAL	= 1ULL << 3,
	PERF_IP_FLAG_SYSCALLRET		= 1ULL << 4,
	PERF_IP_FLAG_ASYNC		= 1ULL << 5,
	PERF_IP_FLAG_INTERRUPT		= 1ULL << 6,
	PERF_IP_FLAG_TX_ABORT		= 1ULL << 7,
	PERF_IP_FLAG_TRACE_BEGIN	= 1ULL << 8,
	PERF_IP_FLAG_TRACE_END		= 1ULL << 9,
	PERF_IP_FLAG_IN_TX		= 1ULL << 10,
};

96 97
#define PERF_IP_FLAG_CHARS "bcrosyiABEx"

98 99 100 101 102 103 104 105 106 107 108 109
#define PERF_BRANCH_MASK		(\
	PERF_IP_FLAG_BRANCH		|\
	PERF_IP_FLAG_CALL		|\
	PERF_IP_FLAG_RETURN		|\
	PERF_IP_FLAG_CONDITIONAL	|\
	PERF_IP_FLAG_SYSCALLRET		|\
	PERF_IP_FLAG_ASYNC		|\
	PERF_IP_FLAG_INTERRUPT		|\
	PERF_IP_FLAG_TX_ABORT		|\
	PERF_IP_FLAG_TRACE_BEGIN	|\
	PERF_IP_FLAG_TRACE_END)

110 111
#define MAX_INSN 16

112
struct perf_sample {
113 114 115 116 117 118 119
	u64 ip;
	u32 pid, tid;
	u64 time;
	u64 addr;
	u64 id;
	u64 stream_id;
	u64 period;
120
	u64 weight;
121
	u64 transaction;
122 123
	u64 insn_cnt;
	u64 cyc_cnt;
124
	u32 cpu;
125
	u32 raw_size;
126
	u64 data_src;
127
	u64 phys_addr;
128 129
	u32 flags;
	u16 insn_len;
130
	u8  cpumode;
131
	u16 misc;
132
	char insn[MAX_INSN];
133
	void *raw_data;
134
	struct ip_callchain *callchain;
135
	struct branch_stack *branch_stack;
136
	struct regs_dump  user_regs;
137
	struct regs_dump  intr_regs;
138
	struct stack_dump user_stack;
139
	struct sample_read read;
140 141
};

142 143 144 145 146 147 148
#define PERF_MEM_DATA_SRC_NONE \
	(PERF_MEM_S(OP, NA) |\
	 PERF_MEM_S(LVL, NA) |\
	 PERF_MEM_S(SNOOP, NA) |\
	 PERF_MEM_S(LOCK, NA) |\
	 PERF_MEM_S(TLB, NA))

149
enum perf_user_event_type { /* above any possible kernel type */
150
	PERF_RECORD_USER_TYPE_START		= 64,
151
	PERF_RECORD_HEADER_ATTR			= 64,
K
Kim Phillips 已提交
152
	PERF_RECORD_HEADER_EVENT_TYPE		= 65, /* deprecated */
153
	PERF_RECORD_HEADER_TRACING_DATA		= 66,
154
	PERF_RECORD_HEADER_BUILD_ID		= 67,
155
	PERF_RECORD_FINISHED_ROUND		= 68,
A
Adrian Hunter 已提交
156
	PERF_RECORD_ID_INDEX			= 69,
157 158
	PERF_RECORD_AUXTRACE_INFO		= 70,
	PERF_RECORD_AUXTRACE			= 71,
159
	PERF_RECORD_AUXTRACE_ERROR		= 72,
160
	PERF_RECORD_THREAD_MAP			= 73,
161
	PERF_RECORD_CPU_MAP			= 74,
162
	PERF_RECORD_STAT_CONFIG			= 75,
J
Jiri Olsa 已提交
163
	PERF_RECORD_STAT			= 76,
164
	PERF_RECORD_STAT_ROUND			= 77,
165
	PERF_RECORD_EVENT_UPDATE		= 78,
166
	PERF_RECORD_TIME_CONV			= 79,
167
	PERF_RECORD_HEADER_FEATURE		= 80,
168
	PERF_RECORD_COMPRESSED			= 81,
169 170 171
	PERF_RECORD_HEADER_MAX
};

172 173 174 175 176
enum auxtrace_error_type {
	PERF_AUXTRACE_ERROR_ITRACE  = 1,
	PERF_AUXTRACE_ERROR_MAX
};

177 178 179
/* Attribute type for custom synthesized events */
#define PERF_TYPE_SYNTH		(INT_MAX + 1U)

180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
/* Attribute config for custom synthesized events */
enum perf_synth_id {
	PERF_SYNTH_INTEL_PTWRITE,
	PERF_SYNTH_INTEL_MWAIT,
	PERF_SYNTH_INTEL_PWRE,
	PERF_SYNTH_INTEL_EXSTOP,
	PERF_SYNTH_INTEL_PWRX,
	PERF_SYNTH_INTEL_CBR,
};

/*
 * Raw data formats for synthesized events. Note that 4 bytes of padding are
 * present to match the 'size' member of PERF_SAMPLE_RAW data which is always
 * 8-byte aligned. That means we must dereference raw_data with an offset of 4.
 * Refer perf_sample__synth_ptr() and perf_synth__raw_data().  It also means the
 * structure sizes are 4 bytes bigger than the raw_size, refer
 * perf_synth__raw_size().
 */

struct perf_synth_intel_ptwrite {
	u32 padding;
	union {
		struct {
			u32	ip		:  1,
				reserved	: 31;
		};
		u32	flags;
	};
	u64	payload;
};

struct perf_synth_intel_mwait {
	u32 padding;
	u32 reserved;
	union {
		struct {
			u64	hints		:  8,
				reserved1	: 24,
				extensions	:  2,
				reserved2	: 30;
		};
		u64	payload;
	};
};

struct perf_synth_intel_pwre {
	u32 padding;
	u32 reserved;
	union {
		struct {
			u64	reserved1	:  7,
				hw		:  1,
				subcstate	:  4,
				cstate		:  4,
				reserved2	: 48;
		};
		u64	payload;
	};
};

struct perf_synth_intel_exstop {
	u32 padding;
	union {
		struct {
			u32	ip		:  1,
				reserved	: 31;
		};
		u32	flags;
	};
};

struct perf_synth_intel_pwrx {
	u32 padding;
	u32 reserved;
	union {
		struct {
			u64	deepest_cstate	:  4,
				last_cstate	:  4,
				wake_reason	:  4,
				reserved1	: 52;
		};
		u64	payload;
	};
};

struct perf_synth_intel_cbr {
	u32 padding;
	union {
		struct {
			u32	cbr		:  8,
				reserved1	:  8,
				max_nonturbo	:  8,
				reserved2	:  8;
		};
		u32	flags;
	};
	u32 freq;
	u32 reserved3;
};

/*
 * raw_data is always 4 bytes from an 8-byte boundary, so subtract 4 to get
 * 8-byte alignment.
 */
static inline void *perf_sample__synth_ptr(struct perf_sample *sample)
{
	return sample->raw_data - 4;
}

static inline void *perf_synth__raw_data(void *p)
{
	return p + 4;
}

#define perf_synth__raw_size(d) (sizeof(d) - 4)

#define perf_sample__bad_synth_size(s, d) ((s)->raw_size < sizeof(d) - 4)

298 299 300 301 302
/*
 * The kernel collects the number of events it couldn't send in a stretch and
 * when possible sends this number in a PERF_RECORD_LOST event. The number of
 * such "chunks" of lost events is stored in .nr_events[PERF_EVENT_LOST] while
 * total_lost tells exactly how many events the kernel in fact lost, i.e. it is
303
 * the sum of all struct perf_record_lost.lost fields reported.
304
 *
305 306 307 308
 * The kernel discards mixed up samples and sends the number in a
 * PERF_RECORD_LOST_SAMPLES event. The number of lost-samples events is stored
 * in .nr_events[PERF_RECORD_LOST_SAMPLES] while total_lost_samples tells
 * exactly how many samples the kernel in fact dropped, i.e. it is the sum of
309
 * all struct perf_record_lost_samples.lost fields reported.
310
 *
311 312 313
 * The total_period is needed because by default auto-freq is used, so
 * multipling nr_events[PERF_EVENT_SAMPLE] by a frequency isn't possible to get
 * the total number of low level events, it is necessary to to sum all struct
314
 * perf_record_sample.period and stash the result in total_period.
315 316 317 318 319
 */
struct events_stats {
	u64 total_period;
	u64 total_non_filtered_period;
	u64 total_lost;
320
	u64 total_lost_samples;
321
	u64 total_aux_lost;
322
	u64 total_aux_partial;
323 324 325 326 327 328 329 330
	u64 total_invalid_chains;
	u32 nr_events[PERF_RECORD_HEADER_MAX];
	u32 nr_non_filtered_samples;
	u32 nr_lost_warned;
	u32 nr_unknown_events;
	u32 nr_invalid_chains;
	u32 nr_unknown_id;
	u32 nr_unprocessable_samples;
331
	u32 nr_auxtrace_errors[PERF_AUXTRACE_ERROR_MAX];
332
	u32 nr_proc_map_timeout;
333 334
};

335 336 337 338 339 340 341 342 343 344 345
struct thread_map_event_entry {
	u64	pid;
	char	comm[16];
};

struct thread_map_event {
	struct perf_event_header	header;
	u64				nr;
	struct thread_map_event_entry	entries[];
};

346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
enum {
	PERF_STAT_CONFIG_TERM__AGGR_MODE	= 0,
	PERF_STAT_CONFIG_TERM__INTERVAL		= 1,
	PERF_STAT_CONFIG_TERM__SCALE		= 2,
	PERF_STAT_CONFIG_TERM__MAX		= 3,
};

struct stat_config_event_entry {
	u64	tag;
	u64	val;
};

struct stat_config_event {
	struct perf_event_header	header;
	u64				nr;
	struct stat_config_event_entry	data[];
};

J
Jiri Olsa 已提交
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
struct stat_event {
	struct perf_event_header	header;

	u64	id;
	u32	cpu;
	u32	thread;

	union {
		struct {
			u64 val;
			u64 ena;
			u64 run;
		};
		u64 values[3];
	};
};

381 382 383 384 385 386 387 388 389 390 391
enum {
	PERF_STAT_ROUND_TYPE__INTERVAL	= 0,
	PERF_STAT_ROUND_TYPE__FINAL	= 1,
};

struct stat_round_event {
	struct perf_event_header	header;
	u64				type;
	u64				time;
};

392 393 394 395 396 397 398
struct time_conv_event {
	struct perf_event_header header;
	u64 time_shift;
	u64 time_mult;
	u64 time_zero;
};

399 400 401 402 403 404
struct feature_event {
	struct perf_event_header 	header;
	u64				feat_id;
	char				data[];
};

405 406 407 408 409
struct compressed_event {
	struct perf_event_header	header;
	char				data[];
};

410
union perf_event {
411
	struct perf_event_header	header;
412 413 414 415 416 417 418 419 420 421
	struct perf_record_mmap		mmap;
	struct perf_record_mmap2	mmap2;
	struct perf_record_comm		comm;
	struct perf_record_namespaces	namespaces;
	struct perf_record_fork		fork;
	struct perf_record_lost		lost;
	struct perf_record_lost_samples	lost_samples;
	struct perf_record_read		read;
	struct perf_record_throttle	throttle;
	struct perf_record_sample	sample;
422
	struct perf_record_bpf_event	bpf;
423
	struct perf_record_ksymbol	ksymbol;
424
	struct attr_event		attr;
425
	struct event_update_event	event_update;
426
	struct event_type_event		event_type;
427
	struct tracing_data_event	tracing_data;
428
	struct build_id_event		build_id;
A
Adrian Hunter 已提交
429
	struct id_index_event		id_index;
430 431
	struct auxtrace_info_event	auxtrace_info;
	struct auxtrace_event		auxtrace;
432
	struct auxtrace_error_event	auxtrace_error;
433
	struct aux_event		aux;
434
	struct itrace_start_event	itrace_start;
435
	struct context_switch_event	context_switch;
436
	struct thread_map_event		thread_map;
437
	struct cpu_map_event		cpu_map;
438
	struct stat_config_event	stat_config;
J
Jiri Olsa 已提交
439
	struct stat_event		stat;
440
	struct stat_round_event		stat_round;
441
	struct time_conv_event		time_conv;
442
	struct feature_event		feat;
443
	struct compressed_event		pack;
444
};
445

446
void perf_event__print_totals(void);
447

448
struct perf_tool;
449
struct perf_thread_map;
450
struct perf_cpu_map;
451
struct perf_stat_config;
452
struct perf_counts_values;
453

454
typedef int (*perf_event__handler_t)(struct perf_tool *tool,
455
				     union perf_event *event,
456
				     struct perf_sample *sample,
457
				     struct machine *machine);
458

459
int perf_event__synthesize_thread_map(struct perf_tool *tool,
460
				      struct perf_thread_map *threads,
461
				      perf_event__handler_t process,
462
				      struct machine *machine, bool mmap_data);
463
int perf_event__synthesize_thread_map2(struct perf_tool *tool,
464
				      struct perf_thread_map *threads,
465 466
				      perf_event__handler_t process,
				      struct machine *machine);
467
int perf_event__synthesize_cpu_map(struct perf_tool *tool,
468
				   struct perf_cpu_map *cpus,
469 470
				   perf_event__handler_t process,
				   struct machine *machine);
471
int perf_event__synthesize_threads(struct perf_tool *tool,
472
				   perf_event__handler_t process,
473
				   struct machine *machine, bool mmap_data,
474
				   unsigned int nr_threads_synthesize);
475
int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
476
				       perf_event__handler_t process,
477
				       struct machine *machine);
478 479 480 481
int perf_event__synthesize_stat_config(struct perf_tool *tool,
				       struct perf_stat_config *config,
				       perf_event__handler_t process,
				       struct machine *machine);
482 483
void perf_event__read_stat_config(struct perf_stat_config *config,
				  struct stat_config_event *event);
484 485 486 487 488
int perf_event__synthesize_stat(struct perf_tool *tool,
				u32 cpu, u32 thread, u64 id,
				struct perf_counts_values *count,
				perf_event__handler_t process,
				struct machine *machine);
489 490 491 492
int perf_event__synthesize_stat_round(struct perf_tool *tool,
				      u64 time, u64 type,
				      perf_event__handler_t process,
				      struct machine *machine);
493
int perf_event__synthesize_modules(struct perf_tool *tool,
494
				   perf_event__handler_t process,
495 496
				   struct machine *machine);

497
int perf_event__process_comm(struct perf_tool *tool,
498 499
			     union perf_event *event,
			     struct perf_sample *sample,
500
			     struct machine *machine);
501
int perf_event__process_lost(struct perf_tool *tool,
502 503
			     union perf_event *event,
			     struct perf_sample *sample,
504
			     struct machine *machine);
505 506 507 508
int perf_event__process_lost_samples(struct perf_tool *tool,
				     union perf_event *event,
				     struct perf_sample *sample,
				     struct machine *machine);
509 510 511 512
int perf_event__process_aux(struct perf_tool *tool,
			    union perf_event *event,
			    struct perf_sample *sample,
			    struct machine *machine);
513 514 515 516
int perf_event__process_itrace_start(struct perf_tool *tool,
				     union perf_event *event,
				     struct perf_sample *sample,
				     struct machine *machine);
517 518 519 520
int perf_event__process_switch(struct perf_tool *tool,
			       union perf_event *event,
			       struct perf_sample *sample,
			       struct machine *machine);
521 522 523 524
int perf_event__process_namespaces(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct machine *machine);
525
int perf_event__process_mmap(struct perf_tool *tool,
526 527
			     union perf_event *event,
			     struct perf_sample *sample,
528
			     struct machine *machine);
529 530 531 532
int perf_event__process_mmap2(struct perf_tool *tool,
			     union perf_event *event,
			     struct perf_sample *sample,
			     struct machine *machine);
533 534 535 536 537
int perf_event__process_fork(struct perf_tool *tool,
			     union perf_event *event,
			     struct perf_sample *sample,
			     struct machine *machine);
int perf_event__process_exit(struct perf_tool *tool,
538 539
			     union perf_event *event,
			     struct perf_sample *sample,
540
			     struct machine *machine);
541 542 543 544
int perf_event__process_ksymbol(struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct machine *machine);
545 546 547 548
int perf_event__process_bpf(struct perf_tool *tool,
			    union perf_event *event,
			    struct perf_sample *sample,
			    struct machine *machine);
549 550 551 552
int perf_tool__process_synth_event(struct perf_tool *tool,
				   union perf_event *event,
				   struct machine *machine,
				   perf_event__handler_t process);
553
int perf_event__process(struct perf_tool *tool,
554 555
			union perf_event *event,
			struct perf_sample *sample,
556
			struct machine *machine);
557

558
struct addr_location;
559

560 561
int machine__resolve(struct machine *machine, struct addr_location *al,
		     struct perf_sample *sample);
562

563 564
void addr_location__put(struct addr_location *al);

565 566 567 568
struct thread;

bool is_bts_event(struct perf_event_attr *attr);
bool sample_addr_correlates_sym(struct perf_event_attr *attr);
569 570
void thread__resolve(struct thread *thread, struct addr_location *al,
		     struct perf_sample *sample);
571

572
const char *perf_event__name(unsigned int id);
573

574
size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,
575
				     u64 read_format);
576
int perf_event__synthesize_sample(union perf_event *event, u64 type,
577
				  u64 read_format,
578
				  const struct perf_sample *sample);
579

580 581 582 583 584
pid_t perf_event__synthesize_comm(struct perf_tool *tool,
				  union perf_event *event, pid_t pid,
				  perf_event__handler_t process,
				  struct machine *machine);

585 586 587 588 589 590
int perf_event__synthesize_namespaces(struct perf_tool *tool,
				      union perf_event *event,
				      pid_t pid, pid_t tgid,
				      perf_event__handler_t process,
				      struct machine *machine);

591 592 593 594 595
int perf_event__synthesize_mmap_events(struct perf_tool *tool,
				       union perf_event *event,
				       pid_t pid, pid_t tgid,
				       perf_event__handler_t process,
				       struct machine *machine,
596
				       bool mmap_data);
597

598 599 600 601
int perf_event__synthesize_extra_kmaps(struct perf_tool *tool,
				       perf_event__handler_t process,
				       struct machine *machine);

602 603
size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp);
size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp);
604
size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp);
605
size_t perf_event__fprintf_task(union perf_event *event, FILE *fp);
606
size_t perf_event__fprintf_aux(union perf_event *event, FILE *fp);
607
size_t perf_event__fprintf_itrace_start(union perf_event *event, FILE *fp);
608
size_t perf_event__fprintf_switch(union perf_event *event, FILE *fp);
609
size_t perf_event__fprintf_thread_map(union perf_event *event, FILE *fp);
610
size_t perf_event__fprintf_cpu_map(union perf_event *event, FILE *fp);
611
size_t perf_event__fprintf_namespaces(union perf_event *event, FILE *fp);
612
size_t perf_event__fprintf_ksymbol(union perf_event *event, FILE *fp);
613
size_t perf_event__fprintf_bpf(union perf_event *event, FILE *fp);
614 615
size_t perf_event__fprintf(union perf_event *event, FILE *fp);

616 617
int kallsyms__get_function_start(const char *kallsyms_filename,
				 const char *symbol_name, u64 *addr);
618

619 620
void *cpu_map_data__alloc(struct perf_cpu_map *map, size_t *size, u16 *type, int *max);
void  cpu_map_data__synthesize(struct cpu_map_data *data, struct perf_cpu_map *map,
621
			       u16 type, int max);
622 623 624 625

void event_attr_init(struct perf_event_attr *attr);

int perf_event_paranoid(void);
626
bool perf_event_paranoid_check(int max_level);
627 628 629

extern int sysctl_perf_event_max_stack;
extern int sysctl_perf_event_max_contexts_per_stack;
630
extern unsigned int proc_map_timeout;
631

632
#endif /* __PERF_RECORD_H */