blob: 01e6adea07ecf798a0a45331a297e8ea5b481e42 [file] [log] [blame]
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +02001#ifndef _LINUX_FTRACE_H
2#define _LINUX_FTRACE_H
3
Frederic Weisbecker00126932009-03-05 01:49:22 +01004#include <linux/trace_clock.h>
Frederic Weisbecker56010202008-10-02 13:26:05 +02005#include <linux/kallsyms.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +01006#include <linux/linkage.h>
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05007#include <linux/bitops.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +01008#include <linux/module.h>
9#include <linux/ktime.h>
Frederic Weisbecker21a8c462008-12-04 23:51:23 +010010#include <linux/sched.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +010011#include <linux/types.h>
12#include <linux/init.h>
13#include <linux/fs.h>
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020014
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +010015#include <asm/ftrace.h>
16
Steven Rostedt606576c2008-10-06 19:06:12 -040017#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnar3e1932a2008-10-02 17:45:47 +020018
Steven Rostedtb0fc4942008-05-12 21:20:43 +020019extern int ftrace_enabled;
20extern int
21ftrace_enable_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -070022 void __user *buffer, size_t *lenp,
Steven Rostedtb0fc4942008-05-12 21:20:43 +020023 loff_t *ppos);
24
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020025typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
26
27struct ftrace_ops {
28 ftrace_func_t func;
29 struct ftrace_ops *next;
30};
31
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050032extern int function_trace_stop;
33
Frederic Weisbeckere7d37372008-11-16 06:02:06 +010034/*
35 * Type of the current tracing.
36 */
37enum 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 */
43extern enum ftrace_tracing_type_t ftrace_tracing_type;
44
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050045/**
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 */
53static 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 */
66static inline void ftrace_start(void)
67{
68 function_trace_stop = 0;
69}
70
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020071/*
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 */
78int register_ftrace_function(struct ftrace_ops *ops);
79int unregister_ftrace_function(struct ftrace_ops *ops);
80void clear_ftrace_function(void);
81
82extern void ftrace_stub(unsigned long a0, unsigned long a1);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020083
Steven Rostedt606576c2008-10-06 19:06:12 -040084#else /* !CONFIG_FUNCTION_TRACER */
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020085# define register_ftrace_function(ops) do { } while (0)
86# define unregister_ftrace_function(ops) do { } while (0)
87# define clear_ftrace_function(ops) do { } while (0)
Steven Rostedt81adbdc2008-10-23 09:33:02 -040088static inline void ftrace_kill(void) { }
Steven Rostedt60a7ecf2008-11-05 16:05:44 -050089static inline void ftrace_stop(void) { }
90static inline void ftrace_start(void) { }
Steven Rostedt606576c2008-10-06 19:06:12 -040091#endif /* CONFIG_FUNCTION_TRACER */
Steven Rostedt352ad252008-05-12 21:20:42 +020092
Steven Rostedtf38f1d22008-12-16 23:06:40 -050093#ifdef CONFIG_STACK_TRACER
94extern int stack_tracer_enabled;
95int
96stack_trace_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -070097 void __user *buffer, size_t *lenp,
Steven Rostedtf38f1d22008-12-16 23:06:40 -050098 loff_t *ppos);
99#endif
100
Steven Rostedtf6180772009-02-14 00:40:25 -0500101struct ftrace_func_command {
102 struct list_head list;
103 char *name;
104 int (*func)(char *func, char *cmd,
105 char *params, int enable);
106};
107
Steven Rostedt3d083392008-05-12 21:20:42 +0200108#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt31e88902008-11-14 16:21:19 -0800109
Steven Rostedt000ab692009-02-17 13:35:06 -0500110int ftrace_arch_code_modify_prepare(void);
111int ftrace_arch_code_modify_post_process(void);
112
Steven Rostedt809dcf22009-02-16 23:06:01 -0500113struct seq_file;
114
Steven Rostedtb6887d72009-02-17 12:32:04 -0500115struct ftrace_probe_ops {
Steven Rostedt59df055f2009-02-14 15:29:06 -0500116 void (*func)(unsigned long ip,
117 unsigned long parent_ip,
118 void **data);
119 int (*callback)(unsigned long ip, void **data);
120 void (*free)(void **data);
Steven Rostedt809dcf22009-02-16 23:06:01 -0500121 int (*print)(struct seq_file *m,
122 unsigned long ip,
Steven Rostedtb6887d72009-02-17 12:32:04 -0500123 struct ftrace_probe_ops *ops,
Steven Rostedt809dcf22009-02-16 23:06:01 -0500124 void *data);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500125};
126
127extern int
Steven Rostedtb6887d72009-02-17 12:32:04 -0500128register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500129 void *data);
130extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500131unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500132 void *data);
133extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500134unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
135extern void unregister_ftrace_function_probe_all(char *glob);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500136
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500137extern int ftrace_text_reserved(void *start, void *end);
138
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200139enum {
Steven Rostedt37ad5082008-05-12 21:20:48 +0200140 FTRACE_FL_FREE = (1 << 0),
141 FTRACE_FL_FAILED = (1 << 1),
142 FTRACE_FL_FILTER = (1 << 2),
143 FTRACE_FL_ENABLED = (1 << 3),
Steven Rostedt41c52c02008-05-22 11:46:33 -0400144 FTRACE_FL_NOTRACE = (1 << 4),
Abhishek Sagar0eb96702008-06-01 21:47:30 +0530145 FTRACE_FL_CONVERTED = (1 << 5),
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200146};
147
Steven Rostedt3d083392008-05-12 21:20:42 +0200148struct dyn_ftrace {
Lai Jiangshanee000b72009-03-24 13:38:06 +0800149 union {
150 unsigned long ip; /* address of mcount call-site */
151 struct dyn_ftrace *freelist;
152 };
153 union {
154 unsigned long flags;
155 struct dyn_ftrace *newlist;
156 };
157 struct dyn_arch_ftrace arch;
Steven Rostedt3d083392008-05-12 21:20:42 +0200158};
159
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200160int ftrace_force_update(void);
Steven Rostedt77a2b372008-05-12 21:20:45 +0200161void ftrace_set_filter(unsigned char *buf, int len, int reset);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200162
Steven Rostedtf6180772009-02-14 00:40:25 -0500163int register_ftrace_command(struct ftrace_func_command *cmd);
164int unregister_ftrace_command(struct ftrace_func_command *cmd);
165
Steven Rostedt3d083392008-05-12 21:20:42 +0200166/* defined in arch */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200167extern int ftrace_ip_converted(unsigned long ip);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200168extern int ftrace_dyn_arch_init(void *data);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200169extern int ftrace_update_ftrace_func(ftrace_func_t func);
170extern void ftrace_caller(void);
171extern void ftrace_call(void);
172extern void mcount_call(void);
Shaohua Lif0001202009-01-09 11:29:42 +0800173
174#ifndef FTRACE_ADDR
175#define FTRACE_ADDR ((unsigned long)ftrace_caller)
176#endif
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100177#ifdef CONFIG_FUNCTION_GRAPH_TRACER
178extern void ftrace_graph_caller(void);
Steven Rostedt5a45cfe2008-11-26 00:16:24 -0500179extern int ftrace_enable_ftrace_graph_caller(void);
180extern int ftrace_disable_ftrace_graph_caller(void);
181#else
182static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
183static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100184#endif
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400185
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400186/**
Wenji Huang57794a92009-02-06 17:33:27 +0800187 * ftrace_make_nop - convert code into nop
Steven Rostedt31e88902008-11-14 16:21:19 -0800188 * @mod: module structure if called by module load initialization
189 * @rec: the mcount call site record
190 * @addr: the address that the call site should be calling
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400191 *
192 * This is a very sensitive operation and great care needs
193 * to be taken by the arch. The operation should carefully
194 * read the location, check to see if what is read is indeed
195 * what we expect it to be, and then on success of the compare,
196 * it should write to the location.
197 *
Steven Rostedt31e88902008-11-14 16:21:19 -0800198 * The code segment at @rec->ip should be a caller to @addr
199 *
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400200 * Return must be:
201 * 0 on success
202 * -EFAULT on error reading the location
203 * -EINVAL on a failed compare of the contents
204 * -EPERM on error writing to the location
205 * Any other value will be considered a failure.
206 */
Steven Rostedt31e88902008-11-14 16:21:19 -0800207extern int ftrace_make_nop(struct module *mod,
208 struct dyn_ftrace *rec, unsigned long addr);
209
210/**
211 * ftrace_make_call - convert a nop call site into a call to addr
212 * @rec: the mcount call site record
213 * @addr: the address that the call site should call
214 *
215 * This is a very sensitive operation and great care needs
216 * to be taken by the arch. The operation should carefully
217 * read the location, check to see if what is read is indeed
218 * what we expect it to be, and then on success of the compare,
219 * it should write to the location.
220 *
221 * The code segment at @rec->ip should be a nop
222 *
223 * Return must be:
224 * 0 on success
225 * -EFAULT on error reading the location
226 * -EINVAL on a failed compare of the contents
227 * -EPERM on error writing to the location
228 * Any other value will be considered a failure.
229 */
230extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
231
Steven Rostedt31e88902008-11-14 16:21:19 -0800232/* May be defined in arch */
233extern int ftrace_arch_read_dyn_info(char *buf, int size);
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400234
Abhishek Sagarecea6562008-06-21 23:47:53 +0530235extern int skip_trace(unsigned long ip);
236
Steven Rostedtc0719e52008-09-06 01:06:03 -0400237extern void ftrace_disable_daemon(void);
238extern void ftrace_enable_daemon(void);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200239#else
Abhishek Sagarecea6562008-06-21 23:47:53 +0530240# define skip_trace(ip) ({ 0; })
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200241# define ftrace_force_update() ({ 0; })
242# define ftrace_set_filter(buf, len, reset) do { } while (0)
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400243# define ftrace_disable_daemon() do { } while (0)
244# define ftrace_enable_daemon() do { } while (0)
jolsa@redhat.come7247a12009-10-07 19:00:35 +0200245static inline void ftrace_release_mod(struct module *mod) {}
Steven Rostedtf6180772009-02-14 00:40:25 -0500246static inline int register_ftrace_command(struct ftrace_func_command *cmd)
247{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100248 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500249}
250static inline int unregister_ftrace_command(char *cmd_name)
251{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100252 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500253}
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500254static inline int ftrace_text_reserved(void *start, void *end)
255{
256 return 0;
257}
Abhishek Sagarecea6562008-06-21 23:47:53 +0530258#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt352ad252008-05-12 21:20:42 +0200259
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200260/* totally disable ftrace - can not re-enable after this */
261void ftrace_kill(void);
262
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200263static inline void tracer_disable(void)
264{
Steven Rostedt606576c2008-10-06 19:06:12 -0400265#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200266 ftrace_enabled = 0;
267#endif
268}
269
Huang Ying37002732008-08-18 16:24:56 +0800270/*
271 * Ftrace disable/restore without lock. Some synchronization mechanism
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700272 * must be used to prevent ftrace_enabled to be changed between
Huang Ying37002732008-08-18 16:24:56 +0800273 * disable/restore.
274 */
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700275static inline int __ftrace_enabled_save(void)
276{
Steven Rostedt606576c2008-10-06 19:06:12 -0400277#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700278 int saved_ftrace_enabled = ftrace_enabled;
279 ftrace_enabled = 0;
280 return saved_ftrace_enabled;
281#else
282 return 0;
283#endif
284}
285
286static inline void __ftrace_enabled_restore(int enabled)
287{
Steven Rostedt606576c2008-10-06 19:06:12 -0400288#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700289 ftrace_enabled = enabled;
290#endif
291}
292
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100293#ifndef HAVE_ARCH_CALLER_ADDR
294# ifdef CONFIG_FRAME_POINTER
295# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
296# define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
297# define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
298# define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
299# define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
300# define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
301# define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
302# else
303# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
304# define CALLER_ADDR1 0UL
305# define CALLER_ADDR2 0UL
306# define CALLER_ADDR3 0UL
307# define CALLER_ADDR4 0UL
308# define CALLER_ADDR5 0UL
309# define CALLER_ADDR6 0UL
310# endif
311#endif /* ifndef HAVE_ARCH_CALLER_ADDR */
Steven Rostedt352ad252008-05-12 21:20:42 +0200312
Steven Rostedt81d68a92008-05-12 21:20:42 +0200313#ifdef CONFIG_IRQSOFF_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100314 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
315 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
Steven Rostedt81d68a92008-05-12 21:20:42 +0200316#else
317# define time_hardirqs_on(a0, a1) do { } while (0)
318# define time_hardirqs_off(a0, a1) do { } while (0)
319#endif
320
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200321#ifdef CONFIG_PREEMPT_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100322 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
323 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200324#else
325# define trace_preempt_on(a0, a1) do { } while (0)
326# define trace_preempt_off(a0, a1) do { } while (0)
327#endif
328
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400329#ifdef CONFIG_FTRACE_MCOUNT_RECORD
330extern void ftrace_init(void);
331#else
332static inline void ftrace_init(void) { }
333#endif
334
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100335/*
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100336 * Structure that defines an entry function trace.
337 */
338struct ftrace_graph_ent {
339 unsigned long func; /* Current function */
340 int depth;
341};
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400342
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100343/*
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100344 * Structure that defines a return function trace.
345 */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100346struct ftrace_graph_ret {
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100347 unsigned long func; /* Current function */
348 unsigned long long calltime;
349 unsigned long long rettime;
Frederic Weisbecker02310222008-11-17 03:22:41 +0100350 /* Number of functions that overran the depth limit for current task */
351 unsigned long overrun;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100352 int depth;
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100353};
354
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100355#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100356
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400357/* for init task */
Tetsuo Handaf876d342009-04-08 14:05:43 +0900358#define INIT_FTRACE_GRAPH .ret_stack = NULL,
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400359
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100360/*
Steven Rostedt712406a2009-02-09 10:54:03 -0800361 * Stack of return addresses for functions
362 * of a thread.
363 * Used in struct thread_info
364 */
365struct ftrace_ret_stack {
366 unsigned long ret;
367 unsigned long func;
368 unsigned long long calltime;
Steven Rostedta2a16d62009-03-24 23:17:58 -0400369 unsigned long long subtime;
Steven Rostedt71e308a2009-06-18 12:45:08 -0400370 unsigned long fp;
Steven Rostedt712406a2009-02-09 10:54:03 -0800371};
372
373/*
374 * Primary handler of a function return.
375 * It relays on ftrace_return_to_handler.
376 * Defined in entry_32/64.S
377 */
378extern void return_to_handler(void);
379
380extern int
Steven Rostedt71e308a2009-06-18 12:45:08 -0400381ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
382 unsigned long frame_pointer);
Steven Rostedt712406a2009-02-09 10:54:03 -0800383
384/*
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100385 * Sometimes we don't want to trace a function with the function
386 * graph tracer but we want them to keep traced by the usual function
387 * tracer if the function graph tracer is not configured.
388 */
389#define __notrace_funcgraph notrace
390
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100391/*
392 * We want to which function is an entrypoint of a hardirq.
393 * That will help us to put a signal on output.
394 */
395#define __irq_entry __attribute__((__section__(".irqentry.text")))
396
397/* Limits of hardirq entrypoints */
398extern char __irqentry_text_start[];
399extern char __irqentry_text_end[];
400
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100401#define FTRACE_RETFUNC_DEPTH 50
402#define FTRACE_RETSTACK_ALLOC_SIZE 32
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100403/* Type of the callback handlers for tracing function graph*/
404typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
Steven Rostedte49dc192008-12-02 23:50:05 -0500405typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100406
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100407extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
408 trace_func_graph_ent_t entryfunc);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100409
Steven Rostedt14a866c2008-12-02 23:50:02 -0500410extern void ftrace_graph_stop(void);
411
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100412/* The current handlers in use */
413extern trace_func_graph_ret_t ftrace_graph_return;
414extern trace_func_graph_ent_t ftrace_graph_entry;
415
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100416extern void unregister_ftrace_graph(void);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100417
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100418extern void ftrace_graph_init_task(struct task_struct *t);
419extern void ftrace_graph_exit_task(struct task_struct *t);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100420
421static inline int task_curr_ret_stack(struct task_struct *t)
422{
423 return t->curr_ret_stack;
424}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100425
426static inline void pause_graph_tracing(void)
427{
428 atomic_inc(&current->tracing_graph_pause);
429}
430
431static inline void unpause_graph_tracing(void)
432{
433 atomic_dec(&current->tracing_graph_pause);
434}
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400435#else /* !CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100436
437#define __notrace_funcgraph
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100438#define __irq_entry
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400439#define INIT_FTRACE_GRAPH
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100440
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100441static inline void ftrace_graph_init_task(struct task_struct *t) { }
442static inline void ftrace_graph_exit_task(struct task_struct *t) { }
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100443
444static inline int task_curr_ret_stack(struct task_struct *tsk)
445{
446 return -1;
447}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100448
449static inline void pause_graph_tracing(void) { }
450static inline void unpause_graph_tracing(void) { }
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400451#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100452
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500453#ifdef CONFIG_TRACING
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500454
455/* flags for current->trace */
456enum {
457 TSK_TRACE_FL_TRACE_BIT = 0,
458 TSK_TRACE_FL_GRAPH_BIT = 1,
459};
460enum {
461 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
462 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
463};
464
465static inline void set_tsk_trace_trace(struct task_struct *tsk)
466{
467 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
468}
469
470static inline void clear_tsk_trace_trace(struct task_struct *tsk)
471{
472 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
473}
474
475static inline int test_tsk_trace_trace(struct task_struct *tsk)
476{
477 return tsk->trace & TSK_TRACE_FL_TRACE;
478}
479
480static inline void set_tsk_trace_graph(struct task_struct *tsk)
481{
482 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
483}
484
485static inline void clear_tsk_trace_graph(struct task_struct *tsk)
486{
487 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
488}
489
490static inline int test_tsk_trace_graph(struct task_struct *tsk)
491{
492 return tsk->trace & TSK_TRACE_FL_GRAPH;
493}
494
Ingo Molnar526211b2009-03-05 10:28:45 +0100495extern int ftrace_dump_on_oops;
496
Steven Rostedt261842b2009-04-16 21:41:52 -0400497#ifdef CONFIG_PREEMPT
498#define INIT_TRACE_RECURSION .trace_recursion = 0,
499#endif
500
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500501#endif /* CONFIG_TRACING */
502
Steven Rostedt261842b2009-04-16 21:41:52 -0400503#ifndef INIT_TRACE_RECURSION
504#define INIT_TRACE_RECURSION
505#endif
Markus Metzgerb1818742009-01-19 10:31:01 +0100506
507#ifdef CONFIG_HW_BRANCH_TRACER
508
509void trace_hw_branch(u64 from, u64 to);
510void trace_hw_branch_oops(void);
511
512#else /* CONFIG_HW_BRANCH_TRACER */
513
514static inline void trace_hw_branch(u64 from, u64 to) {}
515static inline void trace_hw_branch_oops(void) {}
516
517#endif /* CONFIG_HW_BRANCH_TRACER */
518
Mike Frysingere7b8e672010-01-26 04:40:03 -0500519#ifdef CONFIG_FTRACE_SYSCALLS
520
521unsigned long arch_syscall_addr(int nr);
522
523#endif /* CONFIG_FTRACE_SYSCALLS */
524
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200525#endif /* _LINUX_FTRACE_H */