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