Merge branch 'sched/core' into cpus4096
[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_DYNAMIC_FTRACE
91 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
92 #include <asm/ftrace.h>
93
94 enum {
95         FTRACE_FL_FREE          = (1 << 0),
96         FTRACE_FL_FAILED        = (1 << 1),
97         FTRACE_FL_FILTER        = (1 << 2),
98         FTRACE_FL_ENABLED       = (1 << 3),
99         FTRACE_FL_NOTRACE       = (1 << 4),
100         FTRACE_FL_CONVERTED     = (1 << 5),
101         FTRACE_FL_FROZEN        = (1 << 6),
102 };
103
104 struct dyn_ftrace {
105         struct list_head        list;
106         unsigned long           ip; /* address of mcount call-site */
107         unsigned long           flags;
108         struct dyn_arch_ftrace  arch;
109 };
110
111 int ftrace_force_update(void);
112 void ftrace_set_filter(unsigned char *buf, int len, int reset);
113
114 /* defined in arch */
115 extern int ftrace_ip_converted(unsigned long ip);
116 extern int ftrace_dyn_arch_init(void *data);
117 extern int ftrace_update_ftrace_func(ftrace_func_t func);
118 extern void ftrace_caller(void);
119 extern void ftrace_call(void);
120 extern void mcount_call(void);
121 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
122 extern void ftrace_graph_caller(void);
123 extern int ftrace_enable_ftrace_graph_caller(void);
124 extern int ftrace_disable_ftrace_graph_caller(void);
125 #else
126 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
127 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
128 #endif
129
130 /**
131  * ftrace_make_nop - convert code into top
132  * @mod: module structure if called by module load initialization
133  * @rec: the mcount call site record
134  * @addr: the address that the call site should be calling
135  *
136  * This is a very sensitive operation and great care needs
137  * to be taken by the arch.  The operation should carefully
138  * read the location, check to see if what is read is indeed
139  * what we expect it to be, and then on success of the compare,
140  * it should write to the location.
141  *
142  * The code segment at @rec->ip should be a caller to @addr
143  *
144  * Return must be:
145  *  0 on success
146  *  -EFAULT on error reading the location
147  *  -EINVAL on a failed compare of the contents
148  *  -EPERM  on error writing to the location
149  * Any other value will be considered a failure.
150  */
151 extern int ftrace_make_nop(struct module *mod,
152                            struct dyn_ftrace *rec, unsigned long addr);
153
154 /**
155  * ftrace_make_call - convert a nop call site into a call to addr
156  * @rec: the mcount call site record
157  * @addr: the address that the call site should call
158  *
159  * This is a very sensitive operation and great care needs
160  * to be taken by the arch.  The operation should carefully
161  * read the location, check to see if what is read is indeed
162  * what we expect it to be, and then on success of the compare,
163  * it should write to the location.
164  *
165  * The code segment at @rec->ip should be a nop
166  *
167  * Return must be:
168  *  0 on success
169  *  -EFAULT on error reading the location
170  *  -EINVAL on a failed compare of the contents
171  *  -EPERM  on error writing to the location
172  * Any other value will be considered a failure.
173  */
174 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
175
176
177 /* May be defined in arch */
178 extern int ftrace_arch_read_dyn_info(char *buf, int size);
179
180 extern int skip_trace(unsigned long ip);
181
182 extern void ftrace_release(void *start, unsigned long size);
183
184 extern void ftrace_disable_daemon(void);
185 extern void ftrace_enable_daemon(void);
186 #else
187 # define skip_trace(ip)                         ({ 0; })
188 # define ftrace_force_update()                  ({ 0; })
189 # define ftrace_set_filter(buf, len, reset)     do { } while (0)
190 # define ftrace_disable_daemon()                do { } while (0)
191 # define ftrace_enable_daemon()                 do { } while (0)
192 static inline void ftrace_release(void *start, unsigned long size) { }
193 #endif /* CONFIG_DYNAMIC_FTRACE */
194
195 /* totally disable ftrace - can not re-enable after this */
196 void ftrace_kill(void);
197
198 static inline void tracer_disable(void)
199 {
200 #ifdef CONFIG_FUNCTION_TRACER
201         ftrace_enabled = 0;
202 #endif
203 }
204
205 /*
206  * Ftrace disable/restore without lock. Some synchronization mechanism
207  * must be used to prevent ftrace_enabled to be changed between
208  * disable/restore.
209  */
210 static inline int __ftrace_enabled_save(void)
211 {
212 #ifdef CONFIG_FUNCTION_TRACER
213         int saved_ftrace_enabled = ftrace_enabled;
214         ftrace_enabled = 0;
215         return saved_ftrace_enabled;
216 #else
217         return 0;
218 #endif
219 }
220
221 static inline void __ftrace_enabled_restore(int enabled)
222 {
223 #ifdef CONFIG_FUNCTION_TRACER
224         ftrace_enabled = enabled;
225 #endif
226 }
227
228 #ifdef CONFIG_FRAME_POINTER
229 /* TODO: need to fix this for ARM */
230 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
231 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
232 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
233 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
234 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
235 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
236 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
237 #else
238 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
239 # define CALLER_ADDR1 0UL
240 # define CALLER_ADDR2 0UL
241 # define CALLER_ADDR3 0UL
242 # define CALLER_ADDR4 0UL
243 # define CALLER_ADDR5 0UL
244 # define CALLER_ADDR6 0UL
245 #endif
246
247 #ifdef CONFIG_IRQSOFF_TRACER
248   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
249   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
250 #else
251 # define time_hardirqs_on(a0, a1)               do { } while (0)
252 # define time_hardirqs_off(a0, a1)              do { } while (0)
253 #endif
254
255 #ifdef CONFIG_PREEMPT_TRACER
256   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
257   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
258 #else
259 # define trace_preempt_on(a0, a1)               do { } while (0)
260 # define trace_preempt_off(a0, a1)              do { } while (0)
261 #endif
262
263 #ifdef CONFIG_TRACING
264 extern int ftrace_dump_on_oops;
265
266 extern void tracing_start(void);
267 extern void tracing_stop(void);
268 extern void ftrace_off_permanent(void);
269
270 extern void
271 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
272
273 /**
274  * ftrace_printk - printf formatting in the ftrace buffer
275  * @fmt: the printf format for printing
276  *
277  * Note: __ftrace_printk is an internal function for ftrace_printk and
278  *       the @ip is passed in via the ftrace_printk macro.
279  *
280  * This function allows a kernel developer to debug fast path sections
281  * that printk is not appropriate for. By scattering in various
282  * printk like tracing in the code, a developer can quickly see
283  * where problems are occurring.
284  *
285  * This is intended as a debugging tool for the developer only.
286  * Please refrain from leaving ftrace_printks scattered around in
287  * your code.
288  */
289 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
290 extern int
291 __ftrace_printk(unsigned long ip, const char *fmt, ...)
292         __attribute__ ((format (printf, 2, 3)));
293 extern void ftrace_dump(void);
294 #else
295 static inline void
296 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
297 static inline int
298 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0)));
299
300 static inline void tracing_start(void) { }
301 static inline void tracing_stop(void) { }
302 static inline void ftrace_off_permanent(void) { }
303 static inline int
304 ftrace_printk(const char *fmt, ...)
305 {
306         return 0;
307 }
308 static inline void ftrace_dump(void) { }
309 #endif
310
311 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
312 extern void ftrace_init(void);
313 extern void ftrace_init_module(struct module *mod,
314                                unsigned long *start, unsigned long *end);
315 #else
316 static inline void ftrace_init(void) { }
317 static inline void
318 ftrace_init_module(struct module *mod,
319                    unsigned long *start, unsigned long *end) { }
320 #endif
321
322 enum {
323         POWER_NONE = 0,
324         POWER_CSTATE = 1,
325         POWER_PSTATE = 2,
326 };
327
328 struct power_trace {
329 #ifdef CONFIG_POWER_TRACER
330         ktime_t                 stamp;
331         ktime_t                 end;
332         int                     type;
333         int                     state;
334 #endif
335 };
336
337 #ifdef CONFIG_POWER_TRACER
338 extern void trace_power_start(struct power_trace *it, unsigned int type,
339                                         unsigned int state);
340 extern void trace_power_mark(struct power_trace *it, unsigned int type,
341                                         unsigned int state);
342 extern void trace_power_end(struct power_trace *it);
343 #else
344 static inline void trace_power_start(struct power_trace *it, unsigned int type,
345                                         unsigned int state) { }
346 static inline void trace_power_mark(struct power_trace *it, unsigned int type,
347                                         unsigned int state) { }
348 static inline void trace_power_end(struct power_trace *it) { }
349 #endif
350
351
352 /*
353  * Structure that defines an entry function trace.
354  */
355 struct ftrace_graph_ent {
356         unsigned long func; /* Current function */
357         int depth;
358 };
359
360 /*
361  * Structure that defines a return function trace.
362  */
363 struct ftrace_graph_ret {
364         unsigned long func; /* Current function */
365         unsigned long long calltime;
366         unsigned long long rettime;
367         /* Number of functions that overran the depth limit for current task */
368         unsigned long overrun;
369         int depth;
370 };
371
372 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
373
374 /*
375  * Sometimes we don't want to trace a function with the function
376  * graph tracer but we want them to keep traced by the usual function
377  * tracer if the function graph tracer is not configured.
378  */
379 #define __notrace_funcgraph             notrace
380
381 #define FTRACE_RETFUNC_DEPTH 50
382 #define FTRACE_RETSTACK_ALLOC_SIZE 32
383 /* Type of the callback handlers for tracing function graph*/
384 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
385 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
386
387 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
388                                 trace_func_graph_ent_t entryfunc);
389
390 extern void ftrace_graph_stop(void);
391
392 /* The current handlers in use */
393 extern trace_func_graph_ret_t ftrace_graph_return;
394 extern trace_func_graph_ent_t ftrace_graph_entry;
395
396 extern void unregister_ftrace_graph(void);
397
398 extern void ftrace_graph_init_task(struct task_struct *t);
399 extern void ftrace_graph_exit_task(struct task_struct *t);
400
401 static inline int task_curr_ret_stack(struct task_struct *t)
402 {
403         return t->curr_ret_stack;
404 }
405
406 static inline void pause_graph_tracing(void)
407 {
408         atomic_inc(&current->tracing_graph_pause);
409 }
410
411 static inline void unpause_graph_tracing(void)
412 {
413         atomic_dec(&current->tracing_graph_pause);
414 }
415 #else
416
417 #define __notrace_funcgraph
418
419 static inline void ftrace_graph_init_task(struct task_struct *t) { }
420 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
421
422 static inline int task_curr_ret_stack(struct task_struct *tsk)
423 {
424         return -1;
425 }
426
427 static inline void pause_graph_tracing(void) { }
428 static inline void unpause_graph_tracing(void) { }
429 #endif
430
431 #ifdef CONFIG_TRACING
432 #include <linux/sched.h>
433
434 /* flags for current->trace */
435 enum {
436         TSK_TRACE_FL_TRACE_BIT  = 0,
437         TSK_TRACE_FL_GRAPH_BIT  = 1,
438 };
439 enum {
440         TSK_TRACE_FL_TRACE      = 1 << TSK_TRACE_FL_TRACE_BIT,
441         TSK_TRACE_FL_GRAPH      = 1 << TSK_TRACE_FL_GRAPH_BIT,
442 };
443
444 static inline void set_tsk_trace_trace(struct task_struct *tsk)
445 {
446         set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
447 }
448
449 static inline void clear_tsk_trace_trace(struct task_struct *tsk)
450 {
451         clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
452 }
453
454 static inline int test_tsk_trace_trace(struct task_struct *tsk)
455 {
456         return tsk->trace & TSK_TRACE_FL_TRACE;
457 }
458
459 static inline void set_tsk_trace_graph(struct task_struct *tsk)
460 {
461         set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
462 }
463
464 static inline void clear_tsk_trace_graph(struct task_struct *tsk)
465 {
466         clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
467 }
468
469 static inline int test_tsk_trace_graph(struct task_struct *tsk)
470 {
471         return tsk->trace & TSK_TRACE_FL_GRAPH;
472 }
473
474 #endif /* CONFIG_TRACING */
475
476 #endif /* _LINUX_FTRACE_H */