blob: f33fb3b041c645b7af4a7373b8052037a6e1b519 [file] [log] [blame]
Mike Frysinger9849ed42010-07-20 03:13:35 -04001/*
2 * Ftrace header. For implementation details beyond the random comments
3 * scattered below, see: Documentation/trace/ftrace-design.txt
4 */
5
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +02006#ifndef _LINUX_FTRACE_H
7#define _LINUX_FTRACE_H
8
Frederic Weisbecker00126932009-03-05 01:49:22 +01009#include <linux/trace_clock.h>
Frederic Weisbecker56010202008-10-02 13:26:05 +020010#include <linux/kallsyms.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +010011#include <linux/linkage.h>
Steven Rostedtea4e2bc2008-12-03 15:36:57 -050012#include <linux/bitops.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +010013#include <linux/ktime.h>
Frederic Weisbecker21a8c462008-12-04 23:51:23 +010014#include <linux/sched.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +010015#include <linux/types.h>
16#include <linux/init.h>
17#include <linux/fs.h>
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020018
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +010019#include <asm/ftrace.h>
20
Paul Gortmakerde477252011-05-26 13:46:22 -040021struct module;
Steven Rostedt04da85b2011-07-11 10:12:59 -040022struct ftrace_hash;
23
Steven Rostedt606576c2008-10-06 19:06:12 -040024#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnar3e1932a2008-10-02 17:45:47 +020025
Steven Rostedtb0fc4942008-05-12 21:20:43 +020026extern int ftrace_enabled;
27extern int
28ftrace_enable_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -070029 void __user *buffer, size_t *lenp,
Steven Rostedtb0fc4942008-05-12 21:20:43 +020030 loff_t *ppos);
31
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020032typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
33
Steven Rostedtb8489142011-05-04 09:27:52 -040034enum {
35 FTRACE_OPS_FL_ENABLED = 1 << 0,
36 FTRACE_OPS_FL_GLOBAL = 1 << 1,
Steven Rostedtcdbe61b2011-05-05 21:14:55 -040037 FTRACE_OPS_FL_DYNAMIC = 1 << 2,
Steven Rostedtb8489142011-05-04 09:27:52 -040038};
39
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020040struct ftrace_ops {
Steven Rostedtf45948e2011-05-02 12:29:25 -040041 ftrace_func_t func;
42 struct ftrace_ops *next;
Steven Rostedtb8489142011-05-04 09:27:52 -040043 unsigned long flags;
Steven Rostedtf45948e2011-05-02 12:29:25 -040044#ifdef CONFIG_DYNAMIC_FTRACE
45 struct ftrace_hash *notrace_hash;
46 struct ftrace_hash *filter_hash;
47#endif
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020048};
49
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050050extern int function_trace_stop;
51
Frederic Weisbeckere7d37372008-11-16 06:02:06 +010052/*
53 * Type of the current tracing.
54 */
55enum ftrace_tracing_type_t {
56 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
57 FTRACE_TYPE_RETURN, /* Hook the return of the function */
58};
59
60/* Current tracing type, default is FTRACE_TYPE_ENTER */
61extern enum ftrace_tracing_type_t ftrace_tracing_type;
62
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050063/**
64 * ftrace_stop - stop function tracer.
65 *
66 * A quick way to stop the function tracer. Note this an on off switch,
67 * it is not something that is recursive like preempt_disable.
68 * This does not disable the calling of mcount, it only stops the
69 * calling of functions from mcount.
70 */
71static inline void ftrace_stop(void)
72{
73 function_trace_stop = 1;
74}
75
76/**
77 * ftrace_start - start the function tracer.
78 *
79 * This function is the inverse of ftrace_stop. This does not enable
80 * the function tracing if the function tracer is disabled. This only
81 * sets the function tracer flag to continue calling the functions
82 * from mcount.
83 */
84static inline void ftrace_start(void)
85{
86 function_trace_stop = 0;
87}
88
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020089/*
90 * The ftrace_ops must be a static and should also
91 * be read_mostly. These functions do modify read_mostly variables
92 * so use them sparely. Never free an ftrace_op or modify the
93 * next pointer after it has been registered. Even after unregistering
94 * it, the next pointer may still be used internally.
95 */
96int register_ftrace_function(struct ftrace_ops *ops);
97int unregister_ftrace_function(struct ftrace_ops *ops);
98void clear_ftrace_function(void);
99
100extern void ftrace_stub(unsigned long a0, unsigned long a1);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200101
Steven Rostedt606576c2008-10-06 19:06:12 -0400102#else /* !CONFIG_FUNCTION_TRACER */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400103/*
104 * (un)register_ftrace_function must be a macro since the ops parameter
105 * must not be evaluated.
106 */
107#define register_ftrace_function(ops) ({ 0; })
108#define unregister_ftrace_function(ops) ({ 0; })
109static inline void clear_ftrace_function(void) { }
Steven Rostedt81adbdc2008-10-23 09:33:02 -0400110static inline void ftrace_kill(void) { }
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500111static inline void ftrace_stop(void) { }
112static inline void ftrace_start(void) { }
Steven Rostedt606576c2008-10-06 19:06:12 -0400113#endif /* CONFIG_FUNCTION_TRACER */
Steven Rostedt352ad252008-05-12 21:20:42 +0200114
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500115#ifdef CONFIG_STACK_TRACER
116extern int stack_tracer_enabled;
117int
118stack_trace_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700119 void __user *buffer, size_t *lenp,
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500120 loff_t *ppos);
121#endif
122
Steven Rostedtf6180772009-02-14 00:40:25 -0500123struct ftrace_func_command {
124 struct list_head list;
125 char *name;
Steven Rostedt43dd61c2011-07-07 11:09:22 -0400126 int (*func)(struct ftrace_hash *hash,
127 char *func, char *cmd,
Steven Rostedtf6180772009-02-14 00:40:25 -0500128 char *params, int enable);
129};
130
Steven Rostedt3d083392008-05-12 21:20:42 +0200131#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt31e88902008-11-14 16:21:19 -0800132
Steven Rostedt000ab692009-02-17 13:35:06 -0500133int ftrace_arch_code_modify_prepare(void);
134int ftrace_arch_code_modify_post_process(void);
135
Steven Rostedtc88fd862011-08-16 09:53:39 -0400136void ftrace_bug(int err, unsigned long ip);
137
Steven Rostedt809dcf22009-02-16 23:06:01 -0500138struct seq_file;
139
Steven Rostedtb6887d72009-02-17 12:32:04 -0500140struct ftrace_probe_ops {
Steven Rostedt59df055f2009-02-14 15:29:06 -0500141 void (*func)(unsigned long ip,
142 unsigned long parent_ip,
143 void **data);
144 int (*callback)(unsigned long ip, void **data);
145 void (*free)(void **data);
Steven Rostedt809dcf22009-02-16 23:06:01 -0500146 int (*print)(struct seq_file *m,
147 unsigned long ip,
Steven Rostedtb6887d72009-02-17 12:32:04 -0500148 struct ftrace_probe_ops *ops,
Steven Rostedt809dcf22009-02-16 23:06:01 -0500149 void *data);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500150};
151
152extern int
Steven Rostedtb6887d72009-02-17 12:32:04 -0500153register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500154 void *data);
155extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500156unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500157 void *data);
158extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500159unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
160extern void unregister_ftrace_function_probe_all(char *glob);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500161
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500162extern int ftrace_text_reserved(void *start, void *end);
163
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200164enum {
Steven Rostedted926f92011-05-03 13:25:24 -0400165 FTRACE_FL_ENABLED = (1 << 30),
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200166};
167
Steven Rostedted926f92011-05-03 13:25:24 -0400168#define FTRACE_FL_MASK (0x3UL << 30)
169#define FTRACE_REF_MAX ((1 << 30) - 1)
170
Steven Rostedt3d083392008-05-12 21:20:42 +0200171struct dyn_ftrace {
Lai Jiangshanee000b72009-03-24 13:38:06 +0800172 union {
173 unsigned long ip; /* address of mcount call-site */
174 struct dyn_ftrace *freelist;
175 };
Steven Rostedt85ae32a2011-12-16 16:30:31 -0500176 unsigned long flags;
Lai Jiangshanee000b72009-03-24 13:38:06 +0800177 struct dyn_arch_ftrace arch;
Steven Rostedt3d083392008-05-12 21:20:42 +0200178};
179
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200180int ftrace_force_update(void);
Jiri Olsaac483c42012-01-02 10:04:14 +0100181int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400182 int len, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100183int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400184 int len, int reset);
185void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
186void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200187
Steven Rostedtf6180772009-02-14 00:40:25 -0500188int register_ftrace_command(struct ftrace_func_command *cmd);
189int unregister_ftrace_command(struct ftrace_func_command *cmd);
190
Steven Rostedtc88fd862011-08-16 09:53:39 -0400191enum {
192 FTRACE_UPDATE_CALLS = (1 << 0),
193 FTRACE_DISABLE_CALLS = (1 << 1),
194 FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
195 FTRACE_START_FUNC_RET = (1 << 3),
196 FTRACE_STOP_FUNC_RET = (1 << 4),
197};
198
199enum {
200 FTRACE_UPDATE_IGNORE,
201 FTRACE_UPDATE_MAKE_CALL,
202 FTRACE_UPDATE_MAKE_NOP,
203};
204
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500205enum {
206 FTRACE_ITER_FILTER = (1 << 0),
207 FTRACE_ITER_NOTRACE = (1 << 1),
208 FTRACE_ITER_PRINTALL = (1 << 2),
Steven Rostedt69a30832011-12-19 15:21:16 -0500209 FTRACE_ITER_DO_HASH = (1 << 3),
210 FTRACE_ITER_HASH = (1 << 4),
211 FTRACE_ITER_ENABLED = (1 << 5),
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500212};
213
Steven Rostedtc88fd862011-08-16 09:53:39 -0400214void arch_ftrace_update_code(int command);
215
216struct ftrace_rec_iter;
217
218struct ftrace_rec_iter *ftrace_rec_iter_start(void);
219struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
220struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
221
222int ftrace_update_record(struct dyn_ftrace *rec, int enable);
223int ftrace_test_record(struct dyn_ftrace *rec, int enable);
224void ftrace_run_stop_machine(int command);
225int ftrace_location(unsigned long ip);
226
227extern ftrace_func_t ftrace_trace_function;
228
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500229int ftrace_regex_open(struct ftrace_ops *ops, int flag,
230 struct inode *inode, struct file *file);
231ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
232 size_t cnt, loff_t *ppos);
233ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
234 size_t cnt, loff_t *ppos);
235loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int origin);
236int ftrace_regex_release(struct inode *inode, struct file *file);
237
Steven Rostedt2a85a372011-12-19 21:57:44 -0500238void __init
239ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
240
Steven Rostedt3d083392008-05-12 21:20:42 +0200241/* defined in arch */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200242extern int ftrace_ip_converted(unsigned long ip);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200243extern int ftrace_dyn_arch_init(void *data);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200244extern int ftrace_update_ftrace_func(ftrace_func_t func);
245extern void ftrace_caller(void);
246extern void ftrace_call(void);
247extern void mcount_call(void);
Shaohua Lif0001202009-01-09 11:29:42 +0800248
249#ifndef FTRACE_ADDR
250#define FTRACE_ADDR ((unsigned long)ftrace_caller)
251#endif
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100252#ifdef CONFIG_FUNCTION_GRAPH_TRACER
253extern void ftrace_graph_caller(void);
Steven Rostedt5a45cfe2008-11-26 00:16:24 -0500254extern int ftrace_enable_ftrace_graph_caller(void);
255extern int ftrace_disable_ftrace_graph_caller(void);
256#else
257static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
258static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100259#endif
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400260
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400261/**
Wenji Huang57794a92009-02-06 17:33:27 +0800262 * ftrace_make_nop - convert code into nop
Steven Rostedt31e88902008-11-14 16:21:19 -0800263 * @mod: module structure if called by module load initialization
264 * @rec: the mcount call site record
265 * @addr: the address that the call site should be calling
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400266 *
267 * This is a very sensitive operation and great care needs
268 * to be taken by the arch. The operation should carefully
269 * read the location, check to see if what is read is indeed
270 * what we expect it to be, and then on success of the compare,
271 * it should write to the location.
272 *
Steven Rostedt31e88902008-11-14 16:21:19 -0800273 * The code segment at @rec->ip should be a caller to @addr
274 *
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400275 * Return must be:
276 * 0 on success
277 * -EFAULT on error reading the location
278 * -EINVAL on a failed compare of the contents
279 * -EPERM on error writing to the location
280 * Any other value will be considered a failure.
281 */
Steven Rostedt31e88902008-11-14 16:21:19 -0800282extern int ftrace_make_nop(struct module *mod,
283 struct dyn_ftrace *rec, unsigned long addr);
284
285/**
286 * ftrace_make_call - convert a nop call site into a call to addr
287 * @rec: the mcount call site record
288 * @addr: the address that the call site should call
289 *
290 * This is a very sensitive operation and great care needs
291 * to be taken by the arch. The operation should carefully
292 * read the location, check to see if what is read is indeed
293 * what we expect it to be, and then on success of the compare,
294 * it should write to the location.
295 *
296 * The code segment at @rec->ip should be a nop
297 *
298 * Return must be:
299 * 0 on success
300 * -EFAULT on error reading the location
301 * -EINVAL on a failed compare of the contents
302 * -EPERM on error writing to the location
303 * Any other value will be considered a failure.
304 */
305extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
306
Steven Rostedt31e88902008-11-14 16:21:19 -0800307/* May be defined in arch */
308extern int ftrace_arch_read_dyn_info(char *buf, int size);
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400309
Abhishek Sagarecea6562008-06-21 23:47:53 +0530310extern int skip_trace(unsigned long ip);
311
Steven Rostedtc0719e52008-09-06 01:06:03 -0400312extern void ftrace_disable_daemon(void);
313extern void ftrace_enable_daemon(void);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200314#else
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400315static inline int skip_trace(unsigned long ip) { return 0; }
316static inline int ftrace_force_update(void) { return 0; }
317static inline void ftrace_set_filter(unsigned char *buf, int len, int reset)
318{
319}
320static inline void ftrace_disable_daemon(void) { }
321static inline void ftrace_enable_daemon(void) { }
jolsa@redhat.come7247a12009-10-07 19:00:35 +0200322static inline void ftrace_release_mod(struct module *mod) {}
Steven Rostedtf6180772009-02-14 00:40:25 -0500323static inline int register_ftrace_command(struct ftrace_func_command *cmd)
324{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100325 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500326}
327static inline int unregister_ftrace_command(char *cmd_name)
328{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100329 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500330}
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500331static inline int ftrace_text_reserved(void *start, void *end)
332{
333 return 0;
334}
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500335
336/*
337 * Again users of functions that have ftrace_ops may not
338 * have them defined when ftrace is not enabled, but these
339 * functions may still be called. Use a macro instead of inline.
340 */
341#define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; })
Steven Rostedt96de37b2012-01-07 17:26:49 -0500342#define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500343
344static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
345 size_t cnt, loff_t *ppos) { return -ENODEV; }
346static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
347 size_t cnt, loff_t *ppos) { return -ENODEV; }
348static inline loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
349{
350 return -ENODEV;
351}
352static inline int
353ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
Abhishek Sagarecea6562008-06-21 23:47:53 +0530354#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt352ad252008-05-12 21:20:42 +0200355
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200356/* totally disable ftrace - can not re-enable after this */
357void ftrace_kill(void);
358
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200359static inline void tracer_disable(void)
360{
Steven Rostedt606576c2008-10-06 19:06:12 -0400361#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200362 ftrace_enabled = 0;
363#endif
364}
365
Huang Ying37002732008-08-18 16:24:56 +0800366/*
367 * Ftrace disable/restore without lock. Some synchronization mechanism
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700368 * must be used to prevent ftrace_enabled to be changed between
Huang Ying37002732008-08-18 16:24:56 +0800369 * disable/restore.
370 */
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700371static inline int __ftrace_enabled_save(void)
372{
Steven Rostedt606576c2008-10-06 19:06:12 -0400373#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700374 int saved_ftrace_enabled = ftrace_enabled;
375 ftrace_enabled = 0;
376 return saved_ftrace_enabled;
377#else
378 return 0;
379#endif
380}
381
382static inline void __ftrace_enabled_restore(int enabled)
383{
Steven Rostedt606576c2008-10-06 19:06:12 -0400384#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700385 ftrace_enabled = enabled;
386#endif
387}
388
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100389#ifndef HAVE_ARCH_CALLER_ADDR
390# ifdef CONFIG_FRAME_POINTER
391# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
392# define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
393# define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
394# define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
395# define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
396# define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
397# define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
398# else
399# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
400# define CALLER_ADDR1 0UL
401# define CALLER_ADDR2 0UL
402# define CALLER_ADDR3 0UL
403# define CALLER_ADDR4 0UL
404# define CALLER_ADDR5 0UL
405# define CALLER_ADDR6 0UL
406# endif
407#endif /* ifndef HAVE_ARCH_CALLER_ADDR */
Steven Rostedt352ad252008-05-12 21:20:42 +0200408
Steven Rostedt81d68a92008-05-12 21:20:42 +0200409#ifdef CONFIG_IRQSOFF_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100410 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
411 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
Steven Rostedt81d68a92008-05-12 21:20:42 +0200412#else
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400413 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
414 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
Steven Rostedt81d68a92008-05-12 21:20:42 +0200415#endif
416
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200417#ifdef CONFIG_PREEMPT_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100418 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
419 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200420#else
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400421 static inline void trace_preempt_on(unsigned long a0, unsigned long a1) { }
422 static inline void trace_preempt_off(unsigned long a0, unsigned long a1) { }
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200423#endif
424
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400425#ifdef CONFIG_FTRACE_MCOUNT_RECORD
426extern void ftrace_init(void);
427#else
428static inline void ftrace_init(void) { }
429#endif
430
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100431/*
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100432 * Structure that defines an entry function trace.
433 */
434struct ftrace_graph_ent {
435 unsigned long func; /* Current function */
436 int depth;
437};
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400438
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100439/*
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100440 * Structure that defines a return function trace.
441 */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100442struct ftrace_graph_ret {
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100443 unsigned long func; /* Current function */
444 unsigned long long calltime;
445 unsigned long long rettime;
Frederic Weisbecker02310222008-11-17 03:22:41 +0100446 /* Number of functions that overran the depth limit for current task */
447 unsigned long overrun;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100448 int depth;
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100449};
450
Jiri Olsa62b915f2010-04-02 19:01:22 +0200451/* Type of the callback handlers for tracing function graph*/
452typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
453typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
454
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100455#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100456
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400457/* for init task */
Tetsuo Handaf876d342009-04-08 14:05:43 +0900458#define INIT_FTRACE_GRAPH .ret_stack = NULL,
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400459
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100460/*
Steven Rostedt712406a2009-02-09 10:54:03 -0800461 * Stack of return addresses for functions
462 * of a thread.
463 * Used in struct thread_info
464 */
465struct ftrace_ret_stack {
466 unsigned long ret;
467 unsigned long func;
468 unsigned long long calltime;
Steven Rostedta2a16d62009-03-24 23:17:58 -0400469 unsigned long long subtime;
Steven Rostedt71e308a2009-06-18 12:45:08 -0400470 unsigned long fp;
Steven Rostedt712406a2009-02-09 10:54:03 -0800471};
472
473/*
474 * Primary handler of a function return.
475 * It relays on ftrace_return_to_handler.
476 * Defined in entry_32/64.S
477 */
478extern void return_to_handler(void);
479
480extern int
Steven Rostedt71e308a2009-06-18 12:45:08 -0400481ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
482 unsigned long frame_pointer);
Steven Rostedt712406a2009-02-09 10:54:03 -0800483
484/*
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100485 * Sometimes we don't want to trace a function with the function
486 * graph tracer but we want them to keep traced by the usual function
487 * tracer if the function graph tracer is not configured.
488 */
489#define __notrace_funcgraph notrace
490
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100491/*
492 * We want to which function is an entrypoint of a hardirq.
493 * That will help us to put a signal on output.
494 */
495#define __irq_entry __attribute__((__section__(".irqentry.text")))
496
497/* Limits of hardirq entrypoints */
498extern char __irqentry_text_start[];
499extern char __irqentry_text_end[];
500
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100501#define FTRACE_RETFUNC_DEPTH 50
502#define FTRACE_RETSTACK_ALLOC_SIZE 32
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100503extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
504 trace_func_graph_ent_t entryfunc);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100505
Steven Rostedt14a866c2008-12-02 23:50:02 -0500506extern void ftrace_graph_stop(void);
507
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100508/* The current handlers in use */
509extern trace_func_graph_ret_t ftrace_graph_return;
510extern trace_func_graph_ent_t ftrace_graph_entry;
511
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100512extern void unregister_ftrace_graph(void);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100513
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100514extern void ftrace_graph_init_task(struct task_struct *t);
515extern void ftrace_graph_exit_task(struct task_struct *t);
Steven Rostedt868baf02011-02-10 21:26:13 -0500516extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100517
518static inline int task_curr_ret_stack(struct task_struct *t)
519{
520 return t->curr_ret_stack;
521}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100522
523static inline void pause_graph_tracing(void)
524{
525 atomic_inc(&current->tracing_graph_pause);
526}
527
528static inline void unpause_graph_tracing(void)
529{
530 atomic_dec(&current->tracing_graph_pause);
531}
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400532#else /* !CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100533
534#define __notrace_funcgraph
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100535#define __irq_entry
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400536#define INIT_FTRACE_GRAPH
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100537
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100538static inline void ftrace_graph_init_task(struct task_struct *t) { }
539static inline void ftrace_graph_exit_task(struct task_struct *t) { }
Steven Rostedt868baf02011-02-10 21:26:13 -0500540static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100541
Jiri Olsa62b915f2010-04-02 19:01:22 +0200542static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
543 trace_func_graph_ent_t entryfunc)
544{
545 return -1;
546}
547static inline void unregister_ftrace_graph(void) { }
548
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100549static inline int task_curr_ret_stack(struct task_struct *tsk)
550{
551 return -1;
552}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100553
554static inline void pause_graph_tracing(void) { }
555static inline void unpause_graph_tracing(void) { }
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400556#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100557
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500558#ifdef CONFIG_TRACING
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500559
560/* flags for current->trace */
561enum {
562 TSK_TRACE_FL_TRACE_BIT = 0,
563 TSK_TRACE_FL_GRAPH_BIT = 1,
564};
565enum {
566 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
567 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
568};
569
570static inline void set_tsk_trace_trace(struct task_struct *tsk)
571{
572 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
573}
574
575static inline void clear_tsk_trace_trace(struct task_struct *tsk)
576{
577 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
578}
579
580static inline int test_tsk_trace_trace(struct task_struct *tsk)
581{
582 return tsk->trace & TSK_TRACE_FL_TRACE;
583}
584
585static inline void set_tsk_trace_graph(struct task_struct *tsk)
586{
587 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
588}
589
590static inline void clear_tsk_trace_graph(struct task_struct *tsk)
591{
592 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
593}
594
595static inline int test_tsk_trace_graph(struct task_struct *tsk)
596{
597 return tsk->trace & TSK_TRACE_FL_GRAPH;
598}
599
Frederic Weisbeckercecbca92010-04-18 19:08:41 +0200600enum ftrace_dump_mode;
601
602extern enum ftrace_dump_mode ftrace_dump_on_oops;
Ingo Molnar526211b2009-03-05 10:28:45 +0100603
Steven Rostedt261842b2009-04-16 21:41:52 -0400604#ifdef CONFIG_PREEMPT
605#define INIT_TRACE_RECURSION .trace_recursion = 0,
606#endif
607
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500608#endif /* CONFIG_TRACING */
609
Steven Rostedt261842b2009-04-16 21:41:52 -0400610#ifndef INIT_TRACE_RECURSION
611#define INIT_TRACE_RECURSION
612#endif
Markus Metzgerb1818742009-01-19 10:31:01 +0100613
Mike Frysingere7b8e672010-01-26 04:40:03 -0500614#ifdef CONFIG_FTRACE_SYSCALLS
615
616unsigned long arch_syscall_addr(int nr);
617
618#endif /* CONFIG_FTRACE_SYSCALLS */
619
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200620#endif /* _LINUX_FTRACE_H */