blob: f4233b195dab3e5fd64a0a1885c286374499d6ac [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>
Steven Rostedta1e2e312011-08-09 12:50:46 -040013#include <linux/ptrace.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +010014#include <linux/ktime.h>
Frederic Weisbecker21a8c462008-12-04 23:51:23 +010015#include <linux/sched.h>
Frederic Weisbecker00126932009-03-05 01:49:22 +010016#include <linux/types.h>
17#include <linux/init.h>
18#include <linux/fs.h>
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020019
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +010020#include <asm/ftrace.h>
21
Steven Rostedt2f5f6ad2011-08-08 16:57:47 -040022/*
23 * If the arch supports passing the variable contents of
24 * function_trace_op as the third parameter back from the
25 * mcount call, then the arch should define this as 1.
26 */
27#ifndef ARCH_SUPPORTS_FTRACE_OPS
28#define ARCH_SUPPORTS_FTRACE_OPS 0
29#endif
30
Steven Rostedtccf36722012-06-05 09:44:25 -040031/*
32 * If the arch's mcount caller does not support all of ftrace's
33 * features, then it must call an indirect function that
34 * does. Or at least does enough to prevent any unwelcomed side effects.
35 */
36#if !defined(CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST) || \
37 !ARCH_SUPPORTS_FTRACE_OPS
38# define FTRACE_FORCE_LIST_FUNC 1
39#else
40# define FTRACE_FORCE_LIST_FUNC 0
41#endif
42
43
Paul Gortmakerde477252011-05-26 13:46:22 -040044struct module;
Steven Rostedt04da85b2011-07-11 10:12:59 -040045struct ftrace_hash;
46
Steven Rostedt606576c2008-10-06 19:06:12 -040047#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnar3e1932a2008-10-02 17:45:47 +020048
Steven Rostedtb0fc4942008-05-12 21:20:43 +020049extern int ftrace_enabled;
50extern int
51ftrace_enable_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -070052 void __user *buffer, size_t *lenp,
Steven Rostedtb0fc4942008-05-12 21:20:43 +020053 loff_t *ppos);
54
Steven Rostedt2f5f6ad2011-08-08 16:57:47 -040055struct ftrace_ops;
56
57typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
Steven Rostedta1e2e312011-08-09 12:50:46 -040058 struct ftrace_ops *op, struct pt_regs *regs);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020059
Jiri Olsae2484912012-02-15 15:51:48 +010060/*
61 * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are
62 * set in the flags member.
63 *
64 * ENABLED - set/unset when ftrace_ops is registered/unregistered
65 * GLOBAL - set manualy by ftrace_ops user to denote the ftrace_ops
66 * is part of the global tracers sharing the same filter
67 * via set_ftrace_* debugfs files.
68 * DYNAMIC - set when ftrace_ops is registered to denote dynamically
69 * allocated ftrace_ops which need special care
70 * CONTROL - set manualy by ftrace_ops user to denote the ftrace_ops
71 * could be controled by following calls:
72 * ftrace_function_local_enable
73 * ftrace_function_local_disable
Steven Rostedt08f6fba2012-04-30 16:20:23 -040074 * SAVE_REGS - The ftrace_ops wants regs saved at each function called
75 * and passed to the callback. If this flag is set, but the
76 * architecture does not support passing regs
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +090077 * (CONFIG_DYNAMIC_FTRACE_WITH_REGS is not defined), then the
Steven Rostedt08f6fba2012-04-30 16:20:23 -040078 * ftrace_ops will fail to register, unless the next flag
79 * is set.
80 * SAVE_REGS_IF_SUPPORTED - This is the same as SAVE_REGS, but if the
81 * handler can handle an arch that does not save regs
82 * (the handler tests if regs == NULL), then it can set
83 * this flag instead. It will not fail registering the ftrace_ops
84 * but, the regs field will be NULL if the arch does not support
85 * passing regs to the handler.
86 * Note, if this flag is set, the SAVE_REGS flag will automatically
87 * get set upon registering the ftrace_ops, if the arch supports it.
Steven Rostedt47409742012-07-20 11:04:44 -040088 * RECURSION_SAFE - The ftrace_ops can set this to tell the ftrace infrastructure
89 * that the call back has its own recursion protection. If it does
90 * not set this, then the ftrace infrastructure will add recursion
91 * protection for the caller.
Steven Rostedt (Red Hat)395b97a2013-03-27 09:31:28 -040092 * STUB - The ftrace_ops is just a place holder.
Masami Hiramatsuf04f24fb2013-05-09 14:44:17 +090093 * INITIALIZED - The ftrace_ops has already been initialized (first use time
94 * register_ftrace_function() is called, it will initialized the ops)
Jiri Olsae2484912012-02-15 15:51:48 +010095 */
Steven Rostedtb8489142011-05-04 09:27:52 -040096enum {
Steven Rostedt08f6fba2012-04-30 16:20:23 -040097 FTRACE_OPS_FL_ENABLED = 1 << 0,
98 FTRACE_OPS_FL_GLOBAL = 1 << 1,
99 FTRACE_OPS_FL_DYNAMIC = 1 << 2,
100 FTRACE_OPS_FL_CONTROL = 1 << 3,
101 FTRACE_OPS_FL_SAVE_REGS = 1 << 4,
102 FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 1 << 5,
Steven Rostedt47409742012-07-20 11:04:44 -0400103 FTRACE_OPS_FL_RECURSION_SAFE = 1 << 6,
Steven Rostedt (Red Hat)395b97a2013-03-27 09:31:28 -0400104 FTRACE_OPS_FL_STUB = 1 << 7,
Masami Hiramatsuf04f24fb2013-05-09 14:44:17 +0900105 FTRACE_OPS_FL_INITIALIZED = 1 << 8,
Steven Rostedtb8489142011-05-04 09:27:52 -0400106};
107
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200108struct ftrace_ops {
Steven Rostedtf45948e2011-05-02 12:29:25 -0400109 ftrace_func_t func;
110 struct ftrace_ops *next;
Steven Rostedtb8489142011-05-04 09:27:52 -0400111 unsigned long flags;
Jiri Olsae2484912012-02-15 15:51:48 +0100112 int __percpu *disabled;
Steven Rostedtf45948e2011-05-02 12:29:25 -0400113#ifdef CONFIG_DYNAMIC_FTRACE
114 struct ftrace_hash *notrace_hash;
115 struct ftrace_hash *filter_hash;
Masami Hiramatsuf04f24fb2013-05-09 14:44:17 +0900116 struct mutex regex_lock;
Steven Rostedtf45948e2011-05-02 12:29:25 -0400117#endif
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200118};
119
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500120extern int function_trace_stop;
121
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100122/*
123 * Type of the current tracing.
124 */
125enum ftrace_tracing_type_t {
126 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
127 FTRACE_TYPE_RETURN, /* Hook the return of the function */
128};
129
130/* Current tracing type, default is FTRACE_TYPE_ENTER */
131extern enum ftrace_tracing_type_t ftrace_tracing_type;
132
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500133/**
134 * ftrace_stop - stop function tracer.
135 *
136 * A quick way to stop the function tracer. Note this an on off switch,
137 * it is not something that is recursive like preempt_disable.
138 * This does not disable the calling of mcount, it only stops the
139 * calling of functions from mcount.
140 */
141static inline void ftrace_stop(void)
142{
143 function_trace_stop = 1;
144}
145
146/**
147 * ftrace_start - start the function tracer.
148 *
149 * This function is the inverse of ftrace_stop. This does not enable
150 * the function tracing if the function tracer is disabled. This only
151 * sets the function tracer flag to continue calling the functions
152 * from mcount.
153 */
154static inline void ftrace_start(void)
155{
156 function_trace_stop = 0;
157}
158
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200159/*
160 * The ftrace_ops must be a static and should also
161 * be read_mostly. These functions do modify read_mostly variables
162 * so use them sparely. Never free an ftrace_op or modify the
163 * next pointer after it has been registered. Even after unregistering
164 * it, the next pointer may still be used internally.
165 */
166int register_ftrace_function(struct ftrace_ops *ops);
167int unregister_ftrace_function(struct ftrace_ops *ops);
168void clear_ftrace_function(void);
169
Jiri Olsae2484912012-02-15 15:51:48 +0100170/**
171 * ftrace_function_local_enable - enable controlled ftrace_ops on current cpu
172 *
173 * This function enables tracing on current cpu by decreasing
174 * the per cpu control variable.
175 * It must be called with preemption disabled and only on ftrace_ops
176 * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
177 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
178 */
179static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
180{
181 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
182 return;
183
184 (*this_cpu_ptr(ops->disabled))--;
185}
186
187/**
188 * ftrace_function_local_disable - enable controlled ftrace_ops on current cpu
189 *
190 * This function enables tracing on current cpu by decreasing
191 * the per cpu control variable.
192 * It must be called with preemption disabled and only on ftrace_ops
193 * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
194 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
195 */
196static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
197{
198 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
199 return;
200
201 (*this_cpu_ptr(ops->disabled))++;
202}
203
204/**
205 * ftrace_function_local_disabled - returns ftrace_ops disabled value
206 * on current cpu
207 *
208 * This function returns value of ftrace_ops::disabled on current cpu.
209 * It must be called with preemption disabled and only on ftrace_ops
210 * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
211 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
212 */
213static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
214{
215 WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL));
216 return *this_cpu_ptr(ops->disabled);
217}
218
Steven Rostedta1e2e312011-08-09 12:50:46 -0400219extern void ftrace_stub(unsigned long a0, unsigned long a1,
220 struct ftrace_ops *op, struct pt_regs *regs);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200221
Steven Rostedt606576c2008-10-06 19:06:12 -0400222#else /* !CONFIG_FUNCTION_TRACER */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400223/*
224 * (un)register_ftrace_function must be a macro since the ops parameter
225 * must not be evaluated.
226 */
227#define register_ftrace_function(ops) ({ 0; })
228#define unregister_ftrace_function(ops) ({ 0; })
Steven Rostedtea701f12012-07-20 13:08:05 -0400229static inline int ftrace_nr_registered_ops(void)
230{
231 return 0;
232}
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400233static inline void clear_ftrace_function(void) { }
Steven Rostedt81adbdc2008-10-23 09:33:02 -0400234static inline void ftrace_kill(void) { }
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500235static inline void ftrace_stop(void) { }
236static inline void ftrace_start(void) { }
Steven Rostedt606576c2008-10-06 19:06:12 -0400237#endif /* CONFIG_FUNCTION_TRACER */
Steven Rostedt352ad252008-05-12 21:20:42 +0200238
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500239#ifdef CONFIG_STACK_TRACER
240extern int stack_tracer_enabled;
241int
242stack_trace_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700243 void __user *buffer, size_t *lenp,
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500244 loff_t *ppos);
245#endif
246
Steven Rostedtf6180772009-02-14 00:40:25 -0500247struct ftrace_func_command {
248 struct list_head list;
249 char *name;
Steven Rostedt43dd61c2011-07-07 11:09:22 -0400250 int (*func)(struct ftrace_hash *hash,
251 char *func, char *cmd,
Steven Rostedtf6180772009-02-14 00:40:25 -0500252 char *params, int enable);
253};
254
Steven Rostedt3d083392008-05-12 21:20:42 +0200255#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt31e88902008-11-14 16:21:19 -0800256
Steven Rostedt000ab692009-02-17 13:35:06 -0500257int ftrace_arch_code_modify_prepare(void);
258int ftrace_arch_code_modify_post_process(void);
259
Steven Rostedtc88fd862011-08-16 09:53:39 -0400260void ftrace_bug(int err, unsigned long ip);
261
Steven Rostedt809dcf22009-02-16 23:06:01 -0500262struct seq_file;
263
Steven Rostedtb6887d72009-02-17 12:32:04 -0500264struct ftrace_probe_ops {
Steven Rostedt59df055f2009-02-14 15:29:06 -0500265 void (*func)(unsigned long ip,
266 unsigned long parent_ip,
267 void **data);
Steven Rostedt (Red Hat)e67efb92013-03-12 15:07:59 -0400268 int (*init)(struct ftrace_probe_ops *ops,
269 unsigned long ip, void **data);
270 void (*free)(struct ftrace_probe_ops *ops,
271 unsigned long ip, void **data);
Steven Rostedt809dcf22009-02-16 23:06:01 -0500272 int (*print)(struct seq_file *m,
273 unsigned long ip,
Steven Rostedtb6887d72009-02-17 12:32:04 -0500274 struct ftrace_probe_ops *ops,
Steven Rostedt809dcf22009-02-16 23:06:01 -0500275 void *data);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500276};
277
278extern int
Steven Rostedtb6887d72009-02-17 12:32:04 -0500279register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500280 void *data);
281extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500282unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500283 void *data);
284extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500285unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
286extern void unregister_ftrace_function_probe_all(char *glob);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500287
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500288extern int ftrace_text_reserved(void *start, void *end);
289
Steven Rostedtea701f12012-07-20 13:08:05 -0400290extern int ftrace_nr_registered_ops(void);
291
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400292/*
293 * The dyn_ftrace record's flags field is split into two parts.
294 * the first part which is '0-FTRACE_REF_MAX' is a counter of
295 * the number of callbacks that have registered the function that
296 * the dyn_ftrace descriptor represents.
297 *
298 * The second part is a mask:
299 * ENABLED - the function is being traced
300 * REGS - the record wants the function to save regs
301 * REGS_EN - the function is set up to save regs.
302 *
303 * When a new ftrace_ops is registered and wants a function to save
304 * pt_regs, the rec->flag REGS is set. When the function has been
305 * set up to save regs, the REG_EN flag is set. Once a function
306 * starts saving regs it will do so until all ftrace_ops are removed
307 * from tracing that function.
308 */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200309enum {
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400310 FTRACE_FL_ENABLED = (1UL << 29),
311 FTRACE_FL_REGS = (1UL << 30),
312 FTRACE_FL_REGS_EN = (1UL << 31)
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200313};
314
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400315#define FTRACE_FL_MASK (0x7UL << 29)
316#define FTRACE_REF_MAX ((1UL << 29) - 1)
Steven Rostedted926f92011-05-03 13:25:24 -0400317
Steven Rostedt3d083392008-05-12 21:20:42 +0200318struct dyn_ftrace {
Lai Jiangshanee000b72009-03-24 13:38:06 +0800319 union {
320 unsigned long ip; /* address of mcount call-site */
321 struct dyn_ftrace *freelist;
322 };
Steven Rostedt85ae32a2011-12-16 16:30:31 -0500323 unsigned long flags;
Lai Jiangshanee000b72009-03-24 13:38:06 +0800324 struct dyn_arch_ftrace arch;
Steven Rostedt3d083392008-05-12 21:20:42 +0200325};
326
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200327int ftrace_force_update(void);
Masami Hiramatsu647664e2012-06-05 19:28:08 +0900328int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
329 int remove, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100330int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400331 int len, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100332int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400333 int len, int reset);
334void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
335void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
Jiri Olsa5500fa52012-02-15 15:51:54 +0100336void ftrace_free_filter(struct ftrace_ops *ops);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200337
Steven Rostedtf6180772009-02-14 00:40:25 -0500338int register_ftrace_command(struct ftrace_func_command *cmd);
339int unregister_ftrace_command(struct ftrace_func_command *cmd);
340
Steven Rostedtc88fd862011-08-16 09:53:39 -0400341enum {
342 FTRACE_UPDATE_CALLS = (1 << 0),
343 FTRACE_DISABLE_CALLS = (1 << 1),
344 FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
345 FTRACE_START_FUNC_RET = (1 << 3),
346 FTRACE_STOP_FUNC_RET = (1 << 4),
347};
348
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400349/*
350 * The FTRACE_UPDATE_* enum is used to pass information back
351 * from the ftrace_update_record() and ftrace_test_record()
352 * functions. These are called by the code update routines
353 * to find out what is to be done for a given function.
354 *
355 * IGNORE - The function is already what we want it to be
356 * MAKE_CALL - Start tracing the function
357 * MODIFY_CALL - Stop saving regs for the function
358 * MODIFY_CALL_REGS - Start saving regs for the function
359 * MAKE_NOP - Stop tracing the function
360 */
Steven Rostedtc88fd862011-08-16 09:53:39 -0400361enum {
362 FTRACE_UPDATE_IGNORE,
363 FTRACE_UPDATE_MAKE_CALL,
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400364 FTRACE_UPDATE_MODIFY_CALL,
365 FTRACE_UPDATE_MODIFY_CALL_REGS,
Steven Rostedtc88fd862011-08-16 09:53:39 -0400366 FTRACE_UPDATE_MAKE_NOP,
367};
368
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500369enum {
370 FTRACE_ITER_FILTER = (1 << 0),
371 FTRACE_ITER_NOTRACE = (1 << 1),
372 FTRACE_ITER_PRINTALL = (1 << 2),
Steven Rostedt69a30832011-12-19 15:21:16 -0500373 FTRACE_ITER_DO_HASH = (1 << 3),
374 FTRACE_ITER_HASH = (1 << 4),
375 FTRACE_ITER_ENABLED = (1 << 5),
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500376};
377
Steven Rostedtc88fd862011-08-16 09:53:39 -0400378void arch_ftrace_update_code(int command);
379
380struct ftrace_rec_iter;
381
382struct ftrace_rec_iter *ftrace_rec_iter_start(void);
383struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
384struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
385
Steven Rostedt08d636b2011-08-16 09:57:10 -0400386#define for_ftrace_rec_iter(iter) \
387 for (iter = ftrace_rec_iter_start(); \
388 iter; \
389 iter = ftrace_rec_iter_next(iter))
390
391
Steven Rostedtc88fd862011-08-16 09:53:39 -0400392int ftrace_update_record(struct dyn_ftrace *rec, int enable);
393int ftrace_test_record(struct dyn_ftrace *rec, int enable);
394void ftrace_run_stop_machine(int command);
Steven Rostedtf0cf9732012-04-25 14:39:54 -0400395unsigned long ftrace_location(unsigned long ip);
Steven Rostedtc88fd862011-08-16 09:53:39 -0400396
397extern ftrace_func_t ftrace_trace_function;
398
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500399int ftrace_regex_open(struct ftrace_ops *ops, int flag,
400 struct inode *inode, struct file *file);
401ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
402 size_t cnt, loff_t *ppos);
403ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
404 size_t cnt, loff_t *ppos);
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500405int ftrace_regex_release(struct inode *inode, struct file *file);
406
Steven Rostedt2a85a372011-12-19 21:57:44 -0500407void __init
408ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
409
Steven Rostedt3d083392008-05-12 21:20:42 +0200410/* defined in arch */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200411extern int ftrace_ip_converted(unsigned long ip);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200412extern int ftrace_dyn_arch_init(void *data);
Steven Rostedte4f5d542012-04-27 09:13:18 -0400413extern void ftrace_replace_code(int enable);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200414extern int ftrace_update_ftrace_func(ftrace_func_t func);
415extern void ftrace_caller(void);
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400416extern void ftrace_regs_caller(void);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200417extern void ftrace_call(void);
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400418extern void ftrace_regs_call(void);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200419extern void mcount_call(void);
Shaohua Lif0001202009-01-09 11:29:42 +0800420
Steven Rostedt8ed3e2c2012-04-26 14:59:43 -0400421void ftrace_modify_all_code(int command);
422
Shaohua Lif0001202009-01-09 11:29:42 +0800423#ifndef FTRACE_ADDR
424#define FTRACE_ADDR ((unsigned long)ftrace_caller)
425#endif
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400426
427#ifndef FTRACE_REGS_ADDR
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +0900428#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400429# define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller)
430#else
431# define FTRACE_REGS_ADDR FTRACE_ADDR
432#endif
433#endif
434
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100435#ifdef CONFIG_FUNCTION_GRAPH_TRACER
436extern void ftrace_graph_caller(void);
Steven Rostedt5a45cfe2008-11-26 00:16:24 -0500437extern int ftrace_enable_ftrace_graph_caller(void);
438extern int ftrace_disable_ftrace_graph_caller(void);
439#else
440static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
441static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100442#endif
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400443
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400444/**
Wenji Huang57794a92009-02-06 17:33:27 +0800445 * ftrace_make_nop - convert code into nop
Steven Rostedt31e88902008-11-14 16:21:19 -0800446 * @mod: module structure if called by module load initialization
447 * @rec: the mcount call site record
448 * @addr: the address that the call site should be calling
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400449 *
450 * This is a very sensitive operation and great care needs
451 * to be taken by the arch. The operation should carefully
452 * read the location, check to see if what is read is indeed
453 * what we expect it to be, and then on success of the compare,
454 * it should write to the location.
455 *
Steven Rostedt31e88902008-11-14 16:21:19 -0800456 * The code segment at @rec->ip should be a caller to @addr
457 *
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400458 * Return must be:
459 * 0 on success
460 * -EFAULT on error reading the location
461 * -EINVAL on a failed compare of the contents
462 * -EPERM on error writing to the location
463 * Any other value will be considered a failure.
464 */
Steven Rostedt31e88902008-11-14 16:21:19 -0800465extern int ftrace_make_nop(struct module *mod,
466 struct dyn_ftrace *rec, unsigned long addr);
467
468/**
469 * ftrace_make_call - convert a nop call site into a call to addr
470 * @rec: the mcount call site record
471 * @addr: the address that the call site should call
472 *
473 * This is a very sensitive operation and great care needs
474 * to be taken by the arch. The operation should carefully
475 * read the location, check to see if what is read is indeed
476 * what we expect it to be, and then on success of the compare,
477 * it should write to the location.
478 *
479 * The code segment at @rec->ip should be a nop
480 *
481 * Return must be:
482 * 0 on success
483 * -EFAULT on error reading the location
484 * -EINVAL on a failed compare of the contents
485 * -EPERM on error writing to the location
486 * Any other value will be considered a failure.
487 */
488extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
489
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +0900490#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400491/**
492 * ftrace_modify_call - convert from one addr to another (no nop)
493 * @rec: the mcount call site record
494 * @old_addr: the address expected to be currently called to
495 * @addr: the address to change to
496 *
497 * This is a very sensitive operation and great care needs
498 * to be taken by the arch. The operation should carefully
499 * read the location, check to see if what is read is indeed
500 * what we expect it to be, and then on success of the compare,
501 * it should write to the location.
502 *
503 * The code segment at @rec->ip should be a caller to @old_addr
504 *
505 * Return must be:
506 * 0 on success
507 * -EFAULT on error reading the location
508 * -EINVAL on a failed compare of the contents
509 * -EPERM on error writing to the location
510 * Any other value will be considered a failure.
511 */
512extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
513 unsigned long addr);
514#else
515/* Should never be called */
516static inline int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
517 unsigned long addr)
518{
519 return -EINVAL;
520}
521#endif
522
Steven Rostedt31e88902008-11-14 16:21:19 -0800523/* May be defined in arch */
524extern int ftrace_arch_read_dyn_info(char *buf, int size);
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400525
Abhishek Sagarecea6562008-06-21 23:47:53 +0530526extern int skip_trace(unsigned long ip);
527
Steven Rostedtc0719e52008-09-06 01:06:03 -0400528extern void ftrace_disable_daemon(void);
529extern void ftrace_enable_daemon(void);
Steven Rostedt4dc93672012-06-06 13:45:31 -0400530#else /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400531static inline int skip_trace(unsigned long ip) { return 0; }
532static inline int ftrace_force_update(void) { return 0; }
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400533static inline void ftrace_disable_daemon(void) { }
534static inline void ftrace_enable_daemon(void) { }
jolsa@redhat.come7247a12009-10-07 19:00:35 +0200535static inline void ftrace_release_mod(struct module *mod) {}
Tom Zanussi38de93a2013-10-24 08:34:18 -0500536static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
Steven Rostedtf6180772009-02-14 00:40:25 -0500537{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100538 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500539}
Tom Zanussi38de93a2013-10-24 08:34:18 -0500540static inline __init int unregister_ftrace_command(char *cmd_name)
Steven Rostedtf6180772009-02-14 00:40:25 -0500541{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100542 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500543}
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500544static inline int ftrace_text_reserved(void *start, void *end)
545{
546 return 0;
547}
Steven Rostedt4dc93672012-06-06 13:45:31 -0400548static inline unsigned long ftrace_location(unsigned long ip)
549{
550 return 0;
551}
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500552
553/*
554 * Again users of functions that have ftrace_ops may not
555 * have them defined when ftrace is not enabled, but these
556 * functions may still be called. Use a macro instead of inline.
557 */
558#define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; })
Steven Rostedt96de37b2012-01-07 17:26:49 -0500559#define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
Masami Hiramatsu647664e2012-06-05 19:28:08 +0900560#define ftrace_set_filter_ip(ops, ip, remove, reset) ({ -ENODEV; })
Jiri Olsa5500fa52012-02-15 15:51:54 +0100561#define ftrace_set_filter(ops, buf, len, reset) ({ -ENODEV; })
562#define ftrace_set_notrace(ops, buf, len, reset) ({ -ENODEV; })
563#define ftrace_free_filter(ops) do { } while (0)
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500564
565static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
566 size_t cnt, loff_t *ppos) { return -ENODEV; }
567static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
568 size_t cnt, loff_t *ppos) { return -ENODEV; }
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500569static inline int
570ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
Abhishek Sagarecea6562008-06-21 23:47:53 +0530571#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt352ad252008-05-12 21:20:42 +0200572
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200573/* totally disable ftrace - can not re-enable after this */
574void ftrace_kill(void);
575
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200576static inline void tracer_disable(void)
577{
Steven Rostedt606576c2008-10-06 19:06:12 -0400578#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200579 ftrace_enabled = 0;
580#endif
581}
582
Huang Ying37002732008-08-18 16:24:56 +0800583/*
584 * Ftrace disable/restore without lock. Some synchronization mechanism
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700585 * must be used to prevent ftrace_enabled to be changed between
Huang Ying37002732008-08-18 16:24:56 +0800586 * disable/restore.
587 */
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700588static inline int __ftrace_enabled_save(void)
589{
Steven Rostedt606576c2008-10-06 19:06:12 -0400590#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700591 int saved_ftrace_enabled = ftrace_enabled;
592 ftrace_enabled = 0;
593 return saved_ftrace_enabled;
594#else
595 return 0;
596#endif
597}
598
599static inline void __ftrace_enabled_restore(int enabled)
600{
Steven Rostedt606576c2008-10-06 19:06:12 -0400601#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700602 ftrace_enabled = enabled;
603#endif
604}
605
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100606#ifndef HAVE_ARCH_CALLER_ADDR
607# ifdef CONFIG_FRAME_POINTER
608# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
609# define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
610# define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
611# define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
612# define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
613# define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
614# define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
615# else
616# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
617# define CALLER_ADDR1 0UL
618# define CALLER_ADDR2 0UL
619# define CALLER_ADDR3 0UL
620# define CALLER_ADDR4 0UL
621# define CALLER_ADDR5 0UL
622# define CALLER_ADDR6 0UL
623# endif
624#endif /* ifndef HAVE_ARCH_CALLER_ADDR */
Steven Rostedt352ad252008-05-12 21:20:42 +0200625
Steven Rostedt81d68a92008-05-12 21:20:42 +0200626#ifdef CONFIG_IRQSOFF_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100627 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
628 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
Steven Rostedt81d68a92008-05-12 21:20:42 +0200629#else
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400630 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
631 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
Steven Rostedt81d68a92008-05-12 21:20:42 +0200632#endif
633
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200634#ifdef CONFIG_PREEMPT_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100635 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
636 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200637#else
Minho Banb02ee9a2012-05-07 11:36:00 +0900638/*
639 * Use defines instead of static inlines because some arches will make code out
640 * of the CALLER_ADDR, when we really want these to be a real nop.
641 */
642# define trace_preempt_on(a0, a1) do { } while (0)
643# define trace_preempt_off(a0, a1) do { } while (0)
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200644#endif
645
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400646#ifdef CONFIG_FTRACE_MCOUNT_RECORD
647extern void ftrace_init(void);
648#else
649static inline void ftrace_init(void) { }
650#endif
651
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100652/*
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100653 * Structure that defines an entry function trace.
654 */
655struct ftrace_graph_ent {
656 unsigned long func; /* Current function */
657 int depth;
658};
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400659
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100660/*
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100661 * Structure that defines a return function trace.
662 */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100663struct ftrace_graph_ret {
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100664 unsigned long func; /* Current function */
665 unsigned long long calltime;
666 unsigned long long rettime;
Frederic Weisbecker02310222008-11-17 03:22:41 +0100667 /* Number of functions that overran the depth limit for current task */
668 unsigned long overrun;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100669 int depth;
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100670};
671
Jiri Olsa62b915f2010-04-02 19:01:22 +0200672/* Type of the callback handlers for tracing function graph*/
673typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
674typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
675
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100676#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100677
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400678/* for init task */
Tetsuo Handaf876d342009-04-08 14:05:43 +0900679#define INIT_FTRACE_GRAPH .ret_stack = NULL,
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400680
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100681/*
Steven Rostedt712406a2009-02-09 10:54:03 -0800682 * Stack of return addresses for functions
683 * of a thread.
684 * Used in struct thread_info
685 */
686struct ftrace_ret_stack {
687 unsigned long ret;
688 unsigned long func;
689 unsigned long long calltime;
Steven Rostedta2a16d62009-03-24 23:17:58 -0400690 unsigned long long subtime;
Steven Rostedt71e308a2009-06-18 12:45:08 -0400691 unsigned long fp;
Steven Rostedt712406a2009-02-09 10:54:03 -0800692};
693
694/*
695 * Primary handler of a function return.
696 * It relays on ftrace_return_to_handler.
697 * Defined in entry_32/64.S
698 */
699extern void return_to_handler(void);
700
701extern int
Steven Rostedt71e308a2009-06-18 12:45:08 -0400702ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
703 unsigned long frame_pointer);
Steven Rostedt712406a2009-02-09 10:54:03 -0800704
705/*
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100706 * Sometimes we don't want to trace a function with the function
707 * graph tracer but we want them to keep traced by the usual function
708 * tracer if the function graph tracer is not configured.
709 */
710#define __notrace_funcgraph notrace
711
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100712/*
713 * We want to which function is an entrypoint of a hardirq.
714 * That will help us to put a signal on output.
715 */
716#define __irq_entry __attribute__((__section__(".irqentry.text")))
717
718/* Limits of hardirq entrypoints */
719extern char __irqentry_text_start[];
720extern char __irqentry_text_end[];
721
Namhyung Kim29ad23b2013-10-14 17:24:26 +0900722#define FTRACE_NOTRACE_DEPTH 65536
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100723#define FTRACE_RETFUNC_DEPTH 50
724#define FTRACE_RETSTACK_ALLOC_SIZE 32
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100725extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
726 trace_func_graph_ent_t entryfunc);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100727
Steven Rostedt14a866c2008-12-02 23:50:02 -0500728extern void ftrace_graph_stop(void);
729
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100730/* The current handlers in use */
731extern trace_func_graph_ret_t ftrace_graph_return;
732extern trace_func_graph_ent_t ftrace_graph_entry;
733
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100734extern void unregister_ftrace_graph(void);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100735
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100736extern void ftrace_graph_init_task(struct task_struct *t);
737extern void ftrace_graph_exit_task(struct task_struct *t);
Steven Rostedt868baf02011-02-10 21:26:13 -0500738extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100739
740static inline int task_curr_ret_stack(struct task_struct *t)
741{
742 return t->curr_ret_stack;
743}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100744
745static inline void pause_graph_tracing(void)
746{
747 atomic_inc(&current->tracing_graph_pause);
748}
749
750static inline void unpause_graph_tracing(void)
751{
752 atomic_dec(&current->tracing_graph_pause);
753}
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400754#else /* !CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100755
756#define __notrace_funcgraph
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100757#define __irq_entry
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400758#define INIT_FTRACE_GRAPH
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100759
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100760static inline void ftrace_graph_init_task(struct task_struct *t) { }
761static inline void ftrace_graph_exit_task(struct task_struct *t) { }
Steven Rostedt868baf02011-02-10 21:26:13 -0500762static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100763
Jiri Olsa62b915f2010-04-02 19:01:22 +0200764static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
765 trace_func_graph_ent_t entryfunc)
766{
767 return -1;
768}
769static inline void unregister_ftrace_graph(void) { }
770
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100771static inline int task_curr_ret_stack(struct task_struct *tsk)
772{
773 return -1;
774}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100775
776static inline void pause_graph_tracing(void) { }
777static inline void unpause_graph_tracing(void) { }
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400778#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100779
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500780#ifdef CONFIG_TRACING
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500781
782/* flags for current->trace */
783enum {
784 TSK_TRACE_FL_TRACE_BIT = 0,
785 TSK_TRACE_FL_GRAPH_BIT = 1,
786};
787enum {
788 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
789 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
790};
791
792static inline void set_tsk_trace_trace(struct task_struct *tsk)
793{
794 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
795}
796
797static inline void clear_tsk_trace_trace(struct task_struct *tsk)
798{
799 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
800}
801
802static inline int test_tsk_trace_trace(struct task_struct *tsk)
803{
804 return tsk->trace & TSK_TRACE_FL_TRACE;
805}
806
807static inline void set_tsk_trace_graph(struct task_struct *tsk)
808{
809 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
810}
811
812static inline void clear_tsk_trace_graph(struct task_struct *tsk)
813{
814 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
815}
816
817static inline int test_tsk_trace_graph(struct task_struct *tsk)
818{
819 return tsk->trace & TSK_TRACE_FL_GRAPH;
820}
821
Frederic Weisbeckercecbca92010-04-18 19:08:41 +0200822enum ftrace_dump_mode;
823
824extern enum ftrace_dump_mode ftrace_dump_on_oops;
Ingo Molnar526211b2009-03-05 10:28:45 +0100825
Steven Rostedt (Red Hat)de7edd32013-06-14 16:21:43 -0400826extern void disable_trace_on_warning(void);
827extern int __disable_trace_on_warning;
828
Steven Rostedt261842b2009-04-16 21:41:52 -0400829#ifdef CONFIG_PREEMPT
830#define INIT_TRACE_RECURSION .trace_recursion = 0,
831#endif
832
Steven Rostedt (Red Hat)de7edd32013-06-14 16:21:43 -0400833#else /* CONFIG_TRACING */
834static inline void disable_trace_on_warning(void) { }
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500835#endif /* CONFIG_TRACING */
836
Steven Rostedt261842b2009-04-16 21:41:52 -0400837#ifndef INIT_TRACE_RECURSION
838#define INIT_TRACE_RECURSION
839#endif
Markus Metzgerb1818742009-01-19 10:31:01 +0100840
Mike Frysingere7b8e672010-01-26 04:40:03 -0500841#ifdef CONFIG_FTRACE_SYSCALLS
842
843unsigned long arch_syscall_addr(int nr);
844
845#endif /* CONFIG_FTRACE_SYSCALLS */
846
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200847#endif /* _LINUX_FTRACE_H */