Branch data Line data Source code
1 : :
2 : : #ifndef _LINUX_KERNEL_TRACE_H
3 : : #define _LINUX_KERNEL_TRACE_H
4 : :
5 : : #include <linux/fs.h>
6 : : #include <linux/atomic.h>
7 : : #include <linux/sched.h>
8 : : #include <linux/clocksource.h>
9 : : #include <linux/ring_buffer.h>
10 : : #include <linux/mmiotrace.h>
11 : : #include <linux/tracepoint.h>
12 : : #include <linux/ftrace.h>
13 : : #include <linux/hw_breakpoint.h>
14 : : #include <linux/trace_seq.h>
15 : : #include <linux/ftrace_event.h>
16 : :
17 : : #ifdef CONFIG_FTRACE_SYSCALLS
18 : : #include <asm/unistd.h> /* For NR_SYSCALLS */
19 : : #include <asm/syscall.h> /* some archs define it here */
20 : : #endif
21 : :
22 : : enum trace_type {
23 : : __TRACE_FIRST_TYPE = 0,
24 : :
25 : : TRACE_FN,
26 : : TRACE_CTX,
27 : : TRACE_WAKE,
28 : : TRACE_STACK,
29 : : TRACE_PRINT,
30 : : TRACE_BPRINT,
31 : : TRACE_MMIO_RW,
32 : : TRACE_MMIO_MAP,
33 : : TRACE_BRANCH,
34 : : TRACE_GRAPH_RET,
35 : : TRACE_GRAPH_ENT,
36 : : TRACE_USER_STACK,
37 : : TRACE_BLK,
38 : : TRACE_BPUTS,
39 : :
40 : : __TRACE_LAST_TYPE,
41 : : };
42 : :
43 : :
44 : : #undef __field
45 : : #define __field(type, item) type item;
46 : :
47 : : #undef __field_struct
48 : : #define __field_struct(type, item) __field(type, item)
49 : :
50 : : #undef __field_desc
51 : : #define __field_desc(type, container, item)
52 : :
53 : : #undef __array
54 : : #define __array(type, item, size) type item[size];
55 : :
56 : : #undef __array_desc
57 : : #define __array_desc(type, container, item, size)
58 : :
59 : : #undef __dynamic_array
60 : : #define __dynamic_array(type, item) type item[];
61 : :
62 : : #undef F_STRUCT
63 : : #define F_STRUCT(args...) args
64 : :
65 : : #undef FTRACE_ENTRY
66 : : #define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter) \
67 : : struct struct_name { \
68 : : struct trace_entry ent; \
69 : : tstruct \
70 : : }
71 : :
72 : : #undef TP_ARGS
73 : : #define TP_ARGS(args...) args
74 : :
75 : : #undef FTRACE_ENTRY_DUP
76 : : #define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
77 : :
78 : : #undef FTRACE_ENTRY_REG
79 : : #define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
80 : : filter, regfn) \
81 : : FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
82 : : filter)
83 : :
84 : : #include "trace_entries.h"
85 : :
86 : : /*
87 : : * syscalls are special, and need special handling, this is why
88 : : * they are not included in trace_entries.h
89 : : */
90 : : struct syscall_trace_enter {
91 : : struct trace_entry ent;
92 : : int nr;
93 : : unsigned long args[];
94 : : };
95 : :
96 : : struct syscall_trace_exit {
97 : : struct trace_entry ent;
98 : : int nr;
99 : : long ret;
100 : : };
101 : :
102 : : struct kprobe_trace_entry_head {
103 : : struct trace_entry ent;
104 : : unsigned long ip;
105 : : };
106 : :
107 : : struct kretprobe_trace_entry_head {
108 : : struct trace_entry ent;
109 : : unsigned long func;
110 : : unsigned long ret_ip;
111 : : };
112 : :
113 : : /*
114 : : * trace_flag_type is an enumeration that holds different
115 : : * states when a trace occurs. These are:
116 : : * IRQS_OFF - interrupts were disabled
117 : : * IRQS_NOSUPPORT - arch does not support irqs_disabled_flags
118 : : * NEED_RESCHED - reschedule is requested
119 : : * HARDIRQ - inside an interrupt handler
120 : : * SOFTIRQ - inside a softirq handler
121 : : */
122 : : enum trace_flag_type {
123 : : TRACE_FLAG_IRQS_OFF = 0x01,
124 : : TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
125 : : TRACE_FLAG_NEED_RESCHED = 0x04,
126 : : TRACE_FLAG_HARDIRQ = 0x08,
127 : : TRACE_FLAG_SOFTIRQ = 0x10,
128 : : TRACE_FLAG_PREEMPT_RESCHED = 0x20,
129 : : };
130 : :
131 : : #define TRACE_BUF_SIZE 1024
132 : :
133 : : struct trace_array;
134 : :
135 : : /*
136 : : * The CPU trace array - it consists of thousands of trace entries
137 : : * plus some other descriptor data: (for example which task started
138 : : * the trace, etc.)
139 : : */
140 : : struct trace_array_cpu {
141 : : atomic_t disabled;
142 : : void *buffer_page; /* ring buffer spare */
143 : :
144 : : unsigned long entries;
145 : : unsigned long saved_latency;
146 : : unsigned long critical_start;
147 : : unsigned long critical_end;
148 : : unsigned long critical_sequence;
149 : : unsigned long nice;
150 : : unsigned long policy;
151 : : unsigned long rt_priority;
152 : : unsigned long skipped_entries;
153 : : cycle_t preempt_timestamp;
154 : : pid_t pid;
155 : : kuid_t uid;
156 : : char comm[TASK_COMM_LEN];
157 : : };
158 : :
159 : : struct tracer;
160 : :
161 : : struct trace_buffer {
162 : : struct trace_array *tr;
163 : : struct ring_buffer *buffer;
164 : : struct trace_array_cpu __percpu *data;
165 : : cycle_t time_start;
166 : : int cpu;
167 : : };
168 : :
169 : : /*
170 : : * The trace array - an array of per-CPU trace arrays. This is the
171 : : * highest level data structure that individual tracers deal with.
172 : : * They have on/off state as well:
173 : : */
174 : : struct trace_array {
175 : : struct list_head list;
176 : : char *name;
177 : : struct trace_buffer trace_buffer;
178 : : #ifdef CONFIG_TRACER_MAX_TRACE
179 : : /*
180 : : * The max_buffer is used to snapshot the trace when a maximum
181 : : * latency is reached, or when the user initiates a snapshot.
182 : : * Some tracers will use this to store a maximum trace while
183 : : * it continues examining live traces.
184 : : *
185 : : * The buffers for the max_buffer are set up the same as the trace_buffer
186 : : * When a snapshot is taken, the buffer of the max_buffer is swapped
187 : : * with the buffer of the trace_buffer and the buffers are reset for
188 : : * the trace_buffer so the tracing can continue.
189 : : */
190 : : struct trace_buffer max_buffer;
191 : : bool allocated_snapshot;
192 : : #endif
193 : : int buffer_disabled;
194 : : #ifdef CONFIG_FTRACE_SYSCALLS
195 : : int sys_refcount_enter;
196 : : int sys_refcount_exit;
197 : : struct ftrace_event_file __rcu *enter_syscall_files[NR_syscalls];
198 : : struct ftrace_event_file __rcu *exit_syscall_files[NR_syscalls];
199 : : #endif
200 : : int stop_count;
201 : : int clock_id;
202 : : struct tracer *current_trace;
203 : : unsigned int flags;
204 : : raw_spinlock_t start_lock;
205 : : struct dentry *dir;
206 : : struct dentry *options;
207 : : struct dentry *percpu_dir;
208 : : struct dentry *event_dir;
209 : : struct list_head systems;
210 : : struct list_head events;
211 : : cpumask_var_t tracing_cpumask; /* only trace on set CPUs */
212 : : int ref;
213 : : };
214 : :
215 : : enum {
216 : : TRACE_ARRAY_FL_GLOBAL = (1 << 0)
217 : : };
218 : :
219 : : extern struct list_head ftrace_trace_arrays;
220 : :
221 : : extern struct mutex trace_types_lock;
222 : :
223 : : extern int trace_array_get(struct trace_array *tr);
224 : : extern void trace_array_put(struct trace_array *tr);
225 : :
226 : : /*
227 : : * The global tracer (top) should be the first trace array added,
228 : : * but we check the flag anyway.
229 : : */
230 : : static inline struct trace_array *top_trace_array(void)
231 : : {
232 : : struct trace_array *tr;
233 : :
234 : 0 : tr = list_entry(ftrace_trace_arrays.prev,
235 : : typeof(*tr), list);
236 [ # # ][ # # ]: 0 : WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
[ # # ][ # # ]
237 : : return tr;
238 : : }
239 : :
240 : : #define FTRACE_CMP_TYPE(var, type) \
241 : : __builtin_types_compatible_p(typeof(var), type *)
242 : :
243 : : #undef IF_ASSIGN
244 : : #define IF_ASSIGN(var, entry, etype, id) \
245 : : if (FTRACE_CMP_TYPE(var, etype)) { \
246 : : var = (typeof(var))(entry); \
247 : : WARN_ON(id && (entry)->type != id); \
248 : : break; \
249 : : }
250 : :
251 : : /* Will cause compile errors if type is not found. */
252 : : extern void __ftrace_bad_type(void);
253 : :
254 : : /*
255 : : * The trace_assign_type is a verifier that the entry type is
256 : : * the same as the type being assigned. To add new types simply
257 : : * add a line with the following format:
258 : : *
259 : : * IF_ASSIGN(var, ent, type, id);
260 : : *
261 : : * Where "type" is the trace type that includes the trace_entry
262 : : * as the "ent" item. And "id" is the trace identifier that is
263 : : * used in the trace_type enum.
264 : : *
265 : : * If the type can have more than one id, then use zero.
266 : : */
267 : : #define trace_assign_type(var, ent) \
268 : : do { \
269 : : IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \
270 : : IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \
271 : : IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \
272 : : IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
273 : : IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
274 : : IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
275 : : IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \
276 : : IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \
277 : : TRACE_MMIO_RW); \
278 : : IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \
279 : : TRACE_MMIO_MAP); \
280 : : IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
281 : : IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \
282 : : TRACE_GRAPH_ENT); \
283 : : IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \
284 : : TRACE_GRAPH_RET); \
285 : : __ftrace_bad_type(); \
286 : : } while (0)
287 : :
288 : : /*
289 : : * An option specific to a tracer. This is a boolean value.
290 : : * The bit is the bit index that sets its value on the
291 : : * flags value in struct tracer_flags.
292 : : */
293 : : struct tracer_opt {
294 : : const char *name; /* Will appear on the trace_options file */
295 : : u32 bit; /* Mask assigned in val field in tracer_flags */
296 : : };
297 : :
298 : : /*
299 : : * The set of specific options for a tracer. Your tracer
300 : : * have to set the initial value of the flags val.
301 : : */
302 : : struct tracer_flags {
303 : : u32 val;
304 : : struct tracer_opt *opts;
305 : : };
306 : :
307 : : /* Makes more easy to define a tracer opt */
308 : : #define TRACER_OPT(s, b) .name = #s, .bit = b
309 : :
310 : :
311 : : /**
312 : : * struct tracer - a specific tracer and its callbacks to interact with debugfs
313 : : * @name: the name chosen to select it on the available_tracers file
314 : : * @init: called when one switches to this tracer (echo name > current_tracer)
315 : : * @reset: called when one switches to another tracer
316 : : * @start: called when tracing is unpaused (echo 1 > tracing_enabled)
317 : : * @stop: called when tracing is paused (echo 0 > tracing_enabled)
318 : : * @open: called when the trace file is opened
319 : : * @pipe_open: called when the trace_pipe file is opened
320 : : * @wait_pipe: override how the user waits for traces on trace_pipe
321 : : * @close: called when the trace file is released
322 : : * @pipe_close: called when the trace_pipe file is released
323 : : * @read: override the default read callback on trace_pipe
324 : : * @splice_read: override the default splice_read callback on trace_pipe
325 : : * @selftest: selftest to run on boot (see trace_selftest.c)
326 : : * @print_headers: override the first lines that describe your columns
327 : : * @print_line: callback that prints a trace
328 : : * @set_flag: signals one of your private flags changed (trace_options file)
329 : : * @flags: your private flags
330 : : */
331 : : struct tracer {
332 : : const char *name;
333 : : int (*init)(struct trace_array *tr);
334 : : void (*reset)(struct trace_array *tr);
335 : : void (*start)(struct trace_array *tr);
336 : : void (*stop)(struct trace_array *tr);
337 : : void (*open)(struct trace_iterator *iter);
338 : : void (*pipe_open)(struct trace_iterator *iter);
339 : : void (*wait_pipe)(struct trace_iterator *iter);
340 : : void (*close)(struct trace_iterator *iter);
341 : : void (*pipe_close)(struct trace_iterator *iter);
342 : : ssize_t (*read)(struct trace_iterator *iter,
343 : : struct file *filp, char __user *ubuf,
344 : : size_t cnt, loff_t *ppos);
345 : : ssize_t (*splice_read)(struct trace_iterator *iter,
346 : : struct file *filp,
347 : : loff_t *ppos,
348 : : struct pipe_inode_info *pipe,
349 : : size_t len,
350 : : unsigned int flags);
351 : : #ifdef CONFIG_FTRACE_STARTUP_TEST
352 : : int (*selftest)(struct tracer *trace,
353 : : struct trace_array *tr);
354 : : #endif
355 : : void (*print_header)(struct seq_file *m);
356 : : enum print_line_t (*print_line)(struct trace_iterator *iter);
357 : : /* If you handled the flag setting, return 0 */
358 : : int (*set_flag)(u32 old_flags, u32 bit, int set);
359 : : /* Return 0 if OK with change, else return non-zero */
360 : : int (*flag_changed)(struct tracer *tracer,
361 : : u32 mask, int set);
362 : : struct tracer *next;
363 : : struct tracer_flags *flags;
364 : : bool print_max;
365 : : bool enabled;
366 : : #ifdef CONFIG_TRACER_MAX_TRACE
367 : : bool use_max_tr;
368 : : #endif
369 : : };
370 : :
371 : :
372 : : /* Only current can touch trace_recursion */
373 : :
374 : : /*
375 : : * For function tracing recursion:
376 : : * The order of these bits are important.
377 : : *
378 : : * When function tracing occurs, the following steps are made:
379 : : * If arch does not support a ftrace feature:
380 : : * call internal function (uses INTERNAL bits) which calls...
381 : : * If callback is registered to the "global" list, the list
382 : : * function is called and recursion checks the GLOBAL bits.
383 : : * then this function calls...
384 : : * The function callback, which can use the FTRACE bits to
385 : : * check for recursion.
386 : : *
387 : : * Now if the arch does not suppport a feature, and it calls
388 : : * the global list function which calls the ftrace callback
389 : : * all three of these steps will do a recursion protection.
390 : : * There's no reason to do one if the previous caller already
391 : : * did. The recursion that we are protecting against will
392 : : * go through the same steps again.
393 : : *
394 : : * To prevent the multiple recursion checks, if a recursion
395 : : * bit is set that is higher than the MAX bit of the current
396 : : * check, then we know that the check was made by the previous
397 : : * caller, and we can skip the current check.
398 : : */
399 : : enum {
400 : : TRACE_BUFFER_BIT,
401 : : TRACE_BUFFER_NMI_BIT,
402 : : TRACE_BUFFER_IRQ_BIT,
403 : : TRACE_BUFFER_SIRQ_BIT,
404 : :
405 : : /* Start of function recursion bits */
406 : : TRACE_FTRACE_BIT,
407 : : TRACE_FTRACE_NMI_BIT,
408 : : TRACE_FTRACE_IRQ_BIT,
409 : : TRACE_FTRACE_SIRQ_BIT,
410 : :
411 : : /* GLOBAL_BITs must be greater than FTRACE_BITs */
412 : : TRACE_GLOBAL_BIT,
413 : : TRACE_GLOBAL_NMI_BIT,
414 : : TRACE_GLOBAL_IRQ_BIT,
415 : : TRACE_GLOBAL_SIRQ_BIT,
416 : :
417 : : /* INTERNAL_BITs must be greater than GLOBAL_BITs */
418 : : TRACE_INTERNAL_BIT,
419 : : TRACE_INTERNAL_NMI_BIT,
420 : : TRACE_INTERNAL_IRQ_BIT,
421 : : TRACE_INTERNAL_SIRQ_BIT,
422 : :
423 : : TRACE_CONTROL_BIT,
424 : :
425 : : /*
426 : : * Abuse of the trace_recursion.
427 : : * As we need a way to maintain state if we are tracing the function
428 : : * graph in irq because we want to trace a particular function that
429 : : * was called in irq context but we have irq tracing off. Since this
430 : : * can only be modified by current, we can reuse trace_recursion.
431 : : */
432 : : TRACE_IRQ_BIT,
433 : : };
434 : :
435 : : #define trace_recursion_set(bit) do { (current)->trace_recursion |= (1<<(bit)); } while (0)
436 : : #define trace_recursion_clear(bit) do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
437 : : #define trace_recursion_test(bit) ((current)->trace_recursion & (1<<(bit)))
438 : :
439 : : #define TRACE_CONTEXT_BITS 4
440 : :
441 : : #define TRACE_FTRACE_START TRACE_FTRACE_BIT
442 : : #define TRACE_FTRACE_MAX ((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)
443 : :
444 : : #define TRACE_GLOBAL_START TRACE_GLOBAL_BIT
445 : : #define TRACE_GLOBAL_MAX ((1 << (TRACE_GLOBAL_START + TRACE_CONTEXT_BITS)) - 1)
446 : :
447 : : #define TRACE_LIST_START TRACE_INTERNAL_BIT
448 : : #define TRACE_LIST_MAX ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
449 : :
450 : : #define TRACE_CONTEXT_MASK TRACE_LIST_MAX
451 : :
452 : : static __always_inline int trace_get_context_bit(void)
453 : : {
454 : : int bit;
455 : :
456 [ # # ][ # # ]: 0 : if (in_interrupt()) {
457 [ # # ][ # # ]: 0 : if (in_nmi())
458 : : bit = 0;
459 : :
460 [ # # ][ # # ]: 0 : else if (in_irq())
461 : : bit = 1;
462 : : else
463 : : bit = 2;
464 : : } else
465 : : bit = 3;
466 : :
467 : : return bit;
468 : : }
469 : :
470 : : static __always_inline int trace_test_and_set_recursion(int start, int max)
471 : : {
472 : 0 : unsigned int val = current->trace_recursion;
473 : : int bit;
474 : :
475 : : /* A previous recursion check was made */
476 [ # # ][ # # ]: 0 : if ((val & TRACE_CONTEXT_MASK) > max)
[ # # ]
477 : : return 0;
478 : :
479 : 0 : bit = trace_get_context_bit() + start;
480 [ # # ][ # # ]: 0 : if (unlikely(val & (1 << bit)))
481 : : return -1;
482 : :
483 : 0 : val |= 1 << bit;
484 : 0 : current->trace_recursion = val;
485 : 0 : barrier();
486 : :
487 : : return bit;
488 : : }
489 : :
490 : : static __always_inline void trace_clear_recursion(int bit)
491 : : {
492 : 0 : unsigned int val = current->trace_recursion;
493 : :
494 [ # # ]: 0 : if (!bit)
[ # # # # ]
495 : : return;
496 : :
497 : 0 : bit = 1 << bit;
498 : 0 : val &= ~bit;
499 : :
500 : 0 : barrier();
501 : 0 : current->trace_recursion = val;
502 : : }
503 : :
504 : : static inline struct ring_buffer_iter *
505 : : trace_buffer_iter(struct trace_iterator *iter, int cpu)
506 : : {
507 [ # # ][ # # ]: 0 : if (iter->buffer_iter && iter->buffer_iter[cpu])
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
508 : : return iter->buffer_iter[cpu];
509 : : return NULL;
510 : : }
511 : :
512 : : int tracer_init(struct tracer *t, struct trace_array *tr);
513 : : int tracing_is_enabled(void);
514 : : void tracing_reset(struct trace_buffer *buf, int cpu);
515 : : void tracing_reset_online_cpus(struct trace_buffer *buf);
516 : : void tracing_reset_current(int cpu);
517 : : void tracing_reset_all_online_cpus(void);
518 : : int tracing_open_generic(struct inode *inode, struct file *filp);
519 : : bool tracing_is_disabled(void);
520 : : struct dentry *trace_create_file(const char *name,
521 : : umode_t mode,
522 : : struct dentry *parent,
523 : : void *data,
524 : : const struct file_operations *fops);
525 : :
526 : : struct dentry *tracing_init_dentry_tr(struct trace_array *tr);
527 : : struct dentry *tracing_init_dentry(void);
528 : :
529 : : struct ring_buffer_event;
530 : :
531 : : struct ring_buffer_event *
532 : : trace_buffer_lock_reserve(struct ring_buffer *buffer,
533 : : int type,
534 : : unsigned long len,
535 : : unsigned long flags,
536 : : int pc);
537 : :
538 : : struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
539 : : struct trace_array_cpu *data);
540 : :
541 : : struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
542 : : int *ent_cpu, u64 *ent_ts);
543 : :
544 : : void __buffer_unlock_commit(struct ring_buffer *buffer,
545 : : struct ring_buffer_event *event);
546 : :
547 : : int trace_empty(struct trace_iterator *iter);
548 : :
549 : : void *trace_find_next_entry_inc(struct trace_iterator *iter);
550 : :
551 : : void trace_init_global_iter(struct trace_iterator *iter);
552 : :
553 : : void tracing_iter_reset(struct trace_iterator *iter, int cpu);
554 : :
555 : : void poll_wait_pipe(struct trace_iterator *iter);
556 : :
557 : : void tracing_sched_switch_trace(struct trace_array *tr,
558 : : struct task_struct *prev,
559 : : struct task_struct *next,
560 : : unsigned long flags, int pc);
561 : :
562 : : void tracing_sched_wakeup_trace(struct trace_array *tr,
563 : : struct task_struct *wakee,
564 : : struct task_struct *cur,
565 : : unsigned long flags, int pc);
566 : : void trace_function(struct trace_array *tr,
567 : : unsigned long ip,
568 : : unsigned long parent_ip,
569 : : unsigned long flags, int pc);
570 : : void trace_graph_function(struct trace_array *tr,
571 : : unsigned long ip,
572 : : unsigned long parent_ip,
573 : : unsigned long flags, int pc);
574 : : void trace_latency_header(struct seq_file *m);
575 : : void trace_default_header(struct seq_file *m);
576 : : void print_trace_header(struct seq_file *m, struct trace_iterator *iter);
577 : : int trace_empty(struct trace_iterator *iter);
578 : :
579 : : void trace_graph_return(struct ftrace_graph_ret *trace);
580 : : int trace_graph_entry(struct ftrace_graph_ent *trace);
581 : : void set_graph_array(struct trace_array *tr);
582 : :
583 : : void tracing_start_cmdline_record(void);
584 : : void tracing_stop_cmdline_record(void);
585 : : void tracing_sched_switch_assign_trace(struct trace_array *tr);
586 : : void tracing_stop_sched_switch_record(void);
587 : : void tracing_start_sched_switch_record(void);
588 : : int register_tracer(struct tracer *type);
589 : : int is_tracing_stopped(void);
590 : :
591 : : loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
592 : :
593 : : extern cpumask_var_t __read_mostly tracing_buffer_mask;
594 : :
595 : : #define for_each_tracing_cpu(cpu) \
596 : : for_each_cpu(cpu, tracing_buffer_mask)
597 : :
598 : : extern unsigned long nsecs_to_usecs(unsigned long nsecs);
599 : :
600 : : extern unsigned long tracing_thresh;
601 : :
602 : : #ifdef CONFIG_TRACER_MAX_TRACE
603 : : extern unsigned long tracing_max_latency;
604 : :
605 : : void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
606 : : void update_max_tr_single(struct trace_array *tr,
607 : : struct task_struct *tsk, int cpu);
608 : : #endif /* CONFIG_TRACER_MAX_TRACE */
609 : :
610 : : #ifdef CONFIG_STACKTRACE
611 : : void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
612 : : int skip, int pc);
613 : :
614 : : void ftrace_trace_stack_regs(struct ring_buffer *buffer, unsigned long flags,
615 : : int skip, int pc, struct pt_regs *regs);
616 : :
617 : : void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
618 : : int pc);
619 : :
620 : : void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
621 : : int pc);
622 : : #else
623 : : static inline void ftrace_trace_stack(struct ring_buffer *buffer,
624 : : unsigned long flags, int skip, int pc)
625 : : {
626 : : }
627 : :
628 : : static inline void ftrace_trace_stack_regs(struct ring_buffer *buffer,
629 : : unsigned long flags, int skip,
630 : : int pc, struct pt_regs *regs)
631 : : {
632 : : }
633 : :
634 : : static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
635 : : unsigned long flags, int pc)
636 : : {
637 : : }
638 : :
639 : : static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
640 : : int skip, int pc)
641 : : {
642 : : }
643 : : #endif /* CONFIG_STACKTRACE */
644 : :
645 : : extern cycle_t ftrace_now(int cpu);
646 : :
647 : : extern void trace_find_cmdline(int pid, char comm[]);
648 : : extern int trace_find_tgid(int pid);
649 : :
650 : : #ifdef CONFIG_DYNAMIC_FTRACE
651 : : extern unsigned long ftrace_update_tot_cnt;
652 : : #endif
653 : : #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
654 : : extern int DYN_FTRACE_TEST_NAME(void);
655 : : #define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
656 : : extern int DYN_FTRACE_TEST_NAME2(void);
657 : :
658 : : extern bool ring_buffer_expanded;
659 : : extern bool tracing_selftest_disabled;
660 : : DECLARE_PER_CPU(int, ftrace_cpu_disabled);
661 : :
662 : : #ifdef CONFIG_FTRACE_STARTUP_TEST
663 : : extern int trace_selftest_startup_function(struct tracer *trace,
664 : : struct trace_array *tr);
665 : : extern int trace_selftest_startup_function_graph(struct tracer *trace,
666 : : struct trace_array *tr);
667 : : extern int trace_selftest_startup_irqsoff(struct tracer *trace,
668 : : struct trace_array *tr);
669 : : extern int trace_selftest_startup_preemptoff(struct tracer *trace,
670 : : struct trace_array *tr);
671 : : extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
672 : : struct trace_array *tr);
673 : : extern int trace_selftest_startup_wakeup(struct tracer *trace,
674 : : struct trace_array *tr);
675 : : extern int trace_selftest_startup_nop(struct tracer *trace,
676 : : struct trace_array *tr);
677 : : extern int trace_selftest_startup_sched_switch(struct tracer *trace,
678 : : struct trace_array *tr);
679 : : extern int trace_selftest_startup_branch(struct tracer *trace,
680 : : struct trace_array *tr);
681 : : /*
682 : : * Tracer data references selftest functions that only occur
683 : : * on boot up. These can be __init functions. Thus, when selftests
684 : : * are enabled, then the tracers need to reference __init functions.
685 : : */
686 : : #define __tracer_data __refdata
687 : : #else
688 : : /* Tracers are seldom changed. Optimize when selftests are disabled. */
689 : : #define __tracer_data __read_mostly
690 : : #endif /* CONFIG_FTRACE_STARTUP_TEST */
691 : :
692 : : extern void *head_page(struct trace_array_cpu *data);
693 : : extern unsigned long long ns2usecs(cycle_t nsec);
694 : : extern int
695 : : trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
696 : : extern int
697 : : trace_vprintk(unsigned long ip, const char *fmt, va_list args);
698 : : extern int
699 : : trace_array_vprintk(struct trace_array *tr,
700 : : unsigned long ip, const char *fmt, va_list args);
701 : : int trace_array_printk(struct trace_array *tr,
702 : : unsigned long ip, const char *fmt, ...);
703 : : int trace_array_printk_buf(struct ring_buffer *buffer,
704 : : unsigned long ip, const char *fmt, ...);
705 : : void trace_printk_seq(struct trace_seq *s);
706 : : enum print_line_t print_trace_line(struct trace_iterator *iter);
707 : :
708 : : extern unsigned long trace_flags;
709 : :
710 : : /* Standard output formatting function used for function return traces */
711 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
712 : :
713 : : /* Flag options */
714 : : #define TRACE_GRAPH_PRINT_OVERRUN 0x1
715 : : #define TRACE_GRAPH_PRINT_CPU 0x2
716 : : #define TRACE_GRAPH_PRINT_OVERHEAD 0x4
717 : : #define TRACE_GRAPH_PRINT_PROC 0x8
718 : : #define TRACE_GRAPH_PRINT_DURATION 0x10
719 : : #define TRACE_GRAPH_PRINT_ABS_TIME 0x20
720 : : #define TRACE_GRAPH_PRINT_FILL_SHIFT 28
721 : : #define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
722 : :
723 : : extern enum print_line_t
724 : : print_graph_function_flags(struct trace_iterator *iter, u32 flags);
725 : : extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
726 : : extern enum print_line_t
727 : : trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
728 : : extern void graph_trace_open(struct trace_iterator *iter);
729 : : extern void graph_trace_close(struct trace_iterator *iter);
730 : : extern int __trace_graph_entry(struct trace_array *tr,
731 : : struct ftrace_graph_ent *trace,
732 : : unsigned long flags, int pc);
733 : : extern void __trace_graph_return(struct trace_array *tr,
734 : : struct ftrace_graph_ret *trace,
735 : : unsigned long flags, int pc);
736 : :
737 : :
738 : : #ifdef CONFIG_DYNAMIC_FTRACE
739 : : /* TODO: make this variable */
740 : : #define FTRACE_GRAPH_MAX_FUNCS 32
741 : : extern int ftrace_graph_count;
742 : : extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
743 : : extern int ftrace_graph_notrace_count;
744 : : extern unsigned long ftrace_graph_notrace_funcs[FTRACE_GRAPH_MAX_FUNCS];
745 : :
746 : : static inline int ftrace_graph_addr(unsigned long addr)
747 : : {
748 : : int i;
749 : :
750 : : if (!ftrace_graph_count)
751 : : return 1;
752 : :
753 : : for (i = 0; i < ftrace_graph_count; i++) {
754 : : if (addr == ftrace_graph_funcs[i]) {
755 : : /*
756 : : * If no irqs are to be traced, but a set_graph_function
757 : : * is set, and called by an interrupt handler, we still
758 : : * want to trace it.
759 : : */
760 : : if (in_irq())
761 : : trace_recursion_set(TRACE_IRQ_BIT);
762 : : else
763 : : trace_recursion_clear(TRACE_IRQ_BIT);
764 : : return 1;
765 : : }
766 : : }
767 : :
768 : : return 0;
769 : : }
770 : :
771 : : static inline int ftrace_graph_notrace_addr(unsigned long addr)
772 : : {
773 : : int i;
774 : :
775 : : if (!ftrace_graph_notrace_count)
776 : : return 0;
777 : :
778 : : for (i = 0; i < ftrace_graph_notrace_count; i++) {
779 : : if (addr == ftrace_graph_notrace_funcs[i])
780 : : return 1;
781 : : }
782 : :
783 : : return 0;
784 : : }
785 : : #else
786 : : static inline int ftrace_graph_addr(unsigned long addr)
787 : : {
788 : : return 1;
789 : : }
790 : :
791 : : static inline int ftrace_graph_notrace_addr(unsigned long addr)
792 : : {
793 : : return 0;
794 : : }
795 : : #endif /* CONFIG_DYNAMIC_FTRACE */
796 : : #else /* CONFIG_FUNCTION_GRAPH_TRACER */
797 : : static inline enum print_line_t
798 : : print_graph_function_flags(struct trace_iterator *iter, u32 flags)
799 : : {
800 : : return TRACE_TYPE_UNHANDLED;
801 : : }
802 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
803 : :
804 : : extern struct list_head ftrace_pids;
805 : :
806 : : #ifdef CONFIG_FUNCTION_TRACER
807 : : extern bool ftrace_filter_param __initdata;
808 : : static inline int ftrace_trace_task(struct task_struct *task)
809 : : {
810 : : if (list_empty(&ftrace_pids))
811 : : return 1;
812 : :
813 : : return test_tsk_trace_trace(task);
814 : : }
815 : : extern int ftrace_is_dead(void);
816 : : #else
817 : : static inline int ftrace_trace_task(struct task_struct *task)
818 : : {
819 : : return 1;
820 : : }
821 : : static inline int ftrace_is_dead(void) { return 0; }
822 : : #endif
823 : :
824 : : int ftrace_event_is_function(struct ftrace_event_call *call);
825 : :
826 : : /*
827 : : * struct trace_parser - servers for reading the user input separated by spaces
828 : : * @cont: set if the input is not complete - no final space char was found
829 : : * @buffer: holds the parsed user input
830 : : * @idx: user input length
831 : : * @size: buffer size
832 : : */
833 : : struct trace_parser {
834 : : bool cont;
835 : : char *buffer;
836 : : unsigned idx;
837 : : unsigned size;
838 : : };
839 : :
840 : : static inline bool trace_parser_loaded(struct trace_parser *parser)
841 : : {
842 : : return (parser->idx != 0);
843 : : }
844 : :
845 : : static inline bool trace_parser_cont(struct trace_parser *parser)
846 : : {
847 : : return parser->cont;
848 : : }
849 : :
850 : : static inline void trace_parser_clear(struct trace_parser *parser)
851 : : {
852 : 0 : parser->cont = false;
853 : 0 : parser->idx = 0;
854 : : }
855 : :
856 : : extern int trace_parser_get_init(struct trace_parser *parser, int size);
857 : : extern void trace_parser_put(struct trace_parser *parser);
858 : : extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
859 : : size_t cnt, loff_t *ppos);
860 : :
861 : : /*
862 : : * trace_iterator_flags is an enumeration that defines bit
863 : : * positions into trace_flags that controls the output.
864 : : *
865 : : * NOTE: These bits must match the trace_options array in
866 : : * trace.c.
867 : : */
868 : : enum trace_iterator_flags {
869 : : TRACE_ITER_PRINT_PARENT = 0x01,
870 : : TRACE_ITER_SYM_OFFSET = 0x02,
871 : : TRACE_ITER_SYM_ADDR = 0x04,
872 : : TRACE_ITER_VERBOSE = 0x08,
873 : : TRACE_ITER_RAW = 0x10,
874 : : TRACE_ITER_HEX = 0x20,
875 : : TRACE_ITER_BIN = 0x40,
876 : : TRACE_ITER_BLOCK = 0x80,
877 : : TRACE_ITER_STACKTRACE = 0x100,
878 : : TRACE_ITER_PRINTK = 0x200,
879 : : TRACE_ITER_PREEMPTONLY = 0x400,
880 : : TRACE_ITER_BRANCH = 0x800,
881 : : TRACE_ITER_ANNOTATE = 0x1000,
882 : : TRACE_ITER_USERSTACKTRACE = 0x2000,
883 : : TRACE_ITER_SYM_USEROBJ = 0x4000,
884 : : TRACE_ITER_PRINTK_MSGONLY = 0x8000,
885 : : TRACE_ITER_CONTEXT_INFO = 0x10000, /* Print pid/cpu/time */
886 : : TRACE_ITER_LATENCY_FMT = 0x20000,
887 : : TRACE_ITER_SLEEP_TIME = 0x40000,
888 : : TRACE_ITER_GRAPH_TIME = 0x80000,
889 : : TRACE_ITER_RECORD_CMD = 0x100000,
890 : : TRACE_ITER_OVERWRITE = 0x200000,
891 : : TRACE_ITER_STOP_ON_FREE = 0x400000,
892 : : TRACE_ITER_IRQ_INFO = 0x800000,
893 : : TRACE_ITER_MARKERS = 0x1000000,
894 : : TRACE_ITER_FUNCTION = 0x2000000,
895 : : TRACE_ITER_TGID = 0x4000000,
896 : : };
897 : :
898 : : /*
899 : : * TRACE_ITER_SYM_MASK masks the options in trace_flags that
900 : : * control the output of kernel symbols.
901 : : */
902 : : #define TRACE_ITER_SYM_MASK \
903 : : (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
904 : :
905 : : extern struct tracer nop_trace;
906 : :
907 : : #ifdef CONFIG_BRANCH_TRACER
908 : : extern int enable_branch_tracing(struct trace_array *tr);
909 : : extern void disable_branch_tracing(void);
910 : : static inline int trace_branch_enable(struct trace_array *tr)
911 : : {
912 : : if (trace_flags & TRACE_ITER_BRANCH)
913 : : return enable_branch_tracing(tr);
914 : : return 0;
915 : : }
916 : : static inline void trace_branch_disable(void)
917 : : {
918 : : /* due to races, always disable */
919 : : disable_branch_tracing();
920 : : }
921 : : #else
922 : : static inline int trace_branch_enable(struct trace_array *tr)
923 : : {
924 : : return 0;
925 : : }
926 : : static inline void trace_branch_disable(void)
927 : : {
928 : : }
929 : : #endif /* CONFIG_BRANCH_TRACER */
930 : :
931 : : /* set ring buffers to default size if not already done so */
932 : : int tracing_update_buffers(void);
933 : :
934 : : struct ftrace_event_field {
935 : : struct list_head link;
936 : : const char *name;
937 : : const char *type;
938 : : int filter_type;
939 : : int offset;
940 : : int size;
941 : : int is_signed;
942 : : };
943 : :
944 : : struct event_filter {
945 : : int n_preds; /* Number assigned */
946 : : int a_preds; /* allocated */
947 : : struct filter_pred *preds;
948 : : struct filter_pred *root;
949 : : char *filter_string;
950 : : };
951 : :
952 : : struct event_subsystem {
953 : : struct list_head list;
954 : : const char *name;
955 : : struct event_filter *filter;
956 : : int ref_count;
957 : : };
958 : :
959 : : struct ftrace_subsystem_dir {
960 : : struct list_head list;
961 : : struct event_subsystem *subsystem;
962 : : struct trace_array *tr;
963 : : struct dentry *entry;
964 : : int ref_count;
965 : : int nr_events;
966 : : };
967 : :
968 : : #define FILTER_PRED_INVALID ((unsigned short)-1)
969 : : #define FILTER_PRED_IS_RIGHT (1 << 15)
970 : : #define FILTER_PRED_FOLD (1 << 15)
971 : :
972 : : /*
973 : : * The max preds is the size of unsigned short with
974 : : * two flags at the MSBs. One bit is used for both the IS_RIGHT
975 : : * and FOLD flags. The other is reserved.
976 : : *
977 : : * 2^14 preds is way more than enough.
978 : : */
979 : : #define MAX_FILTER_PRED 16384
980 : :
981 : : struct filter_pred;
982 : : struct regex;
983 : :
984 : : typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
985 : :
986 : : typedef int (*regex_match_func)(char *str, struct regex *r, int len);
987 : :
988 : : enum regex_type {
989 : : MATCH_FULL = 0,
990 : : MATCH_FRONT_ONLY,
991 : : MATCH_MIDDLE_ONLY,
992 : : MATCH_END_ONLY,
993 : : };
994 : :
995 : : struct regex {
996 : : char pattern[MAX_FILTER_STR_VAL];
997 : : int len;
998 : : int field_len;
999 : : regex_match_func match;
1000 : : };
1001 : :
1002 : : struct filter_pred {
1003 : : filter_pred_fn_t fn;
1004 : : u64 val;
1005 : : struct regex regex;
1006 : : unsigned short *ops;
1007 : : struct ftrace_event_field *field;
1008 : : int offset;
1009 : : int not;
1010 : : int op;
1011 : : unsigned short index;
1012 : : unsigned short parent;
1013 : : unsigned short left;
1014 : : unsigned short right;
1015 : : };
1016 : :
1017 : : extern enum regex_type
1018 : : filter_parse_regex(char *buff, int len, char **search, int *not);
1019 : : extern void print_event_filter(struct ftrace_event_file *file,
1020 : : struct trace_seq *s);
1021 : : extern int apply_event_filter(struct ftrace_event_file *file,
1022 : : char *filter_string);
1023 : : extern int apply_subsystem_event_filter(struct ftrace_subsystem_dir *dir,
1024 : : char *filter_string);
1025 : : extern void print_subsystem_event_filter(struct event_subsystem *system,
1026 : : struct trace_seq *s);
1027 : : extern int filter_assign_type(const char *type);
1028 : : extern int create_event_filter(struct ftrace_event_call *call,
1029 : : char *filter_str, bool set_str,
1030 : : struct event_filter **filterp);
1031 : : extern void free_event_filter(struct event_filter *filter);
1032 : :
1033 : : struct ftrace_event_field *
1034 : : trace_find_event_field(struct ftrace_event_call *call, char *name);
1035 : :
1036 : : extern void trace_event_enable_cmd_record(bool enable);
1037 : : extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
1038 : : extern int event_trace_del_tracer(struct trace_array *tr);
1039 : :
1040 : : extern struct ftrace_event_file *find_event_file(struct trace_array *tr,
1041 : : const char *system,
1042 : : const char *event);
1043 : :
1044 : 0 : static inline void *event_file_data(struct file *filp)
1045 : : {
1046 : 0 : return ACCESS_ONCE(file_inode(filp)->i_private);
1047 : : }
1048 : :
1049 : : extern struct mutex event_mutex;
1050 : : extern struct list_head ftrace_events;
1051 : :
1052 : : extern const struct file_operations event_trigger_fops;
1053 : :
1054 : : extern int register_trigger_cmds(void);
1055 : : extern void clear_event_triggers(struct trace_array *tr);
1056 : :
1057 : : struct event_trigger_data {
1058 : : unsigned long count;
1059 : : int ref;
1060 : : struct event_trigger_ops *ops;
1061 : : struct event_command *cmd_ops;
1062 : : struct event_filter __rcu *filter;
1063 : : char *filter_str;
1064 : : void *private_data;
1065 : : struct list_head list;
1066 : : };
1067 : :
1068 : : /**
1069 : : * struct event_trigger_ops - callbacks for trace event triggers
1070 : : *
1071 : : * The methods in this structure provide per-event trigger hooks for
1072 : : * various trigger operations.
1073 : : *
1074 : : * All the methods below, except for @init() and @free(), must be
1075 : : * implemented.
1076 : : *
1077 : : * @func: The trigger 'probe' function called when the triggering
1078 : : * event occurs. The data passed into this callback is the data
1079 : : * that was supplied to the event_command @reg() function that
1080 : : * registered the trigger (see struct event_command).
1081 : : *
1082 : : * @init: An optional initialization function called for the trigger
1083 : : * when the trigger is registered (via the event_command reg()
1084 : : * function). This can be used to perform per-trigger
1085 : : * initialization such as incrementing a per-trigger reference
1086 : : * count, for instance. This is usually implemented by the
1087 : : * generic utility function @event_trigger_init() (see
1088 : : * trace_event_triggers.c).
1089 : : *
1090 : : * @free: An optional de-initialization function called for the
1091 : : * trigger when the trigger is unregistered (via the
1092 : : * event_command @reg() function). This can be used to perform
1093 : : * per-trigger de-initialization such as decrementing a
1094 : : * per-trigger reference count and freeing corresponding trigger
1095 : : * data, for instance. This is usually implemented by the
1096 : : * generic utility function @event_trigger_free() (see
1097 : : * trace_event_triggers.c).
1098 : : *
1099 : : * @print: The callback function invoked to have the trigger print
1100 : : * itself. This is usually implemented by a wrapper function
1101 : : * that calls the generic utility function @event_trigger_print()
1102 : : * (see trace_event_triggers.c).
1103 : : */
1104 : : struct event_trigger_ops {
1105 : : void (*func)(struct event_trigger_data *data);
1106 : : int (*init)(struct event_trigger_ops *ops,
1107 : : struct event_trigger_data *data);
1108 : : void (*free)(struct event_trigger_ops *ops,
1109 : : struct event_trigger_data *data);
1110 : : int (*print)(struct seq_file *m,
1111 : : struct event_trigger_ops *ops,
1112 : : struct event_trigger_data *data);
1113 : : };
1114 : :
1115 : : /**
1116 : : * struct event_command - callbacks and data members for event commands
1117 : : *
1118 : : * Event commands are invoked by users by writing the command name
1119 : : * into the 'trigger' file associated with a trace event. The
1120 : : * parameters associated with a specific invocation of an event
1121 : : * command are used to create an event trigger instance, which is
1122 : : * added to the list of trigger instances associated with that trace
1123 : : * event. When the event is hit, the set of triggers associated with
1124 : : * that event is invoked.
1125 : : *
1126 : : * The data members in this structure provide per-event command data
1127 : : * for various event commands.
1128 : : *
1129 : : * All the data members below, except for @post_trigger, must be set
1130 : : * for each event command.
1131 : : *
1132 : : * @name: The unique name that identifies the event command. This is
1133 : : * the name used when setting triggers via trigger files.
1134 : : *
1135 : : * @trigger_type: A unique id that identifies the event command
1136 : : * 'type'. This value has two purposes, the first to ensure that
1137 : : * only one trigger of the same type can be set at a given time
1138 : : * for a particular event e.g. it doesn't make sense to have both
1139 : : * a traceon and traceoff trigger attached to a single event at
1140 : : * the same time, so traceon and traceoff have the same type
1141 : : * though they have different names. The @trigger_type value is
1142 : : * also used as a bit value for deferring the actual trigger
1143 : : * action until after the current event is finished. Some
1144 : : * commands need to do this if they themselves log to the trace
1145 : : * buffer (see the @post_trigger() member below). @trigger_type
1146 : : * values are defined by adding new values to the trigger_type
1147 : : * enum in include/linux/ftrace_event.h.
1148 : : *
1149 : : * @post_trigger: A flag that says whether or not this command needs
1150 : : * to have its action delayed until after the current event has
1151 : : * been closed. Some triggers need to avoid being invoked while
1152 : : * an event is currently in the process of being logged, since
1153 : : * the trigger may itself log data into the trace buffer. Thus
1154 : : * we make sure the current event is committed before invoking
1155 : : * those triggers. To do that, the trigger invocation is split
1156 : : * in two - the first part checks the filter using the current
1157 : : * trace record; if a command has the @post_trigger flag set, it
1158 : : * sets a bit for itself in the return value, otherwise it
1159 : : * directly invokes the trigger. Once all commands have been
1160 : : * either invoked or set their return flag, the current record is
1161 : : * either committed or discarded. At that point, if any commands
1162 : : * have deferred their triggers, those commands are finally
1163 : : * invoked following the close of the current event. In other
1164 : : * words, if the event_trigger_ops @func() probe implementation
1165 : : * itself logs to the trace buffer, this flag should be set,
1166 : : * otherwise it can be left unspecified.
1167 : : *
1168 : : * All the methods below, except for @set_filter(), must be
1169 : : * implemented.
1170 : : *
1171 : : * @func: The callback function responsible for parsing and
1172 : : * registering the trigger written to the 'trigger' file by the
1173 : : * user. It allocates the trigger instance and registers it with
1174 : : * the appropriate trace event. It makes use of the other
1175 : : * event_command callback functions to orchestrate this, and is
1176 : : * usually implemented by the generic utility function
1177 : : * @event_trigger_callback() (see trace_event_triggers.c).
1178 : : *
1179 : : * @reg: Adds the trigger to the list of triggers associated with the
1180 : : * event, and enables the event trigger itself, after
1181 : : * initializing it (via the event_trigger_ops @init() function).
1182 : : * This is also where commands can use the @trigger_type value to
1183 : : * make the decision as to whether or not multiple instances of
1184 : : * the trigger should be allowed. This is usually implemented by
1185 : : * the generic utility function @register_trigger() (see
1186 : : * trace_event_triggers.c).
1187 : : *
1188 : : * @unreg: Removes the trigger from the list of triggers associated
1189 : : * with the event, and disables the event trigger itself, after
1190 : : * initializing it (via the event_trigger_ops @free() function).
1191 : : * This is usually implemented by the generic utility function
1192 : : * @unregister_trigger() (see trace_event_triggers.c).
1193 : : *
1194 : : * @set_filter: An optional function called to parse and set a filter
1195 : : * for the trigger. If no @set_filter() method is set for the
1196 : : * event command, filters set by the user for the command will be
1197 : : * ignored. This is usually implemented by the generic utility
1198 : : * function @set_trigger_filter() (see trace_event_triggers.c).
1199 : : *
1200 : : * @get_trigger_ops: The callback function invoked to retrieve the
1201 : : * event_trigger_ops implementation associated with the command.
1202 : : */
1203 : : struct event_command {
1204 : : struct list_head list;
1205 : : char *name;
1206 : : enum event_trigger_type trigger_type;
1207 : : bool post_trigger;
1208 : : int (*func)(struct event_command *cmd_ops,
1209 : : struct ftrace_event_file *file,
1210 : : char *glob, char *cmd, char *params);
1211 : : int (*reg)(char *glob,
1212 : : struct event_trigger_ops *ops,
1213 : : struct event_trigger_data *data,
1214 : : struct ftrace_event_file *file);
1215 : : void (*unreg)(char *glob,
1216 : : struct event_trigger_ops *ops,
1217 : : struct event_trigger_data *data,
1218 : : struct ftrace_event_file *file);
1219 : : int (*set_filter)(char *filter_str,
1220 : : struct event_trigger_data *data,
1221 : : struct ftrace_event_file *file);
1222 : : struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
1223 : : };
1224 : :
1225 : : extern int trace_event_enable_disable(struct ftrace_event_file *file,
1226 : : int enable, int soft_disable);
1227 : : extern int tracing_alloc_snapshot(void);
1228 : :
1229 : : extern const char *__start___trace_bprintk_fmt[];
1230 : : extern const char *__stop___trace_bprintk_fmt[];
1231 : :
1232 : : extern const char *__start___tracepoint_str[];
1233 : : extern const char *__stop___tracepoint_str[];
1234 : :
1235 : : void trace_printk_init_buffers(void);
1236 : : void trace_printk_start_comm(void);
1237 : : int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
1238 : : int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);
1239 : :
1240 : : /*
1241 : : * Normal trace_printk() and friends allocates special buffers
1242 : : * to do the manipulation, as well as saves the print formats
1243 : : * into sections to display. But the trace infrastructure wants
1244 : : * to use these without the added overhead at the price of being
1245 : : * a bit slower (used mainly for warnings, where we don't care
1246 : : * about performance). The internal_trace_puts() is for such
1247 : : * a purpose.
1248 : : */
1249 : : #define internal_trace_puts(str) __trace_puts(_THIS_IP_, str, strlen(str))
1250 : :
1251 : : #undef FTRACE_ENTRY
1252 : : #define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter) \
1253 : : extern struct ftrace_event_call \
1254 : : __attribute__((__aligned__(4))) event_##call;
1255 : : #undef FTRACE_ENTRY_DUP
1256 : : #define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print, filter) \
1257 : : FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
1258 : : filter)
1259 : : #include "trace_entries.h"
1260 : :
1261 : : #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
1262 : : int perf_ftrace_event_register(struct ftrace_event_call *call,
1263 : : enum trace_reg type, void *data);
1264 : : #else
1265 : : #define perf_ftrace_event_register NULL
1266 : : #endif
1267 : :
1268 : : #endif /* _LINUX_KERNEL_TRACE_H */
|
