]> git.karo-electronics.de Git - mv-sheeva.git/blob - include/linux/ftrace.h
afba918c623c5a2ab86e4ac8363e1b24e9c95c3f
[mv-sheeva.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_GRAPH_TRACER
119 extern void ftrace_graph_caller(void);
120 extern int ftrace_enable_ftrace_graph_caller(void);
121 extern int ftrace_disable_ftrace_graph_caller(void);
122 #else
123 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
124 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
125 #endif
126
127 /**
128  * ftrace_make_nop - convert code into top
129  * @mod: module structure if called by module load initialization
130  * @rec: the mcount call site record
131  * @addr: the address that the call site should be calling
132  *
133  * This is a very sensitive operation and great care needs
134  * to be taken by the arch.  The operation should carefully
135  * read the location, check to see if what is read is indeed
136  * what we expect it to be, and then on success of the compare,
137  * it should write to the location.
138  *
139  * The code segment at @rec->ip should be a caller to @addr
140  *
141  * Return must be:
142  *  0 on success
143  *  -EFAULT on error reading the location
144  *  -EINVAL on a failed compare of the contents
145  *  -EPERM  on error writing to the location
146  * Any other value will be considered a failure.
147  */
148 extern int ftrace_make_nop(struct module *mod,
149                            struct dyn_ftrace *rec, unsigned long addr);
150
151 /**
152  * ftrace_make_call - convert a nop call site into a call to addr
153  * @rec: the mcount call site record
154  * @addr: the address that the call site should call
155  *
156  * This is a very sensitive operation and great care needs
157  * to be taken by the arch.  The operation should carefully
158  * read the location, check to see if what is read is indeed
159  * what we expect it to be, and then on success of the compare,
160  * it should write to the location.
161  *
162  * The code segment at @rec->ip should be a nop
163  *
164  * Return must be:
165  *  0 on success
166  *  -EFAULT on error reading the location
167  *  -EINVAL on a failed compare of the contents
168  *  -EPERM  on error writing to the location
169  * Any other value will be considered a failure.
170  */
171 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
172
173
174 /* May be defined in arch */
175 extern int ftrace_arch_read_dyn_info(char *buf, int size);
176
177 extern int skip_trace(unsigned long ip);
178
179 extern void ftrace_release(void *start, unsigned long size);
180
181 extern void ftrace_disable_daemon(void);
182 extern void ftrace_enable_daemon(void);
183 #else
184 # define skip_trace(ip)                         ({ 0; })
185 # define ftrace_force_update()                  ({ 0; })
186 # define ftrace_set_filter(buf, len, reset)     do { } while (0)
187 # define ftrace_disable_daemon()                do { } while (0)
188 # define ftrace_enable_daemon()                 do { } while (0)
189 static inline void ftrace_release(void *start, unsigned long size) { }
190 #endif /* CONFIG_DYNAMIC_FTRACE */
191
192 /* totally disable ftrace - can not re-enable after this */
193 void ftrace_kill(void);
194
195 static inline void tracer_disable(void)
196 {
197 #ifdef CONFIG_FUNCTION_TRACER
198         ftrace_enabled = 0;
199 #endif
200 }
201
202 /*
203  * Ftrace disable/restore without lock. Some synchronization mechanism
204  * must be used to prevent ftrace_enabled to be changed between
205  * disable/restore.
206  */
207 static inline int __ftrace_enabled_save(void)
208 {
209 #ifdef CONFIG_FUNCTION_TRACER
210         int saved_ftrace_enabled = ftrace_enabled;
211         ftrace_enabled = 0;
212         return saved_ftrace_enabled;
213 #else
214         return 0;
215 #endif
216 }
217
218 static inline void __ftrace_enabled_restore(int enabled)
219 {
220 #ifdef CONFIG_FUNCTION_TRACER
221         ftrace_enabled = enabled;
222 #endif
223 }
224
225 #ifdef CONFIG_FRAME_POINTER
226 /* TODO: need to fix this for ARM */
227 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
228 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
229 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
230 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
231 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
232 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
233 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
234 #else
235 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
236 # define CALLER_ADDR1 0UL
237 # define CALLER_ADDR2 0UL
238 # define CALLER_ADDR3 0UL
239 # define CALLER_ADDR4 0UL
240 # define CALLER_ADDR5 0UL
241 # define CALLER_ADDR6 0UL
242 #endif
243
244 #ifdef CONFIG_IRQSOFF_TRACER
245   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
246   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
247 #else
248 # define time_hardirqs_on(a0, a1)               do { } while (0)
249 # define time_hardirqs_off(a0, a1)              do { } while (0)
250 #endif
251
252 #ifdef CONFIG_PREEMPT_TRACER
253   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
254   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
255 #else
256 # define trace_preempt_on(a0, a1)               do { } while (0)
257 # define trace_preempt_off(a0, a1)              do { } while (0)
258 #endif
259
260 #ifdef CONFIG_TRACING
261 extern int ftrace_dump_on_oops;
262
263 extern void tracing_start(void);
264 extern void tracing_stop(void);
265 extern void ftrace_off_permanent(void);
266
267 extern void
268 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
269
270 /**
271  * ftrace_printk - printf formatting in the ftrace buffer
272  * @fmt: the printf format for printing
273  *
274  * Note: __ftrace_printk is an internal function for ftrace_printk and
275  *       the @ip is passed in via the ftrace_printk macro.
276  *
277  * This function allows a kernel developer to debug fast path sections
278  * that printk is not appropriate for. By scattering in various
279  * printk like tracing in the code, a developer can quickly see
280  * where problems are occurring.
281  *
282  * This is intended as a debugging tool for the developer only.
283  * Please refrain from leaving ftrace_printks scattered around in
284  * your code.
285  */
286 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
287 extern int
288 __ftrace_printk(unsigned long ip, const char *fmt, ...)
289         __attribute__ ((format (printf, 2, 3)));
290 extern void ftrace_dump(void);
291 #else
292 static inline void
293 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
294 static inline int
295 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0)));
296
297 static inline void tracing_start(void) { }
298 static inline void tracing_stop(void) { }
299 static inline void ftrace_off_permanent(void) { }
300 static inline int
301 ftrace_printk(const char *fmt, ...)
302 {
303         return 0;
304 }
305 static inline void ftrace_dump(void) { }
306 #endif
307
308 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
309 extern void ftrace_init(void);
310 extern void ftrace_init_module(struct module *mod,
311                                unsigned long *start, unsigned long *end);
312 #else
313 static inline void ftrace_init(void) { }
314 static inline void
315 ftrace_init_module(struct module *mod,
316                    unsigned long *start, unsigned long *end) { }
317 #endif
318
319 enum {
320         POWER_NONE = 0,
321         POWER_CSTATE = 1,
322         POWER_PSTATE = 2,
323 };
324
325 struct power_trace {
326 #ifdef CONFIG_POWER_TRACER
327         ktime_t                 stamp;
328         ktime_t                 end;
329         int                     type;
330         int                     state;
331 #endif
332 };
333
334 #ifdef CONFIG_POWER_TRACER
335 extern void trace_power_start(struct power_trace *it, unsigned int type,
336                                         unsigned int state);
337 extern void trace_power_mark(struct power_trace *it, unsigned int type,
338                                         unsigned int state);
339 extern void trace_power_end(struct power_trace *it);
340 #else
341 static inline void trace_power_start(struct power_trace *it, unsigned int type,
342                                         unsigned int state) { }
343 static inline void trace_power_mark(struct power_trace *it, unsigned int type,
344                                         unsigned int state) { }
345 static inline void trace_power_end(struct power_trace *it) { }
346 #endif
347
348
349 /*
350  * Structure that defines an entry function trace.
351  */
352 struct ftrace_graph_ent {
353         unsigned long func; /* Current function */
354         int depth;
355 };
356
357 /*
358  * Structure that defines a return function trace.
359  */
360 struct ftrace_graph_ret {
361         unsigned long func; /* Current function */
362         unsigned long long calltime;
363         unsigned long long rettime;
364         /* Number of functions that overran the depth limit for current task */
365         unsigned long overrun;
366         int depth;
367 };
368
369 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
370 #define FTRACE_RETFUNC_DEPTH 50
371 #define FTRACE_RETSTACK_ALLOC_SIZE 32
372 /* Type of the callback handlers for tracing function graph*/
373 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
374 typedef void (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
375
376 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
377                                 trace_func_graph_ent_t entryfunc);
378
379 /* The current handlers in use */
380 extern trace_func_graph_ret_t ftrace_graph_return;
381 extern trace_func_graph_ent_t ftrace_graph_entry;
382
383 extern void unregister_ftrace_graph(void);
384
385 extern void ftrace_graph_init_task(struct task_struct *t);
386 extern void ftrace_graph_exit_task(struct task_struct *t);
387 #else
388 static inline void ftrace_graph_init_task(struct task_struct *t) { }
389 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
390 #endif
391
392 #endif /* _LINUX_FTRACE_H */