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