677432b9cb7e6e45dc98c400b304689d0cb4ca13
[linux-2.6.git] / include / linux / ftrace.h
1 #ifndef _LINUX_FTRACE_H
2 #define _LINUX_FTRACE_H
3
4 #include <linux/linkage.h>
5 #include <linux/fs.h>
6 #include <linux/ktime.h>
7 #include <linux/init.h>
8 #include <linux/types.h>
9 #include <linux/module.h>
10 #include <linux/kallsyms.h>
11 #include <linux/bitops.h>
12 #include <linux/sched.h>
13
14 #ifdef CONFIG_FUNCTION_TRACER
15
16 extern int ftrace_enabled;
17 extern int
18 ftrace_enable_sysctl(struct ctl_table *table, int write,
19                      struct file *filp, void __user *buffer, size_t *lenp,
20                      loff_t *ppos);
21
22 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
23
24 struct ftrace_ops {
25         ftrace_func_t     func;
26         struct ftrace_ops *next;
27 };
28
29 extern int function_trace_stop;
30
31 /*
32  * Type of the current tracing.
33  */
34 enum ftrace_tracing_type_t {
35         FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
36         FTRACE_TYPE_RETURN,     /* Hook the return of the function */
37 };
38
39 /* Current tracing type, default is FTRACE_TYPE_ENTER */
40 extern enum ftrace_tracing_type_t ftrace_tracing_type;
41
42 /**
43  * ftrace_stop - stop function tracer.
44  *
45  * A quick way to stop the function tracer. Note this an on off switch,
46  * it is not something that is recursive like preempt_disable.
47  * This does not disable the calling of mcount, it only stops the
48  * calling of functions from mcount.
49  */
50 static inline void ftrace_stop(void)
51 {
52         function_trace_stop = 1;
53 }
54
55 /**
56  * ftrace_start - start the function tracer.
57  *
58  * This function is the inverse of ftrace_stop. This does not enable
59  * the function tracing if the function tracer is disabled. This only
60  * sets the function tracer flag to continue calling the functions
61  * from mcount.
62  */
63 static inline void ftrace_start(void)
64 {
65         function_trace_stop = 0;
66 }
67
68 /*
69  * The ftrace_ops must be a static and should also
70  * be read_mostly.  These functions do modify read_mostly variables
71  * so use them sparely. Never free an ftrace_op or modify the
72  * next pointer after it has been registered. Even after unregistering
73  * it, the next pointer may still be used internally.
74  */
75 int register_ftrace_function(struct ftrace_ops *ops);
76 int unregister_ftrace_function(struct ftrace_ops *ops);
77 void clear_ftrace_function(void);
78
79 extern void ftrace_stub(unsigned long a0, unsigned long a1);
80
81 #else /* !CONFIG_FUNCTION_TRACER */
82 # define register_ftrace_function(ops) do { } while (0)
83 # define unregister_ftrace_function(ops) do { } while (0)
84 # define clear_ftrace_function(ops) do { } while (0)
85 static inline void ftrace_kill(void) { }
86 static inline void ftrace_stop(void) { }
87 static inline void ftrace_start(void) { }
88 #endif /* CONFIG_FUNCTION_TRACER */
89
90 #ifdef CONFIG_STACK_TRACER
91 extern int stack_tracer_enabled;
92 int
93 stack_trace_sysctl(struct ctl_table *table, int write,
94                    struct file *file, void __user *buffer, size_t *lenp,
95                    loff_t *ppos);
96 #endif
97
98 #ifdef CONFIG_DYNAMIC_FTRACE
99 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
100 #include <asm/ftrace.h>
101
102 enum {
103         FTRACE_FL_FREE          = (1 << 0),
104         FTRACE_FL_FAILED        = (1 << 1),
105         FTRACE_FL_FILTER        = (1 << 2),
106         FTRACE_FL_ENABLED       = (1 << 3),
107         FTRACE_FL_NOTRACE       = (1 << 4),
108         FTRACE_FL_CONVERTED     = (1 << 5),
109         FTRACE_FL_FROZEN        = (1 << 6),
110 };
111
112 struct dyn_ftrace {
113         struct list_head        list;
114         unsigned long           ip; /* address of mcount call-site */
115         unsigned long           flags;
116         struct dyn_arch_ftrace  arch;
117 };
118
119 int ftrace_force_update(void);
120 void ftrace_set_filter(unsigned char *buf, int len, int reset);
121
122 /* defined in arch */
123 extern int ftrace_ip_converted(unsigned long ip);
124 extern int ftrace_dyn_arch_init(void *data);
125 extern int ftrace_update_ftrace_func(ftrace_func_t func);
126 extern void ftrace_caller(void);
127 extern void ftrace_call(void);
128 extern void mcount_call(void);
129 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
130 extern void ftrace_graph_caller(void);
131 extern int ftrace_enable_ftrace_graph_caller(void);
132 extern int ftrace_disable_ftrace_graph_caller(void);
133 #else
134 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
135 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
136 #endif
137
138 /**
139  * ftrace_make_nop - convert code into top
140  * @mod: module structure if called by module load initialization
141  * @rec: the mcount call site record
142  * @addr: the address that the call site should be calling
143  *
144  * This is a very sensitive operation and great care needs
145  * to be taken by the arch.  The operation should carefully
146  * read the location, check to see if what is read is indeed
147  * what we expect it to be, and then on success of the compare,
148  * it should write to the location.
149  *
150  * The code segment at @rec->ip should be a caller to @addr
151  *
152  * Return must be:
153  *  0 on success
154  *  -EFAULT on error reading the location
155  *  -EINVAL on a failed compare of the contents
156  *  -EPERM  on error writing to the location
157  * Any other value will be considered a failure.
158  */
159 extern int ftrace_make_nop(struct module *mod,
160                            struct dyn_ftrace *rec, unsigned long addr);
161
162 /**
163  * ftrace_make_call - convert a nop call site into a call to addr
164  * @rec: the mcount call site record
165  * @addr: the address that the call site should call
166  *
167  * This is a very sensitive operation and great care needs
168  * to be taken by the arch.  The operation should carefully
169  * read the location, check to see if what is read is indeed
170  * what we expect it to be, and then on success of the compare,
171  * it should write to the location.
172  *
173  * The code segment at @rec->ip should be a nop
174  *
175  * Return must be:
176  *  0 on success
177  *  -EFAULT on error reading the location
178  *  -EINVAL on a failed compare of the contents
179  *  -EPERM  on error writing to the location
180  * Any other value will be considered a failure.
181  */
182 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
183
184
185 /* May be defined in arch */
186 extern int ftrace_arch_read_dyn_info(char *buf, int size);
187
188 extern int skip_trace(unsigned long ip);
189
190 extern void ftrace_release(void *start, unsigned long size);
191
192 extern void ftrace_disable_daemon(void);
193 extern void ftrace_enable_daemon(void);
194 #else
195 # define skip_trace(ip)                         ({ 0; })
196 # define ftrace_force_update()                  ({ 0; })
197 # define ftrace_set_filter(buf, len, reset)     do { } while (0)
198 # define ftrace_disable_daemon()                do { } while (0)
199 # define ftrace_enable_daemon()                 do { } while (0)
200 static inline void ftrace_release(void *start, unsigned long size) { }
201 #endif /* CONFIG_DYNAMIC_FTRACE */
202
203 /* totally disable ftrace - can not re-enable after this */
204 void ftrace_kill(void);
205
206 static inline void tracer_disable(void)
207 {
208 #ifdef CONFIG_FUNCTION_TRACER
209         ftrace_enabled = 0;
210 #endif
211 }
212
213 /*
214  * Ftrace disable/restore without lock. Some synchronization mechanism
215  * must be used to prevent ftrace_enabled to be changed between
216  * disable/restore.
217  */
218 static inline int __ftrace_enabled_save(void)
219 {
220 #ifdef CONFIG_FUNCTION_TRACER
221         int saved_ftrace_enabled = ftrace_enabled;
222         ftrace_enabled = 0;
223         return saved_ftrace_enabled;
224 #else
225         return 0;
226 #endif
227 }
228
229 static inline void __ftrace_enabled_restore(int enabled)
230 {
231 #ifdef CONFIG_FUNCTION_TRACER
232         ftrace_enabled = enabled;
233 #endif
234 }
235
236 #ifdef CONFIG_FRAME_POINTER
237 /* TODO: need to fix this for ARM */
238 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
239 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
240 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
241 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
242 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
243 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
244 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
245 #else
246 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
247 # define CALLER_ADDR1 0UL
248 # define CALLER_ADDR2 0UL
249 # define CALLER_ADDR3 0UL
250 # define CALLER_ADDR4 0UL
251 # define CALLER_ADDR5 0UL
252 # define CALLER_ADDR6 0UL
253 #endif
254
255 #ifdef CONFIG_IRQSOFF_TRACER
256   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
257   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
258 #else
259 # define time_hardirqs_on(a0, a1)               do { } while (0)
260 # define time_hardirqs_off(a0, a1)              do { } while (0)
261 #endif
262
263 #ifdef CONFIG_PREEMPT_TRACER
264   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
265   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
266 #else
267 # define trace_preempt_on(a0, a1)               do { } while (0)
268 # define trace_preempt_off(a0, a1)              do { } while (0)
269 #endif
270
271 #ifdef CONFIG_TRACING
272 extern int ftrace_dump_on_oops;
273
274 extern void tracing_start(void);
275 extern void tracing_stop(void);
276 extern void ftrace_off_permanent(void);
277
278 extern void
279 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
280
281 /**
282  * ftrace_printk - printf formatting in the ftrace buffer
283  * @fmt: the printf format for printing
284  *
285  * Note: __ftrace_printk is an internal function for ftrace_printk and
286  *       the @ip is passed in via the ftrace_printk macro.
287  *
288  * This function allows a kernel developer to debug fast path sections
289  * that printk is not appropriate for. By scattering in various
290  * printk like tracing in the code, a developer can quickly see
291  * where problems are occurring.
292  *
293  * This is intended as a debugging tool for the developer only.
294  * Please refrain from leaving ftrace_printks scattered around in
295  * your code.
296  */
297 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
298 extern int
299 __ftrace_printk(unsigned long ip, const char *fmt, ...)
300         __attribute__ ((format (printf, 2, 3)));
301 extern void ftrace_dump(void);
302 #else
303 static inline void
304 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
305 static inline int
306 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
307
308 static inline void tracing_start(void) { }
309 static inline void tracing_stop(void) { }
310 static inline void ftrace_off_permanent(void) { }
311 static inline int
312 ftrace_printk(const char *fmt, ...)
313 {
314         return 0;
315 }
316 static inline void ftrace_dump(void) { }
317 #endif
318
319 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
320 extern void ftrace_init(void);
321 extern void ftrace_init_module(struct module *mod,
322                                unsigned long *start, unsigned long *end);
323 #else
324 static inline void ftrace_init(void) { }
325 static inline void
326 ftrace_init_module(struct module *mod,
327                    unsigned long *start, unsigned long *end) { }
328 #endif
329
330 enum {
331         POWER_NONE = 0,
332         POWER_CSTATE = 1,
333         POWER_PSTATE = 2,
334 };
335
336 struct power_trace {
337 #ifdef CONFIG_POWER_TRACER
338         ktime_t                 stamp;
339         ktime_t                 end;
340         int                     type;
341         int                     state;
342 #endif
343 };
344
345 #ifdef CONFIG_POWER_TRACER
346 extern void trace_power_start(struct power_trace *it, unsigned int type,
347                                         unsigned int state);
348 extern void trace_power_mark(struct power_trace *it, unsigned int type,
349                                         unsigned int state);
350 extern void trace_power_end(struct power_trace *it);
351 #else
352 static inline void trace_power_start(struct power_trace *it, unsigned int type,
353                                         unsigned int state) { }
354 static inline void trace_power_mark(struct power_trace *it, unsigned int type,
355                                         unsigned int state) { }
356 static inline void trace_power_end(struct power_trace *it) { }
357 #endif
358
359
360 /*
361  * Structure that defines an entry function trace.
362  */
363 struct ftrace_graph_ent {
364         unsigned long func; /* Current function */
365         int depth;
366 };
367
368 /*
369  * Structure that defines a return function trace.
370  */
371 struct ftrace_graph_ret {
372         unsigned long func; /* Current function */
373         unsigned long long calltime;
374         unsigned long long rettime;
375         /* Number of functions that overran the depth limit for current task */
376         unsigned long overrun;
377         int depth;
378 };
379
380 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
381
382 /*
383  * Sometimes we don't want to trace a function with the function
384  * graph tracer but we want them to keep traced by the usual function
385  * tracer if the function graph tracer is not configured.
386  */
387 #define __notrace_funcgraph             notrace
388
389 /*
390  * We want to which function is an entrypoint of a hardirq.
391  * That will help us to put a signal on output.
392  */
393 #define __irq_entry              __attribute__((__section__(".irqentry.text")))
394
395 /* Limits of hardirq entrypoints */
396 extern char __irqentry_text_start[];
397 extern char __irqentry_text_end[];
398
399 #define FTRACE_RETFUNC_DEPTH 50
400 #define FTRACE_RETSTACK_ALLOC_SIZE 32
401 /* Type of the callback handlers for tracing function graph*/
402 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
403 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
404
405 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
406                                 trace_func_graph_ent_t entryfunc);
407
408 extern void ftrace_graph_stop(void);
409
410 /* The current handlers in use */
411 extern trace_func_graph_ret_t ftrace_graph_return;
412 extern trace_func_graph_ent_t ftrace_graph_entry;
413
414 extern void unregister_ftrace_graph(void);
415
416 extern void ftrace_graph_init_task(struct task_struct *t);
417 extern void ftrace_graph_exit_task(struct task_struct *t);
418
419 static inline int task_curr_ret_stack(struct task_struct *t)
420 {
421         return t->curr_ret_stack;
422 }
423
424 static inline void pause_graph_tracing(void)
425 {
426         atomic_inc(&current->tracing_graph_pause);
427 }
428
429 static inline void unpause_graph_tracing(void)
430 {
431         atomic_dec(&current->tracing_graph_pause);
432 }
433 #else
434
435 #define __notrace_funcgraph
436 #define __irq_entry
437
438 static inline void ftrace_graph_init_task(struct task_struct *t) { }
439 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
440
441 static inline int task_curr_ret_stack(struct task_struct *tsk)
442 {
443         return -1;
444 }
445
446 static inline void pause_graph_tracing(void) { }
447 static inline void unpause_graph_tracing(void) { }
448 #endif
449
450 #ifdef CONFIG_TRACING
451 #include <linux/sched.h>
452
453 /* flags for current->trace */
454 enum {
455         TSK_TRACE_FL_TRACE_BIT  = 0,
456         TSK_TRACE_FL_GRAPH_BIT  = 1,
457 };
458 enum {
459         TSK_TRACE_FL_TRACE      = 1 << TSK_TRACE_FL_TRACE_BIT,
460         TSK_TRACE_FL_GRAPH      = 1 << TSK_TRACE_FL_GRAPH_BIT,
461 };
462
463 static inline void set_tsk_trace_trace(struct task_struct *tsk)
464 {
465         set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
466 }
467
468 static inline void clear_tsk_trace_trace(struct task_struct *tsk)
469 {
470         clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
471 }
472
473 static inline int test_tsk_trace_trace(struct task_struct *tsk)
474 {
475         return tsk->trace & TSK_TRACE_FL_TRACE;
476 }
477
478 static inline void set_tsk_trace_graph(struct task_struct *tsk)
479 {
480         set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
481 }
482
483 static inline void clear_tsk_trace_graph(struct task_struct *tsk)
484 {
485         clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
486 }
487
488 static inline int test_tsk_trace_graph(struct task_struct *tsk)
489 {
490         return tsk->trace & TSK_TRACE_FL_GRAPH;
491 }
492
493 #endif /* CONFIG_TRACING */
494
495 #endif /* _LINUX_FTRACE_H */