1 /* 2 * auxtrace.h: AUX area trace support 3 * Copyright (c) 2013-2015, Intel Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 */ 15 16 #ifndef __PERF_AUXTRACE_H 17 #define __PERF_AUXTRACE_H 18 19 #include <sys/types.h> 20 #include <errno.h> 21 #include <stdbool.h> 22 #include <stddef.h> 23 #include <linux/list.h> 24 #include <linux/perf_event.h> 25 #include <linux/types.h> 26 #include <asm/bitsperlong.h> 27 28 #include "../perf.h" 29 #include "event.h" 30 #include "session.h" 31 #include "debug.h" 32 33 union perf_event; 34 struct perf_session; 35 struct perf_evlist; 36 struct perf_tool; 37 struct perf_mmap; 38 struct option; 39 struct record_opts; 40 struct auxtrace_info_event; 41 struct events_stats; 42 43 /* Auxtrace records must have the same alignment as perf event records */ 44 #define PERF_AUXTRACE_RECORD_ALIGNMENT 8 45 46 enum auxtrace_type { 47 PERF_AUXTRACE_UNKNOWN, 48 PERF_AUXTRACE_INTEL_PT, 49 PERF_AUXTRACE_INTEL_BTS, 50 PERF_AUXTRACE_CS_ETM, 51 PERF_AUXTRACE_ARM_SPE, 52 PERF_AUXTRACE_S390_CPUMSF, 53 }; 54 55 enum itrace_period_type { 56 PERF_ITRACE_PERIOD_INSTRUCTIONS, 57 PERF_ITRACE_PERIOD_TICKS, 58 PERF_ITRACE_PERIOD_NANOSECS, 59 }; 60 61 /** 62 * struct itrace_synth_opts - AUX area tracing synthesis options. 63 * @set: indicates whether or not options have been set 64 * @default_no_sample: Default to no sampling. 65 * @inject: indicates the event (not just the sample) must be fully synthesized 66 * because 'perf inject' will write it out 67 * @instructions: whether to synthesize 'instructions' events 68 * @branches: whether to synthesize 'branches' events 69 * @transactions: whether to synthesize events for transactions 70 * @ptwrites: whether to synthesize events for ptwrites 71 * @pwr_events: whether to synthesize power events 72 * @errors: whether to synthesize decoder error events 73 * @dont_decode: whether to skip decoding entirely 74 * @log: write a decoding log 75 * @calls: limit branch samples to calls (can be combined with @returns) 76 * @returns: limit branch samples to returns (can be combined with @calls) 77 * @callchain: add callchain to 'instructions' events 78 * @thread_stack: feed branches to the thread_stack 79 * @last_branch: add branch context to 'instruction' events 80 * @callchain_sz: maximum callchain size 81 * @last_branch_sz: branch context size 82 * @period: 'instructions' events period 83 * @period_type: 'instructions' events period type 84 * @initial_skip: skip N events at the beginning. 85 * @cpu_bitmap: CPUs for which to synthesize events, or NULL for all 86 */ 87 struct itrace_synth_opts { 88 bool set; 89 bool default_no_sample; 90 bool inject; 91 bool instructions; 92 bool branches; 93 bool transactions; 94 bool ptwrites; 95 bool pwr_events; 96 bool errors; 97 bool dont_decode; 98 bool log; 99 bool calls; 100 bool returns; 101 bool callchain; 102 bool thread_stack; 103 bool last_branch; 104 unsigned int callchain_sz; 105 unsigned int last_branch_sz; 106 unsigned long long period; 107 enum itrace_period_type period_type; 108 unsigned long initial_skip; 109 unsigned long *cpu_bitmap; 110 }; 111 112 /** 113 * struct auxtrace_index_entry - indexes a AUX area tracing event within a 114 * perf.data file. 115 * @file_offset: offset within the perf.data file 116 * @sz: size of the event 117 */ 118 struct auxtrace_index_entry { 119 u64 file_offset; 120 u64 sz; 121 }; 122 123 #define PERF_AUXTRACE_INDEX_ENTRY_COUNT 256 124 125 /** 126 * struct auxtrace_index - index of AUX area tracing events within a perf.data 127 * file. 128 * @list: linking a number of arrays of entries 129 * @nr: number of entries 130 * @entries: array of entries 131 */ 132 struct auxtrace_index { 133 struct list_head list; 134 size_t nr; 135 struct auxtrace_index_entry entries[PERF_AUXTRACE_INDEX_ENTRY_COUNT]; 136 }; 137 138 /** 139 * struct auxtrace - session callbacks to allow AUX area data decoding. 140 * @process_event: lets the decoder see all session events 141 * @process_auxtrace_event: process a PERF_RECORD_AUXTRACE event 142 * @flush_events: process any remaining data 143 * @free_events: free resources associated with event processing 144 * @free: free resources associated with the session 145 */ 146 struct auxtrace { 147 int (*process_event)(struct perf_session *session, 148 union perf_event *event, 149 struct perf_sample *sample, 150 struct perf_tool *tool); 151 int (*process_auxtrace_event)(struct perf_session *session, 152 union perf_event *event, 153 struct perf_tool *tool); 154 int (*flush_events)(struct perf_session *session, 155 struct perf_tool *tool); 156 void (*free_events)(struct perf_session *session); 157 void (*free)(struct perf_session *session); 158 }; 159 160 /** 161 * struct auxtrace_buffer - a buffer containing AUX area tracing data. 162 * @list: buffers are queued in a list held by struct auxtrace_queue 163 * @size: size of the buffer in bytes 164 * @pid: in per-thread mode, the pid this buffer is associated with 165 * @tid: in per-thread mode, the tid this buffer is associated with 166 * @cpu: in per-cpu mode, the cpu this buffer is associated with 167 * @data: actual buffer data (can be null if the data has not been loaded) 168 * @data_offset: file offset at which the buffer can be read 169 * @mmap_addr: mmap address at which the buffer can be read 170 * @mmap_size: size of the mmap at @mmap_addr 171 * @data_needs_freeing: @data was malloc'd so free it when it is no longer 172 * needed 173 * @consecutive: the original data was split up and this buffer is consecutive 174 * to the previous buffer 175 * @offset: offset as determined by aux_head / aux_tail members of struct 176 * perf_event_mmap_page 177 * @reference: an implementation-specific reference determined when the data is 178 * recorded 179 * @buffer_nr: used to number each buffer 180 * @use_size: implementation actually only uses this number of bytes 181 * @use_data: implementation actually only uses data starting at this address 182 */ 183 struct auxtrace_buffer { 184 struct list_head list; 185 size_t size; 186 pid_t pid; 187 pid_t tid; 188 int cpu; 189 void *data; 190 off_t data_offset; 191 void *mmap_addr; 192 size_t mmap_size; 193 bool data_needs_freeing; 194 bool consecutive; 195 u64 offset; 196 u64 reference; 197 u64 buffer_nr; 198 size_t use_size; 199 void *use_data; 200 }; 201 202 /** 203 * struct auxtrace_queue - a queue of AUX area tracing data buffers. 204 * @head: head of buffer list 205 * @tid: in per-thread mode, the tid this queue is associated with 206 * @cpu: in per-cpu mode, the cpu this queue is associated with 207 * @set: %true once this queue has been dedicated to a specific thread or cpu 208 * @priv: implementation-specific data 209 */ 210 struct auxtrace_queue { 211 struct list_head head; 212 pid_t tid; 213 int cpu; 214 bool set; 215 void *priv; 216 }; 217 218 /** 219 * struct auxtrace_queues - an array of AUX area tracing queues. 220 * @queue_array: array of queues 221 * @nr_queues: number of queues 222 * @new_data: set whenever new data is queued 223 * @populated: queues have been fully populated using the auxtrace_index 224 * @next_buffer_nr: used to number each buffer 225 */ 226 struct auxtrace_queues { 227 struct auxtrace_queue *queue_array; 228 unsigned int nr_queues; 229 bool new_data; 230 bool populated; 231 u64 next_buffer_nr; 232 }; 233 234 /** 235 * struct auxtrace_heap_item - element of struct auxtrace_heap. 236 * @queue_nr: queue number 237 * @ordinal: value used for sorting (lowest ordinal is top of the heap) expected 238 * to be a timestamp 239 */ 240 struct auxtrace_heap_item { 241 unsigned int queue_nr; 242 u64 ordinal; 243 }; 244 245 /** 246 * struct auxtrace_heap - a heap suitable for sorting AUX area tracing queues. 247 * @heap_array: the heap 248 * @heap_cnt: the number of elements in the heap 249 * @heap_sz: maximum number of elements (grows as needed) 250 */ 251 struct auxtrace_heap { 252 struct auxtrace_heap_item *heap_array; 253 unsigned int heap_cnt; 254 unsigned int heap_sz; 255 }; 256 257 /** 258 * struct auxtrace_mmap - records an mmap of the auxtrace buffer. 259 * @base: address of mapped area 260 * @userpg: pointer to buffer's perf_event_mmap_page 261 * @mask: %0 if @len is not a power of two, otherwise (@len - %1) 262 * @len: size of mapped area 263 * @prev: previous aux_head 264 * @idx: index of this mmap 265 * @tid: tid for a per-thread mmap (also set if there is only 1 tid on a per-cpu 266 * mmap) otherwise %0 267 * @cpu: cpu number for a per-cpu mmap otherwise %-1 268 */ 269 struct auxtrace_mmap { 270 void *base; 271 void *userpg; 272 size_t mask; 273 size_t len; 274 u64 prev; 275 int idx; 276 pid_t tid; 277 int cpu; 278 }; 279 280 /** 281 * struct auxtrace_mmap_params - parameters to set up struct auxtrace_mmap. 282 * @mask: %0 if @len is not a power of two, otherwise (@len - %1) 283 * @offset: file offset of mapped area 284 * @len: size of mapped area 285 * @prot: mmap memory protection 286 * @idx: index of this mmap 287 * @tid: tid for a per-thread mmap (also set if there is only 1 tid on a per-cpu 288 * mmap) otherwise %0 289 * @cpu: cpu number for a per-cpu mmap otherwise %-1 290 */ 291 struct auxtrace_mmap_params { 292 size_t mask; 293 off_t offset; 294 size_t len; 295 int prot; 296 int idx; 297 pid_t tid; 298 int cpu; 299 }; 300 301 /** 302 * struct auxtrace_record - callbacks for recording AUX area data. 303 * @recording_options: validate and process recording options 304 * @info_priv_size: return the size of the private data in auxtrace_info_event 305 * @info_fill: fill-in the private data in auxtrace_info_event 306 * @free: free this auxtrace record structure 307 * @snapshot_start: starting a snapshot 308 * @snapshot_finish: finishing a snapshot 309 * @find_snapshot: find data to snapshot within auxtrace mmap 310 * @parse_snapshot_options: parse snapshot options 311 * @reference: provide a 64-bit reference number for auxtrace_event 312 * @read_finish: called after reading from an auxtrace mmap 313 * @alignment: alignment (if any) for AUX area data 314 */ 315 struct auxtrace_record { 316 int (*recording_options)(struct auxtrace_record *itr, 317 struct perf_evlist *evlist, 318 struct record_opts *opts); 319 size_t (*info_priv_size)(struct auxtrace_record *itr, 320 struct perf_evlist *evlist); 321 int (*info_fill)(struct auxtrace_record *itr, 322 struct perf_session *session, 323 struct auxtrace_info_event *auxtrace_info, 324 size_t priv_size); 325 void (*free)(struct auxtrace_record *itr); 326 int (*snapshot_start)(struct auxtrace_record *itr); 327 int (*snapshot_finish)(struct auxtrace_record *itr); 328 int (*find_snapshot)(struct auxtrace_record *itr, int idx, 329 struct auxtrace_mmap *mm, unsigned char *data, 330 u64 *head, u64 *old); 331 int (*parse_snapshot_options)(struct auxtrace_record *itr, 332 struct record_opts *opts, 333 const char *str); 334 u64 (*reference)(struct auxtrace_record *itr); 335 int (*read_finish)(struct auxtrace_record *itr, int idx); 336 unsigned int alignment; 337 }; 338 339 /** 340 * struct addr_filter - address filter. 341 * @list: list node 342 * @range: true if it is a range filter 343 * @start: true if action is 'filter' or 'start' 344 * @action: 'filter', 'start' or 'stop' ('tracestop' is accepted but converted 345 * to 'stop') 346 * @sym_from: symbol name for the filter address 347 * @sym_to: symbol name that determines the filter size 348 * @sym_from_idx: selects n'th from symbols with the same name (0 means global 349 * and less than 0 means symbol must be unique) 350 * @sym_to_idx: same as @sym_from_idx but for @sym_to 351 * @addr: filter address 352 * @size: filter region size (for range filters) 353 * @filename: DSO file name or NULL for the kernel 354 * @str: allocated string that contains the other string members 355 */ 356 struct addr_filter { 357 struct list_head list; 358 bool range; 359 bool start; 360 const char *action; 361 const char *sym_from; 362 const char *sym_to; 363 int sym_from_idx; 364 int sym_to_idx; 365 u64 addr; 366 u64 size; 367 const char *filename; 368 char *str; 369 }; 370 371 /** 372 * struct addr_filters - list of address filters. 373 * @head: list of address filters 374 * @cnt: number of address filters 375 */ 376 struct addr_filters { 377 struct list_head head; 378 int cnt; 379 }; 380 381 #ifdef HAVE_AUXTRACE_SUPPORT 382 383 /* 384 * In snapshot mode the mmapped page is read-only which makes using 385 * __sync_val_compare_and_swap() problematic. However, snapshot mode expects 386 * the buffer is not updated while the snapshot is made (e.g. Intel PT disables 387 * the event) so there is not a race anyway. 388 */ 389 static inline u64 auxtrace_mmap__read_snapshot_head(struct auxtrace_mmap *mm) 390 { 391 struct perf_event_mmap_page *pc = mm->userpg; 392 u64 head = READ_ONCE(pc->aux_head); 393 394 /* Ensure all reads are done after we read the head */ 395 rmb(); 396 return head; 397 } 398 399 static inline u64 auxtrace_mmap__read_head(struct auxtrace_mmap *mm) 400 { 401 struct perf_event_mmap_page *pc = mm->userpg; 402 #if BITS_PER_LONG == 64 || !defined(HAVE_SYNC_COMPARE_AND_SWAP_SUPPORT) 403 u64 head = READ_ONCE(pc->aux_head); 404 #else 405 u64 head = __sync_val_compare_and_swap(&pc->aux_head, 0, 0); 406 #endif 407 408 /* Ensure all reads are done after we read the head */ 409 rmb(); 410 return head; 411 } 412 413 static inline void auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail) 414 { 415 struct perf_event_mmap_page *pc = mm->userpg; 416 #if BITS_PER_LONG != 64 && defined(HAVE_SYNC_COMPARE_AND_SWAP_SUPPORT) 417 u64 old_tail; 418 #endif 419 420 /* Ensure all reads are done before we write the tail out */ 421 mb(); 422 #if BITS_PER_LONG == 64 || !defined(HAVE_SYNC_COMPARE_AND_SWAP_SUPPORT) 423 pc->aux_tail = tail; 424 #else 425 do { 426 old_tail = __sync_val_compare_and_swap(&pc->aux_tail, 0, 0); 427 } while (!__sync_bool_compare_and_swap(&pc->aux_tail, old_tail, tail)); 428 #endif 429 } 430 431 int auxtrace_mmap__mmap(struct auxtrace_mmap *mm, 432 struct auxtrace_mmap_params *mp, 433 void *userpg, int fd); 434 void auxtrace_mmap__munmap(struct auxtrace_mmap *mm); 435 void auxtrace_mmap_params__init(struct auxtrace_mmap_params *mp, 436 off_t auxtrace_offset, 437 unsigned int auxtrace_pages, 438 bool auxtrace_overwrite); 439 void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp, 440 struct perf_evlist *evlist, int idx, 441 bool per_cpu); 442 443 typedef int (*process_auxtrace_t)(struct perf_tool *tool, 444 struct perf_mmap *map, 445 union perf_event *event, void *data1, 446 size_t len1, void *data2, size_t len2); 447 448 int auxtrace_mmap__read(struct perf_mmap *map, struct auxtrace_record *itr, 449 struct perf_tool *tool, process_auxtrace_t fn); 450 451 int auxtrace_mmap__read_snapshot(struct perf_mmap *map, 452 struct auxtrace_record *itr, 453 struct perf_tool *tool, process_auxtrace_t fn, 454 size_t snapshot_size); 455 456 int auxtrace_queues__init(struct auxtrace_queues *queues); 457 int auxtrace_queues__add_event(struct auxtrace_queues *queues, 458 struct perf_session *session, 459 union perf_event *event, off_t data_offset, 460 struct auxtrace_buffer **buffer_ptr); 461 void auxtrace_queues__free(struct auxtrace_queues *queues); 462 int auxtrace_queues__process_index(struct auxtrace_queues *queues, 463 struct perf_session *session); 464 struct auxtrace_buffer *auxtrace_buffer__next(struct auxtrace_queue *queue, 465 struct auxtrace_buffer *buffer); 466 void *auxtrace_buffer__get_data(struct auxtrace_buffer *buffer, int fd); 467 void auxtrace_buffer__put_data(struct auxtrace_buffer *buffer); 468 void auxtrace_buffer__drop_data(struct auxtrace_buffer *buffer); 469 void auxtrace_buffer__free(struct auxtrace_buffer *buffer); 470 471 int auxtrace_heap__add(struct auxtrace_heap *heap, unsigned int queue_nr, 472 u64 ordinal); 473 void auxtrace_heap__pop(struct auxtrace_heap *heap); 474 void auxtrace_heap__free(struct auxtrace_heap *heap); 475 476 struct auxtrace_cache_entry { 477 struct hlist_node hash; 478 u32 key; 479 }; 480 481 struct auxtrace_cache *auxtrace_cache__new(unsigned int bits, size_t entry_size, 482 unsigned int limit_percent); 483 void auxtrace_cache__free(struct auxtrace_cache *auxtrace_cache); 484 void *auxtrace_cache__alloc_entry(struct auxtrace_cache *c); 485 void auxtrace_cache__free_entry(struct auxtrace_cache *c, void *entry); 486 int auxtrace_cache__add(struct auxtrace_cache *c, u32 key, 487 struct auxtrace_cache_entry *entry); 488 void *auxtrace_cache__lookup(struct auxtrace_cache *c, u32 key); 489 490 struct auxtrace_record *auxtrace_record__init(struct perf_evlist *evlist, 491 int *err); 492 493 int auxtrace_parse_snapshot_options(struct auxtrace_record *itr, 494 struct record_opts *opts, 495 const char *str); 496 int auxtrace_record__options(struct auxtrace_record *itr, 497 struct perf_evlist *evlist, 498 struct record_opts *opts); 499 size_t auxtrace_record__info_priv_size(struct auxtrace_record *itr, 500 struct perf_evlist *evlist); 501 int auxtrace_record__info_fill(struct auxtrace_record *itr, 502 struct perf_session *session, 503 struct auxtrace_info_event *auxtrace_info, 504 size_t priv_size); 505 void auxtrace_record__free(struct auxtrace_record *itr); 506 int auxtrace_record__snapshot_start(struct auxtrace_record *itr); 507 int auxtrace_record__snapshot_finish(struct auxtrace_record *itr); 508 int auxtrace_record__find_snapshot(struct auxtrace_record *itr, int idx, 509 struct auxtrace_mmap *mm, 510 unsigned char *data, u64 *head, u64 *old); 511 u64 auxtrace_record__reference(struct auxtrace_record *itr); 512 513 int auxtrace_index__auxtrace_event(struct list_head *head, union perf_event *event, 514 off_t file_offset); 515 int auxtrace_index__write(int fd, struct list_head *head); 516 int auxtrace_index__process(int fd, u64 size, struct perf_session *session, 517 bool needs_swap); 518 void auxtrace_index__free(struct list_head *head); 519 520 void auxtrace_synth_error(struct auxtrace_error_event *auxtrace_error, int type, 521 int code, int cpu, pid_t pid, pid_t tid, u64 ip, 522 const char *msg, u64 timestamp); 523 524 int perf_event__synthesize_auxtrace_info(struct auxtrace_record *itr, 525 struct perf_tool *tool, 526 struct perf_session *session, 527 perf_event__handler_t process); 528 int perf_event__process_auxtrace_info(struct perf_session *session, 529 union perf_event *event); 530 s64 perf_event__process_auxtrace(struct perf_session *session, 531 union perf_event *event); 532 int perf_event__process_auxtrace_error(struct perf_session *session, 533 union perf_event *event); 534 int itrace_parse_synth_opts(const struct option *opt, const char *str, 535 int unset); 536 void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts, 537 bool no_sample); 538 539 size_t perf_event__fprintf_auxtrace_error(union perf_event *event, FILE *fp); 540 void perf_session__auxtrace_error_inc(struct perf_session *session, 541 union perf_event *event); 542 void events_stats__auxtrace_error_warn(const struct events_stats *stats); 543 544 void addr_filters__init(struct addr_filters *filts); 545 void addr_filters__exit(struct addr_filters *filts); 546 int addr_filters__parse_bare_filter(struct addr_filters *filts, 547 const char *filter); 548 int auxtrace_parse_filters(struct perf_evlist *evlist); 549 550 static inline int auxtrace__process_event(struct perf_session *session, 551 union perf_event *event, 552 struct perf_sample *sample, 553 struct perf_tool *tool) 554 { 555 if (!session->auxtrace) 556 return 0; 557 558 return session->auxtrace->process_event(session, event, sample, tool); 559 } 560 561 static inline int auxtrace__flush_events(struct perf_session *session, 562 struct perf_tool *tool) 563 { 564 if (!session->auxtrace) 565 return 0; 566 567 return session->auxtrace->flush_events(session, tool); 568 } 569 570 static inline void auxtrace__free_events(struct perf_session *session) 571 { 572 if (!session->auxtrace) 573 return; 574 575 return session->auxtrace->free_events(session); 576 } 577 578 static inline void auxtrace__free(struct perf_session *session) 579 { 580 if (!session->auxtrace) 581 return; 582 583 return session->auxtrace->free(session); 584 } 585 586 #define ITRACE_HELP \ 587 " i: synthesize instructions events\n" \ 588 " b: synthesize branches events\n" \ 589 " c: synthesize branches events (calls only)\n" \ 590 " r: synthesize branches events (returns only)\n" \ 591 " x: synthesize transactions events\n" \ 592 " w: synthesize ptwrite events\n" \ 593 " p: synthesize power events\n" \ 594 " e: synthesize error events\n" \ 595 " d: create a debug log\n" \ 596 " g[len]: synthesize a call chain (use with i or x)\n" \ 597 " l[len]: synthesize last branch entries (use with i or x)\n" \ 598 " sNUMBER: skip initial number of events\n" \ 599 " PERIOD[ns|us|ms|i|t]: specify period to sample stream\n" \ 600 " concatenate multiple options. Default is ibxwpe or cewp\n" 601 602 603 #else 604 605 static inline struct auxtrace_record * 606 auxtrace_record__init(struct perf_evlist *evlist __maybe_unused, 607 int *err) 608 { 609 *err = 0; 610 return NULL; 611 } 612 613 static inline 614 void auxtrace_record__free(struct auxtrace_record *itr __maybe_unused) 615 { 616 } 617 618 static inline int 619 perf_event__synthesize_auxtrace_info(struct auxtrace_record *itr __maybe_unused, 620 struct perf_tool *tool __maybe_unused, 621 struct perf_session *session __maybe_unused, 622 perf_event__handler_t process __maybe_unused) 623 { 624 return -EINVAL; 625 } 626 627 static inline 628 int auxtrace_record__options(struct auxtrace_record *itr __maybe_unused, 629 struct perf_evlist *evlist __maybe_unused, 630 struct record_opts *opts __maybe_unused) 631 { 632 return 0; 633 } 634 635 #define perf_event__process_auxtrace_info 0 636 #define perf_event__process_auxtrace 0 637 #define perf_event__process_auxtrace_error 0 638 639 static inline 640 void perf_session__auxtrace_error_inc(struct perf_session *session 641 __maybe_unused, 642 union perf_event *event 643 __maybe_unused) 644 { 645 } 646 647 static inline 648 void events_stats__auxtrace_error_warn(const struct events_stats *stats 649 __maybe_unused) 650 { 651 } 652 653 static inline 654 int itrace_parse_synth_opts(const struct option *opt __maybe_unused, 655 const char *str __maybe_unused, 656 int unset __maybe_unused) 657 { 658 pr_err("AUX area tracing not supported\n"); 659 return -EINVAL; 660 } 661 662 static inline 663 int auxtrace_parse_snapshot_options(struct auxtrace_record *itr __maybe_unused, 664 struct record_opts *opts __maybe_unused, 665 const char *str) 666 { 667 if (!str) 668 return 0; 669 pr_err("AUX area tracing not supported\n"); 670 return -EINVAL; 671 } 672 673 static inline 674 int auxtrace__process_event(struct perf_session *session __maybe_unused, 675 union perf_event *event __maybe_unused, 676 struct perf_sample *sample __maybe_unused, 677 struct perf_tool *tool __maybe_unused) 678 { 679 return 0; 680 } 681 682 static inline 683 int auxtrace__flush_events(struct perf_session *session __maybe_unused, 684 struct perf_tool *tool __maybe_unused) 685 { 686 return 0; 687 } 688 689 static inline 690 void auxtrace__free_events(struct perf_session *session __maybe_unused) 691 { 692 } 693 694 static inline 695 void auxtrace_cache__free(struct auxtrace_cache *auxtrace_cache __maybe_unused) 696 { 697 } 698 699 static inline 700 void auxtrace__free(struct perf_session *session __maybe_unused) 701 { 702 } 703 704 static inline 705 int auxtrace_index__write(int fd __maybe_unused, 706 struct list_head *head __maybe_unused) 707 { 708 return -EINVAL; 709 } 710 711 static inline 712 int auxtrace_index__process(int fd __maybe_unused, 713 u64 size __maybe_unused, 714 struct perf_session *session __maybe_unused, 715 bool needs_swap __maybe_unused) 716 { 717 return -EINVAL; 718 } 719 720 static inline 721 void auxtrace_index__free(struct list_head *head __maybe_unused) 722 { 723 } 724 725 static inline 726 int auxtrace_parse_filters(struct perf_evlist *evlist __maybe_unused) 727 { 728 return 0; 729 } 730 731 int auxtrace_mmap__mmap(struct auxtrace_mmap *mm, 732 struct auxtrace_mmap_params *mp, 733 void *userpg, int fd); 734 void auxtrace_mmap__munmap(struct auxtrace_mmap *mm); 735 void auxtrace_mmap_params__init(struct auxtrace_mmap_params *mp, 736 off_t auxtrace_offset, 737 unsigned int auxtrace_pages, 738 bool auxtrace_overwrite); 739 void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp, 740 struct perf_evlist *evlist, int idx, 741 bool per_cpu); 742 743 #define ITRACE_HELP "" 744 745 #endif 746 747 #endif 748