blob: 847bb3c48dd09edd49ddc0c42f8a835a5a084639 [file] [log] [blame]
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +02001#ifndef _LINUX_FTRACE_H
2#define _LINUX_FTRACE_H
3
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +02004#include <linux/linkage.h>
Ingo Molnard49dbf32008-05-16 10:41:53 +02005#include <linux/fs.h>
Steven Noonaneb7fa932008-10-02 12:00:07 -07006#include <linux/ktime.h>
Frédéric Weisbeckerd13744c2008-09-23 11:32:08 +01007#include <linux/init.h>
8#include <linux/types.h>
Hugh Dickins9c246242008-12-09 13:14:27 -08009#include <linux/module.h>
Frederic Weisbecker56010202008-10-02 13:26:05 +020010#include <linux/kallsyms.h>
Steven Rostedtea4e2bc2008-12-03 15:36:57 -050011#include <linux/bitops.h>
Frederic Weisbecker21a8c462008-12-04 23:51:23 +010012#include <linux/sched.h>
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020013
Steven Rostedt606576c2008-10-06 19:06:12 -040014#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnar3e1932a2008-10-02 17:45:47 +020015
Steven Rostedtb0fc4942008-05-12 21:20:43 +020016extern int ftrace_enabled;
17extern int
18ftrace_enable_sysctl(struct ctl_table *table, int write,
19 struct file *filp, void __user *buffer, size_t *lenp,
20 loff_t *ppos);
21
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020022typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
23
24struct ftrace_ops {
25 ftrace_func_t func;
26 struct ftrace_ops *next;
27};
28
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050029extern int function_trace_stop;
30
Frederic Weisbeckere7d37372008-11-16 06:02:06 +010031/*
32 * Type of the current tracing.
33 */
34enum 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 */
40extern enum ftrace_tracing_type_t ftrace_tracing_type;
41
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050042/**
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 */
50static 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 */
63static inline void ftrace_start(void)
64{
65 function_trace_stop = 0;
66}
67
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020068/*
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 */
75int register_ftrace_function(struct ftrace_ops *ops);
76int unregister_ftrace_function(struct ftrace_ops *ops);
77void clear_ftrace_function(void);
78
79extern void ftrace_stub(unsigned long a0, unsigned long a1);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020080
Steven Rostedt606576c2008-10-06 19:06:12 -040081#else /* !CONFIG_FUNCTION_TRACER */
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020082# 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)
Steven Rostedt81adbdc2008-10-23 09:33:02 -040085static inline void ftrace_kill(void) { }
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050086static inline void ftrace_stop(void) { }
87static inline void ftrace_start(void) { }
Steven Rostedt606576c2008-10-06 19:06:12 -040088#endif /* CONFIG_FUNCTION_TRACER */
Steven Rostedt352ad252008-05-12 21:20:42 +020089
Steven Rostedtf38f1d22008-12-16 23:06:40 -050090#ifdef CONFIG_STACK_TRACER
91extern int stack_tracer_enabled;
92int
93stack_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
Steven Rostedtf6180772009-02-14 00:40:25 -050098struct ftrace_func_command {
99 struct list_head list;
100 char *name;
101 int (*func)(char *func, char *cmd,
102 char *params, int enable);
103};
104
Steven Rostedt3d083392008-05-12 21:20:42 +0200105#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt31e88902008-11-14 16:21:19 -0800106/* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
107#include <asm/ftrace.h>
108
Steven Rostedt000ab692009-02-17 13:35:06 -0500109int ftrace_arch_code_modify_prepare(void);
110int ftrace_arch_code_modify_post_process(void);
111
Steven Rostedt809dcf22009-02-16 23:06:01 -0500112struct seq_file;
113
Steven Rostedtb6887d72009-02-17 12:32:04 -0500114struct ftrace_probe_ops {
Steven Rostedt59df055f2009-02-14 15:29:06 -0500115 void (*func)(unsigned long ip,
116 unsigned long parent_ip,
117 void **data);
118 int (*callback)(unsigned long ip, void **data);
119 void (*free)(void **data);
Steven Rostedt809dcf22009-02-16 23:06:01 -0500120 int (*print)(struct seq_file *m,
121 unsigned long ip,
Steven Rostedtb6887d72009-02-17 12:32:04 -0500122 struct ftrace_probe_ops *ops,
Steven Rostedt809dcf22009-02-16 23:06:01 -0500123 void *data);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500124};
125
126extern int
Steven Rostedtb6887d72009-02-17 12:32:04 -0500127register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500128 void *data);
129extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500130unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500131 void *data);
132extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500133unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
134extern void unregister_ftrace_function_probe_all(char *glob);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500135
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200136enum {
Steven Rostedt37ad5082008-05-12 21:20:48 +0200137 FTRACE_FL_FREE = (1 << 0),
138 FTRACE_FL_FAILED = (1 << 1),
139 FTRACE_FL_FILTER = (1 << 2),
140 FTRACE_FL_ENABLED = (1 << 3),
Steven Rostedt41c52c02008-05-22 11:46:33 -0400141 FTRACE_FL_NOTRACE = (1 << 4),
Abhishek Sagar0eb96702008-06-01 21:47:30 +0530142 FTRACE_FL_CONVERTED = (1 << 5),
Abhishek Sagarecea6562008-06-21 23:47:53 +0530143 FTRACE_FL_FROZEN = (1 << 6),
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200144};
145
Steven Rostedt3d083392008-05-12 21:20:42 +0200146struct dyn_ftrace {
Steven Rostedt08f5ac902008-10-23 09:33:07 -0400147 struct list_head list;
148 unsigned long ip; /* address of mcount call-site */
149 unsigned long flags;
Steven Rostedt31e88902008-11-14 16:21:19 -0800150 struct dyn_arch_ftrace arch;
Steven Rostedt3d083392008-05-12 21:20:42 +0200151};
152
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200153int ftrace_force_update(void);
Steven Rostedt77a2b372008-05-12 21:20:45 +0200154void ftrace_set_filter(unsigned char *buf, int len, int reset);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200155
Steven Rostedtf6180772009-02-14 00:40:25 -0500156int register_ftrace_command(struct ftrace_func_command *cmd);
157int unregister_ftrace_command(struct ftrace_func_command *cmd);
158
Steven Rostedt3d083392008-05-12 21:20:42 +0200159/* defined in arch */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200160extern int ftrace_ip_converted(unsigned long ip);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200161extern int ftrace_dyn_arch_init(void *data);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200162extern int ftrace_update_ftrace_func(ftrace_func_t func);
163extern void ftrace_caller(void);
164extern void ftrace_call(void);
165extern void mcount_call(void);
Shaohua Lif0001202009-01-09 11:29:42 +0800166
167#ifndef FTRACE_ADDR
168#define FTRACE_ADDR ((unsigned long)ftrace_caller)
169#endif
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100170#ifdef CONFIG_FUNCTION_GRAPH_TRACER
171extern void ftrace_graph_caller(void);
Steven Rostedt5a45cfe2008-11-26 00:16:24 -0500172extern int ftrace_enable_ftrace_graph_caller(void);
173extern int ftrace_disable_ftrace_graph_caller(void);
174#else
175static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
176static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100177#endif
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400178
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400179/**
Wenji Huang57794a92009-02-06 17:33:27 +0800180 * ftrace_make_nop - convert code into nop
Steven Rostedt31e88902008-11-14 16:21:19 -0800181 * @mod: module structure if called by module load initialization
182 * @rec: the mcount call site record
183 * @addr: the address that the call site should be calling
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400184 *
185 * This is a very sensitive operation and great care needs
186 * to be taken by the arch. The operation should carefully
187 * read the location, check to see if what is read is indeed
188 * what we expect it to be, and then on success of the compare,
189 * it should write to the location.
190 *
Steven Rostedt31e88902008-11-14 16:21:19 -0800191 * The code segment at @rec->ip should be a caller to @addr
192 *
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400193 * Return must be:
194 * 0 on success
195 * -EFAULT on error reading the location
196 * -EINVAL on a failed compare of the contents
197 * -EPERM on error writing to the location
198 * Any other value will be considered a failure.
199 */
Steven Rostedt31e88902008-11-14 16:21:19 -0800200extern int ftrace_make_nop(struct module *mod,
201 struct dyn_ftrace *rec, unsigned long addr);
202
203/**
204 * ftrace_make_call - convert a nop call site into a call to addr
205 * @rec: the mcount call site record
206 * @addr: the address that the call site should call
207 *
208 * This is a very sensitive operation and great care needs
209 * to be taken by the arch. The operation should carefully
210 * read the location, check to see if what is read is indeed
211 * what we expect it to be, and then on success of the compare,
212 * it should write to the location.
213 *
214 * The code segment at @rec->ip should be a nop
215 *
216 * Return must be:
217 * 0 on success
218 * -EFAULT on error reading the location
219 * -EINVAL on a failed compare of the contents
220 * -EPERM on error writing to the location
221 * Any other value will be considered a failure.
222 */
223extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
224
225
226/* May be defined in arch */
227extern int ftrace_arch_read_dyn_info(char *buf, int size);
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400228
Abhishek Sagarecea6562008-06-21 23:47:53 +0530229extern int skip_trace(unsigned long ip);
230
Steven Rostedtc0719e52008-09-06 01:06:03 -0400231extern void ftrace_release(void *start, unsigned long size);
232
233extern void ftrace_disable_daemon(void);
234extern void ftrace_enable_daemon(void);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200235#else
Abhishek Sagarecea6562008-06-21 23:47:53 +0530236# define skip_trace(ip) ({ 0; })
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200237# define ftrace_force_update() ({ 0; })
238# define ftrace_set_filter(buf, len, reset) do { } while (0)
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400239# define ftrace_disable_daemon() do { } while (0)
240# define ftrace_enable_daemon() do { } while (0)
Steven Rostedtc0719e52008-09-06 01:06:03 -0400241static inline void ftrace_release(void *start, unsigned long size) { }
Steven Rostedtf6180772009-02-14 00:40:25 -0500242static inline int register_ftrace_command(struct ftrace_func_command *cmd)
243{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100244 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500245}
246static inline int unregister_ftrace_command(char *cmd_name)
247{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100248 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500249}
Abhishek Sagarecea6562008-06-21 23:47:53 +0530250#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt352ad252008-05-12 21:20:42 +0200251
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200252/* totally disable ftrace - can not re-enable after this */
253void ftrace_kill(void);
254
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200255static inline void tracer_disable(void)
256{
Steven Rostedt606576c2008-10-06 19:06:12 -0400257#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200258 ftrace_enabled = 0;
259#endif
260}
261
Huang Ying37002732008-08-18 16:24:56 +0800262/*
263 * Ftrace disable/restore without lock. Some synchronization mechanism
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700264 * must be used to prevent ftrace_enabled to be changed between
Huang Ying37002732008-08-18 16:24:56 +0800265 * disable/restore.
266 */
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700267static inline int __ftrace_enabled_save(void)
268{
Steven Rostedt606576c2008-10-06 19:06:12 -0400269#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700270 int saved_ftrace_enabled = ftrace_enabled;
271 ftrace_enabled = 0;
272 return saved_ftrace_enabled;
273#else
274 return 0;
275#endif
276}
277
278static inline void __ftrace_enabled_restore(int enabled)
279{
Steven Rostedt606576c2008-10-06 19:06:12 -0400280#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700281 ftrace_enabled = enabled;
282#endif
283}
284
Steven Rostedt352ad252008-05-12 21:20:42 +0200285#ifdef CONFIG_FRAME_POINTER
286/* TODO: need to fix this for ARM */
287# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
288# define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
289# define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
290# define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
291# define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
292# define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
Ingo Molnar86387f72008-05-12 21:20:51 +0200293# define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
Steven Rostedt352ad252008-05-12 21:20:42 +0200294#else
295# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
296# define CALLER_ADDR1 0UL
297# define CALLER_ADDR2 0UL
298# define CALLER_ADDR3 0UL
299# define CALLER_ADDR4 0UL
300# define CALLER_ADDR5 0UL
Ingo Molnar86387f72008-05-12 21:20:51 +0200301# define CALLER_ADDR6 0UL
Steven Rostedt352ad252008-05-12 21:20:42 +0200302#endif
303
Steven Rostedt81d68a92008-05-12 21:20:42 +0200304#ifdef CONFIG_IRQSOFF_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100305 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
306 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
Steven Rostedt81d68a92008-05-12 21:20:42 +0200307#else
308# define time_hardirqs_on(a0, a1) do { } while (0)
309# define time_hardirqs_off(a0, a1) do { } while (0)
310#endif
311
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200312#ifdef CONFIG_PREEMPT_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100313 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
314 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200315#else
316# define trace_preempt_on(a0, a1) do { } while (0)
317# define trace_preempt_off(a0, a1) do { } while (0)
318#endif
319
Ingo Molnarb1829d22008-05-28 01:22:08 +0200320#ifdef CONFIG_TRACING
Steven Rostedt944ac422008-10-23 19:26:08 -0400321extern int ftrace_dump_on_oops;
322
Steven Rostedt0f048702008-11-05 16:05:44 -0500323extern void tracing_start(void);
324extern void tracing_stop(void);
Steven Rostedt69bb54e2008-11-21 12:59:38 -0500325extern void ftrace_off_permanent(void);
Steven Rostedt0f048702008-11-05 16:05:44 -0500326
Ingo Molnar74f4e362008-05-12 21:21:15 +0200327extern void
328ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
Steven Rostedt2f2c99d2008-08-01 16:45:49 -0400329
330/**
331 * ftrace_printk - printf formatting in the ftrace buffer
332 * @fmt: the printf format for printing
333 *
334 * Note: __ftrace_printk is an internal function for ftrace_printk and
335 * the @ip is passed in via the ftrace_printk macro.
336 *
337 * This function allows a kernel developer to debug fast path sections
338 * that printk is not appropriate for. By scattering in various
339 * printk like tracing in the code, a developer can quickly see
340 * where problems are occurring.
341 *
342 * This is intended as a debugging tool for the developer only.
343 * Please refrain from leaving ftrace_printks scattered around in
344 * your code.
345 */
346# define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400347extern int
348__ftrace_printk(unsigned long ip, const char *fmt, ...)
349 __attribute__ ((format (printf, 2, 3)));
Arnaldo Carvalho de Melo90112622009-01-23 12:06:23 -0200350# define ftrace_vprintk(fmt, ap) __ftrace_printk(_THIS_IP_, fmt, ap)
351extern int
352__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
Steven Rostedt3f5a54e2008-07-30 22:36:46 -0400353extern void ftrace_dump(void);
Ingo Molnar74f4e362008-05-12 21:21:15 +0200354#else
355static inline void
356ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400357static inline int
Lai Jiangshan3ddeb912008-12-20 17:15:14 +0800358ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
Ingo Molnar7b928c22008-08-15 17:48:02 +0200359
Steven Rostedt0f048702008-11-05 16:05:44 -0500360static inline void tracing_start(void) { }
361static inline void tracing_stop(void) { }
Steven Rostedt69bb54e2008-11-21 12:59:38 -0500362static inline void ftrace_off_permanent(void) { }
Ingo Molnar7b928c22008-08-15 17:48:02 +0200363static inline int
364ftrace_printk(const char *fmt, ...)
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400365{
366 return 0;
367}
Arnaldo Carvalho de Melo90112622009-01-23 12:06:23 -0200368static inline int
369ftrace_vprintk(const char *fmt, va_list ap)
370{
371 return 0;
372}
Steven Rostedt3f5a54e2008-07-30 22:36:46 -0400373static inline void ftrace_dump(void) { }
Ingo Molnar74f4e362008-05-12 21:21:15 +0200374#endif
375
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400376#ifdef CONFIG_FTRACE_MCOUNT_RECORD
377extern void ftrace_init(void);
Steven Rostedt31e88902008-11-14 16:21:19 -0800378extern void ftrace_init_module(struct module *mod,
379 unsigned long *start, unsigned long *end);
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400380#else
381static inline void ftrace_init(void) { }
Steven Rostedt90d595f2008-08-14 15:45:09 -0400382static inline void
Steven Rostedt31e88902008-11-14 16:21:19 -0800383ftrace_init_module(struct module *mod,
384 unsigned long *start, unsigned long *end) { }
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400385#endif
386
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100387/*
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100388 * Structure that defines an entry function trace.
389 */
390struct ftrace_graph_ent {
391 unsigned long func; /* Current function */
392 int depth;
393};
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400394
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100395/*
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100396 * Structure that defines a return function trace.
397 */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100398struct ftrace_graph_ret {
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100399 unsigned long func; /* Current function */
400 unsigned long long calltime;
401 unsigned long long rettime;
Frederic Weisbecker02310222008-11-17 03:22:41 +0100402 /* Number of functions that overran the depth limit for current task */
403 unsigned long overrun;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100404 int depth;
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100405};
406
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100407#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100408
409/*
Steven Rostedt712406a2009-02-09 10:54:03 -0800410 * Stack of return addresses for functions
411 * of a thread.
412 * Used in struct thread_info
413 */
414struct ftrace_ret_stack {
415 unsigned long ret;
416 unsigned long func;
417 unsigned long long calltime;
418};
419
420/*
421 * Primary handler of a function return.
422 * It relays on ftrace_return_to_handler.
423 * Defined in entry_32/64.S
424 */
425extern void return_to_handler(void);
426
427extern int
428ftrace_push_return_trace(unsigned long ret, unsigned long long time,
429 unsigned long func, int *depth);
430extern void
431ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret);
432
433/*
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100434 * Sometimes we don't want to trace a function with the function
435 * graph tracer but we want them to keep traced by the usual function
436 * tracer if the function graph tracer is not configured.
437 */
438#define __notrace_funcgraph notrace
439
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100440/*
441 * We want to which function is an entrypoint of a hardirq.
442 * That will help us to put a signal on output.
443 */
444#define __irq_entry __attribute__((__section__(".irqentry.text")))
445
446/* Limits of hardirq entrypoints */
447extern char __irqentry_text_start[];
448extern char __irqentry_text_end[];
449
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100450#define FTRACE_RETFUNC_DEPTH 50
451#define FTRACE_RETSTACK_ALLOC_SIZE 32
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100452/* Type of the callback handlers for tracing function graph*/
453typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
Steven Rostedte49dc192008-12-02 23:50:05 -0500454typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100455
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100456extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
457 trace_func_graph_ent_t entryfunc);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100458
Steven Rostedt14a866c2008-12-02 23:50:02 -0500459extern void ftrace_graph_stop(void);
460
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100461/* The current handlers in use */
462extern trace_func_graph_ret_t ftrace_graph_return;
463extern trace_func_graph_ent_t ftrace_graph_entry;
464
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100465extern void unregister_ftrace_graph(void);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100466
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100467extern void ftrace_graph_init_task(struct task_struct *t);
468extern void ftrace_graph_exit_task(struct task_struct *t);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100469
470static inline int task_curr_ret_stack(struct task_struct *t)
471{
472 return t->curr_ret_stack;
473}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100474
475static inline void pause_graph_tracing(void)
476{
477 atomic_inc(&current->tracing_graph_pause);
478}
479
480static inline void unpause_graph_tracing(void)
481{
482 atomic_dec(&current->tracing_graph_pause);
483}
Ingo Molnar82f60f02008-11-23 09:18:56 +0100484#else
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100485
486#define __notrace_funcgraph
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100487#define __irq_entry
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100488
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100489static inline void ftrace_graph_init_task(struct task_struct *t) { }
490static inline void ftrace_graph_exit_task(struct task_struct *t) { }
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100491
492static inline int task_curr_ret_stack(struct task_struct *tsk)
493{
494 return -1;
495}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100496
497static inline void pause_graph_tracing(void) { }
498static inline void unpause_graph_tracing(void) { }
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100499#endif
500
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500501#ifdef CONFIG_TRACING
502#include <linux/sched.h>
503
504/* flags for current->trace */
505enum {
506 TSK_TRACE_FL_TRACE_BIT = 0,
507 TSK_TRACE_FL_GRAPH_BIT = 1,
508};
509enum {
510 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
511 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
512};
513
514static inline void set_tsk_trace_trace(struct task_struct *tsk)
515{
516 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
517}
518
519static inline void clear_tsk_trace_trace(struct task_struct *tsk)
520{
521 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
522}
523
524static inline int test_tsk_trace_trace(struct task_struct *tsk)
525{
526 return tsk->trace & TSK_TRACE_FL_TRACE;
527}
528
529static inline void set_tsk_trace_graph(struct task_struct *tsk)
530{
531 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
532}
533
534static inline void clear_tsk_trace_graph(struct task_struct *tsk)
535{
536 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
537}
538
539static inline int test_tsk_trace_graph(struct task_struct *tsk)
540{
541 return tsk->trace & TSK_TRACE_FL_GRAPH;
542}
543
544#endif /* CONFIG_TRACING */
545
Markus Metzgerb1818742009-01-19 10:31:01 +0100546
547#ifdef CONFIG_HW_BRANCH_TRACER
548
549void trace_hw_branch(u64 from, u64 to);
550void trace_hw_branch_oops(void);
551
552#else /* CONFIG_HW_BRANCH_TRACER */
553
554static inline void trace_hw_branch(u64 from, u64 to) {}
555static inline void trace_hw_branch_oops(void) {}
556
557#endif /* CONFIG_HW_BRANCH_TRACER */
558
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200559#endif /* _LINUX_FTRACE_H */