| 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 | |
| 158 | void tracing_record_cmdline(struct task_struct *tsk); |
| 159 | |
| 160 | int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...); |
| 161 | |
| 162 | struct event_filter; |
| 163 | |
| 164 | enum trace_reg { |
| 165 | TRACE_REG_REGISTER, |
| 166 | TRACE_REG_UNREGISTER, |
| 167 | #ifdef CONFIG_PERF_EVENTS |
| 168 | TRACE_REG_PERF_REGISTER, |
| 169 | TRACE_REG_PERF_UNREGISTER, |
| 170 | TRACE_REG_PERF_OPEN, |
| 171 | TRACE_REG_PERF_CLOSE, |
| 172 | TRACE_REG_PERF_ADD, |
| 173 | TRACE_REG_PERF_DEL, |
| 174 | #endif |
| 175 | }; |
| 176 | |
| 177 | struct trace_event_call; |
| 178 | |
| 179 | struct trace_event_class { |
| 180 | const char *system; |
| 181 | void *probe; |
| 182 | #ifdef CONFIG_PERF_EVENTS |
| 183 | void *perf_probe; |
| 184 | #endif |
| 185 | int (*reg)(struct trace_event_call *event, |
| 186 | enum trace_reg type, void *data); |
| 187 | int (*define_fields)(struct trace_event_call *); |
| 188 | struct list_head *(*get_fields)(struct trace_event_call *); |
| 189 | struct list_head fields; |
| 190 | int (*raw_init)(struct trace_event_call *); |
| 191 | }; |
| 192 | |
| 193 | extern int trace_event_reg(struct trace_event_call *event, |
| 194 | enum trace_reg type, void *data); |
| 195 | |
| 196 | struct trace_event_buffer { |
| 197 | struct ring_buffer *buffer; |
| 198 | struct ring_buffer_event *event; |
| 199 | struct trace_event_file *trace_file; |
| 200 | void *entry; |
| 201 | unsigned long flags; |
| 202 | int pc; |
| 203 | }; |
| 204 | |
| 205 | void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer, |
| 206 | struct trace_event_file *trace_file, |
| 207 | unsigned long len); |
| 208 | |
| 209 | void trace_event_buffer_commit(struct trace_event_buffer *fbuffer); |
| 210 | |
| 211 | enum { |
| 212 | TRACE_EVENT_FL_FILTERED_BIT, |
| 213 | TRACE_EVENT_FL_CAP_ANY_BIT, |
| 214 | TRACE_EVENT_FL_NO_SET_FILTER_BIT, |
| 215 | TRACE_EVENT_FL_IGNORE_ENABLE_BIT, |
| 216 | TRACE_EVENT_FL_WAS_ENABLED_BIT, |
| 217 | TRACE_EVENT_FL_TRACEPOINT_BIT, |
| 218 | TRACE_EVENT_FL_KPROBE_BIT, |
| 219 | TRACE_EVENT_FL_UPROBE_BIT, |
| 220 | }; |
| 221 | |
| 222 | /* |
| 223 | * Event flags: |
| 224 | * FILTERED - The event has a filter attached |
| 225 | * CAP_ANY - Any user can enable for perf |
| 226 | * NO_SET_FILTER - Set when filter has error and is to be ignored |
| 227 | * IGNORE_ENABLE - For trace internal events, do not enable with debugfs file |
| 228 | * WAS_ENABLED - Set and stays set when an event was ever enabled |
| 229 | * (used for module unloading, if a module event is enabled, |
| 230 | * it is best to clear the buffers that used it). |
| 231 | * TRACEPOINT - Event is a tracepoint |
| 232 | * KPROBE - Event is a kprobe |
| 233 | * UPROBE - Event is a uprobe |
| 234 | */ |
| 235 | enum { |
| 236 | TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT), |
| 237 | TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT), |
| 238 | TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT), |
| 239 | TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT), |
| 240 | TRACE_EVENT_FL_WAS_ENABLED = (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT), |
| 241 | TRACE_EVENT_FL_TRACEPOINT = (1 << TRACE_EVENT_FL_TRACEPOINT_BIT), |
| 242 | TRACE_EVENT_FL_KPROBE = (1 << TRACE_EVENT_FL_KPROBE_BIT), |
| 243 | TRACE_EVENT_FL_UPROBE = (1 << TRACE_EVENT_FL_UPROBE_BIT), |
| 244 | }; |
| 245 | |
| 246 | #define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE) |
| 247 | |
| 248 | struct trace_event_call { |
| 249 | struct list_head list; |
| 250 | struct trace_event_class *class; |
| 251 | union { |
| 252 | char *name; |
| 253 | /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */ |
| 254 | struct tracepoint *tp; |
| 255 | }; |
| 256 | struct trace_event event; |
| 257 | char *print_fmt; |
| 258 | struct event_filter *filter; |
| 259 | void *mod; |
| 260 | void *data; |
| 261 | /* |
| 262 | * bit 0: filter_active |
| 263 | * bit 1: allow trace by non root (cap any) |
| 264 | * bit 2: failed to apply filter |
| 265 | * bit 3: trace internal event (do not enable) |
| 266 | * bit 4: Event was enabled by module |
| 267 | * bit 5: use call filter rather than file filter |
| 268 | * bit 6: Event is a tracepoint |
| 269 | */ |
| 270 | int flags; /* static flags of different events */ |
| 271 | |
| 272 | #ifdef CONFIG_PERF_EVENTS |
| 273 | int perf_refcount; |
| 274 | struct hlist_head __percpu *perf_events; |
| 275 | struct bpf_prog *prog; |
| 276 | |
| 277 | int (*perf_perm)(struct trace_event_call *, |
| 278 | struct perf_event *); |
| 279 | #endif |
| 280 | }; |
| 281 | |
| 282 | static inline const char * |
| 283 | trace_event_name(struct trace_event_call *call) |
| 284 | { |
| 285 | if (call->flags & TRACE_EVENT_FL_TRACEPOINT) |
| 286 | return call->tp ? call->tp->name : NULL; |
| 287 | else |
| 288 | return call->name; |
| 289 | } |
| 290 | |
| 291 | struct trace_array; |
| 292 | struct trace_subsystem_dir; |
| 293 | |
| 294 | enum { |
| 295 | EVENT_FILE_FL_ENABLED_BIT, |
| 296 | EVENT_FILE_FL_RECORDED_CMD_BIT, |
| 297 | EVENT_FILE_FL_FILTERED_BIT, |
| 298 | EVENT_FILE_FL_NO_SET_FILTER_BIT, |
| 299 | EVENT_FILE_FL_SOFT_MODE_BIT, |
| 300 | EVENT_FILE_FL_SOFT_DISABLED_BIT, |
| 301 | EVENT_FILE_FL_TRIGGER_MODE_BIT, |
| 302 | EVENT_FILE_FL_TRIGGER_COND_BIT, |
| 303 | EVENT_FILE_FL_PID_FILTER_BIT, |
| 304 | }; |
| 305 | |
| 306 | /* |
| 307 | * Event file flags: |
| 308 | * ENABLED - The event is enabled |
| 309 | * RECORDED_CMD - The comms should be recorded at sched_switch |
| 310 | * FILTERED - The event has a filter attached |
| 311 | * NO_SET_FILTER - Set when filter has error and is to be ignored |
| 312 | * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED |
| 313 | * SOFT_DISABLED - When set, do not trace the event (even though its |
| 314 | * tracepoint may be enabled) |
| 315 | * TRIGGER_MODE - When set, invoke the triggers associated with the event |
| 316 | * TRIGGER_COND - When set, one or more triggers has an associated filter |
| 317 | * PID_FILTER - When set, the event is filtered based on pid |
| 318 | */ |
| 319 | enum { |
| 320 | EVENT_FILE_FL_ENABLED = (1 << EVENT_FILE_FL_ENABLED_BIT), |
| 321 | EVENT_FILE_FL_RECORDED_CMD = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT), |
| 322 | EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT), |
| 323 | EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT), |
| 324 | EVENT_FILE_FL_SOFT_MODE = (1 << EVENT_FILE_FL_SOFT_MODE_BIT), |
| 325 | EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT), |
| 326 | EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT), |
| 327 | EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT), |
| 328 | EVENT_FILE_FL_PID_FILTER = (1 << EVENT_FILE_FL_PID_FILTER_BIT), |
| 329 | }; |
| 330 | |
| 331 | struct trace_event_file { |
| 332 | struct list_head list; |
| 333 | struct trace_event_call *event_call; |
| 334 | struct event_filter *filter; |
| 335 | struct dentry *dir; |
| 336 | struct trace_array *tr; |
| 337 | struct trace_subsystem_dir *system; |
| 338 | struct list_head triggers; |
| 339 | |
| 340 | /* |
| 341 | * 32 bit flags: |
| 342 | * bit 0: enabled |
| 343 | * bit 1: enabled cmd record |
| 344 | * bit 2: enable/disable with the soft disable bit |
| 345 | * bit 3: soft disabled |
| 346 | * bit 4: trigger enabled |
| 347 | * |
| 348 | * Note: The bits must be set atomically to prevent races |
| 349 | * from other writers. Reads of flags do not need to be in |
| 350 | * sync as they occur in critical sections. But the way flags |
| 351 | * is currently used, these changes do not affect the code |
| 352 | * except that when a change is made, it may have a slight |
| 353 | * delay in propagating the changes to other CPUs due to |
| 354 | * caching and such. Which is mostly OK ;-) |
| 355 | */ |
| 356 | unsigned long flags; |
| 357 | atomic_t sm_ref; /* soft-mode reference counter */ |
| 358 | atomic_t tm_ref; /* trigger-mode reference counter */ |
| 359 | }; |
| 360 | |
| 361 | #define __TRACE_EVENT_FLAGS(name, value) \ |
| 362 | static int __init trace_init_flags_##name(void) \ |
| 363 | { \ |
| 364 | event_##name.flags |= value; \ |
| 365 | return 0; \ |
| 366 | } \ |
| 367 | early_initcall(trace_init_flags_##name); |
| 368 | |
| 369 | #define __TRACE_EVENT_PERF_PERM(name, expr...) \ |
| 370 | static int perf_perm_##name(struct trace_event_call *tp_event, \ |
| 371 | struct perf_event *p_event) \ |
| 372 | { \ |
| 373 | return ({ expr; }); \ |
| 374 | } \ |
| 375 | static int __init trace_init_perf_perm_##name(void) \ |
| 376 | { \ |
| 377 | event_##name.perf_perm = &perf_perm_##name; \ |
| 378 | return 0; \ |
| 379 | } \ |
| 380 | early_initcall(trace_init_perf_perm_##name); |
| 381 | |
| 382 | #define PERF_MAX_TRACE_SIZE 2048 |
| 383 | |
| 384 | #define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */ |
| 385 | |
| 386 | enum event_trigger_type { |
| 387 | ETT_NONE = (0), |
| 388 | ETT_TRACE_ONOFF = (1 << 0), |
| 389 | ETT_SNAPSHOT = (1 << 1), |
| 390 | ETT_STACKTRACE = (1 << 2), |
| 391 | ETT_EVENT_ENABLE = (1 << 3), |
| 392 | ETT_EVENT_HIST = (1 << 4), |
| 393 | ETT_HIST_ENABLE = (1 << 5), |
| 394 | }; |
| 395 | |
| 396 | extern int filter_match_preds(struct event_filter *filter, void *rec); |
| 397 | |
| 398 | extern enum event_trigger_type event_triggers_call(struct trace_event_file *file, |
| 399 | void *rec); |
| 400 | extern void event_triggers_post_call(struct trace_event_file *file, |
| 401 | enum event_trigger_type tt, |
| 402 | void *rec); |
| 403 | |
| 404 | bool trace_event_ignore_this_pid(struct trace_event_file *trace_file); |
| 405 | |
| 406 | /** |
| 407 | * trace_trigger_soft_disabled - do triggers and test if soft disabled |
| 408 | * @file: The file pointer of the event to test |
| 409 | * |
| 410 | * If any triggers without filters are attached to this event, they |
| 411 | * will be called here. If the event is soft disabled and has no |
| 412 | * triggers that require testing the fields, it will return true, |
| 413 | * otherwise false. |
| 414 | */ |
| 415 | static inline bool |
| 416 | trace_trigger_soft_disabled(struct trace_event_file *file) |
| 417 | { |
| 418 | unsigned long eflags = file->flags; |
| 419 | |
| 420 | if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) { |
| 421 | if (eflags & EVENT_FILE_FL_TRIGGER_MODE) |
| 422 | event_triggers_call(file, NULL); |
| 423 | if (eflags & EVENT_FILE_FL_SOFT_DISABLED) |
| 424 | return true; |
| 425 | if (eflags & EVENT_FILE_FL_PID_FILTER) |
| 426 | return trace_event_ignore_this_pid(file); |
| 427 | } |
| 428 | return false; |
| 429 | } |
| 430 | |
| 431 | #ifdef CONFIG_BPF_EVENTS |
| 432 | unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx); |
| 433 | #else |
| 434 | static inline unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx) |
| 435 | { |
| 436 | return 1; |
| 437 | } |
| 438 | #endif |
| 439 | |
| 440 | enum { |
| 441 | FILTER_OTHER = 0, |
| 442 | FILTER_STATIC_STRING, |
| 443 | FILTER_DYN_STRING, |
| 444 | FILTER_PTR_STRING, |
| 445 | FILTER_TRACE_FN, |
| 446 | FILTER_COMM, |
| 447 | FILTER_CPU, |
| 448 | }; |
| 449 | |
| 450 | extern int trace_event_raw_init(struct trace_event_call *call); |
| 451 | extern int trace_define_field(struct trace_event_call *call, const char *type, |
| 452 | const char *name, int offset, int size, |
| 453 | int is_signed, int filter_type); |
| 454 | extern int trace_add_event_call(struct trace_event_call *call); |
| 455 | extern int trace_remove_event_call(struct trace_event_call *call); |
| 456 | extern int trace_event_get_offsets(struct trace_event_call *call); |
| 457 | |
| 458 | #define is_signed_type(type) (((type)(-1)) < (type)1) |
| 459 | |
| 460 | int trace_set_clr_event(const char *system, const char *event, int set); |
| 461 | |
| 462 | /* |
| 463 | * The double __builtin_constant_p is because gcc will give us an error |
| 464 | * if we try to allocate the static variable to fmt if it is not a |
| 465 | * constant. Even with the outer if statement optimizing out. |
| 466 | */ |
| 467 | #define event_trace_printk(ip, fmt, args...) \ |
| 468 | do { \ |
| 469 | __trace_printk_check_format(fmt, ##args); \ |
| 470 | tracing_record_cmdline(current); \ |
| 471 | if (__builtin_constant_p(fmt)) { \ |
| 472 | static const char *trace_printk_fmt \ |
| 473 | __attribute__((section("__trace_printk_fmt"))) = \ |
| 474 | __builtin_constant_p(fmt) ? fmt : NULL; \ |
| 475 | \ |
| 476 | __trace_bprintk(ip, trace_printk_fmt, ##args); \ |
| 477 | } else \ |
| 478 | __trace_printk(ip, fmt, ##args); \ |
| 479 | } while (0) |
| 480 | |
| 481 | #ifdef CONFIG_PERF_EVENTS |
| 482 | struct perf_event; |
| 483 | |
| 484 | DECLARE_PER_CPU(struct pt_regs, perf_trace_regs); |
| 485 | |
| 486 | extern int perf_trace_init(struct perf_event *event); |
| 487 | extern void perf_trace_destroy(struct perf_event *event); |
| 488 | extern int perf_trace_add(struct perf_event *event, int flags); |
| 489 | extern void perf_trace_del(struct perf_event *event, int flags); |
| 490 | extern int ftrace_profile_set_filter(struct perf_event *event, int event_id, |
| 491 | char *filter_str); |
| 492 | extern void ftrace_profile_free_filter(struct perf_event *event); |
| 493 | void perf_trace_buf_update(void *record, u16 type); |
| 494 | void *perf_trace_buf_alloc(int size, struct pt_regs **regs, int *rctxp); |
| 495 | |
| 496 | void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx, |
| 497 | struct trace_event_call *call, u64 count, |
| 498 | struct pt_regs *regs, struct hlist_head *head, |
| 499 | struct task_struct *task); |
| 500 | |
| 501 | static inline void |
| 502 | perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type, |
| 503 | u64 count, struct pt_regs *regs, void *head, |
| 504 | struct task_struct *task) |
| 505 | { |
| 506 | perf_tp_event(type, count, raw_data, size, regs, head, rctx, task); |
| 507 | } |
| 508 | #endif |
| 509 | |
| 510 | #endif /* _LINUX_TRACE_EVENT_H */ |