1 /* SPDX-License-Identifier: GPL-2.0 */ 2 3 #ifndef _LINUX_TRACE_EVENT_H 4 #define _LINUX_TRACE_EVENT_H 5 6 #include <linux/ring_buffer.h> 7 #include <linux/trace_seq.h> 8 #include <linux/percpu.h> 9 #include <linux/hardirq.h> 10 #include <linux/perf_event.h> 11 #include <linux/tracepoint.h> 12 13 struct trace_array; 14 struct array_buffer; 15 struct tracer; 16 struct dentry; 17 struct bpf_prog; 18 19 const char *trace_print_flags_seq(struct trace_seq *p, const char *delim, 20 unsigned long flags, 21 const struct trace_print_flags *flag_array); 22 23 const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val, 24 const struct trace_print_flags *symbol_array); 25 26 #if BITS_PER_LONG == 32 27 const char *trace_print_flags_seq_u64(struct trace_seq *p, const char *delim, 28 unsigned long long flags, 29 const struct trace_print_flags_u64 *flag_array); 30 31 const char *trace_print_symbols_seq_u64(struct trace_seq *p, 32 unsigned long long val, 33 const struct trace_print_flags_u64 34 *symbol_array); 35 #endif 36 37 const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr, 38 unsigned int bitmask_size); 39 40 const char *trace_print_hex_seq(struct trace_seq *p, 41 const unsigned char *buf, int len, 42 bool concatenate); 43 44 const char *trace_print_array_seq(struct trace_seq *p, 45 const void *buf, int count, 46 size_t el_size); 47 48 const char * 49 trace_print_hex_dump_seq(struct trace_seq *p, const char *prefix_str, 50 int prefix_type, int rowsize, int groupsize, 51 const void *buf, size_t len, bool ascii); 52 53 struct trace_iterator; 54 struct trace_event; 55 56 int trace_raw_output_prep(struct trace_iterator *iter, 57 struct trace_event *event); 58 extern __printf(2, 3) 59 void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...); 60 61 /* 62 * The trace entry - the most basic unit of tracing. This is what 63 * is printed in the end as a single line in the trace output, such as: 64 * 65 * bash-15816 [01] 235.197585: idle_cpu <- irq_enter 66 */ 67 struct trace_entry { 68 unsigned short type; 69 unsigned char flags; 70 unsigned char preempt_count; 71 int pid; 72 }; 73 74 #define TRACE_EVENT_TYPE_MAX \ 75 ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1) 76 77 /* 78 * Trace iterator - used by printout routines who present trace 79 * results to users and which routines might sleep, etc: 80 */ 81 struct trace_iterator { 82 struct trace_array *tr; 83 struct tracer *trace; 84 struct array_buffer *array_buffer; 85 void *private; 86 int cpu_file; 87 struct mutex mutex; 88 struct ring_buffer_iter **buffer_iter; 89 unsigned long iter_flags; 90 void *temp; /* temp holder */ 91 unsigned int temp_size; 92 char *fmt; /* modified format holder */ 93 unsigned int fmt_size; 94 95 /* trace_seq for __print_flags() and __print_symbolic() etc. */ 96 struct trace_seq tmp_seq; 97 98 cpumask_var_t started; 99 100 /* it's true when current open file is snapshot */ 101 bool snapshot; 102 103 /* The below is zeroed out in pipe_read */ 104 struct trace_seq seq; 105 struct trace_entry *ent; 106 unsigned long lost_events; 107 int leftover; 108 int ent_size; 109 int cpu; 110 u64 ts; 111 112 loff_t pos; 113 long idx; 114 115 /* All new field here will be zeroed out in pipe_read */ 116 }; 117 118 enum trace_iter_flags { 119 TRACE_FILE_LAT_FMT = 1, 120 TRACE_FILE_ANNOTATE = 2, 121 TRACE_FILE_TIME_IN_NS = 4, 122 }; 123 124 125 typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter, 126 int flags, struct trace_event *event); 127 128 struct trace_event_functions { 129 trace_print_func trace; 130 trace_print_func raw; 131 trace_print_func hex; 132 trace_print_func binary; 133 }; 134 135 struct trace_event { 136 struct hlist_node node; 137 struct list_head list; 138 int type; 139 struct trace_event_functions *funcs; 140 }; 141 142 extern int register_trace_event(struct trace_event *event); 143 extern int unregister_trace_event(struct trace_event *event); 144 145 /* Return values for print_line callback */ 146 enum print_line_t { 147 TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */ 148 TRACE_TYPE_HANDLED = 1, 149 TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */ 150 TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */ 151 }; 152 153 enum print_line_t trace_handle_return(struct trace_seq *s); 154 155 static inline void tracing_generic_entry_update(struct trace_entry *entry, 156 unsigned short type, 157 unsigned int trace_ctx) 158 { 159 entry->preempt_count = trace_ctx & 0xff; 160 entry->pid = current->pid; 161 entry->type = type; 162 entry->flags = trace_ctx >> 16; 163 } 164 165 unsigned int tracing_gen_ctx_irq_test(unsigned int irqs_status); 166 167 enum trace_flag_type { 168 TRACE_FLAG_IRQS_OFF = 0x01, 169 TRACE_FLAG_IRQS_NOSUPPORT = 0x02, 170 TRACE_FLAG_NEED_RESCHED = 0x04, 171 TRACE_FLAG_HARDIRQ = 0x08, 172 TRACE_FLAG_SOFTIRQ = 0x10, 173 TRACE_FLAG_PREEMPT_RESCHED = 0x20, 174 TRACE_FLAG_NMI = 0x40, 175 }; 176 177 #ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT 178 static inline unsigned int tracing_gen_ctx_flags(unsigned long irqflags) 179 { 180 unsigned int irq_status = irqs_disabled_flags(irqflags) ? 181 TRACE_FLAG_IRQS_OFF : 0; 182 return tracing_gen_ctx_irq_test(irq_status); 183 } 184 static inline unsigned int tracing_gen_ctx(void) 185 { 186 unsigned long irqflags; 187 188 local_save_flags(irqflags); 189 return tracing_gen_ctx_flags(irqflags); 190 } 191 #else 192 193 static inline unsigned int tracing_gen_ctx_flags(unsigned long irqflags) 194 { 195 return tracing_gen_ctx_irq_test(TRACE_FLAG_IRQS_NOSUPPORT); 196 } 197 static inline unsigned int tracing_gen_ctx(void) 198 { 199 return tracing_gen_ctx_irq_test(TRACE_FLAG_IRQS_NOSUPPORT); 200 } 201 #endif 202 203 static inline unsigned int tracing_gen_ctx_dec(void) 204 { 205 unsigned int trace_ctx; 206 207 trace_ctx = tracing_gen_ctx(); 208 /* 209 * Subtract one from the preeption counter if preemption is enabled, 210 * see trace_event_buffer_reserve()for details. 211 */ 212 if (IS_ENABLED(CONFIG_PREEMPTION)) 213 trace_ctx--; 214 return trace_ctx; 215 } 216 217 struct trace_event_file; 218 219 struct ring_buffer_event * 220 trace_event_buffer_lock_reserve(struct trace_buffer **current_buffer, 221 struct trace_event_file *trace_file, 222 int type, unsigned long len, 223 unsigned int trace_ctx); 224 225 #define TRACE_RECORD_CMDLINE BIT(0) 226 #define TRACE_RECORD_TGID BIT(1) 227 228 void tracing_record_taskinfo(struct task_struct *task, int flags); 229 void tracing_record_taskinfo_sched_switch(struct task_struct *prev, 230 struct task_struct *next, int flags); 231 232 void tracing_record_cmdline(struct task_struct *task); 233 void tracing_record_tgid(struct task_struct *task); 234 235 int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...); 236 237 struct event_filter; 238 239 enum trace_reg { 240 TRACE_REG_REGISTER, 241 TRACE_REG_UNREGISTER, 242 #ifdef CONFIG_PERF_EVENTS 243 TRACE_REG_PERF_REGISTER, 244 TRACE_REG_PERF_UNREGISTER, 245 TRACE_REG_PERF_OPEN, 246 TRACE_REG_PERF_CLOSE, 247 /* 248 * These (ADD/DEL) use a 'boolean' return value, where 1 (true) means a 249 * custom action was taken and the default action is not to be 250 * performed. 251 */ 252 TRACE_REG_PERF_ADD, 253 TRACE_REG_PERF_DEL, 254 #endif 255 }; 256 257 struct trace_event_call; 258 259 #define TRACE_FUNCTION_TYPE ((const char *)~0UL) 260 261 struct trace_event_fields { 262 const char *type; 263 union { 264 struct { 265 const char *name; 266 const int size; 267 const int align; 268 const int is_signed; 269 const int filter_type; 270 }; 271 int (*define_fields)(struct trace_event_call *); 272 }; 273 }; 274 275 struct trace_event_class { 276 const char *system; 277 void *probe; 278 #ifdef CONFIG_PERF_EVENTS 279 void *perf_probe; 280 #endif 281 int (*reg)(struct trace_event_call *event, 282 enum trace_reg type, void *data); 283 struct trace_event_fields *fields_array; 284 struct list_head *(*get_fields)(struct trace_event_call *); 285 struct list_head fields; 286 int (*raw_init)(struct trace_event_call *); 287 }; 288 289 extern int trace_event_reg(struct trace_event_call *event, 290 enum trace_reg type, void *data); 291 292 struct trace_event_buffer { 293 struct trace_buffer *buffer; 294 struct ring_buffer_event *event; 295 struct trace_event_file *trace_file; 296 void *entry; 297 unsigned int trace_ctx; 298 struct pt_regs *regs; 299 }; 300 301 void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer, 302 struct trace_event_file *trace_file, 303 unsigned long len); 304 305 void trace_event_buffer_commit(struct trace_event_buffer *fbuffer); 306 307 enum { 308 TRACE_EVENT_FL_FILTERED_BIT, 309 TRACE_EVENT_FL_CAP_ANY_BIT, 310 TRACE_EVENT_FL_NO_SET_FILTER_BIT, 311 TRACE_EVENT_FL_IGNORE_ENABLE_BIT, 312 TRACE_EVENT_FL_TRACEPOINT_BIT, 313 TRACE_EVENT_FL_KPROBE_BIT, 314 TRACE_EVENT_FL_UPROBE_BIT, 315 }; 316 317 /* 318 * Event flags: 319 * FILTERED - The event has a filter attached 320 * CAP_ANY - Any user can enable for perf 321 * NO_SET_FILTER - Set when filter has error and is to be ignored 322 * IGNORE_ENABLE - For trace internal events, do not enable with debugfs file 323 * TRACEPOINT - Event is a tracepoint 324 * KPROBE - Event is a kprobe 325 * UPROBE - Event is a uprobe 326 */ 327 enum { 328 TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT), 329 TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT), 330 TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT), 331 TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT), 332 TRACE_EVENT_FL_TRACEPOINT = (1 << TRACE_EVENT_FL_TRACEPOINT_BIT), 333 TRACE_EVENT_FL_KPROBE = (1 << TRACE_EVENT_FL_KPROBE_BIT), 334 TRACE_EVENT_FL_UPROBE = (1 << TRACE_EVENT_FL_UPROBE_BIT), 335 }; 336 337 #define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE) 338 339 struct trace_event_call { 340 struct list_head list; 341 struct trace_event_class *class; 342 union { 343 char *name; 344 /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */ 345 struct tracepoint *tp; 346 }; 347 struct trace_event event; 348 char *print_fmt; 349 struct event_filter *filter; 350 void *mod; 351 void *data; 352 /* 353 * bit 0: filter_active 354 * bit 1: allow trace by non root (cap any) 355 * bit 2: failed to apply filter 356 * bit 3: trace internal event (do not enable) 357 * bit 4: Event was enabled by module 358 * bit 5: use call filter rather than file filter 359 * bit 6: Event is a tracepoint 360 */ 361 int flags; /* static flags of different events */ 362 363 #ifdef CONFIG_PERF_EVENTS 364 int perf_refcount; 365 struct hlist_head __percpu *perf_events; 366 struct bpf_prog_array __rcu *prog_array; 367 368 int (*perf_perm)(struct trace_event_call *, 369 struct perf_event *); 370 #endif 371 }; 372 373 #ifdef CONFIG_PERF_EVENTS 374 static inline bool bpf_prog_array_valid(struct trace_event_call *call) 375 { 376 /* 377 * This inline function checks whether call->prog_array 378 * is valid or not. The function is called in various places, 379 * outside rcu_read_lock/unlock, as a heuristic to speed up execution. 380 * 381 * If this function returns true, and later call->prog_array 382 * becomes false inside rcu_read_lock/unlock region, 383 * we bail out then. If this function return false, 384 * there is a risk that we might miss a few events if the checking 385 * were delayed until inside rcu_read_lock/unlock region and 386 * call->prog_array happened to become non-NULL then. 387 * 388 * Here, READ_ONCE() is used instead of rcu_access_pointer(). 389 * rcu_access_pointer() requires the actual definition of 390 * "struct bpf_prog_array" while READ_ONCE() only needs 391 * a declaration of the same type. 392 */ 393 return !!READ_ONCE(call->prog_array); 394 } 395 #endif 396 397 static inline const char * 398 trace_event_name(struct trace_event_call *call) 399 { 400 if (call->flags & TRACE_EVENT_FL_TRACEPOINT) 401 return call->tp ? call->tp->name : NULL; 402 else 403 return call->name; 404 } 405 406 static inline struct list_head * 407 trace_get_fields(struct trace_event_call *event_call) 408 { 409 if (!event_call->class->get_fields) 410 return &event_call->class->fields; 411 return event_call->class->get_fields(event_call); 412 } 413 414 struct trace_array; 415 struct trace_subsystem_dir; 416 417 enum { 418 EVENT_FILE_FL_ENABLED_BIT, 419 EVENT_FILE_FL_RECORDED_CMD_BIT, 420 EVENT_FILE_FL_RECORDED_TGID_BIT, 421 EVENT_FILE_FL_FILTERED_BIT, 422 EVENT_FILE_FL_NO_SET_FILTER_BIT, 423 EVENT_FILE_FL_SOFT_MODE_BIT, 424 EVENT_FILE_FL_SOFT_DISABLED_BIT, 425 EVENT_FILE_FL_TRIGGER_MODE_BIT, 426 EVENT_FILE_FL_TRIGGER_COND_BIT, 427 EVENT_FILE_FL_PID_FILTER_BIT, 428 EVENT_FILE_FL_WAS_ENABLED_BIT, 429 }; 430 431 extern struct trace_event_file *trace_get_event_file(const char *instance, 432 const char *system, 433 const char *event); 434 extern void trace_put_event_file(struct trace_event_file *file); 435 436 #define MAX_DYNEVENT_CMD_LEN (2048) 437 438 enum dynevent_type { 439 DYNEVENT_TYPE_SYNTH = 1, 440 DYNEVENT_TYPE_KPROBE, 441 DYNEVENT_TYPE_NONE, 442 }; 443 444 struct dynevent_cmd; 445 446 typedef int (*dynevent_create_fn_t)(struct dynevent_cmd *cmd); 447 448 struct dynevent_cmd { 449 struct seq_buf seq; 450 const char *event_name; 451 unsigned int n_fields; 452 enum dynevent_type type; 453 dynevent_create_fn_t run_command; 454 void *private_data; 455 }; 456 457 extern int dynevent_create(struct dynevent_cmd *cmd); 458 459 extern int synth_event_delete(const char *name); 460 461 extern void synth_event_cmd_init(struct dynevent_cmd *cmd, 462 char *buf, int maxlen); 463 464 extern int __synth_event_gen_cmd_start(struct dynevent_cmd *cmd, 465 const char *name, 466 struct module *mod, ...); 467 468 #define synth_event_gen_cmd_start(cmd, name, mod, ...) \ 469 __synth_event_gen_cmd_start(cmd, name, mod, ## __VA_ARGS__, NULL) 470 471 struct synth_field_desc { 472 const char *type; 473 const char *name; 474 }; 475 476 extern int synth_event_gen_cmd_array_start(struct dynevent_cmd *cmd, 477 const char *name, 478 struct module *mod, 479 struct synth_field_desc *fields, 480 unsigned int n_fields); 481 extern int synth_event_create(const char *name, 482 struct synth_field_desc *fields, 483 unsigned int n_fields, struct module *mod); 484 485 extern int synth_event_add_field(struct dynevent_cmd *cmd, 486 const char *type, 487 const char *name); 488 extern int synth_event_add_field_str(struct dynevent_cmd *cmd, 489 const char *type_name); 490 extern int synth_event_add_fields(struct dynevent_cmd *cmd, 491 struct synth_field_desc *fields, 492 unsigned int n_fields); 493 494 #define synth_event_gen_cmd_end(cmd) \ 495 dynevent_create(cmd) 496 497 struct synth_event; 498 499 struct synth_event_trace_state { 500 struct trace_event_buffer fbuffer; 501 struct synth_trace_event *entry; 502 struct trace_buffer *buffer; 503 struct synth_event *event; 504 unsigned int cur_field; 505 unsigned int n_u64; 506 bool disabled; 507 bool add_next; 508 bool add_name; 509 }; 510 511 extern int synth_event_trace(struct trace_event_file *file, 512 unsigned int n_vals, ...); 513 extern int synth_event_trace_array(struct trace_event_file *file, u64 *vals, 514 unsigned int n_vals); 515 extern int synth_event_trace_start(struct trace_event_file *file, 516 struct synth_event_trace_state *trace_state); 517 extern int synth_event_add_next_val(u64 val, 518 struct synth_event_trace_state *trace_state); 519 extern int synth_event_add_val(const char *field_name, u64 val, 520 struct synth_event_trace_state *trace_state); 521 extern int synth_event_trace_end(struct synth_event_trace_state *trace_state); 522 523 extern int kprobe_event_delete(const char *name); 524 525 extern void kprobe_event_cmd_init(struct dynevent_cmd *cmd, 526 char *buf, int maxlen); 527 528 #define kprobe_event_gen_cmd_start(cmd, name, loc, ...) \ 529 __kprobe_event_gen_cmd_start(cmd, false, name, loc, ## __VA_ARGS__, NULL) 530 531 #define kretprobe_event_gen_cmd_start(cmd, name, loc, ...) \ 532 __kprobe_event_gen_cmd_start(cmd, true, name, loc, ## __VA_ARGS__, NULL) 533 534 extern int __kprobe_event_gen_cmd_start(struct dynevent_cmd *cmd, 535 bool kretprobe, 536 const char *name, 537 const char *loc, ...); 538 539 #define kprobe_event_add_fields(cmd, ...) \ 540 __kprobe_event_add_fields(cmd, ## __VA_ARGS__, NULL) 541 542 #define kprobe_event_add_field(cmd, field) \ 543 __kprobe_event_add_fields(cmd, field, NULL) 544 545 extern int __kprobe_event_add_fields(struct dynevent_cmd *cmd, ...); 546 547 #define kprobe_event_gen_cmd_end(cmd) \ 548 dynevent_create(cmd) 549 550 #define kretprobe_event_gen_cmd_end(cmd) \ 551 dynevent_create(cmd) 552 553 /* 554 * Event file flags: 555 * ENABLED - The event is enabled 556 * RECORDED_CMD - The comms should be recorded at sched_switch 557 * RECORDED_TGID - The tgids should be recorded at sched_switch 558 * FILTERED - The event has a filter attached 559 * NO_SET_FILTER - Set when filter has error and is to be ignored 560 * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED 561 * SOFT_DISABLED - When set, do not trace the event (even though its 562 * tracepoint may be enabled) 563 * TRIGGER_MODE - When set, invoke the triggers associated with the event 564 * TRIGGER_COND - When set, one or more triggers has an associated filter 565 * PID_FILTER - When set, the event is filtered based on pid 566 * WAS_ENABLED - Set when enabled to know to clear trace on module removal 567 */ 568 enum { 569 EVENT_FILE_FL_ENABLED = (1 << EVENT_FILE_FL_ENABLED_BIT), 570 EVENT_FILE_FL_RECORDED_CMD = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT), 571 EVENT_FILE_FL_RECORDED_TGID = (1 << EVENT_FILE_FL_RECORDED_TGID_BIT), 572 EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT), 573 EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT), 574 EVENT_FILE_FL_SOFT_MODE = (1 << EVENT_FILE_FL_SOFT_MODE_BIT), 575 EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT), 576 EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT), 577 EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT), 578 EVENT_FILE_FL_PID_FILTER = (1 << EVENT_FILE_FL_PID_FILTER_BIT), 579 EVENT_FILE_FL_WAS_ENABLED = (1 << EVENT_FILE_FL_WAS_ENABLED_BIT), 580 }; 581 582 struct trace_event_file { 583 struct list_head list; 584 struct trace_event_call *event_call; 585 struct event_filter __rcu *filter; 586 struct dentry *dir; 587 struct trace_array *tr; 588 struct trace_subsystem_dir *system; 589 struct list_head triggers; 590 591 /* 592 * 32 bit flags: 593 * bit 0: enabled 594 * bit 1: enabled cmd record 595 * bit 2: enable/disable with the soft disable bit 596 * bit 3: soft disabled 597 * bit 4: trigger enabled 598 * 599 * Note: The bits must be set atomically to prevent races 600 * from other writers. Reads of flags do not need to be in 601 * sync as they occur in critical sections. But the way flags 602 * is currently used, these changes do not affect the code 603 * except that when a change is made, it may have a slight 604 * delay in propagating the changes to other CPUs due to 605 * caching and such. Which is mostly OK ;-) 606 */ 607 unsigned long flags; 608 atomic_t sm_ref; /* soft-mode reference counter */ 609 atomic_t tm_ref; /* trigger-mode reference counter */ 610 }; 611 612 #define __TRACE_EVENT_FLAGS(name, value) \ 613 static int __init trace_init_flags_##name(void) \ 614 { \ 615 event_##name.flags |= value; \ 616 return 0; \ 617 } \ 618 early_initcall(trace_init_flags_##name); 619 620 #define __TRACE_EVENT_PERF_PERM(name, expr...) \ 621 static int perf_perm_##name(struct trace_event_call *tp_event, \ 622 struct perf_event *p_event) \ 623 { \ 624 return ({ expr; }); \ 625 } \ 626 static int __init trace_init_perf_perm_##name(void) \ 627 { \ 628 event_##name.perf_perm = &perf_perm_##name; \ 629 return 0; \ 630 } \ 631 early_initcall(trace_init_perf_perm_##name); 632 633 #define PERF_MAX_TRACE_SIZE 2048 634 635 #define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */ 636 637 enum event_trigger_type { 638 ETT_NONE = (0), 639 ETT_TRACE_ONOFF = (1 << 0), 640 ETT_SNAPSHOT = (1 << 1), 641 ETT_STACKTRACE = (1 << 2), 642 ETT_EVENT_ENABLE = (1 << 3), 643 ETT_EVENT_HIST = (1 << 4), 644 ETT_HIST_ENABLE = (1 << 5), 645 }; 646 647 extern int filter_match_preds(struct event_filter *filter, void *rec); 648 649 extern enum event_trigger_type 650 event_triggers_call(struct trace_event_file *file, void *rec, 651 struct ring_buffer_event *event); 652 extern void 653 event_triggers_post_call(struct trace_event_file *file, 654 enum event_trigger_type tt); 655 656 bool trace_event_ignore_this_pid(struct trace_event_file *trace_file); 657 658 /** 659 * trace_trigger_soft_disabled - do triggers and test if soft disabled 660 * @file: The file pointer of the event to test 661 * 662 * If any triggers without filters are attached to this event, they 663 * will be called here. If the event is soft disabled and has no 664 * triggers that require testing the fields, it will return true, 665 * otherwise false. 666 */ 667 static inline bool 668 trace_trigger_soft_disabled(struct trace_event_file *file) 669 { 670 unsigned long eflags = file->flags; 671 672 if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) { 673 if (eflags & EVENT_FILE_FL_TRIGGER_MODE) 674 event_triggers_call(file, NULL, NULL); 675 if (eflags & EVENT_FILE_FL_SOFT_DISABLED) 676 return true; 677 if (eflags & EVENT_FILE_FL_PID_FILTER) 678 return trace_event_ignore_this_pid(file); 679 } 680 return false; 681 } 682 683 #ifdef CONFIG_BPF_EVENTS 684 unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx); 685 int perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog); 686 void perf_event_detach_bpf_prog(struct perf_event *event); 687 int perf_event_query_prog_array(struct perf_event *event, void __user *info); 688 int bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *prog); 689 int bpf_probe_unregister(struct bpf_raw_event_map *btp, struct bpf_prog *prog); 690 struct bpf_raw_event_map *bpf_get_raw_tracepoint(const char *name); 691 void bpf_put_raw_tracepoint(struct bpf_raw_event_map *btp); 692 int bpf_get_perf_event_info(const struct perf_event *event, u32 *prog_id, 693 u32 *fd_type, const char **buf, 694 u64 *probe_offset, u64 *probe_addr); 695 #else 696 static inline unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx) 697 { 698 return 1; 699 } 700 701 static inline int 702 perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog) 703 { 704 return -EOPNOTSUPP; 705 } 706 707 static inline void perf_event_detach_bpf_prog(struct perf_event *event) { } 708 709 static inline int 710 perf_event_query_prog_array(struct perf_event *event, void __user *info) 711 { 712 return -EOPNOTSUPP; 713 } 714 static inline int bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *p) 715 { 716 return -EOPNOTSUPP; 717 } 718 static inline int bpf_probe_unregister(struct bpf_raw_event_map *btp, struct bpf_prog *p) 719 { 720 return -EOPNOTSUPP; 721 } 722 static inline struct bpf_raw_event_map *bpf_get_raw_tracepoint(const char *name) 723 { 724 return NULL; 725 } 726 static inline void bpf_put_raw_tracepoint(struct bpf_raw_event_map *btp) 727 { 728 } 729 static inline int bpf_get_perf_event_info(const struct perf_event *event, 730 u32 *prog_id, u32 *fd_type, 731 const char **buf, u64 *probe_offset, 732 u64 *probe_addr) 733 { 734 return -EOPNOTSUPP; 735 } 736 #endif 737 738 enum { 739 FILTER_OTHER = 0, 740 FILTER_STATIC_STRING, 741 FILTER_DYN_STRING, 742 FILTER_PTR_STRING, 743 FILTER_TRACE_FN, 744 FILTER_COMM, 745 FILTER_CPU, 746 }; 747 748 extern int trace_event_raw_init(struct trace_event_call *call); 749 extern int trace_define_field(struct trace_event_call *call, const char *type, 750 const char *name, int offset, int size, 751 int is_signed, int filter_type); 752 extern int trace_add_event_call(struct trace_event_call *call); 753 extern int trace_remove_event_call(struct trace_event_call *call); 754 extern int trace_event_get_offsets(struct trace_event_call *call); 755 756 #define is_signed_type(type) (((type)(-1)) < (type)1) 757 758 int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set); 759 int trace_set_clr_event(const char *system, const char *event, int set); 760 int trace_array_set_clr_event(struct trace_array *tr, const char *system, 761 const char *event, bool enable); 762 /* 763 * The double __builtin_constant_p is because gcc will give us an error 764 * if we try to allocate the static variable to fmt if it is not a 765 * constant. Even with the outer if statement optimizing out. 766 */ 767 #define event_trace_printk(ip, fmt, args...) \ 768 do { \ 769 __trace_printk_check_format(fmt, ##args); \ 770 tracing_record_cmdline(current); \ 771 if (__builtin_constant_p(fmt)) { \ 772 static const char *trace_printk_fmt \ 773 __section("__trace_printk_fmt") = \ 774 __builtin_constant_p(fmt) ? fmt : NULL; \ 775 \ 776 __trace_bprintk(ip, trace_printk_fmt, ##args); \ 777 } else \ 778 __trace_printk(ip, fmt, ##args); \ 779 } while (0) 780 781 #ifdef CONFIG_PERF_EVENTS 782 struct perf_event; 783 784 DECLARE_PER_CPU(struct pt_regs, perf_trace_regs); 785 DECLARE_PER_CPU(int, bpf_kprobe_override); 786 787 extern int perf_trace_init(struct perf_event *event); 788 extern void perf_trace_destroy(struct perf_event *event); 789 extern int perf_trace_add(struct perf_event *event, int flags); 790 extern void perf_trace_del(struct perf_event *event, int flags); 791 #ifdef CONFIG_KPROBE_EVENTS 792 extern int perf_kprobe_init(struct perf_event *event, bool is_retprobe); 793 extern void perf_kprobe_destroy(struct perf_event *event); 794 extern int bpf_get_kprobe_info(const struct perf_event *event, 795 u32 *fd_type, const char **symbol, 796 u64 *probe_offset, u64 *probe_addr, 797 bool perf_type_tracepoint); 798 #endif 799 #ifdef CONFIG_UPROBE_EVENTS 800 extern int perf_uprobe_init(struct perf_event *event, 801 unsigned long ref_ctr_offset, bool is_retprobe); 802 extern void perf_uprobe_destroy(struct perf_event *event); 803 extern int bpf_get_uprobe_info(const struct perf_event *event, 804 u32 *fd_type, const char **filename, 805 u64 *probe_offset, bool perf_type_tracepoint); 806 #endif 807 extern int ftrace_profile_set_filter(struct perf_event *event, int event_id, 808 char *filter_str); 809 extern void ftrace_profile_free_filter(struct perf_event *event); 810 void perf_trace_buf_update(void *record, u16 type); 811 void *perf_trace_buf_alloc(int size, struct pt_regs **regs, int *rctxp); 812 813 void bpf_trace_run1(struct bpf_prog *prog, u64 arg1); 814 void bpf_trace_run2(struct bpf_prog *prog, u64 arg1, u64 arg2); 815 void bpf_trace_run3(struct bpf_prog *prog, u64 arg1, u64 arg2, 816 u64 arg3); 817 void bpf_trace_run4(struct bpf_prog *prog, u64 arg1, u64 arg2, 818 u64 arg3, u64 arg4); 819 void bpf_trace_run5(struct bpf_prog *prog, u64 arg1, u64 arg2, 820 u64 arg3, u64 arg4, u64 arg5); 821 void bpf_trace_run6(struct bpf_prog *prog, u64 arg1, u64 arg2, 822 u64 arg3, u64 arg4, u64 arg5, u64 arg6); 823 void bpf_trace_run7(struct bpf_prog *prog, u64 arg1, u64 arg2, 824 u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7); 825 void bpf_trace_run8(struct bpf_prog *prog, u64 arg1, u64 arg2, 826 u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7, 827 u64 arg8); 828 void bpf_trace_run9(struct bpf_prog *prog, u64 arg1, u64 arg2, 829 u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7, 830 u64 arg8, u64 arg9); 831 void bpf_trace_run10(struct bpf_prog *prog, u64 arg1, u64 arg2, 832 u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7, 833 u64 arg8, u64 arg9, u64 arg10); 834 void bpf_trace_run11(struct bpf_prog *prog, u64 arg1, u64 arg2, 835 u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7, 836 u64 arg8, u64 arg9, u64 arg10, u64 arg11); 837 void bpf_trace_run12(struct bpf_prog *prog, u64 arg1, u64 arg2, 838 u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7, 839 u64 arg8, u64 arg9, u64 arg10, u64 arg11, u64 arg12); 840 void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx, 841 struct trace_event_call *call, u64 count, 842 struct pt_regs *regs, struct hlist_head *head, 843 struct task_struct *task); 844 845 static inline void 846 perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type, 847 u64 count, struct pt_regs *regs, void *head, 848 struct task_struct *task) 849 { 850 perf_tp_event(type, count, raw_data, size, regs, head, rctx, task); 851 } 852 853 #endif 854 855 #endif /* _LINUX_TRACE_EVENT_H */ 856