| 1 | |
| 2 | #ifndef _LINUX_TRACE_EVENT_H |
| 3 | #define _LINUX_TRACE_EVENT_H |
| 4 | |
| 5 | #include <linux/ring_buffer.h> |
| 6 | #include <linux/trace_seq.h> |
| 7 | #include <linux/percpu.h> |
| 8 | #include <linux/hardirq.h> |
| 9 | #include <linux/perf_event.h> |
| 10 | #include <linux/tracepoint.h> |
| 11 | |
| 12 | struct trace_array; |
| 13 | struct trace_buffer; |
| 14 | struct tracer; |
| 15 | struct dentry; |
| 16 | struct bpf_prog; |
| 17 | |
| 18 | const char *trace_print_flags_seq(struct trace_seq *p, const char *delim, |
| 19 | unsigned long flags, |
| 20 | const struct trace_print_flags *flag_array); |
| 21 | |
| 22 | const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val, |
| 23 | const struct trace_print_flags *symbol_array); |
| 24 | |
| 25 | #if BITS_PER_LONG == 32 |
| 26 | const char *trace_print_symbols_seq_u64(struct trace_seq *p, |
| 27 | unsigned long long val, |
| 28 | const struct trace_print_flags_u64 |
| 29 | *symbol_array); |
| 30 | #endif |
| 31 | |
| 32 | const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr, |
| 33 | unsigned int bitmask_size); |
| 34 | |
| 35 | const char *trace_print_hex_seq(struct trace_seq *p, |
| 36 | const unsigned char *buf, int len); |
| 37 | |
| 38 | const char *trace_print_array_seq(struct trace_seq *p, |
| 39 | const void *buf, int count, |
| 40 | size_t el_size); |
| 41 | |
| 42 | struct trace_iterator; |
| 43 | struct trace_event; |
| 44 | |
| 45 | int trace_raw_output_prep(struct trace_iterator *iter, |
| 46 | struct trace_event *event); |
| 47 | |
| 48 | /* |
| 49 | * The trace entry - the most basic unit of tracing. This is what |
| 50 | * is printed in the end as a single line in the trace output, such as: |
| 51 | * |
| 52 | * bash-15816 [01] 235.197585: idle_cpu <- irq_enter |
| 53 | */ |
| 54 | struct trace_entry { |
| 55 | unsigned short type; |
| 56 | unsigned char flags; |
| 57 | unsigned char preempt_count; |
| 58 | int pid; |
| 59 | }; |
| 60 | |
| 61 | #define TRACE_EVENT_TYPE_MAX \ |
| 62 | ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1) |
| 63 | |
| 64 | /* |
| 65 | * Trace iterator - used by printout routines who present trace |
| 66 | * results to users and which routines might sleep, etc: |
| 67 | */ |
| 68 | struct trace_iterator { |
| 69 | struct trace_array *tr; |
| 70 | struct tracer *trace; |
| 71 | struct trace_buffer *trace_buffer; |
| 72 | void *private; |
| 73 | int cpu_file; |
| 74 | struct mutex mutex; |
| 75 | struct ring_buffer_iter **buffer_iter; |
| 76 | unsigned long iter_flags; |
| 77 | |
| 78 | /* trace_seq for __print_flags() and __print_symbolic() etc. */ |
| 79 | struct trace_seq tmp_seq; |
| 80 | |
| 81 | cpumask_var_t started; |
| 82 | |
| 83 | /* it's true when current open file is snapshot */ |
| 84 | bool snapshot; |
| 85 | |
| 86 | /* The below is zeroed out in pipe_read */ |
| 87 | struct trace_seq seq; |
| 88 | struct trace_entry *ent; |
| 89 | unsigned long lost_events; |
| 90 | int leftover; |
| 91 | int ent_size; |
| 92 | int cpu; |
| 93 | u64 ts; |
| 94 | |
| 95 | loff_t pos; |
| 96 | long idx; |
| 97 | |
| 98 | /* All new field here will be zeroed out in pipe_read */ |
| 99 | }; |
| 100 | |
| 101 | enum trace_iter_flags { |
| 102 | TRACE_FILE_LAT_FMT = 1, |
| 103 | TRACE_FILE_ANNOTATE = 2, |
| 104 | TRACE_FILE_TIME_IN_NS = 4, |
| 105 | }; |
| 106 | |
| 107 | |
| 108 | typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter, |
| 109 | int flags, struct trace_event *event); |
| 110 | |
| 111 | struct trace_event_functions { |
| 112 | trace_print_func trace; |
| 113 | trace_print_func raw; |
| 114 | trace_print_func hex; |
| 115 | trace_print_func binary; |
| 116 | }; |
| 117 | |
| 118 | struct trace_event { |
| 119 | struct hlist_node node; |
| 120 | struct list_head list; |
| 121 | int type; |
| 122 | struct trace_event_functions *funcs; |
| 123 | }; |
| 124 | |
| 125 | extern int register_trace_event(struct trace_event *event); |
| 126 | extern int unregister_trace_event(struct trace_event *event); |
| 127 | |
| 128 | /* Return values for print_line callback */ |
| 129 | enum print_line_t { |
| 130 | TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */ |
| 131 | TRACE_TYPE_HANDLED = 1, |
| 132 | TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */ |
| 133 | TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */ |
| 134 | }; |
| 135 | |
| 136 | /* |
| 137 | * Several functions return TRACE_TYPE_PARTIAL_LINE if the trace_seq |
| 138 | * overflowed, and TRACE_TYPE_HANDLED otherwise. This helper function |
| 139 | * simplifies those functions and keeps them in sync. |
| 140 | */ |
| 141 | static inline enum print_line_t trace_handle_return(struct trace_seq *s) |
| 142 | { |
| 143 | return trace_seq_has_overflowed(s) ? |
| 144 | TRACE_TYPE_PARTIAL_LINE : TRACE_TYPE_HANDLED; |
| 145 | } |
| 146 | |
| 147 | void tracing_generic_entry_update(struct trace_entry *entry, |
| 148 | unsigned long flags, |
| 149 | int pc); |
| 150 | struct trace_event_file; |
| 151 | |
| 152 | struct ring_buffer_event * |
| 153 | trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer, |
| 154 | struct trace_event_file *trace_file, |
| 155 | int type, unsigned long len, |
| 156 | unsigned long flags, int pc); |
| 157 | struct ring_buffer_event * |
| 158 | trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer, |
| 159 | int type, unsigned long len, |
| 160 | unsigned long flags, int pc); |
| 161 | void trace_buffer_unlock_commit(struct trace_array *tr, |
| 162 | struct ring_buffer *buffer, |
| 163 | struct ring_buffer_event *event, |
| 164 | unsigned long flags, int pc); |
| 165 | void trace_buffer_unlock_commit_regs(struct trace_array *tr, |
| 166 | struct ring_buffer *buffer, |
| 167 | struct ring_buffer_event *event, |
| 168 | unsigned long flags, int pc, |
| 169 | struct pt_regs *regs); |
| 170 | void trace_current_buffer_discard_commit(struct ring_buffer *buffer, |
| 171 | struct ring_buffer_event *event); |
| 172 | |
| 173 | void tracing_record_cmdline(struct task_struct *tsk); |
| 174 | |
| 175 | int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...); |
| 176 | |
| 177 | struct event_filter; |
| 178 | |
| 179 | enum trace_reg { |
| 180 | TRACE_REG_REGISTER, |
| 181 | TRACE_REG_UNREGISTER, |
| 182 | #ifdef CONFIG_PERF_EVENTS |
| 183 | TRACE_REG_PERF_REGISTER, |
| 184 | TRACE_REG_PERF_UNREGISTER, |
| 185 | TRACE_REG_PERF_OPEN, |
| 186 | TRACE_REG_PERF_CLOSE, |
| 187 | TRACE_REG_PERF_ADD, |
| 188 | TRACE_REG_PERF_DEL, |
| 189 | #endif |
| 190 | }; |
| 191 | |
| 192 | struct trace_event_call; |
| 193 | |
| 194 | struct trace_event_class { |
| 195 | const char *system; |
| 196 | void *probe; |
| 197 | #ifdef CONFIG_PERF_EVENTS |
| 198 | void *perf_probe; |
| 199 | #endif |
| 200 | int (*reg)(struct trace_event_call *event, |
| 201 | enum trace_reg type, void *data); |
| 202 | int (*define_fields)(struct trace_event_call *); |
| 203 | struct list_head *(*get_fields)(struct trace_event_call *); |
| 204 | struct list_head fields; |
| 205 | int (*raw_init)(struct trace_event_call *); |
| 206 | }; |
| 207 | |
| 208 | extern int trace_event_reg(struct trace_event_call *event, |
| 209 | enum trace_reg type, void *data); |
| 210 | |
| 211 | struct trace_event_buffer { |
| 212 | struct ring_buffer *buffer; |
| 213 | struct ring_buffer_event *event; |
| 214 | struct trace_event_file *trace_file; |
| 215 | void *entry; |
| 216 | unsigned long flags; |
| 217 | int pc; |
| 218 | }; |
| 219 | |
| 220 | void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer, |
| 221 | struct trace_event_file *trace_file, |
| 222 | unsigned long len); |
| 223 | |
| 224 | void trace_event_buffer_commit(struct trace_event_buffer *fbuffer); |
| 225 | |
| 226 | enum { |
| 227 | TRACE_EVENT_FL_FILTERED_BIT, |
| 228 | TRACE_EVENT_FL_CAP_ANY_BIT, |
| 229 | TRACE_EVENT_FL_NO_SET_FILTER_BIT, |
| 230 | TRACE_EVENT_FL_IGNORE_ENABLE_BIT, |
| 231 | TRACE_EVENT_FL_WAS_ENABLED_BIT, |
| 232 | TRACE_EVENT_FL_USE_CALL_FILTER_BIT, |
| 233 | TRACE_EVENT_FL_TRACEPOINT_BIT, |
| 234 | TRACE_EVENT_FL_KPROBE_BIT, |
| 235 | TRACE_EVENT_FL_UPROBE_BIT, |
| 236 | }; |
| 237 | |
| 238 | /* |
| 239 | * Event flags: |
| 240 | * FILTERED - The event has a filter attached |
| 241 | * CAP_ANY - Any user can enable for perf |
| 242 | * NO_SET_FILTER - Set when filter has error and is to be ignored |
| 243 | * IGNORE_ENABLE - For trace internal events, do not enable with debugfs file |
| 244 | * WAS_ENABLED - Set and stays set when an event was ever enabled |
| 245 | * (used for module unloading, if a module event is enabled, |
| 246 | * it is best to clear the buffers that used it). |
| 247 | * USE_CALL_FILTER - For trace internal events, don't use file filter |
| 248 | * TRACEPOINT - Event is a tracepoint |
| 249 | * KPROBE - Event is a kprobe |
| 250 | * UPROBE - Event is a uprobe |
| 251 | */ |
| 252 | enum { |
| 253 | TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT), |
| 254 | TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT), |
| 255 | TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT), |
| 256 | TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT), |
| 257 | TRACE_EVENT_FL_WAS_ENABLED = (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT), |
| 258 | TRACE_EVENT_FL_USE_CALL_FILTER = (1 << TRACE_EVENT_FL_USE_CALL_FILTER_BIT), |
| 259 | TRACE_EVENT_FL_TRACEPOINT = (1 << TRACE_EVENT_FL_TRACEPOINT_BIT), |
| 260 | TRACE_EVENT_FL_KPROBE = (1 << TRACE_EVENT_FL_KPROBE_BIT), |
| 261 | TRACE_EVENT_FL_UPROBE = (1 << TRACE_EVENT_FL_UPROBE_BIT), |
| 262 | }; |
| 263 | |
| 264 | #define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE) |
| 265 | |
| 266 | struct trace_event_call { |
| 267 | struct list_head list; |
| 268 | struct trace_event_class *class; |
| 269 | union { |
| 270 | char *name; |
| 271 | /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */ |
| 272 | struct tracepoint *tp; |
| 273 | }; |
| 274 | struct trace_event event; |
| 275 | char *print_fmt; |
| 276 | struct event_filter *filter; |
| 277 | void *mod; |
| 278 | void *data; |
| 279 | /* |
| 280 | * bit 0: filter_active |
| 281 | * bit 1: allow trace by non root (cap any) |
| 282 | * bit 2: failed to apply filter |
| 283 | * bit 3: trace internal event (do not enable) |
| 284 | * bit 4: Event was enabled by module |
| 285 | * bit 5: use call filter rather than file filter |
| 286 | * bit 6: Event is a tracepoint |
| 287 | */ |
| 288 | int flags; /* static flags of different events */ |
| 289 | |
| 290 | #ifdef CONFIG_PERF_EVENTS |
| 291 | int perf_refcount; |
| 292 | struct hlist_head __percpu *perf_events; |
| 293 | struct bpf_prog *prog; |
| 294 | |
| 295 | int (*perf_perm)(struct trace_event_call *, |
| 296 | struct perf_event *); |
| 297 | #endif |
| 298 | }; |
| 299 | |
| 300 | static inline const char * |
| 301 | trace_event_name(struct trace_event_call *call) |
| 302 | { |
| 303 | if (call->flags & TRACE_EVENT_FL_TRACEPOINT) |
| 304 | return call->tp ? call->tp->name : NULL; |
| 305 | else |
| 306 | return call->name; |
| 307 | } |
| 308 | |
| 309 | struct trace_array; |
| 310 | struct trace_subsystem_dir; |
| 311 | |
| 312 | enum { |
| 313 | EVENT_FILE_FL_ENABLED_BIT, |
| 314 | EVENT_FILE_FL_RECORDED_CMD_BIT, |
| 315 | EVENT_FILE_FL_FILTERED_BIT, |
| 316 | EVENT_FILE_FL_NO_SET_FILTER_BIT, |
| 317 | EVENT_FILE_FL_SOFT_MODE_BIT, |
| 318 | EVENT_FILE_FL_SOFT_DISABLED_BIT, |
| 319 | EVENT_FILE_FL_TRIGGER_MODE_BIT, |
| 320 | EVENT_FILE_FL_TRIGGER_COND_BIT, |
| 321 | EVENT_FILE_FL_PID_FILTER_BIT, |
| 322 | }; |
| 323 | |
| 324 | /* |
| 325 | * Event file flags: |
| 326 | * ENABLED - The event is enabled |
| 327 | * RECORDED_CMD - The comms should be recorded at sched_switch |
| 328 | * FILTERED - The event has a filter attached |
| 329 | * NO_SET_FILTER - Set when filter has error and is to be ignored |
| 330 | * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED |
| 331 | * SOFT_DISABLED - When set, do not trace the event (even though its |
| 332 | * tracepoint may be enabled) |
| 333 | * TRIGGER_MODE - When set, invoke the triggers associated with the event |
| 334 | * TRIGGER_COND - When set, one or more triggers has an associated filter |
| 335 | * PID_FILTER - When set, the event is filtered based on pid |
| 336 | */ |
| 337 | enum { |
| 338 | EVENT_FILE_FL_ENABLED = (1 << EVENT_FILE_FL_ENABLED_BIT), |
| 339 | EVENT_FILE_FL_RECORDED_CMD = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT), |
| 340 | EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT), |
| 341 | EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT), |
| 342 | EVENT_FILE_FL_SOFT_MODE = (1 << EVENT_FILE_FL_SOFT_MODE_BIT), |
| 343 | EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT), |
| 344 | EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT), |
| 345 | EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT), |
| 346 | EVENT_FILE_FL_PID_FILTER = (1 << EVENT_FILE_FL_PID_FILTER_BIT), |
| 347 | }; |
| 348 | |
| 349 | struct trace_event_file { |
| 350 | struct list_head list; |
| 351 | struct trace_event_call *event_call; |
| 352 | struct event_filter *filter; |
| 353 | struct dentry *dir; |
| 354 | struct trace_array *tr; |
| 355 | struct trace_subsystem_dir *system; |
| 356 | struct list_head triggers; |
| 357 | |
| 358 | /* |
| 359 | * 32 bit flags: |
| 360 | * bit 0: enabled |
| 361 | * bit 1: enabled cmd record |
| 362 | * bit 2: enable/disable with the soft disable bit |
| 363 | * bit 3: soft disabled |
| 364 | * bit 4: trigger enabled |
| 365 | * |
| 366 | * Note: The bits must be set atomically to prevent races |
| 367 | * from other writers. Reads of flags do not need to be in |
| 368 | * sync as they occur in critical sections. But the way flags |
| 369 | * is currently used, these changes do not affect the code |
| 370 | * except that when a change is made, it may have a slight |
| 371 | * delay in propagating the changes to other CPUs due to |
| 372 | * caching and such. Which is mostly OK ;-) |
| 373 | */ |
| 374 | unsigned long flags; |
| 375 | atomic_t sm_ref; /* soft-mode reference counter */ |
| 376 | atomic_t tm_ref; /* trigger-mode reference counter */ |
| 377 | }; |
| 378 | |
| 379 | #define __TRACE_EVENT_FLAGS(name, value) \ |
| 380 | static int __init trace_init_flags_##name(void) \ |
| 381 | { \ |
| 382 | event_##name.flags |= value; \ |
| 383 | return 0; \ |
| 384 | } \ |
| 385 | early_initcall(trace_init_flags_##name); |
| 386 | |
| 387 | #define __TRACE_EVENT_PERF_PERM(name, expr...) \ |
| 388 | static int perf_perm_##name(struct trace_event_call *tp_event, \ |
| 389 | struct perf_event *p_event) \ |
| 390 | { \ |
| 391 | return ({ expr; }); \ |
| 392 | } \ |
| 393 | static int __init trace_init_perf_perm_##name(void) \ |
| 394 | { \ |
| 395 | event_##name.perf_perm = &perf_perm_##name; \ |
| 396 | return 0; \ |
| 397 | } \ |
| 398 | early_initcall(trace_init_perf_perm_##name); |
| 399 | |
| 400 | #define PERF_MAX_TRACE_SIZE 2048 |
| 401 | |
| 402 | #define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */ |
| 403 | |
| 404 | enum event_trigger_type { |
| 405 | ETT_NONE = (0), |
| 406 | ETT_TRACE_ONOFF = (1 << 0), |
| 407 | ETT_SNAPSHOT = (1 << 1), |
| 408 | ETT_STACKTRACE = (1 << 2), |
| 409 | ETT_EVENT_ENABLE = (1 << 3), |
| 410 | }; |
| 411 | |
| 412 | extern int filter_match_preds(struct event_filter *filter, void *rec); |
| 413 | |
| 414 | extern int filter_check_discard(struct trace_event_file *file, void *rec, |
| 415 | struct ring_buffer *buffer, |
| 416 | struct ring_buffer_event *event); |
| 417 | extern int call_filter_check_discard(struct trace_event_call *call, void *rec, |
| 418 | struct ring_buffer *buffer, |
| 419 | struct ring_buffer_event *event); |
| 420 | extern enum event_trigger_type event_triggers_call(struct trace_event_file *file, |
| 421 | void *rec); |
| 422 | extern void event_triggers_post_call(struct trace_event_file *file, |
| 423 | enum event_trigger_type tt, |
| 424 | void *rec); |
| 425 | |
| 426 | bool trace_event_ignore_this_pid(struct trace_event_file *trace_file); |
| 427 | |
| 428 | /** |
| 429 | * trace_trigger_soft_disabled - do triggers and test if soft disabled |
| 430 | * @file: The file pointer of the event to test |
| 431 | * |
| 432 | * If any triggers without filters are attached to this event, they |
| 433 | * will be called here. If the event is soft disabled and has no |
| 434 | * triggers that require testing the fields, it will return true, |
| 435 | * otherwise false. |
| 436 | */ |
| 437 | static inline bool |
| 438 | trace_trigger_soft_disabled(struct trace_event_file *file) |
| 439 | { |
| 440 | unsigned long eflags = file->flags; |
| 441 | |
| 442 | if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) { |
| 443 | if (eflags & EVENT_FILE_FL_TRIGGER_MODE) |
| 444 | event_triggers_call(file, NULL); |
| 445 | if (eflags & EVENT_FILE_FL_SOFT_DISABLED) |
| 446 | return true; |
| 447 | if (eflags & EVENT_FILE_FL_PID_FILTER) |
| 448 | return trace_event_ignore_this_pid(file); |
| 449 | } |
| 450 | return false; |
| 451 | } |
| 452 | |
| 453 | /* |
| 454 | * Helper function for event_trigger_unlock_commit{_regs}(). |
| 455 | * If there are event triggers attached to this event that requires |
| 456 | * filtering against its fields, then they wil be called as the |
| 457 | * entry already holds the field information of the current event. |
| 458 | * |
| 459 | * It also checks if the event should be discarded or not. |
| 460 | * It is to be discarded if the event is soft disabled and the |
| 461 | * event was only recorded to process triggers, or if the event |
| 462 | * filter is active and this event did not match the filters. |
| 463 | * |
| 464 | * Returns true if the event is discarded, false otherwise. |
| 465 | */ |
| 466 | static inline bool |
| 467 | __event_trigger_test_discard(struct trace_event_file *file, |
| 468 | struct ring_buffer *buffer, |
| 469 | struct ring_buffer_event *event, |
| 470 | void *entry, |
| 471 | enum event_trigger_type *tt) |
| 472 | { |
| 473 | unsigned long eflags = file->flags; |
| 474 | |
| 475 | if (eflags & EVENT_FILE_FL_TRIGGER_COND) |
| 476 | *tt = event_triggers_call(file, entry); |
| 477 | |
| 478 | if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags)) |
| 479 | ring_buffer_discard_commit(buffer, event); |
| 480 | else if (!filter_check_discard(file, entry, buffer, event)) |
| 481 | return false; |
| 482 | |
| 483 | return true; |
| 484 | } |
| 485 | |
| 486 | /** |
| 487 | * event_trigger_unlock_commit - handle triggers and finish event commit |
| 488 | * @file: The file pointer assoctiated to the event |
| 489 | * @buffer: The ring buffer that the event is being written to |
| 490 | * @event: The event meta data in the ring buffer |
| 491 | * @entry: The event itself |
| 492 | * @irq_flags: The state of the interrupts at the start of the event |
| 493 | * @pc: The state of the preempt count at the start of the event. |
| 494 | * |
| 495 | * This is a helper function to handle triggers that require data |
| 496 | * from the event itself. It also tests the event against filters and |
| 497 | * if the event is soft disabled and should be discarded. |
| 498 | */ |
| 499 | static inline void |
| 500 | event_trigger_unlock_commit(struct trace_event_file *file, |
| 501 | struct ring_buffer *buffer, |
| 502 | struct ring_buffer_event *event, |
| 503 | void *entry, unsigned long irq_flags, int pc) |
| 504 | { |
| 505 | enum event_trigger_type tt = ETT_NONE; |
| 506 | |
| 507 | if (!__event_trigger_test_discard(file, buffer, event, entry, &tt)) |
| 508 | trace_buffer_unlock_commit(file->tr, buffer, event, irq_flags, pc); |
| 509 | |
| 510 | if (tt) |
| 511 | event_triggers_post_call(file, tt, entry); |
| 512 | } |
| 513 | |
| 514 | /** |
| 515 | * event_trigger_unlock_commit_regs - handle triggers and finish event commit |
| 516 | * @file: The file pointer assoctiated to the event |
| 517 | * @buffer: The ring buffer that the event is being written to |
| 518 | * @event: The event meta data in the ring buffer |
| 519 | * @entry: The event itself |
| 520 | * @irq_flags: The state of the interrupts at the start of the event |
| 521 | * @pc: The state of the preempt count at the start of the event. |
| 522 | * |
| 523 | * This is a helper function to handle triggers that require data |
| 524 | * from the event itself. It also tests the event against filters and |
| 525 | * if the event is soft disabled and should be discarded. |
| 526 | * |
| 527 | * Same as event_trigger_unlock_commit() but calls |
| 528 | * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit(). |
| 529 | */ |
| 530 | static inline void |
| 531 | event_trigger_unlock_commit_regs(struct trace_event_file *file, |
| 532 | struct ring_buffer *buffer, |
| 533 | struct ring_buffer_event *event, |
| 534 | void *entry, unsigned long irq_flags, int pc, |
| 535 | struct pt_regs *regs) |
| 536 | { |
| 537 | enum event_trigger_type tt = ETT_NONE; |
| 538 | |
| 539 | if (!__event_trigger_test_discard(file, buffer, event, entry, &tt)) |
| 540 | trace_buffer_unlock_commit_regs(file->tr, buffer, event, |
| 541 | irq_flags, pc, regs); |
| 542 | |
| 543 | if (tt) |
| 544 | event_triggers_post_call(file, tt, entry); |
| 545 | } |
| 546 | |
| 547 | #ifdef CONFIG_BPF_EVENTS |
| 548 | unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx); |
| 549 | #else |
| 550 | static inline unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx) |
| 551 | { |
| 552 | return 1; |
| 553 | } |
| 554 | #endif |
| 555 | |
| 556 | enum { |
| 557 | FILTER_OTHER = 0, |
| 558 | FILTER_STATIC_STRING, |
| 559 | FILTER_DYN_STRING, |
| 560 | FILTER_PTR_STRING, |
| 561 | FILTER_TRACE_FN, |
| 562 | FILTER_COMM, |
| 563 | FILTER_CPU, |
| 564 | }; |
| 565 | |
| 566 | extern int trace_event_raw_init(struct trace_event_call *call); |
| 567 | extern int trace_define_field(struct trace_event_call *call, const char *type, |
| 568 | const char *name, int offset, int size, |
| 569 | int is_signed, int filter_type); |
| 570 | extern int trace_add_event_call(struct trace_event_call *call); |
| 571 | extern int trace_remove_event_call(struct trace_event_call *call); |
| 572 | extern int trace_event_get_offsets(struct trace_event_call *call); |
| 573 | |
| 574 | #define is_signed_type(type) (((type)(-1)) < (type)1) |
| 575 | |
| 576 | int trace_set_clr_event(const char *system, const char *event, int set); |
| 577 | |
| 578 | /* |
| 579 | * The double __builtin_constant_p is because gcc will give us an error |
| 580 | * if we try to allocate the static variable to fmt if it is not a |
| 581 | * constant. Even with the outer if statement optimizing out. |
| 582 | */ |
| 583 | #define event_trace_printk(ip, fmt, args...) \ |
| 584 | do { \ |
| 585 | __trace_printk_check_format(fmt, ##args); \ |
| 586 | tracing_record_cmdline(current); \ |
| 587 | if (__builtin_constant_p(fmt)) { \ |
| 588 | static const char *trace_printk_fmt \ |
| 589 | __attribute__((section("__trace_printk_fmt"))) = \ |
| 590 | __builtin_constant_p(fmt) ? fmt : NULL; \ |
| 591 | \ |
| 592 | __trace_bprintk(ip, trace_printk_fmt, ##args); \ |
| 593 | } else \ |
| 594 | __trace_printk(ip, fmt, ##args); \ |
| 595 | } while (0) |
| 596 | |
| 597 | #ifdef CONFIG_PERF_EVENTS |
| 598 | struct perf_event; |
| 599 | |
| 600 | DECLARE_PER_CPU(struct pt_regs, perf_trace_regs); |
| 601 | |
| 602 | extern int perf_trace_init(struct perf_event *event); |
| 603 | extern void perf_trace_destroy(struct perf_event *event); |
| 604 | extern int perf_trace_add(struct perf_event *event, int flags); |
| 605 | extern void perf_trace_del(struct perf_event *event, int flags); |
| 606 | extern int ftrace_profile_set_filter(struct perf_event *event, int event_id, |
| 607 | char *filter_str); |
| 608 | extern void ftrace_profile_free_filter(struct perf_event *event); |
| 609 | void perf_trace_buf_update(void *record, u16 type); |
| 610 | void *perf_trace_buf_alloc(int size, struct pt_regs **regs, int *rctxp); |
| 611 | |
| 612 | static inline void |
| 613 | perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type, |
| 614 | u64 count, struct pt_regs *regs, void *head, |
| 615 | struct task_struct *task) |
| 616 | { |
| 617 | perf_tp_event(type, count, raw_data, size, regs, head, rctx, task); |
| 618 | } |
| 619 | #endif |
| 620 | |
| 621 | #endif /* _LINUX_TRACE_EVENT_H */ |