ftrace: stacktrace fix
[linux-2.6.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 <asm/atomic.h>
6 #include <linux/sched.h>
7 #include <linux/clocksource.h>
8
9 enum trace_type {
10         __TRACE_FIRST_TYPE = 0,
11
12         TRACE_FN,
13         TRACE_CTX,
14         TRACE_WAKE,
15         TRACE_STACK,
16         TRACE_SPECIAL,
17
18         __TRACE_LAST_TYPE
19 };
20
21 /*
22  * Function trace entry - function address and parent function addres:
23  */
24 struct ftrace_entry {
25         unsigned long           ip;
26         unsigned long           parent_ip;
27 };
28
29 /*
30  * Context switch trace entry - which task (and prio) we switched from/to:
31  */
32 struct ctx_switch_entry {
33         unsigned int            prev_pid;
34         unsigned char           prev_prio;
35         unsigned char           prev_state;
36         unsigned int            next_pid;
37         unsigned char           next_prio;
38         unsigned char           next_state;
39 };
40
41 /*
42  * Special (free-form) trace entry:
43  */
44 struct special_entry {
45         unsigned long           arg1;
46         unsigned long           arg2;
47         unsigned long           arg3;
48 };
49
50 /*
51  * Stack-trace entry:
52  */
53
54 #define FTRACE_STACK_ENTRIES    8
55
56 struct stack_entry {
57         unsigned long           caller[FTRACE_STACK_ENTRIES];
58 };
59
60 /*
61  * The trace entry - the most basic unit of tracing. This is what
62  * is printed in the end as a single line in the trace output, such as:
63  *
64  *     bash-15816 [01]   235.197585: idle_cpu <- irq_enter
65  */
66 struct trace_entry {
67         char                    type;
68         char                    cpu;
69         char                    flags;
70         char                    preempt_count;
71         int                     pid;
72         cycle_t                 t;
73         union {
74                 struct ftrace_entry             fn;
75                 struct ctx_switch_entry         ctx;
76                 struct special_entry            special;
77                 struct stack_entry              stack;
78         };
79 };
80
81 #define TRACE_ENTRY_SIZE        sizeof(struct trace_entry)
82
83 /*
84  * The CPU trace array - it consists of thousands of trace entries
85  * plus some other descriptor data: (for example which task started
86  * the trace, etc.)
87  */
88 struct trace_array_cpu {
89         struct list_head        trace_pages;
90         atomic_t                disabled;
91         raw_spinlock_t          lock;
92         struct lock_class_key   lock_key;
93
94         /* these fields get copied into max-trace: */
95         unsigned                trace_head_idx;
96         unsigned                trace_tail_idx;
97         void                    *trace_head; /* producer */
98         void                    *trace_tail; /* consumer */
99         unsigned long           trace_idx;
100         unsigned long           overrun;
101         unsigned long           saved_latency;
102         unsigned long           critical_start;
103         unsigned long           critical_end;
104         unsigned long           critical_sequence;
105         unsigned long           nice;
106         unsigned long           policy;
107         unsigned long           rt_priority;
108         cycle_t                 preempt_timestamp;
109         pid_t                   pid;
110         uid_t                   uid;
111         char                    comm[TASK_COMM_LEN];
112 };
113
114 struct trace_iterator;
115
116 /*
117  * The trace array - an array of per-CPU trace arrays. This is the
118  * highest level data structure that individual tracers deal with.
119  * They have on/off state as well:
120  */
121 struct trace_array {
122         unsigned long           entries;
123         long                    ctrl;
124         int                     cpu;
125         cycle_t                 time_start;
126         struct task_struct      *waiter;
127         struct trace_array_cpu  *data[NR_CPUS];
128 };
129
130 /*
131  * A specific tracer, represented by methods that operate on a trace array:
132  */
133 struct tracer {
134         const char              *name;
135         void                    (*init)(struct trace_array *tr);
136         void                    (*reset)(struct trace_array *tr);
137         void                    (*open)(struct trace_iterator *iter);
138         void                    (*pipe_open)(struct trace_iterator *iter);
139         void                    (*close)(struct trace_iterator *iter);
140         void                    (*start)(struct trace_iterator *iter);
141         void                    (*stop)(struct trace_iterator *iter);
142         ssize_t                 (*read)(struct trace_iterator *iter,
143                                         struct file *filp, char __user *ubuf,
144                                         size_t cnt, loff_t *ppos);
145         void                    (*ctrl_update)(struct trace_array *tr);
146 #ifdef CONFIG_FTRACE_STARTUP_TEST
147         int                     (*selftest)(struct tracer *trace,
148                                             struct trace_array *tr);
149 #endif
150         int                     (*print_line)(struct trace_iterator *iter);
151         struct tracer           *next;
152         int                     print_max;
153 };
154
155 struct trace_seq {
156         unsigned char           buffer[PAGE_SIZE];
157         unsigned int            len;
158         unsigned int            readpos;
159 };
160
161 /*
162  * Trace iterator - used by printout routines who present trace
163  * results to users and which routines might sleep, etc:
164  */
165 struct trace_iterator {
166         struct trace_array      *tr;
167         struct tracer           *trace;
168         void                    *private;
169         long                    last_overrun[NR_CPUS];
170         long                    overrun[NR_CPUS];
171
172         /* The below is zeroed out in pipe_read */
173         struct trace_seq        seq;
174         struct trace_entry      *ent;
175         int                     cpu;
176
177         struct trace_entry      *prev_ent;
178         int                     prev_cpu;
179
180         unsigned long           iter_flags;
181         loff_t                  pos;
182         unsigned long           next_idx[NR_CPUS];
183         struct list_head        *next_page[NR_CPUS];
184         unsigned                next_page_idx[NR_CPUS];
185         long                    idx;
186 };
187
188 void tracing_reset(struct trace_array_cpu *data);
189 int tracing_open_generic(struct inode *inode, struct file *filp);
190 struct dentry *tracing_init_dentry(void);
191 void ftrace(struct trace_array *tr,
192                             struct trace_array_cpu *data,
193                             unsigned long ip,
194                             unsigned long parent_ip,
195                             unsigned long flags);
196 void tracing_sched_switch_trace(struct trace_array *tr,
197                                 struct trace_array_cpu *data,
198                                 struct task_struct *prev,
199                                 struct task_struct *next,
200                                 unsigned long flags);
201 void tracing_record_cmdline(struct task_struct *tsk);
202
203 void tracing_sched_wakeup_trace(struct trace_array *tr,
204                                 struct trace_array_cpu *data,
205                                 struct task_struct *wakee,
206                                 struct task_struct *cur,
207                                 unsigned long flags);
208 void trace_special(struct trace_array *tr,
209                    struct trace_array_cpu *data,
210                    unsigned long arg1,
211                    unsigned long arg2,
212                    unsigned long arg3);
213 void trace_function(struct trace_array *tr,
214                     struct trace_array_cpu *data,
215                     unsigned long ip,
216                     unsigned long parent_ip,
217                     unsigned long flags);
218
219 void tracing_start_function_trace(void);
220 void tracing_stop_function_trace(void);
221 int register_tracer(struct tracer *type);
222 void unregister_tracer(struct tracer *type);
223
224 extern unsigned long nsecs_to_usecs(unsigned long nsecs);
225
226 extern unsigned long tracing_max_latency;
227 extern unsigned long tracing_thresh;
228
229 extern atomic_t trace_record_cmdline_enabled;
230
231 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
232 void update_max_tr_single(struct trace_array *tr,
233                           struct task_struct *tsk, int cpu);
234
235 extern cycle_t ftrace_now(int cpu);
236
237 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
238 typedef void
239 (*tracer_switch_func_t)(void *private,
240                         void *__rq,
241                         struct task_struct *prev,
242                         struct task_struct *next);
243
244 struct tracer_switch_ops {
245         tracer_switch_func_t            func;
246         void                            *private;
247         struct tracer_switch_ops        *next;
248 };
249
250 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
251
252 #ifdef CONFIG_DYNAMIC_FTRACE
253 extern unsigned long ftrace_update_tot_cnt;
254 #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
255 extern int DYN_FTRACE_TEST_NAME(void);
256 #endif
257
258 #ifdef CONFIG_FTRACE_STARTUP_TEST
259 #ifdef CONFIG_FTRACE
260 extern int trace_selftest_startup_function(struct tracer *trace,
261                                            struct trace_array *tr);
262 #endif
263 #ifdef CONFIG_IRQSOFF_TRACER
264 extern int trace_selftest_startup_irqsoff(struct tracer *trace,
265                                           struct trace_array *tr);
266 #endif
267 #ifdef CONFIG_PREEMPT_TRACER
268 extern int trace_selftest_startup_preemptoff(struct tracer *trace,
269                                              struct trace_array *tr);
270 #endif
271 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
272 extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
273                                                  struct trace_array *tr);
274 #endif
275 #ifdef CONFIG_SCHED_TRACER
276 extern int trace_selftest_startup_wakeup(struct tracer *trace,
277                                          struct trace_array *tr);
278 #endif
279 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
280 extern int trace_selftest_startup_sched_switch(struct tracer *trace,
281                                                struct trace_array *tr);
282 #endif
283 #endif /* CONFIG_FTRACE_STARTUP_TEST */
284
285 extern void *head_page(struct trace_array_cpu *data);
286 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
287 extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
288                                  size_t cnt);
289 extern long ns2usecs(cycle_t nsec);
290
291 extern unsigned long trace_flags;
292
293 /*
294  * trace_iterator_flags is an enumeration that defines bit
295  * positions into trace_flags that controls the output.
296  *
297  * NOTE: These bits must match the trace_options array in
298  *       trace.c.
299  */
300 enum trace_iterator_flags {
301         TRACE_ITER_PRINT_PARENT         = 0x01,
302         TRACE_ITER_SYM_OFFSET           = 0x02,
303         TRACE_ITER_SYM_ADDR             = 0x04,
304         TRACE_ITER_VERBOSE              = 0x08,
305         TRACE_ITER_RAW                  = 0x10,
306         TRACE_ITER_HEX                  = 0x20,
307         TRACE_ITER_BIN                  = 0x40,
308         TRACE_ITER_BLOCK                = 0x80,
309         TRACE_ITER_STACKTRACE           = 0x100,
310         TRACE_ITER_SCHED_TREE           = 0x200,
311 };
312
313 #endif /* _LINUX_KERNEL_TRACE_H */