blob: e5ca8ef50e9bf674e46fa58d7fff5f0424ab5bad [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.
Jiri Olsae2484912012-02-15 15:51:48 +010092 */
Steven Rostedtb8489142011-05-04 09:27:52 -040093enum {
Steven Rostedt08f6fba2012-04-30 16:20:23 -040094 FTRACE_OPS_FL_ENABLED = 1 << 0,
95 FTRACE_OPS_FL_GLOBAL = 1 << 1,
96 FTRACE_OPS_FL_DYNAMIC = 1 << 2,
97 FTRACE_OPS_FL_CONTROL = 1 << 3,
98 FTRACE_OPS_FL_SAVE_REGS = 1 << 4,
99 FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 1 << 5,
Steven Rostedt47409742012-07-20 11:04:44 -0400100 FTRACE_OPS_FL_RECURSION_SAFE = 1 << 6,
Steven Rostedtb8489142011-05-04 09:27:52 -0400101};
102
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200103struct ftrace_ops {
Steven Rostedtf45948e2011-05-02 12:29:25 -0400104 ftrace_func_t func;
105 struct ftrace_ops *next;
Steven Rostedtb8489142011-05-04 09:27:52 -0400106 unsigned long flags;
Jiri Olsae2484912012-02-15 15:51:48 +0100107 int __percpu *disabled;
Steven Rostedtf45948e2011-05-02 12:29:25 -0400108#ifdef CONFIG_DYNAMIC_FTRACE
109 struct ftrace_hash *notrace_hash;
110 struct ftrace_hash *filter_hash;
111#endif
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200112};
113
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500114extern int function_trace_stop;
115
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100116/*
117 * Type of the current tracing.
118 */
119enum ftrace_tracing_type_t {
120 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
121 FTRACE_TYPE_RETURN, /* Hook the return of the function */
122};
123
124/* Current tracing type, default is FTRACE_TYPE_ENTER */
125extern enum ftrace_tracing_type_t ftrace_tracing_type;
126
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500127/**
128 * ftrace_stop - stop function tracer.
129 *
130 * A quick way to stop the function tracer. Note this an on off switch,
131 * it is not something that is recursive like preempt_disable.
132 * This does not disable the calling of mcount, it only stops the
133 * calling of functions from mcount.
134 */
135static inline void ftrace_stop(void)
136{
137 function_trace_stop = 1;
138}
139
140/**
141 * ftrace_start - start the function tracer.
142 *
143 * This function is the inverse of ftrace_stop. This does not enable
144 * the function tracing if the function tracer is disabled. This only
145 * sets the function tracer flag to continue calling the functions
146 * from mcount.
147 */
148static inline void ftrace_start(void)
149{
150 function_trace_stop = 0;
151}
152
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200153/*
154 * The ftrace_ops must be a static and should also
155 * be read_mostly. These functions do modify read_mostly variables
156 * so use them sparely. Never free an ftrace_op or modify the
157 * next pointer after it has been registered. Even after unregistering
158 * it, the next pointer may still be used internally.
159 */
160int register_ftrace_function(struct ftrace_ops *ops);
161int unregister_ftrace_function(struct ftrace_ops *ops);
162void clear_ftrace_function(void);
163
Jiri Olsae2484912012-02-15 15:51:48 +0100164/**
165 * ftrace_function_local_enable - enable controlled ftrace_ops on current cpu
166 *
167 * This function enables tracing on current cpu by decreasing
168 * the per cpu control variable.
169 * It must be called with preemption disabled and only on ftrace_ops
170 * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
171 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
172 */
173static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
174{
175 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
176 return;
177
178 (*this_cpu_ptr(ops->disabled))--;
179}
180
181/**
182 * ftrace_function_local_disable - enable controlled ftrace_ops on current cpu
183 *
184 * This function enables tracing on current cpu by decreasing
185 * the per cpu control variable.
186 * It must be called with preemption disabled and only on ftrace_ops
187 * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
188 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
189 */
190static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
191{
192 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
193 return;
194
195 (*this_cpu_ptr(ops->disabled))++;
196}
197
198/**
199 * ftrace_function_local_disabled - returns ftrace_ops disabled value
200 * on current cpu
201 *
202 * This function returns value of ftrace_ops::disabled on current cpu.
203 * It must be called with preemption disabled and only on ftrace_ops
204 * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
205 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
206 */
207static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
208{
209 WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL));
210 return *this_cpu_ptr(ops->disabled);
211}
212
Steven Rostedta1e2e312011-08-09 12:50:46 -0400213extern void ftrace_stub(unsigned long a0, unsigned long a1,
214 struct ftrace_ops *op, struct pt_regs *regs);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200215
Steven Rostedt606576c2008-10-06 19:06:12 -0400216#else /* !CONFIG_FUNCTION_TRACER */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400217/*
218 * (un)register_ftrace_function must be a macro since the ops parameter
219 * must not be evaluated.
220 */
221#define register_ftrace_function(ops) ({ 0; })
222#define unregister_ftrace_function(ops) ({ 0; })
Steven Rostedtea701f12012-07-20 13:08:05 -0400223static inline int ftrace_nr_registered_ops(void)
224{
225 return 0;
226}
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400227static inline void clear_ftrace_function(void) { }
Steven Rostedt81adbdc2008-10-23 09:33:02 -0400228static inline void ftrace_kill(void) { }
Steven Rostedt60a7ecf2008-11-05 16:05:44 -0500229static inline void ftrace_stop(void) { }
230static inline void ftrace_start(void) { }
Steven Rostedt606576c2008-10-06 19:06:12 -0400231#endif /* CONFIG_FUNCTION_TRACER */
Steven Rostedt352ad252008-05-12 21:20:42 +0200232
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500233#ifdef CONFIG_STACK_TRACER
234extern int stack_tracer_enabled;
235int
236stack_trace_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700237 void __user *buffer, size_t *lenp,
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500238 loff_t *ppos);
239#endif
240
Steven Rostedtf6180772009-02-14 00:40:25 -0500241struct ftrace_func_command {
242 struct list_head list;
243 char *name;
Steven Rostedt43dd61c2011-07-07 11:09:22 -0400244 int (*func)(struct ftrace_hash *hash,
245 char *func, char *cmd,
Steven Rostedtf6180772009-02-14 00:40:25 -0500246 char *params, int enable);
247};
248
Steven Rostedt3d083392008-05-12 21:20:42 +0200249#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt31e88902008-11-14 16:21:19 -0800250
Steven Rostedt000ab692009-02-17 13:35:06 -0500251int ftrace_arch_code_modify_prepare(void);
252int ftrace_arch_code_modify_post_process(void);
253
Steven Rostedtc88fd862011-08-16 09:53:39 -0400254void ftrace_bug(int err, unsigned long ip);
255
Steven Rostedt809dcf22009-02-16 23:06:01 -0500256struct seq_file;
257
Steven Rostedtb6887d72009-02-17 12:32:04 -0500258struct ftrace_probe_ops {
Steven Rostedt59df055f2009-02-14 15:29:06 -0500259 void (*func)(unsigned long ip,
260 unsigned long parent_ip,
261 void **data);
262 int (*callback)(unsigned long ip, void **data);
263 void (*free)(void **data);
Steven Rostedt809dcf22009-02-16 23:06:01 -0500264 int (*print)(struct seq_file *m,
265 unsigned long ip,
Steven Rostedtb6887d72009-02-17 12:32:04 -0500266 struct ftrace_probe_ops *ops,
Steven Rostedt809dcf22009-02-16 23:06:01 -0500267 void *data);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500268};
269
270extern int
Steven Rostedtb6887d72009-02-17 12:32:04 -0500271register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500272 void *data);
273extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500274unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500275 void *data);
276extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500277unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
278extern void unregister_ftrace_function_probe_all(char *glob);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500279
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500280extern int ftrace_text_reserved(void *start, void *end);
281
Steven Rostedtea701f12012-07-20 13:08:05 -0400282extern int ftrace_nr_registered_ops(void);
283
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400284/*
285 * The dyn_ftrace record's flags field is split into two parts.
286 * the first part which is '0-FTRACE_REF_MAX' is a counter of
287 * the number of callbacks that have registered the function that
288 * the dyn_ftrace descriptor represents.
289 *
290 * The second part is a mask:
291 * ENABLED - the function is being traced
292 * REGS - the record wants the function to save regs
293 * REGS_EN - the function is set up to save regs.
294 *
295 * When a new ftrace_ops is registered and wants a function to save
296 * pt_regs, the rec->flag REGS is set. When the function has been
297 * set up to save regs, the REG_EN flag is set. Once a function
298 * starts saving regs it will do so until all ftrace_ops are removed
299 * from tracing that function.
300 */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200301enum {
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400302 FTRACE_FL_ENABLED = (1UL << 29),
303 FTRACE_FL_REGS = (1UL << 30),
304 FTRACE_FL_REGS_EN = (1UL << 31)
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200305};
306
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400307#define FTRACE_FL_MASK (0x7UL << 29)
308#define FTRACE_REF_MAX ((1UL << 29) - 1)
Steven Rostedted926f92011-05-03 13:25:24 -0400309
Steven Rostedt3d083392008-05-12 21:20:42 +0200310struct dyn_ftrace {
Lai Jiangshanee000b72009-03-24 13:38:06 +0800311 union {
312 unsigned long ip; /* address of mcount call-site */
313 struct dyn_ftrace *freelist;
314 };
Steven Rostedt85ae32a2011-12-16 16:30:31 -0500315 unsigned long flags;
Lai Jiangshanee000b72009-03-24 13:38:06 +0800316 struct dyn_arch_ftrace arch;
Steven Rostedt3d083392008-05-12 21:20:42 +0200317};
318
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200319int ftrace_force_update(void);
Masami Hiramatsu647664e2012-06-05 19:28:08 +0900320int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
321 int remove, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100322int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400323 int len, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100324int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400325 int len, int reset);
326void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
327void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
Jiri Olsa5500fa52012-02-15 15:51:54 +0100328void ftrace_free_filter(struct ftrace_ops *ops);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200329
Steven Rostedtf6180772009-02-14 00:40:25 -0500330int register_ftrace_command(struct ftrace_func_command *cmd);
331int unregister_ftrace_command(struct ftrace_func_command *cmd);
332
Steven Rostedtc88fd862011-08-16 09:53:39 -0400333enum {
334 FTRACE_UPDATE_CALLS = (1 << 0),
335 FTRACE_DISABLE_CALLS = (1 << 1),
336 FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
337 FTRACE_START_FUNC_RET = (1 << 3),
338 FTRACE_STOP_FUNC_RET = (1 << 4),
339};
340
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400341/*
342 * The FTRACE_UPDATE_* enum is used to pass information back
343 * from the ftrace_update_record() and ftrace_test_record()
344 * functions. These are called by the code update routines
345 * to find out what is to be done for a given function.
346 *
347 * IGNORE - The function is already what we want it to be
348 * MAKE_CALL - Start tracing the function
349 * MODIFY_CALL - Stop saving regs for the function
350 * MODIFY_CALL_REGS - Start saving regs for the function
351 * MAKE_NOP - Stop tracing the function
352 */
Steven Rostedtc88fd862011-08-16 09:53:39 -0400353enum {
354 FTRACE_UPDATE_IGNORE,
355 FTRACE_UPDATE_MAKE_CALL,
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400356 FTRACE_UPDATE_MODIFY_CALL,
357 FTRACE_UPDATE_MODIFY_CALL_REGS,
Steven Rostedtc88fd862011-08-16 09:53:39 -0400358 FTRACE_UPDATE_MAKE_NOP,
359};
360
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500361enum {
362 FTRACE_ITER_FILTER = (1 << 0),
363 FTRACE_ITER_NOTRACE = (1 << 1),
364 FTRACE_ITER_PRINTALL = (1 << 2),
Steven Rostedt69a30832011-12-19 15:21:16 -0500365 FTRACE_ITER_DO_HASH = (1 << 3),
366 FTRACE_ITER_HASH = (1 << 4),
367 FTRACE_ITER_ENABLED = (1 << 5),
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500368};
369
Steven Rostedtc88fd862011-08-16 09:53:39 -0400370void arch_ftrace_update_code(int command);
371
372struct ftrace_rec_iter;
373
374struct ftrace_rec_iter *ftrace_rec_iter_start(void);
375struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
376struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
377
Steven Rostedt08d636b2011-08-16 09:57:10 -0400378#define for_ftrace_rec_iter(iter) \
379 for (iter = ftrace_rec_iter_start(); \
380 iter; \
381 iter = ftrace_rec_iter_next(iter))
382
383
Steven Rostedtc88fd862011-08-16 09:53:39 -0400384int ftrace_update_record(struct dyn_ftrace *rec, int enable);
385int ftrace_test_record(struct dyn_ftrace *rec, int enable);
386void ftrace_run_stop_machine(int command);
Steven Rostedtf0cf9732012-04-25 14:39:54 -0400387unsigned long ftrace_location(unsigned long ip);
Steven Rostedtc88fd862011-08-16 09:53:39 -0400388
389extern ftrace_func_t ftrace_trace_function;
390
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500391int ftrace_regex_open(struct ftrace_ops *ops, int flag,
392 struct inode *inode, struct file *file);
393ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
394 size_t cnt, loff_t *ppos);
395ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
396 size_t cnt, loff_t *ppos);
Andrew Morton965c8e52012-12-17 15:59:39 -0800397loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int whence);
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500398int ftrace_regex_release(struct inode *inode, struct file *file);
399
Steven Rostedt2a85a372011-12-19 21:57:44 -0500400void __init
401ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
402
Steven Rostedt3d083392008-05-12 21:20:42 +0200403/* defined in arch */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200404extern int ftrace_ip_converted(unsigned long ip);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200405extern int ftrace_dyn_arch_init(void *data);
Steven Rostedte4f5d542012-04-27 09:13:18 -0400406extern void ftrace_replace_code(int enable);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200407extern int ftrace_update_ftrace_func(ftrace_func_t func);
408extern void ftrace_caller(void);
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400409extern void ftrace_regs_caller(void);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200410extern void ftrace_call(void);
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400411extern void ftrace_regs_call(void);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200412extern void mcount_call(void);
Shaohua Lif0001202009-01-09 11:29:42 +0800413
Steven Rostedt8ed3e2c2012-04-26 14:59:43 -0400414void ftrace_modify_all_code(int command);
415
Shaohua Lif0001202009-01-09 11:29:42 +0800416#ifndef FTRACE_ADDR
417#define FTRACE_ADDR ((unsigned long)ftrace_caller)
418#endif
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400419
420#ifndef FTRACE_REGS_ADDR
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +0900421#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400422# define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller)
423#else
424# define FTRACE_REGS_ADDR FTRACE_ADDR
425#endif
426#endif
427
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100428#ifdef CONFIG_FUNCTION_GRAPH_TRACER
429extern void ftrace_graph_caller(void);
Steven Rostedt5a45cfe2008-11-26 00:16:24 -0500430extern int ftrace_enable_ftrace_graph_caller(void);
431extern int ftrace_disable_ftrace_graph_caller(void);
432#else
433static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
434static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100435#endif
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400436
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400437/**
Wenji Huang57794a92009-02-06 17:33:27 +0800438 * ftrace_make_nop - convert code into nop
Steven Rostedt31e88902008-11-14 16:21:19 -0800439 * @mod: module structure if called by module load initialization
440 * @rec: the mcount call site record
441 * @addr: the address that the call site should be calling
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400442 *
443 * This is a very sensitive operation and great care needs
444 * to be taken by the arch. The operation should carefully
445 * read the location, check to see if what is read is indeed
446 * what we expect it to be, and then on success of the compare,
447 * it should write to the location.
448 *
Steven Rostedt31e88902008-11-14 16:21:19 -0800449 * The code segment at @rec->ip should be a caller to @addr
450 *
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400451 * Return must be:
452 * 0 on success
453 * -EFAULT on error reading the location
454 * -EINVAL on a failed compare of the contents
455 * -EPERM on error writing to the location
456 * Any other value will be considered a failure.
457 */
Steven Rostedt31e88902008-11-14 16:21:19 -0800458extern int ftrace_make_nop(struct module *mod,
459 struct dyn_ftrace *rec, unsigned long addr);
460
461/**
462 * ftrace_make_call - convert a nop call site into a call to addr
463 * @rec: the mcount call site record
464 * @addr: the address that the call site should call
465 *
466 * This is a very sensitive operation and great care needs
467 * to be taken by the arch. The operation should carefully
468 * read the location, check to see if what is read is indeed
469 * what we expect it to be, and then on success of the compare,
470 * it should write to the location.
471 *
472 * The code segment at @rec->ip should be a nop
473 *
474 * Return must be:
475 * 0 on success
476 * -EFAULT on error reading the location
477 * -EINVAL on a failed compare of the contents
478 * -EPERM on error writing to the location
479 * Any other value will be considered a failure.
480 */
481extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
482
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +0900483#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400484/**
485 * ftrace_modify_call - convert from one addr to another (no nop)
486 * @rec: the mcount call site record
487 * @old_addr: the address expected to be currently called to
488 * @addr: the address to change to
489 *
490 * This is a very sensitive operation and great care needs
491 * to be taken by the arch. The operation should carefully
492 * read the location, check to see if what is read is indeed
493 * what we expect it to be, and then on success of the compare,
494 * it should write to the location.
495 *
496 * The code segment at @rec->ip should be a caller to @old_addr
497 *
498 * Return must be:
499 * 0 on success
500 * -EFAULT on error reading the location
501 * -EINVAL on a failed compare of the contents
502 * -EPERM on error writing to the location
503 * Any other value will be considered a failure.
504 */
505extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
506 unsigned long addr);
507#else
508/* Should never be called */
509static inline int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
510 unsigned long addr)
511{
512 return -EINVAL;
513}
514#endif
515
Steven Rostedt31e88902008-11-14 16:21:19 -0800516/* May be defined in arch */
517extern int ftrace_arch_read_dyn_info(char *buf, int size);
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400518
Abhishek Sagarecea6562008-06-21 23:47:53 +0530519extern int skip_trace(unsigned long ip);
520
Steven Rostedtc0719e52008-09-06 01:06:03 -0400521extern void ftrace_disable_daemon(void);
522extern void ftrace_enable_daemon(void);
Steven Rostedt4dc93672012-06-06 13:45:31 -0400523#else /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400524static inline int skip_trace(unsigned long ip) { return 0; }
525static inline int ftrace_force_update(void) { return 0; }
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400526static inline void ftrace_disable_daemon(void) { }
527static inline void ftrace_enable_daemon(void) { }
jolsa@redhat.come7247a12009-10-07 19:00:35 +0200528static inline void ftrace_release_mod(struct module *mod) {}
Steven Rostedtf6180772009-02-14 00:40:25 -0500529static inline int register_ftrace_command(struct ftrace_func_command *cmd)
530{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100531 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500532}
533static inline int unregister_ftrace_command(char *cmd_name)
534{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100535 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500536}
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500537static inline int ftrace_text_reserved(void *start, void *end)
538{
539 return 0;
540}
Steven Rostedt4dc93672012-06-06 13:45:31 -0400541static inline unsigned long ftrace_location(unsigned long ip)
542{
543 return 0;
544}
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500545
546/*
547 * Again users of functions that have ftrace_ops may not
548 * have them defined when ftrace is not enabled, but these
549 * functions may still be called. Use a macro instead of inline.
550 */
551#define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; })
Steven Rostedt96de37b2012-01-07 17:26:49 -0500552#define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
Masami Hiramatsu647664e2012-06-05 19:28:08 +0900553#define ftrace_set_filter_ip(ops, ip, remove, reset) ({ -ENODEV; })
Jiri Olsa5500fa52012-02-15 15:51:54 +0100554#define ftrace_set_filter(ops, buf, len, reset) ({ -ENODEV; })
555#define ftrace_set_notrace(ops, buf, len, reset) ({ -ENODEV; })
556#define ftrace_free_filter(ops) do { } while (0)
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500557
558static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
559 size_t cnt, loff_t *ppos) { return -ENODEV; }
560static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
561 size_t cnt, loff_t *ppos) { return -ENODEV; }
Andrew Morton965c8e52012-12-17 15:59:39 -0800562static inline loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int whence)
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500563{
564 return -ENODEV;
565}
566static inline int
567ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
Abhishek Sagarecea6562008-06-21 23:47:53 +0530568#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt352ad252008-05-12 21:20:42 +0200569
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200570/* totally disable ftrace - can not re-enable after this */
571void ftrace_kill(void);
572
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200573static inline void tracer_disable(void)
574{
Steven Rostedt606576c2008-10-06 19:06:12 -0400575#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200576 ftrace_enabled = 0;
577#endif
578}
579
Huang Ying37002732008-08-18 16:24:56 +0800580/*
581 * Ftrace disable/restore without lock. Some synchronization mechanism
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700582 * must be used to prevent ftrace_enabled to be changed between
Huang Ying37002732008-08-18 16:24:56 +0800583 * disable/restore.
584 */
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700585static inline int __ftrace_enabled_save(void)
586{
Steven Rostedt606576c2008-10-06 19:06:12 -0400587#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700588 int saved_ftrace_enabled = ftrace_enabled;
589 ftrace_enabled = 0;
590 return saved_ftrace_enabled;
591#else
592 return 0;
593#endif
594}
595
596static inline void __ftrace_enabled_restore(int enabled)
597{
Steven Rostedt606576c2008-10-06 19:06:12 -0400598#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700599 ftrace_enabled = enabled;
600#endif
601}
602
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100603#ifndef HAVE_ARCH_CALLER_ADDR
604# ifdef CONFIG_FRAME_POINTER
605# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
606# define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
607# define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
608# define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
609# define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
610# define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
611# define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
612# else
613# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
614# define CALLER_ADDR1 0UL
615# define CALLER_ADDR2 0UL
616# define CALLER_ADDR3 0UL
617# define CALLER_ADDR4 0UL
618# define CALLER_ADDR5 0UL
619# define CALLER_ADDR6 0UL
620# endif
621#endif /* ifndef HAVE_ARCH_CALLER_ADDR */
Steven Rostedt352ad252008-05-12 21:20:42 +0200622
Steven Rostedt81d68a92008-05-12 21:20:42 +0200623#ifdef CONFIG_IRQSOFF_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100624 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
625 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
Steven Rostedt81d68a92008-05-12 21:20:42 +0200626#else
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400627 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
628 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
Steven Rostedt81d68a92008-05-12 21:20:42 +0200629#endif
630
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200631#ifdef CONFIG_PREEMPT_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100632 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
633 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200634#else
Minho Banb02ee9a2012-05-07 11:36:00 +0900635/*
636 * Use defines instead of static inlines because some arches will make code out
637 * of the CALLER_ADDR, when we really want these to be a real nop.
638 */
639# define trace_preempt_on(a0, a1) do { } while (0)
640# define trace_preempt_off(a0, a1) do { } while (0)
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200641#endif
642
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400643#ifdef CONFIG_FTRACE_MCOUNT_RECORD
644extern void ftrace_init(void);
645#else
646static inline void ftrace_init(void) { }
647#endif
648
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100649/*
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100650 * Structure that defines an entry function trace.
651 */
652struct ftrace_graph_ent {
653 unsigned long func; /* Current function */
654 int depth;
655};
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400656
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100657/*
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100658 * Structure that defines a return function trace.
659 */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100660struct ftrace_graph_ret {
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100661 unsigned long func; /* Current function */
662 unsigned long long calltime;
663 unsigned long long rettime;
Frederic Weisbecker02310222008-11-17 03:22:41 +0100664 /* Number of functions that overran the depth limit for current task */
665 unsigned long overrun;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100666 int depth;
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100667};
668
Jiri Olsa62b915f2010-04-02 19:01:22 +0200669/* Type of the callback handlers for tracing function graph*/
670typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
671typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
672
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100673#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100674
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400675/* for init task */
Tetsuo Handaf876d342009-04-08 14:05:43 +0900676#define INIT_FTRACE_GRAPH .ret_stack = NULL,
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400677
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100678/*
Steven Rostedt712406a2009-02-09 10:54:03 -0800679 * Stack of return addresses for functions
680 * of a thread.
681 * Used in struct thread_info
682 */
683struct ftrace_ret_stack {
684 unsigned long ret;
685 unsigned long func;
686 unsigned long long calltime;
Steven Rostedta2a16d62009-03-24 23:17:58 -0400687 unsigned long long subtime;
Steven Rostedt71e308a2009-06-18 12:45:08 -0400688 unsigned long fp;
Steven Rostedt712406a2009-02-09 10:54:03 -0800689};
690
691/*
692 * Primary handler of a function return.
693 * It relays on ftrace_return_to_handler.
694 * Defined in entry_32/64.S
695 */
696extern void return_to_handler(void);
697
698extern int
Steven Rostedt71e308a2009-06-18 12:45:08 -0400699ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
700 unsigned long frame_pointer);
Steven Rostedt712406a2009-02-09 10:54:03 -0800701
702/*
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100703 * Sometimes we don't want to trace a function with the function
704 * graph tracer but we want them to keep traced by the usual function
705 * tracer if the function graph tracer is not configured.
706 */
707#define __notrace_funcgraph notrace
708
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100709/*
710 * We want to which function is an entrypoint of a hardirq.
711 * That will help us to put a signal on output.
712 */
713#define __irq_entry __attribute__((__section__(".irqentry.text")))
714
715/* Limits of hardirq entrypoints */
716extern char __irqentry_text_start[];
717extern char __irqentry_text_end[];
718
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100719#define FTRACE_RETFUNC_DEPTH 50
720#define FTRACE_RETSTACK_ALLOC_SIZE 32
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100721extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
722 trace_func_graph_ent_t entryfunc);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100723
Steven Rostedt14a866c2008-12-02 23:50:02 -0500724extern void ftrace_graph_stop(void);
725
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100726/* The current handlers in use */
727extern trace_func_graph_ret_t ftrace_graph_return;
728extern trace_func_graph_ent_t ftrace_graph_entry;
729
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100730extern void unregister_ftrace_graph(void);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100731
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100732extern void ftrace_graph_init_task(struct task_struct *t);
733extern void ftrace_graph_exit_task(struct task_struct *t);
Steven Rostedt868baf02011-02-10 21:26:13 -0500734extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100735
736static inline int task_curr_ret_stack(struct task_struct *t)
737{
738 return t->curr_ret_stack;
739}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100740
741static inline void pause_graph_tracing(void)
742{
743 atomic_inc(&current->tracing_graph_pause);
744}
745
746static inline void unpause_graph_tracing(void)
747{
748 atomic_dec(&current->tracing_graph_pause);
749}
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400750#else /* !CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100751
752#define __notrace_funcgraph
Frederic Weisbeckerbcbc4f22008-12-09 23:54:20 +0100753#define __irq_entry
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400754#define INIT_FTRACE_GRAPH
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100755
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100756static inline void ftrace_graph_init_task(struct task_struct *t) { }
757static inline void ftrace_graph_exit_task(struct task_struct *t) { }
Steven Rostedt868baf02011-02-10 21:26:13 -0500758static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100759
Jiri Olsa62b915f2010-04-02 19:01:22 +0200760static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
761 trace_func_graph_ent_t entryfunc)
762{
763 return -1;
764}
765static inline void unregister_ftrace_graph(void) { }
766
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100767static inline int task_curr_ret_stack(struct task_struct *tsk)
768{
769 return -1;
770}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100771
772static inline void pause_graph_tracing(void) { }
773static inline void unpause_graph_tracing(void) { }
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400774#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100775
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500776#ifdef CONFIG_TRACING
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500777
778/* flags for current->trace */
779enum {
780 TSK_TRACE_FL_TRACE_BIT = 0,
781 TSK_TRACE_FL_GRAPH_BIT = 1,
782};
783enum {
784 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
785 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
786};
787
788static inline void set_tsk_trace_trace(struct task_struct *tsk)
789{
790 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
791}
792
793static inline void clear_tsk_trace_trace(struct task_struct *tsk)
794{
795 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
796}
797
798static inline int test_tsk_trace_trace(struct task_struct *tsk)
799{
800 return tsk->trace & TSK_TRACE_FL_TRACE;
801}
802
803static inline void set_tsk_trace_graph(struct task_struct *tsk)
804{
805 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
806}
807
808static inline void clear_tsk_trace_graph(struct task_struct *tsk)
809{
810 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
811}
812
813static inline int test_tsk_trace_graph(struct task_struct *tsk)
814{
815 return tsk->trace & TSK_TRACE_FL_GRAPH;
816}
817
Frederic Weisbeckercecbca92010-04-18 19:08:41 +0200818enum ftrace_dump_mode;
819
820extern enum ftrace_dump_mode ftrace_dump_on_oops;
Ingo Molnar526211b2009-03-05 10:28:45 +0100821
Steven Rostedt261842b2009-04-16 21:41:52 -0400822#ifdef CONFIG_PREEMPT
823#define INIT_TRACE_RECURSION .trace_recursion = 0,
824#endif
825
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500826#endif /* CONFIG_TRACING */
827
Steven Rostedt261842b2009-04-16 21:41:52 -0400828#ifndef INIT_TRACE_RECURSION
829#define INIT_TRACE_RECURSION
830#endif
Markus Metzgerb1818742009-01-19 10:31:01 +0100831
Mike Frysingere7b8e672010-01-26 04:40:03 -0500832#ifdef CONFIG_FTRACE_SYSCALLS
833
834unsigned long arch_syscall_addr(int nr);
835
836#endif /* CONFIG_FTRACE_SYSCALLS */
837
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200838#endif /* _LINUX_FTRACE_H */