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