1 #ifndef __PERF_RECORD_H 2 #define __PERF_RECORD_H 3 4 #include <limits.h> 5 #include <stdio.h> 6 #include <linux/kernel.h> 7 8 #include "../perf.h" 9 #include "build-id.h" 10 #include "perf_regs.h" 11 12 struct mmap_event { 13 struct perf_event_header header; 14 u32 pid, tid; 15 u64 start; 16 u64 len; 17 u64 pgoff; 18 char filename[PATH_MAX]; 19 }; 20 21 struct mmap2_event { 22 struct perf_event_header header; 23 u32 pid, tid; 24 u64 start; 25 u64 len; 26 u64 pgoff; 27 u32 maj; 28 u32 min; 29 u64 ino; 30 u64 ino_generation; 31 u32 prot; 32 u32 flags; 33 char filename[PATH_MAX]; 34 }; 35 36 struct comm_event { 37 struct perf_event_header header; 38 u32 pid, tid; 39 char comm[16]; 40 }; 41 42 struct namespaces_event { 43 struct perf_event_header header; 44 u32 pid, tid; 45 u64 nr_namespaces; 46 struct perf_ns_link_info link_info[]; 47 }; 48 49 struct fork_event { 50 struct perf_event_header header; 51 u32 pid, ppid; 52 u32 tid, ptid; 53 u64 time; 54 }; 55 56 struct lost_event { 57 struct perf_event_header header; 58 u64 id; 59 u64 lost; 60 }; 61 62 struct lost_samples_event { 63 struct perf_event_header header; 64 u64 lost; 65 }; 66 67 /* 68 * PERF_FORMAT_ENABLED | PERF_FORMAT_RUNNING | PERF_FORMAT_ID 69 */ 70 struct read_event { 71 struct perf_event_header header; 72 u32 pid, tid; 73 u64 value; 74 u64 time_enabled; 75 u64 time_running; 76 u64 id; 77 }; 78 79 struct throttle_event { 80 struct perf_event_header header; 81 u64 time; 82 u64 id; 83 u64 stream_id; 84 }; 85 86 #define PERF_SAMPLE_MASK \ 87 (PERF_SAMPLE_IP | PERF_SAMPLE_TID | \ 88 PERF_SAMPLE_TIME | PERF_SAMPLE_ADDR | \ 89 PERF_SAMPLE_ID | PERF_SAMPLE_STREAM_ID | \ 90 PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD | \ 91 PERF_SAMPLE_IDENTIFIER) 92 93 /* perf sample has 16 bits size limit */ 94 #define PERF_SAMPLE_MAX_SIZE (1 << 16) 95 96 struct sample_event { 97 struct perf_event_header header; 98 u64 array[]; 99 }; 100 101 struct regs_dump { 102 u64 abi; 103 u64 mask; 104 u64 *regs; 105 106 /* Cached values/mask filled by first register access. */ 107 u64 cache_regs[PERF_REGS_MAX]; 108 u64 cache_mask; 109 }; 110 111 struct stack_dump { 112 u16 offset; 113 u64 size; 114 char *data; 115 }; 116 117 struct sample_read_value { 118 u64 value; 119 u64 id; 120 }; 121 122 struct sample_read { 123 u64 time_enabled; 124 u64 time_running; 125 union { 126 struct { 127 u64 nr; 128 struct sample_read_value *values; 129 } group; 130 struct sample_read_value one; 131 }; 132 }; 133 134 struct ip_callchain { 135 u64 nr; 136 u64 ips[0]; 137 }; 138 139 struct branch_flags { 140 u64 mispred:1; 141 u64 predicted:1; 142 u64 in_tx:1; 143 u64 abort:1; 144 u64 cycles:16; 145 u64 type:4; 146 u64 reserved:40; 147 }; 148 149 struct branch_entry { 150 u64 from; 151 u64 to; 152 struct branch_flags flags; 153 }; 154 155 struct branch_stack { 156 u64 nr; 157 struct branch_entry entries[0]; 158 }; 159 160 enum { 161 PERF_IP_FLAG_BRANCH = 1ULL << 0, 162 PERF_IP_FLAG_CALL = 1ULL << 1, 163 PERF_IP_FLAG_RETURN = 1ULL << 2, 164 PERF_IP_FLAG_CONDITIONAL = 1ULL << 3, 165 PERF_IP_FLAG_SYSCALLRET = 1ULL << 4, 166 PERF_IP_FLAG_ASYNC = 1ULL << 5, 167 PERF_IP_FLAG_INTERRUPT = 1ULL << 6, 168 PERF_IP_FLAG_TX_ABORT = 1ULL << 7, 169 PERF_IP_FLAG_TRACE_BEGIN = 1ULL << 8, 170 PERF_IP_FLAG_TRACE_END = 1ULL << 9, 171 PERF_IP_FLAG_IN_TX = 1ULL << 10, 172 }; 173 174 #define PERF_IP_FLAG_CHARS "bcrosyiABEx" 175 176 #define PERF_BRANCH_MASK (\ 177 PERF_IP_FLAG_BRANCH |\ 178 PERF_IP_FLAG_CALL |\ 179 PERF_IP_FLAG_RETURN |\ 180 PERF_IP_FLAG_CONDITIONAL |\ 181 PERF_IP_FLAG_SYSCALLRET |\ 182 PERF_IP_FLAG_ASYNC |\ 183 PERF_IP_FLAG_INTERRUPT |\ 184 PERF_IP_FLAG_TX_ABORT |\ 185 PERF_IP_FLAG_TRACE_BEGIN |\ 186 PERF_IP_FLAG_TRACE_END) 187 188 #define MAX_INSN 16 189 190 struct perf_sample { 191 u64 ip; 192 u32 pid, tid; 193 u64 time; 194 u64 addr; 195 u64 id; 196 u64 stream_id; 197 u64 period; 198 u64 weight; 199 u64 transaction; 200 u32 cpu; 201 u32 raw_size; 202 u64 data_src; 203 u64 phys_addr; 204 u32 flags; 205 u16 insn_len; 206 u8 cpumode; 207 char insn[MAX_INSN]; 208 void *raw_data; 209 struct ip_callchain *callchain; 210 struct branch_stack *branch_stack; 211 struct regs_dump user_regs; 212 struct regs_dump intr_regs; 213 struct stack_dump user_stack; 214 struct sample_read read; 215 }; 216 217 #define PERF_MEM_DATA_SRC_NONE \ 218 (PERF_MEM_S(OP, NA) |\ 219 PERF_MEM_S(LVL, NA) |\ 220 PERF_MEM_S(SNOOP, NA) |\ 221 PERF_MEM_S(LOCK, NA) |\ 222 PERF_MEM_S(TLB, NA)) 223 224 struct build_id_event { 225 struct perf_event_header header; 226 pid_t pid; 227 u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))]; 228 char filename[]; 229 }; 230 231 enum perf_user_event_type { /* above any possible kernel type */ 232 PERF_RECORD_USER_TYPE_START = 64, 233 PERF_RECORD_HEADER_ATTR = 64, 234 PERF_RECORD_HEADER_EVENT_TYPE = 65, /* deprecated */ 235 PERF_RECORD_HEADER_TRACING_DATA = 66, 236 PERF_RECORD_HEADER_BUILD_ID = 67, 237 PERF_RECORD_FINISHED_ROUND = 68, 238 PERF_RECORD_ID_INDEX = 69, 239 PERF_RECORD_AUXTRACE_INFO = 70, 240 PERF_RECORD_AUXTRACE = 71, 241 PERF_RECORD_AUXTRACE_ERROR = 72, 242 PERF_RECORD_THREAD_MAP = 73, 243 PERF_RECORD_CPU_MAP = 74, 244 PERF_RECORD_STAT_CONFIG = 75, 245 PERF_RECORD_STAT = 76, 246 PERF_RECORD_STAT_ROUND = 77, 247 PERF_RECORD_EVENT_UPDATE = 78, 248 PERF_RECORD_TIME_CONV = 79, 249 PERF_RECORD_HEADER_FEATURE = 80, 250 PERF_RECORD_HEADER_MAX 251 }; 252 253 enum auxtrace_error_type { 254 PERF_AUXTRACE_ERROR_ITRACE = 1, 255 PERF_AUXTRACE_ERROR_MAX 256 }; 257 258 /* Attribute type for custom synthesized events */ 259 #define PERF_TYPE_SYNTH (INT_MAX + 1U) 260 261 /* Attribute config for custom synthesized events */ 262 enum perf_synth_id { 263 PERF_SYNTH_INTEL_PTWRITE, 264 PERF_SYNTH_INTEL_MWAIT, 265 PERF_SYNTH_INTEL_PWRE, 266 PERF_SYNTH_INTEL_EXSTOP, 267 PERF_SYNTH_INTEL_PWRX, 268 PERF_SYNTH_INTEL_CBR, 269 }; 270 271 /* 272 * Raw data formats for synthesized events. Note that 4 bytes of padding are 273 * present to match the 'size' member of PERF_SAMPLE_RAW data which is always 274 * 8-byte aligned. That means we must dereference raw_data with an offset of 4. 275 * Refer perf_sample__synth_ptr() and perf_synth__raw_data(). It also means the 276 * structure sizes are 4 bytes bigger than the raw_size, refer 277 * perf_synth__raw_size(). 278 */ 279 280 struct perf_synth_intel_ptwrite { 281 u32 padding; 282 union { 283 struct { 284 u32 ip : 1, 285 reserved : 31; 286 }; 287 u32 flags; 288 }; 289 u64 payload; 290 }; 291 292 struct perf_synth_intel_mwait { 293 u32 padding; 294 u32 reserved; 295 union { 296 struct { 297 u64 hints : 8, 298 reserved1 : 24, 299 extensions : 2, 300 reserved2 : 30; 301 }; 302 u64 payload; 303 }; 304 }; 305 306 struct perf_synth_intel_pwre { 307 u32 padding; 308 u32 reserved; 309 union { 310 struct { 311 u64 reserved1 : 7, 312 hw : 1, 313 subcstate : 4, 314 cstate : 4, 315 reserved2 : 48; 316 }; 317 u64 payload; 318 }; 319 }; 320 321 struct perf_synth_intel_exstop { 322 u32 padding; 323 union { 324 struct { 325 u32 ip : 1, 326 reserved : 31; 327 }; 328 u32 flags; 329 }; 330 }; 331 332 struct perf_synth_intel_pwrx { 333 u32 padding; 334 u32 reserved; 335 union { 336 struct { 337 u64 deepest_cstate : 4, 338 last_cstate : 4, 339 wake_reason : 4, 340 reserved1 : 52; 341 }; 342 u64 payload; 343 }; 344 }; 345 346 struct perf_synth_intel_cbr { 347 u32 padding; 348 union { 349 struct { 350 u32 cbr : 8, 351 reserved1 : 8, 352 max_nonturbo : 8, 353 reserved2 : 8; 354 }; 355 u32 flags; 356 }; 357 u32 freq; 358 u32 reserved3; 359 }; 360 361 /* 362 * raw_data is always 4 bytes from an 8-byte boundary, so subtract 4 to get 363 * 8-byte alignment. 364 */ 365 static inline void *perf_sample__synth_ptr(struct perf_sample *sample) 366 { 367 return sample->raw_data - 4; 368 } 369 370 static inline void *perf_synth__raw_data(void *p) 371 { 372 return p + 4; 373 } 374 375 #define perf_synth__raw_size(d) (sizeof(d) - 4) 376 377 #define perf_sample__bad_synth_size(s, d) ((s)->raw_size < sizeof(d) - 4) 378 379 /* 380 * The kernel collects the number of events it couldn't send in a stretch and 381 * when possible sends this number in a PERF_RECORD_LOST event. The number of 382 * such "chunks" of lost events is stored in .nr_events[PERF_EVENT_LOST] while 383 * total_lost tells exactly how many events the kernel in fact lost, i.e. it is 384 * the sum of all struct lost_event.lost fields reported. 385 * 386 * The kernel discards mixed up samples and sends the number in a 387 * PERF_RECORD_LOST_SAMPLES event. The number of lost-samples events is stored 388 * in .nr_events[PERF_RECORD_LOST_SAMPLES] while total_lost_samples tells 389 * exactly how many samples the kernel in fact dropped, i.e. it is the sum of 390 * all struct lost_samples_event.lost fields reported. 391 * 392 * The total_period is needed because by default auto-freq is used, so 393 * multipling nr_events[PERF_EVENT_SAMPLE] by a frequency isn't possible to get 394 * the total number of low level events, it is necessary to to sum all struct 395 * sample_event.period and stash the result in total_period. 396 */ 397 struct events_stats { 398 u64 total_period; 399 u64 total_non_filtered_period; 400 u64 total_lost; 401 u64 total_lost_samples; 402 u64 total_aux_lost; 403 u64 total_aux_partial; 404 u64 total_invalid_chains; 405 u32 nr_events[PERF_RECORD_HEADER_MAX]; 406 u32 nr_non_filtered_samples; 407 u32 nr_lost_warned; 408 u32 nr_unknown_events; 409 u32 nr_invalid_chains; 410 u32 nr_unknown_id; 411 u32 nr_unprocessable_samples; 412 u32 nr_auxtrace_errors[PERF_AUXTRACE_ERROR_MAX]; 413 u32 nr_proc_map_timeout; 414 }; 415 416 enum { 417 PERF_CPU_MAP__CPUS = 0, 418 PERF_CPU_MAP__MASK = 1, 419 }; 420 421 struct cpu_map_entries { 422 u16 nr; 423 u16 cpu[]; 424 }; 425 426 struct cpu_map_mask { 427 u16 nr; 428 u16 long_size; 429 unsigned long mask[]; 430 }; 431 432 struct cpu_map_data { 433 u16 type; 434 char data[]; 435 }; 436 437 struct cpu_map_event { 438 struct perf_event_header header; 439 struct cpu_map_data data; 440 }; 441 442 struct attr_event { 443 struct perf_event_header header; 444 struct perf_event_attr attr; 445 u64 id[]; 446 }; 447 448 enum { 449 PERF_EVENT_UPDATE__UNIT = 0, 450 PERF_EVENT_UPDATE__SCALE = 1, 451 PERF_EVENT_UPDATE__NAME = 2, 452 PERF_EVENT_UPDATE__CPUS = 3, 453 }; 454 455 struct event_update_event_cpus { 456 struct cpu_map_data cpus; 457 }; 458 459 struct event_update_event_scale { 460 double scale; 461 }; 462 463 struct event_update_event { 464 struct perf_event_header header; 465 u64 type; 466 u64 id; 467 468 char data[]; 469 }; 470 471 #define MAX_EVENT_NAME 64 472 473 struct perf_trace_event_type { 474 u64 event_id; 475 char name[MAX_EVENT_NAME]; 476 }; 477 478 struct event_type_event { 479 struct perf_event_header header; 480 struct perf_trace_event_type event_type; 481 }; 482 483 struct tracing_data_event { 484 struct perf_event_header header; 485 u32 size; 486 }; 487 488 struct id_index_entry { 489 u64 id; 490 u64 idx; 491 u64 cpu; 492 u64 tid; 493 }; 494 495 struct id_index_event { 496 struct perf_event_header header; 497 u64 nr; 498 struct id_index_entry entries[0]; 499 }; 500 501 struct auxtrace_info_event { 502 struct perf_event_header header; 503 u32 type; 504 u32 reserved__; /* For alignment */ 505 u64 priv[]; 506 }; 507 508 struct auxtrace_event { 509 struct perf_event_header header; 510 u64 size; 511 u64 offset; 512 u64 reference; 513 u32 idx; 514 u32 tid; 515 u32 cpu; 516 u32 reserved__; /* For alignment */ 517 }; 518 519 #define MAX_AUXTRACE_ERROR_MSG 64 520 521 struct auxtrace_error_event { 522 struct perf_event_header header; 523 u32 type; 524 u32 code; 525 u32 cpu; 526 u32 pid; 527 u32 tid; 528 u32 reserved__; /* For alignment */ 529 u64 ip; 530 char msg[MAX_AUXTRACE_ERROR_MSG]; 531 }; 532 533 struct aux_event { 534 struct perf_event_header header; 535 u64 aux_offset; 536 u64 aux_size; 537 u64 flags; 538 }; 539 540 struct itrace_start_event { 541 struct perf_event_header header; 542 u32 pid, tid; 543 }; 544 545 struct context_switch_event { 546 struct perf_event_header header; 547 u32 next_prev_pid; 548 u32 next_prev_tid; 549 }; 550 551 struct thread_map_event_entry { 552 u64 pid; 553 char comm[16]; 554 }; 555 556 struct thread_map_event { 557 struct perf_event_header header; 558 u64 nr; 559 struct thread_map_event_entry entries[]; 560 }; 561 562 enum { 563 PERF_STAT_CONFIG_TERM__AGGR_MODE = 0, 564 PERF_STAT_CONFIG_TERM__INTERVAL = 1, 565 PERF_STAT_CONFIG_TERM__SCALE = 2, 566 PERF_STAT_CONFIG_TERM__MAX = 3, 567 }; 568 569 struct stat_config_event_entry { 570 u64 tag; 571 u64 val; 572 }; 573 574 struct stat_config_event { 575 struct perf_event_header header; 576 u64 nr; 577 struct stat_config_event_entry data[]; 578 }; 579 580 struct stat_event { 581 struct perf_event_header header; 582 583 u64 id; 584 u32 cpu; 585 u32 thread; 586 587 union { 588 struct { 589 u64 val; 590 u64 ena; 591 u64 run; 592 }; 593 u64 values[3]; 594 }; 595 }; 596 597 enum { 598 PERF_STAT_ROUND_TYPE__INTERVAL = 0, 599 PERF_STAT_ROUND_TYPE__FINAL = 1, 600 }; 601 602 struct stat_round_event { 603 struct perf_event_header header; 604 u64 type; 605 u64 time; 606 }; 607 608 struct time_conv_event { 609 struct perf_event_header header; 610 u64 time_shift; 611 u64 time_mult; 612 u64 time_zero; 613 }; 614 615 struct feature_event { 616 struct perf_event_header header; 617 u64 feat_id; 618 char data[]; 619 }; 620 621 union perf_event { 622 struct perf_event_header header; 623 struct mmap_event mmap; 624 struct mmap2_event mmap2; 625 struct comm_event comm; 626 struct namespaces_event namespaces; 627 struct fork_event fork; 628 struct lost_event lost; 629 struct lost_samples_event lost_samples; 630 struct read_event read; 631 struct throttle_event throttle; 632 struct sample_event sample; 633 struct attr_event attr; 634 struct event_update_event event_update; 635 struct event_type_event event_type; 636 struct tracing_data_event tracing_data; 637 struct build_id_event build_id; 638 struct id_index_event id_index; 639 struct auxtrace_info_event auxtrace_info; 640 struct auxtrace_event auxtrace; 641 struct auxtrace_error_event auxtrace_error; 642 struct aux_event aux; 643 struct itrace_start_event itrace_start; 644 struct context_switch_event context_switch; 645 struct thread_map_event thread_map; 646 struct cpu_map_event cpu_map; 647 struct stat_config_event stat_config; 648 struct stat_event stat; 649 struct stat_round_event stat_round; 650 struct time_conv_event time_conv; 651 struct feature_event feat; 652 }; 653 654 void perf_event__print_totals(void); 655 656 struct perf_tool; 657 struct thread_map; 658 struct cpu_map; 659 struct perf_stat_config; 660 struct perf_counts_values; 661 662 typedef int (*perf_event__handler_t)(struct perf_tool *tool, 663 union perf_event *event, 664 struct perf_sample *sample, 665 struct machine *machine); 666 667 int perf_event__synthesize_thread_map(struct perf_tool *tool, 668 struct thread_map *threads, 669 perf_event__handler_t process, 670 struct machine *machine, bool mmap_data, 671 unsigned int proc_map_timeout); 672 int perf_event__synthesize_thread_map2(struct perf_tool *tool, 673 struct thread_map *threads, 674 perf_event__handler_t process, 675 struct machine *machine); 676 int perf_event__synthesize_cpu_map(struct perf_tool *tool, 677 struct cpu_map *cpus, 678 perf_event__handler_t process, 679 struct machine *machine); 680 int perf_event__synthesize_threads(struct perf_tool *tool, 681 perf_event__handler_t process, 682 struct machine *machine, bool mmap_data, 683 unsigned int proc_map_timeout); 684 int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, 685 perf_event__handler_t process, 686 struct machine *machine); 687 int perf_event__synthesize_stat_config(struct perf_tool *tool, 688 struct perf_stat_config *config, 689 perf_event__handler_t process, 690 struct machine *machine); 691 void perf_event__read_stat_config(struct perf_stat_config *config, 692 struct stat_config_event *event); 693 int perf_event__synthesize_stat(struct perf_tool *tool, 694 u32 cpu, u32 thread, u64 id, 695 struct perf_counts_values *count, 696 perf_event__handler_t process, 697 struct machine *machine); 698 int perf_event__synthesize_stat_round(struct perf_tool *tool, 699 u64 time, u64 type, 700 perf_event__handler_t process, 701 struct machine *machine); 702 int perf_event__synthesize_modules(struct perf_tool *tool, 703 perf_event__handler_t process, 704 struct machine *machine); 705 706 int perf_event__process_comm(struct perf_tool *tool, 707 union perf_event *event, 708 struct perf_sample *sample, 709 struct machine *machine); 710 int perf_event__process_lost(struct perf_tool *tool, 711 union perf_event *event, 712 struct perf_sample *sample, 713 struct machine *machine); 714 int perf_event__process_lost_samples(struct perf_tool *tool, 715 union perf_event *event, 716 struct perf_sample *sample, 717 struct machine *machine); 718 int perf_event__process_aux(struct perf_tool *tool, 719 union perf_event *event, 720 struct perf_sample *sample, 721 struct machine *machine); 722 int perf_event__process_itrace_start(struct perf_tool *tool, 723 union perf_event *event, 724 struct perf_sample *sample, 725 struct machine *machine); 726 int perf_event__process_switch(struct perf_tool *tool, 727 union perf_event *event, 728 struct perf_sample *sample, 729 struct machine *machine); 730 int perf_event__process_namespaces(struct perf_tool *tool, 731 union perf_event *event, 732 struct perf_sample *sample, 733 struct machine *machine); 734 int perf_event__process_mmap(struct perf_tool *tool, 735 union perf_event *event, 736 struct perf_sample *sample, 737 struct machine *machine); 738 int perf_event__process_mmap2(struct perf_tool *tool, 739 union perf_event *event, 740 struct perf_sample *sample, 741 struct machine *machine); 742 int perf_event__process_fork(struct perf_tool *tool, 743 union perf_event *event, 744 struct perf_sample *sample, 745 struct machine *machine); 746 int perf_event__process_exit(struct perf_tool *tool, 747 union perf_event *event, 748 struct perf_sample *sample, 749 struct machine *machine); 750 int perf_event__process(struct perf_tool *tool, 751 union perf_event *event, 752 struct perf_sample *sample, 753 struct machine *machine); 754 755 struct addr_location; 756 757 int machine__resolve(struct machine *machine, struct addr_location *al, 758 struct perf_sample *sample); 759 760 void addr_location__put(struct addr_location *al); 761 762 struct thread; 763 764 bool is_bts_event(struct perf_event_attr *attr); 765 bool sample_addr_correlates_sym(struct perf_event_attr *attr); 766 void thread__resolve(struct thread *thread, struct addr_location *al, 767 struct perf_sample *sample); 768 769 const char *perf_event__name(unsigned int id); 770 771 size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type, 772 u64 read_format); 773 int perf_event__synthesize_sample(union perf_event *event, u64 type, 774 u64 read_format, 775 const struct perf_sample *sample, 776 bool swapped); 777 778 pid_t perf_event__synthesize_comm(struct perf_tool *tool, 779 union perf_event *event, pid_t pid, 780 perf_event__handler_t process, 781 struct machine *machine); 782 783 int perf_event__synthesize_namespaces(struct perf_tool *tool, 784 union perf_event *event, 785 pid_t pid, pid_t tgid, 786 perf_event__handler_t process, 787 struct machine *machine); 788 789 int perf_event__synthesize_mmap_events(struct perf_tool *tool, 790 union perf_event *event, 791 pid_t pid, pid_t tgid, 792 perf_event__handler_t process, 793 struct machine *machine, 794 bool mmap_data, 795 unsigned int proc_map_timeout); 796 797 size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp); 798 size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp); 799 size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp); 800 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp); 801 size_t perf_event__fprintf_aux(union perf_event *event, FILE *fp); 802 size_t perf_event__fprintf_itrace_start(union perf_event *event, FILE *fp); 803 size_t perf_event__fprintf_switch(union perf_event *event, FILE *fp); 804 size_t perf_event__fprintf_thread_map(union perf_event *event, FILE *fp); 805 size_t perf_event__fprintf_cpu_map(union perf_event *event, FILE *fp); 806 size_t perf_event__fprintf_namespaces(union perf_event *event, FILE *fp); 807 size_t perf_event__fprintf(union perf_event *event, FILE *fp); 808 809 int kallsyms__get_function_start(const char *kallsyms_filename, 810 const char *symbol_name, u64 *addr); 811 812 void *cpu_map_data__alloc(struct cpu_map *map, size_t *size, u16 *type, int *max); 813 void cpu_map_data__synthesize(struct cpu_map_data *data, struct cpu_map *map, 814 u16 type, int max); 815 816 void event_attr_init(struct perf_event_attr *attr); 817 818 int perf_event_paranoid(void); 819 820 extern int sysctl_perf_event_max_stack; 821 extern int sysctl_perf_event_max_contexts_per_stack; 822 823 #endif /* __PERF_RECORD_H */ 824