tracing/function-return-tracer: clean up task start/exit callbacks
[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/kallsyms.h>
10
11 #ifdef CONFIG_FUNCTION_TRACER
12
13 extern int ftrace_enabled;
14 extern int
15 ftrace_enable_sysctl(struct ctl_table *table, int write,
16                      struct file *filp, void __user *buffer, size_t *lenp,
17                      loff_t *ppos);
18
19 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
20
21 struct ftrace_ops {
22         ftrace_func_t     func;
23         struct ftrace_ops *next;
24 };
25
26 extern int function_trace_stop;
27
28 /*
29  * Type of the current tracing.
30  */
31 enum ftrace_tracing_type_t {
32         FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
33         FTRACE_TYPE_RETURN,     /* Hook the return of the function */
34 };
35
36 /* Current tracing type, default is FTRACE_TYPE_ENTER */
37 extern enum ftrace_tracing_type_t ftrace_tracing_type;
38
39 /**
40  * ftrace_stop - stop function tracer.
41  *
42  * A quick way to stop the function tracer. Note this an on off switch,
43  * it is not something that is recursive like preempt_disable.
44  * This does not disable the calling of mcount, it only stops the
45  * calling of functions from mcount.
46  */
47 static inline void ftrace_stop(void)
48 {
49         function_trace_stop = 1;
50 }
51
52 /**
53  * ftrace_start - start the function tracer.
54  *
55  * This function is the inverse of ftrace_stop. This does not enable
56  * the function tracing if the function tracer is disabled. This only
57  * sets the function tracer flag to continue calling the functions
58  * from mcount.
59  */
60 static inline void ftrace_start(void)
61 {
62         function_trace_stop = 0;
63 }
64
65 /*
66  * The ftrace_ops must be a static and should also
67  * be read_mostly.  These functions do modify read_mostly variables
68  * so use them sparely. Never free an ftrace_op or modify the
69  * next pointer after it has been registered. Even after unregistering
70  * it, the next pointer may still be used internally.
71  */
72 int register_ftrace_function(struct ftrace_ops *ops);
73 int unregister_ftrace_function(struct ftrace_ops *ops);
74 void clear_ftrace_function(void);
75
76 extern void ftrace_stub(unsigned long a0, unsigned long a1);
77
78 #else /* !CONFIG_FUNCTION_TRACER */
79 # define register_ftrace_function(ops) do { } while (0)
80 # define unregister_ftrace_function(ops) do { } while (0)
81 # define clear_ftrace_function(ops) do { } while (0)
82 static inline void ftrace_kill(void) { }
83 static inline void ftrace_stop(void) { }
84 static inline void ftrace_start(void) { }
85 #endif /* CONFIG_FUNCTION_TRACER */
86
87 #ifdef CONFIG_DYNAMIC_FTRACE
88 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
89 #include <asm/ftrace.h>
90
91 enum {
92         FTRACE_FL_FREE          = (1 << 0),
93         FTRACE_FL_FAILED        = (1 << 1),
94         FTRACE_FL_FILTER        = (1 << 2),
95         FTRACE_FL_ENABLED       = (1 << 3),
96         FTRACE_FL_NOTRACE       = (1 << 4),
97         FTRACE_FL_CONVERTED     = (1 << 5),
98         FTRACE_FL_FROZEN        = (1 << 6),
99 };
100
101 struct dyn_ftrace {
102         struct list_head        list;
103         unsigned long           ip; /* address of mcount call-site */
104         unsigned long           flags;
105         struct dyn_arch_ftrace  arch;
106 };
107
108 int ftrace_force_update(void);
109 void ftrace_set_filter(unsigned char *buf, int len, int reset);
110
111 /* defined in arch */
112 extern int ftrace_ip_converted(unsigned long ip);
113 extern int ftrace_dyn_arch_init(void *data);
114 extern int ftrace_update_ftrace_func(ftrace_func_t func);
115 extern void ftrace_caller(void);
116 extern void ftrace_call(void);
117 extern void mcount_call(void);
118 #ifdef CONFIG_FUNCTION_RET_TRACER
119 extern void ftrace_return_caller(void);
120 #endif
121
122 /**
123  * ftrace_make_nop - convert code into top
124  * @mod: module structure if called by module load initialization
125  * @rec: the mcount call site record
126  * @addr: the address that the call site should be calling
127  *
128  * This is a very sensitive operation and great care needs
129  * to be taken by the arch.  The operation should carefully
130  * read the location, check to see if what is read is indeed
131  * what we expect it to be, and then on success of the compare,
132  * it should write to the location.
133  *
134  * The code segment at @rec->ip should be a caller to @addr
135  *
136  * Return must be:
137  *  0 on success
138  *  -EFAULT on error reading the location
139  *  -EINVAL on a failed compare of the contents
140  *  -EPERM  on error writing to the location
141  * Any other value will be considered a failure.
142  */
143 extern int ftrace_make_nop(struct module *mod,
144                            struct dyn_ftrace *rec, unsigned long addr);
145
146 /**
147  * ftrace_make_call - convert a nop call site into a call to addr
148  * @rec: the mcount call site record
149  * @addr: the address that the call site should call
150  *
151  * This is a very sensitive operation and great care needs
152  * to be taken by the arch.  The operation should carefully
153  * read the location, check to see if what is read is indeed
154  * what we expect it to be, and then on success of the compare,
155  * it should write to the location.
156  *
157  * The code segment at @rec->ip should be a nop
158  *
159  * Return must be:
160  *  0 on success
161  *  -EFAULT on error reading the location
162  *  -EINVAL on a failed compare of the contents
163  *  -EPERM  on error writing to the location
164  * Any other value will be considered a failure.
165  */
166 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
167
168
169 /* May be defined in arch */
170 extern int ftrace_arch_read_dyn_info(char *buf, int size);
171
172 extern int skip_trace(unsigned long ip);
173
174 extern void ftrace_release(void *start, unsigned long size);
175
176 extern void ftrace_disable_daemon(void);
177 extern void ftrace_enable_daemon(void);
178 #else
179 # define skip_trace(ip)                         ({ 0; })
180 # define ftrace_force_update()                  ({ 0; })
181 # define ftrace_set_filter(buf, len, reset)     do { } while (0)
182 # define ftrace_disable_daemon()                do { } while (0)
183 # define ftrace_enable_daemon()                 do { } while (0)
184 static inline void ftrace_release(void *start, unsigned long size) { }
185 #endif /* CONFIG_DYNAMIC_FTRACE */
186
187 /* totally disable ftrace - can not re-enable after this */
188 void ftrace_kill(void);
189
190 static inline void tracer_disable(void)
191 {
192 #ifdef CONFIG_FUNCTION_TRACER
193         ftrace_enabled = 0;
194 #endif
195 }
196
197 /*
198  * Ftrace disable/restore without lock. Some synchronization mechanism
199  * must be used to prevent ftrace_enabled to be changed between
200  * disable/restore.
201  */
202 static inline int __ftrace_enabled_save(void)
203 {
204 #ifdef CONFIG_FUNCTION_TRACER
205         int saved_ftrace_enabled = ftrace_enabled;
206         ftrace_enabled = 0;
207         return saved_ftrace_enabled;
208 #else
209         return 0;
210 #endif
211 }
212
213 static inline void __ftrace_enabled_restore(int enabled)
214 {
215 #ifdef CONFIG_FUNCTION_TRACER
216         ftrace_enabled = enabled;
217 #endif
218 }
219
220 #ifdef CONFIG_FRAME_POINTER
221 /* TODO: need to fix this for ARM */
222 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
223 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
224 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
225 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
226 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
227 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
228 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
229 #else
230 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
231 # define CALLER_ADDR1 0UL
232 # define CALLER_ADDR2 0UL
233 # define CALLER_ADDR3 0UL
234 # define CALLER_ADDR4 0UL
235 # define CALLER_ADDR5 0UL
236 # define CALLER_ADDR6 0UL
237 #endif
238
239 #ifdef CONFIG_IRQSOFF_TRACER
240   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
241   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
242 #else
243 # define time_hardirqs_on(a0, a1)               do { } while (0)
244 # define time_hardirqs_off(a0, a1)              do { } while (0)
245 #endif
246
247 #ifdef CONFIG_PREEMPT_TRACER
248   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
249   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
250 #else
251 # define trace_preempt_on(a0, a1)               do { } while (0)
252 # define trace_preempt_off(a0, a1)              do { } while (0)
253 #endif
254
255 #ifdef CONFIG_TRACING
256 extern int ftrace_dump_on_oops;
257
258 extern void tracing_start(void);
259 extern void tracing_stop(void);
260
261 extern void
262 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
263
264 /**
265  * ftrace_printk - printf formatting in the ftrace buffer
266  * @fmt: the printf format for printing
267  *
268  * Note: __ftrace_printk is an internal function for ftrace_printk and
269  *       the @ip is passed in via the ftrace_printk macro.
270  *
271  * This function allows a kernel developer to debug fast path sections
272  * that printk is not appropriate for. By scattering in various
273  * printk like tracing in the code, a developer can quickly see
274  * where problems are occurring.
275  *
276  * This is intended as a debugging tool for the developer only.
277  * Please refrain from leaving ftrace_printks scattered around in
278  * your code.
279  */
280 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
281 extern int
282 __ftrace_printk(unsigned long ip, const char *fmt, ...)
283         __attribute__ ((format (printf, 2, 3)));
284 extern void ftrace_dump(void);
285 #else
286 static inline void
287 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
288 static inline int
289 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0)));
290
291 static inline void tracing_start(void) { }
292 static inline void tracing_stop(void) { }
293 static inline int
294 ftrace_printk(const char *fmt, ...)
295 {
296         return 0;
297 }
298 static inline void ftrace_dump(void) { }
299 #endif
300
301 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
302 extern void ftrace_init(void);
303 extern void ftrace_init_module(struct module *mod,
304                                unsigned long *start, unsigned long *end);
305 #else
306 static inline void ftrace_init(void) { }
307 static inline void
308 ftrace_init_module(struct module *mod,
309                    unsigned long *start, unsigned long *end) { }
310 #endif
311
312
313 /*
314  * Structure that defines a return function trace.
315  */
316 struct ftrace_retfunc {
317         unsigned long ret; /* Return address */
318         unsigned long func; /* Current function */
319         unsigned long long calltime;
320         unsigned long long rettime;
321         /* Number of functions that overran the depth limit for current task */
322         unsigned long overrun;
323 };
324
325 #ifdef CONFIG_FUNCTION_RET_TRACER
326 #define FTRACE_RETFUNC_DEPTH 50
327 #define FTRACE_RETSTACK_ALLOC_SIZE 32
328 /* Type of a callback handler of tracing return function */
329 typedef void (*trace_function_return_t)(struct ftrace_retfunc *);
330
331 extern int register_ftrace_return(trace_function_return_t func);
332 /* The current handler in use */
333 extern trace_function_return_t ftrace_function_return;
334 extern void unregister_ftrace_return(void);
335
336 extern void ftrace_retfunc_init_task(struct task_struct *t);
337 extern void ftrace_retfunc_exit_task(struct task_struct *t);
338 #else
339 static inline void ftrace_retfunc_init_task(struct task_struct *t) { }
340 static inline void ftrace_retfunc_exit_task(struct task_struct *t) { }
341 #endif
342
343 #endif /* _LINUX_FTRACE_H */