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