blob: 66a36a815f0a410f34c462fee1ec2a887a8a91ac [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 */
Steven Rostedt (Red Hat)7544256a2014-06-25 13:26:59 -040036#if !ARCH_SUPPORTS_FTRACE_OPS
Steven Rostedtccf36722012-06-05 09:44:25 -040037# define FTRACE_FORCE_LIST_FUNC 1
38#else
39# define FTRACE_FORCE_LIST_FUNC 0
40#endif
41
Steven Rostedt (Red Hat)5f893b22014-12-12 20:05:10 -050042/* Main tracing buffer and events set up */
43#ifdef CONFIG_TRACING
44void trace_init(void);
45#else
46static inline void trace_init(void) { }
47#endif
Steven Rostedtccf36722012-06-05 09:44:25 -040048
Paul Gortmakerde477252011-05-26 13:46:22 -040049struct module;
Steven Rostedt04da85b2011-07-11 10:12:59 -040050struct ftrace_hash;
51
Steven Rostedt606576c2008-10-06 19:06:12 -040052#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnar3e1932a2008-10-02 17:45:47 +020053
Steven Rostedtb0fc4942008-05-12 21:20:43 +020054extern int ftrace_enabled;
55extern int
56ftrace_enable_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -070057 void __user *buffer, size_t *lenp,
Steven Rostedtb0fc4942008-05-12 21:20:43 +020058 loff_t *ppos);
59
Steven Rostedt2f5f6ad2011-08-08 16:57:47 -040060struct ftrace_ops;
61
62typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
Steven Rostedta1e2e312011-08-09 12:50:46 -040063 struct ftrace_ops *op, struct pt_regs *regs);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +020064
Steven Rostedt (Red Hat)87354052014-07-22 20:41:42 -040065ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
66
Jiri Olsae2484912012-02-15 15:51:48 +010067/*
68 * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are
69 * set in the flags member.
Masami Hiramatsuf8b8be82014-11-21 05:25:16 -050070 * CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION_SAFE, STUB and
71 * IPMODIFY are a kind of attribute flags which can be set only before
72 * registering the ftrace_ops, and can not be modified while registered.
73 * Changing those attribute flags after regsitering ftrace_ops will
74 * cause unexpected results.
Jiri Olsae2484912012-02-15 15:51:48 +010075 *
76 * ENABLED - set/unset when ftrace_ops is registered/unregistered
Jiri Olsae2484912012-02-15 15:51:48 +010077 * DYNAMIC - set when ftrace_ops is registered to denote dynamically
78 * allocated ftrace_ops which need special care
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -050079 * PER_CPU - set manualy by ftrace_ops user to denote the ftrace_ops
80 * could be controlled by following calls:
Jiri Olsae2484912012-02-15 15:51:48 +010081 * ftrace_function_local_enable
82 * ftrace_function_local_disable
Steven Rostedt08f6fba2012-04-30 16:20:23 -040083 * SAVE_REGS - The ftrace_ops wants regs saved at each function called
84 * and passed to the callback. If this flag is set, but the
85 * architecture does not support passing regs
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +090086 * (CONFIG_DYNAMIC_FTRACE_WITH_REGS is not defined), then the
Steven Rostedt08f6fba2012-04-30 16:20:23 -040087 * ftrace_ops will fail to register, unless the next flag
88 * is set.
89 * SAVE_REGS_IF_SUPPORTED - This is the same as SAVE_REGS, but if the
90 * handler can handle an arch that does not save regs
91 * (the handler tests if regs == NULL), then it can set
92 * this flag instead. It will not fail registering the ftrace_ops
93 * but, the regs field will be NULL if the arch does not support
94 * passing regs to the handler.
95 * Note, if this flag is set, the SAVE_REGS flag will automatically
96 * get set upon registering the ftrace_ops, if the arch supports it.
Steven Rostedt47409742012-07-20 11:04:44 -040097 * RECURSION_SAFE - The ftrace_ops can set this to tell the ftrace infrastructure
98 * that the call back has its own recursion protection. If it does
99 * not set this, then the ftrace infrastructure will add recursion
100 * protection for the caller.
Steven Rostedt (Red Hat)395b97a2013-03-27 09:31:28 -0400101 * STUB - The ftrace_ops is just a place holder.
Masami Hiramatsuf04f24fb2013-05-09 14:44:17 +0900102 * INITIALIZED - The ftrace_ops has already been initialized (first use time
103 * register_ftrace_function() is called, it will initialized the ops)
Steven Rostedt (Red Hat)591dffd2014-01-10 16:17:45 -0500104 * DELETED - The ops are being deleted, do not let them be registered again.
Steven Rostedt (Red Hat)e1effa02014-08-05 17:19:38 -0400105 * ADDING - The ops is in the process of being added.
106 * REMOVING - The ops is in the process of being removed.
107 * MODIFYING - The ops is in the process of changing its filter functions.
Steven Rostedt (Red Hat)f3bea492014-07-02 23:23:31 -0400108 * ALLOC_TRAMP - A dynamic trampoline was allocated by the core code.
109 * The arch specific code sets this flag when it allocated a
110 * trampoline. This lets the arch know that it can update the
111 * trampoline in case the callback function changes.
112 * The ftrace_ops trampoline can be set by the ftrace users, and
113 * in such cases the arch must not modify it. Only the arch ftrace
114 * core code should set this flag.
Masami Hiramatsuf8b8be82014-11-21 05:25:16 -0500115 * IPMODIFY - The ops can modify the IP register. This can only be set with
116 * SAVE_REGS. If another ops with this flag set is already registered
117 * for any of the functions that this ops will be registered for, then
118 * this ops will fail to register or set_filter_ip.
Steven Rostedt (Red Hat)e3eea142015-07-24 10:38:12 -0400119 * PID - Is affected by set_ftrace_pid (allows filtering on those pids)
Jiri Olsae2484912012-02-15 15:51:48 +0100120 */
Steven Rostedtb8489142011-05-04 09:27:52 -0400121enum {
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400122 FTRACE_OPS_FL_ENABLED = 1 << 0,
Steven Rostedt (Red Hat)4104d322014-01-10 17:01:58 -0500123 FTRACE_OPS_FL_DYNAMIC = 1 << 1,
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500124 FTRACE_OPS_FL_PER_CPU = 1 << 2,
Steven Rostedt (Red Hat)4104d322014-01-10 17:01:58 -0500125 FTRACE_OPS_FL_SAVE_REGS = 1 << 3,
126 FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 1 << 4,
127 FTRACE_OPS_FL_RECURSION_SAFE = 1 << 5,
128 FTRACE_OPS_FL_STUB = 1 << 6,
129 FTRACE_OPS_FL_INITIALIZED = 1 << 7,
130 FTRACE_OPS_FL_DELETED = 1 << 8,
Steven Rostedt (Red Hat)e1effa02014-08-05 17:19:38 -0400131 FTRACE_OPS_FL_ADDING = 1 << 9,
132 FTRACE_OPS_FL_REMOVING = 1 << 10,
133 FTRACE_OPS_FL_MODIFYING = 1 << 11,
Steven Rostedt (Red Hat)f3bea492014-07-02 23:23:31 -0400134 FTRACE_OPS_FL_ALLOC_TRAMP = 1 << 12,
Masami Hiramatsuf8b8be82014-11-21 05:25:16 -0500135 FTRACE_OPS_FL_IPMODIFY = 1 << 13,
Steven Rostedt (Red Hat)e3eea142015-07-24 10:38:12 -0400136 FTRACE_OPS_FL_PID = 1 << 14,
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500137 FTRACE_OPS_FL_RCU = 1 << 15,
Steven Rostedtb8489142011-05-04 09:27:52 -0400138};
139
Steven Rostedt (Red Hat)33b7f992014-08-15 17:23:02 -0400140#ifdef CONFIG_DYNAMIC_FTRACE
141/* The hash used to know what functions callbacks trace */
142struct ftrace_ops_hash {
143 struct ftrace_hash *notrace_hash;
144 struct ftrace_hash *filter_hash;
145 struct mutex regex_lock;
146};
147#endif
148
Steven Rostedt (Red Hat)b7e00a62013-11-07 09:36:25 -0500149/*
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500150 * Note, ftrace_ops can be referenced outside of RCU protection, unless
151 * the RCU flag is set. If ftrace_ops is allocated and not part of kernel
152 * core data, the unregistering of it will perform a scheduling on all CPUs
153 * to make sure that there are no more users. Depending on the load of the
154 * system that may take a bit of time.
Steven Rostedt (Red Hat)b7e00a62013-11-07 09:36:25 -0500155 *
156 * Any private data added must also take care not to be freed and if private
157 * data is added to a ftrace_ops that is in core code, the user of the
158 * ftrace_ops must perform a schedule_on_each_cpu() before freeing it.
159 */
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200160struct ftrace_ops {
Steven Rostedtf45948e2011-05-02 12:29:25 -0400161 ftrace_func_t func;
162 struct ftrace_ops *next;
Steven Rostedtb8489142011-05-04 09:27:52 -0400163 unsigned long flags;
Steven Rostedt (Red Hat)b7e00a62013-11-07 09:36:25 -0500164 void *private;
Steven Rostedt (Red Hat)e3eea142015-07-24 10:38:12 -0400165 ftrace_func_t saved_func;
Steven Rostedt (Red Hat)79922b82014-05-06 21:56:17 -0400166 int __percpu *disabled;
Steven Rostedtf45948e2011-05-02 12:29:25 -0400167#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt (Red Hat)33b7f992014-08-15 17:23:02 -0400168 struct ftrace_ops_hash local_hash;
169 struct ftrace_ops_hash *func_hash;
Steven Rostedt (Red Hat)fef5aee2014-07-24 12:25:47 -0400170 struct ftrace_ops_hash old_hash;
Steven Rostedt (Red Hat)79922b82014-05-06 21:56:17 -0400171 unsigned long trampoline;
Steven Rostedt (Red Hat)aec0be22014-11-18 21:14:11 -0500172 unsigned long trampoline_size;
Steven Rostedtf45948e2011-05-02 12:29:25 -0400173#endif
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200174};
175
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100176/*
177 * Type of the current tracing.
178 */
179enum ftrace_tracing_type_t {
180 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
181 FTRACE_TYPE_RETURN, /* Hook the return of the function */
182};
183
184/* Current tracing type, default is FTRACE_TYPE_ENTER */
185extern enum ftrace_tracing_type_t ftrace_tracing_type;
186
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200187/*
188 * The ftrace_ops must be a static and should also
189 * be read_mostly. These functions do modify read_mostly variables
190 * so use them sparely. Never free an ftrace_op or modify the
191 * next pointer after it has been registered. Even after unregistering
192 * it, the next pointer may still be used internally.
193 */
194int register_ftrace_function(struct ftrace_ops *ops);
195int unregister_ftrace_function(struct ftrace_ops *ops);
196void clear_ftrace_function(void);
197
Jiri Olsae2484912012-02-15 15:51:48 +0100198/**
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500199 * ftrace_function_local_enable - enable ftrace_ops on current cpu
Jiri Olsae2484912012-02-15 15:51:48 +0100200 *
201 * This function enables tracing on current cpu by decreasing
202 * the per cpu control variable.
203 * It must be called with preemption disabled and only on ftrace_ops
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500204 * registered with FTRACE_OPS_FL_PER_CPU. If called without preemption
Jiri Olsae2484912012-02-15 15:51:48 +0100205 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
206 */
207static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
208{
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500209 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_PER_CPU)))
Jiri Olsae2484912012-02-15 15:51:48 +0100210 return;
211
212 (*this_cpu_ptr(ops->disabled))--;
213}
214
215/**
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500216 * ftrace_function_local_disable - disable ftrace_ops on current cpu
Jiri Olsae2484912012-02-15 15:51:48 +0100217 *
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500218 * This function disables tracing on current cpu by increasing
Jiri Olsae2484912012-02-15 15:51:48 +0100219 * the per cpu control variable.
220 * It must be called with preemption disabled and only on ftrace_ops
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500221 * registered with FTRACE_OPS_FL_PER_CPU. If called without preemption
Jiri Olsae2484912012-02-15 15:51:48 +0100222 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
223 */
224static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
225{
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500226 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_PER_CPU)))
Jiri Olsae2484912012-02-15 15:51:48 +0100227 return;
228
229 (*this_cpu_ptr(ops->disabled))++;
230}
231
232/**
233 * ftrace_function_local_disabled - returns ftrace_ops disabled value
234 * on current cpu
235 *
236 * This function returns value of ftrace_ops::disabled on current cpu.
237 * It must be called with preemption disabled and only on ftrace_ops
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500238 * registered with FTRACE_OPS_FL_PER_CPU. If called without preemption
Jiri Olsae2484912012-02-15 15:51:48 +0100239 * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
240 */
241static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
242{
Steven Rostedt (Red Hat)ba27f2b2015-11-30 17:23:39 -0500243 WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_PER_CPU));
Jiri Olsae2484912012-02-15 15:51:48 +0100244 return *this_cpu_ptr(ops->disabled);
245}
246
Steven Rostedta1e2e312011-08-09 12:50:46 -0400247extern void ftrace_stub(unsigned long a0, unsigned long a1,
248 struct ftrace_ops *op, struct pt_regs *regs);
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200249
Steven Rostedt606576c2008-10-06 19:06:12 -0400250#else /* !CONFIG_FUNCTION_TRACER */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400251/*
252 * (un)register_ftrace_function must be a macro since the ops parameter
253 * must not be evaluated.
254 */
255#define register_ftrace_function(ops) ({ 0; })
256#define unregister_ftrace_function(ops) ({ 0; })
Steven Rostedtea701f12012-07-20 13:08:05 -0400257static inline int ftrace_nr_registered_ops(void)
258{
259 return 0;
260}
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400261static inline void clear_ftrace_function(void) { }
Steven Rostedt81adbdc2008-10-23 09:33:02 -0400262static inline void ftrace_kill(void) { }
Steven Rostedt606576c2008-10-06 19:06:12 -0400263#endif /* CONFIG_FUNCTION_TRACER */
Steven Rostedt352ad252008-05-12 21:20:42 +0200264
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500265#ifdef CONFIG_STACK_TRACER
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900266
267#define STACK_TRACE_ENTRIES 500
268
269struct stack_trace;
270
271extern unsigned stack_trace_index[];
272extern struct stack_trace stack_trace_max;
273extern unsigned long stack_trace_max_size;
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500274extern arch_spinlock_t stack_trace_max_lock;
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900275
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500276extern int stack_tracer_enabled;
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900277void stack_trace_print(void);
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500278int
279stack_trace_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700280 void __user *buffer, size_t *lenp,
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500281 loff_t *ppos);
282#endif
283
Steven Rostedtf6180772009-02-14 00:40:25 -0500284struct ftrace_func_command {
285 struct list_head list;
286 char *name;
Steven Rostedt43dd61c2011-07-07 11:09:22 -0400287 int (*func)(struct ftrace_hash *hash,
288 char *func, char *cmd,
Steven Rostedtf6180772009-02-14 00:40:25 -0500289 char *params, int enable);
290};
291
Steven Rostedt3d083392008-05-12 21:20:42 +0200292#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt31e88902008-11-14 16:21:19 -0800293
Steven Rostedt000ab692009-02-17 13:35:06 -0500294int ftrace_arch_code_modify_prepare(void);
295int ftrace_arch_code_modify_post_process(void);
296
Steven Rostedt (Red Hat)4fd32792014-10-24 17:56:04 -0400297struct dyn_ftrace;
298
Steven Rostedt (Red Hat)02a392a2015-11-25 12:50:47 -0500299enum ftrace_bug_type {
300 FTRACE_BUG_UNKNOWN,
301 FTRACE_BUG_INIT,
302 FTRACE_BUG_NOP,
303 FTRACE_BUG_CALL,
304 FTRACE_BUG_UPDATE,
305};
306extern enum ftrace_bug_type ftrace_bug_type;
307
Steven Rostedt (Red Hat)b05086c2015-11-25 14:13:11 -0500308/*
309 * Archs can set this to point to a variable that holds the value that was
310 * expected at the call site before calling ftrace_bug().
311 */
312extern const void *ftrace_expected;
313
Steven Rostedt (Red Hat)4fd32792014-10-24 17:56:04 -0400314void ftrace_bug(int err, struct dyn_ftrace *rec);
Steven Rostedtc88fd862011-08-16 09:53:39 -0400315
Steven Rostedt809dcf22009-02-16 23:06:01 -0500316struct seq_file;
317
Steven Rostedtb6887d72009-02-17 12:32:04 -0500318struct ftrace_probe_ops {
Steven Rostedt59df055f2009-02-14 15:29:06 -0500319 void (*func)(unsigned long ip,
320 unsigned long parent_ip,
321 void **data);
Steven Rostedt (Red Hat)e67efb92013-03-12 15:07:59 -0400322 int (*init)(struct ftrace_probe_ops *ops,
323 unsigned long ip, void **data);
324 void (*free)(struct ftrace_probe_ops *ops,
325 unsigned long ip, void **data);
Steven Rostedt809dcf22009-02-16 23:06:01 -0500326 int (*print)(struct seq_file *m,
327 unsigned long ip,
Steven Rostedtb6887d72009-02-17 12:32:04 -0500328 struct ftrace_probe_ops *ops,
Steven Rostedt809dcf22009-02-16 23:06:01 -0500329 void *data);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500330};
331
332extern int
Steven Rostedtb6887d72009-02-17 12:32:04 -0500333register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500334 void *data);
335extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500336unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
Steven Rostedt59df055f2009-02-14 15:29:06 -0500337 void *data);
338extern void
Steven Rostedtb6887d72009-02-17 12:32:04 -0500339unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
340extern void unregister_ftrace_function_probe_all(char *glob);
Steven Rostedt59df055f2009-02-14 15:29:06 -0500341
Sasha Levind88471c2013-01-09 18:09:20 -0500342extern int ftrace_text_reserved(const void *start, const void *end);
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500343
Steven Rostedtea701f12012-07-20 13:08:05 -0400344extern int ftrace_nr_registered_ops(void);
345
Steven Rostedt (Red Hat)aec0be22014-11-18 21:14:11 -0500346bool is_ftrace_trampoline(unsigned long addr);
347
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400348/*
349 * The dyn_ftrace record's flags field is split into two parts.
350 * the first part which is '0-FTRACE_REF_MAX' is a counter of
351 * the number of callbacks that have registered the function that
352 * the dyn_ftrace descriptor represents.
353 *
354 * The second part is a mask:
355 * ENABLED - the function is being traced
356 * REGS - the record wants the function to save regs
357 * REGS_EN - the function is set up to save regs.
Masami Hiramatsuf8b8be82014-11-21 05:25:16 -0500358 * IPMODIFY - the record allows for the IP address to be changed.
Steven Rostedt (Red Hat)b7ffffb2016-01-07 15:40:01 -0500359 * DISABLED - the record is not ready to be touched yet
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400360 *
361 * When a new ftrace_ops is registered and wants a function to save
362 * pt_regs, the rec->flag REGS is set. When the function has been
363 * set up to save regs, the REG_EN flag is set. Once a function
364 * starts saving regs it will do so until all ftrace_ops are removed
365 * from tracing that function.
366 */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200367enum {
Steven Rostedt (Red Hat)79922b82014-05-06 21:56:17 -0400368 FTRACE_FL_ENABLED = (1UL << 31),
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400369 FTRACE_FL_REGS = (1UL << 30),
Steven Rostedt (Red Hat)79922b82014-05-06 21:56:17 -0400370 FTRACE_FL_REGS_EN = (1UL << 29),
371 FTRACE_FL_TRAMP = (1UL << 28),
372 FTRACE_FL_TRAMP_EN = (1UL << 27),
Masami Hiramatsuf8b8be82014-11-21 05:25:16 -0500373 FTRACE_FL_IPMODIFY = (1UL << 26),
Steven Rostedt (Red Hat)b7ffffb2016-01-07 15:40:01 -0500374 FTRACE_FL_DISABLED = (1UL << 25),
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200375};
376
Steven Rostedt (Red Hat)b7ffffb2016-01-07 15:40:01 -0500377#define FTRACE_REF_MAX_SHIFT 25
378#define FTRACE_FL_BITS 7
Steven Rostedt (Red Hat)cf2cb0b2014-05-07 12:42:28 -0400379#define FTRACE_FL_MASKED_BITS ((1UL << FTRACE_FL_BITS) - 1)
380#define FTRACE_FL_MASK (FTRACE_FL_MASKED_BITS << FTRACE_REF_MAX_SHIFT)
381#define FTRACE_REF_MAX ((1UL << FTRACE_REF_MAX_SHIFT) - 1)
Steven Rostedted926f92011-05-03 13:25:24 -0400382
Steven Rostedt (Red Hat)0376bde2014-05-07 13:46:45 -0400383#define ftrace_rec_count(rec) ((rec)->flags & ~FTRACE_FL_MASK)
384
Steven Rostedt3d083392008-05-12 21:20:42 +0200385struct dyn_ftrace {
Jiri Slabya7627822014-02-24 20:00:00 +0100386 unsigned long ip; /* address of mcount call-site */
Steven Rostedt85ae32a2011-12-16 16:30:31 -0500387 unsigned long flags;
Jiri Slabya7627822014-02-24 20:00:00 +0100388 struct dyn_arch_ftrace arch;
Steven Rostedt3d083392008-05-12 21:20:42 +0200389};
390
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200391int ftrace_force_update(void);
Masami Hiramatsu647664e2012-06-05 19:28:08 +0900392int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
393 int remove, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100394int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400395 int len, int reset);
Jiri Olsaac483c42012-01-02 10:04:14 +0100396int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
Steven Rostedt936e0742011-05-05 22:54:01 -0400397 int len, int reset);
398void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
399void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
Jiri Olsa5500fa52012-02-15 15:51:54 +0100400void ftrace_free_filter(struct ftrace_ops *ops);
Steven Rostedte1c08bd2008-05-12 21:20:44 +0200401
Steven Rostedtf6180772009-02-14 00:40:25 -0500402int register_ftrace_command(struct ftrace_func_command *cmd);
403int unregister_ftrace_command(struct ftrace_func_command *cmd);
404
Steven Rostedtc88fd862011-08-16 09:53:39 -0400405enum {
406 FTRACE_UPDATE_CALLS = (1 << 0),
407 FTRACE_DISABLE_CALLS = (1 << 1),
408 FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
409 FTRACE_START_FUNC_RET = (1 << 3),
410 FTRACE_STOP_FUNC_RET = (1 << 4),
411};
412
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400413/*
414 * The FTRACE_UPDATE_* enum is used to pass information back
415 * from the ftrace_update_record() and ftrace_test_record()
416 * functions. These are called by the code update routines
417 * to find out what is to be done for a given function.
418 *
419 * IGNORE - The function is already what we want it to be
420 * MAKE_CALL - Start tracing the function
421 * MODIFY_CALL - Stop saving regs for the function
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400422 * MAKE_NOP - Stop tracing the function
423 */
Steven Rostedtc88fd862011-08-16 09:53:39 -0400424enum {
425 FTRACE_UPDATE_IGNORE,
426 FTRACE_UPDATE_MAKE_CALL,
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400427 FTRACE_UPDATE_MODIFY_CALL,
Steven Rostedtc88fd862011-08-16 09:53:39 -0400428 FTRACE_UPDATE_MAKE_NOP,
429};
430
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500431enum {
432 FTRACE_ITER_FILTER = (1 << 0),
433 FTRACE_ITER_NOTRACE = (1 << 1),
434 FTRACE_ITER_PRINTALL = (1 << 2),
Steven Rostedt69a30832011-12-19 15:21:16 -0500435 FTRACE_ITER_DO_HASH = (1 << 3),
436 FTRACE_ITER_HASH = (1 << 4),
437 FTRACE_ITER_ENABLED = (1 << 5),
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500438};
439
Steven Rostedtc88fd862011-08-16 09:53:39 -0400440void arch_ftrace_update_code(int command);
441
442struct ftrace_rec_iter;
443
444struct ftrace_rec_iter *ftrace_rec_iter_start(void);
445struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
446struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
447
Steven Rostedt08d636b2011-08-16 09:57:10 -0400448#define for_ftrace_rec_iter(iter) \
449 for (iter = ftrace_rec_iter_start(); \
450 iter; \
451 iter = ftrace_rec_iter_next(iter))
452
453
Steven Rostedtc88fd862011-08-16 09:53:39 -0400454int ftrace_update_record(struct dyn_ftrace *rec, int enable);
455int ftrace_test_record(struct dyn_ftrace *rec, int enable);
456void ftrace_run_stop_machine(int command);
Steven Rostedtf0cf9732012-04-25 14:39:54 -0400457unsigned long ftrace_location(unsigned long ip);
Michael Ellerman04cf31a2016-03-24 22:04:01 +1100458unsigned long ftrace_location_range(unsigned long start, unsigned long end);
Steven Rostedt (Red Hat)7413af12014-05-06 21:34:14 -0400459unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec);
460unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec);
Steven Rostedtc88fd862011-08-16 09:53:39 -0400461
462extern ftrace_func_t ftrace_trace_function;
463
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500464int ftrace_regex_open(struct ftrace_ops *ops, int flag,
465 struct inode *inode, struct file *file);
466ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
467 size_t cnt, loff_t *ppos);
468ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
469 size_t cnt, loff_t *ppos);
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500470int ftrace_regex_release(struct inode *inode, struct file *file);
471
Steven Rostedt2a85a372011-12-19 21:57:44 -0500472void __init
473ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
474
Steven Rostedt3d083392008-05-12 21:20:42 +0200475/* defined in arch */
Steven Rostedt3c1720f2008-05-12 21:20:43 +0200476extern int ftrace_ip_converted(unsigned long ip);
Jiri Slaby3a36cb12014-02-24 19:59:59 +0100477extern int ftrace_dyn_arch_init(void);
Steven Rostedte4f5d542012-04-27 09:13:18 -0400478extern void ftrace_replace_code(int enable);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200479extern int ftrace_update_ftrace_func(ftrace_func_t func);
480extern void ftrace_caller(void);
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400481extern void ftrace_regs_caller(void);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200482extern void ftrace_call(void);
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400483extern void ftrace_regs_call(void);
Steven Rostedtd61f82d2008-05-12 21:20:43 +0200484extern void mcount_call(void);
Shaohua Lif0001202009-01-09 11:29:42 +0800485
Steven Rostedt8ed3e2c2012-04-26 14:59:43 -0400486void ftrace_modify_all_code(int command);
487
Shaohua Lif0001202009-01-09 11:29:42 +0800488#ifndef FTRACE_ADDR
489#define FTRACE_ADDR ((unsigned long)ftrace_caller)
490#endif
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400491
Steven Rostedt (Red Hat)79922b82014-05-06 21:56:17 -0400492#ifndef FTRACE_GRAPH_ADDR
493#define FTRACE_GRAPH_ADDR ((unsigned long)ftrace_graph_caller)
494#endif
495
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400496#ifndef FTRACE_REGS_ADDR
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +0900497#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400498# define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller)
499#else
500# define FTRACE_REGS_ADDR FTRACE_ADDR
501#endif
502#endif
503
Steven Rostedt (Red Hat)646d7042014-07-11 14:39:10 -0400504/*
505 * If an arch would like functions that are only traced
506 * by the function graph tracer to jump directly to its own
507 * trampoline, then they can define FTRACE_GRAPH_TRAMP_ADDR
508 * to be that address to jump to.
509 */
510#ifndef FTRACE_GRAPH_TRAMP_ADDR
511#define FTRACE_GRAPH_TRAMP_ADDR ((unsigned long) 0)
512#endif
513
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100514#ifdef CONFIG_FUNCTION_GRAPH_TRACER
515extern void ftrace_graph_caller(void);
Steven Rostedt5a45cfe2008-11-26 00:16:24 -0500516extern int ftrace_enable_ftrace_graph_caller(void);
517extern int ftrace_disable_ftrace_graph_caller(void);
518#else
519static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
520static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
Frederic Weisbeckere7d37372008-11-16 06:02:06 +0100521#endif
Steven Rostedtad90c0e2008-05-27 20:48:37 -0400522
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400523/**
Wenji Huang57794a92009-02-06 17:33:27 +0800524 * ftrace_make_nop - convert code into nop
Steven Rostedt31e88902008-11-14 16:21:19 -0800525 * @mod: module structure if called by module load initialization
526 * @rec: the mcount call site record
527 * @addr: the address that the call site should be calling
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400528 *
529 * This is a very sensitive operation and great care needs
530 * to be taken by the arch. The operation should carefully
531 * read the location, check to see if what is read is indeed
532 * what we expect it to be, and then on success of the compare,
533 * it should write to the location.
534 *
Steven Rostedt31e88902008-11-14 16:21:19 -0800535 * The code segment at @rec->ip should be a caller to @addr
536 *
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400537 * Return must be:
538 * 0 on success
539 * -EFAULT on error reading the location
540 * -EINVAL on a failed compare of the contents
541 * -EPERM on error writing to the location
542 * Any other value will be considered a failure.
543 */
Steven Rostedt31e88902008-11-14 16:21:19 -0800544extern int ftrace_make_nop(struct module *mod,
545 struct dyn_ftrace *rec, unsigned long addr);
546
547/**
548 * ftrace_make_call - convert a nop call site into a call to addr
549 * @rec: the mcount call site record
550 * @addr: the address that the call site should call
551 *
552 * This is a very sensitive operation and great care needs
553 * to be taken by the arch. The operation should carefully
554 * read the location, check to see if what is read is indeed
555 * what we expect it to be, and then on success of the compare,
556 * it should write to the location.
557 *
558 * The code segment at @rec->ip should be a nop
559 *
560 * Return must be:
561 * 0 on success
562 * -EFAULT on error reading the location
563 * -EINVAL on a failed compare of the contents
564 * -EPERM on error writing to the location
565 * Any other value will be considered a failure.
566 */
567extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
568
Masami Hiramatsu06aeaae2012-09-28 17:15:17 +0900569#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
Steven Rostedt08f6fba2012-04-30 16:20:23 -0400570/**
571 * ftrace_modify_call - convert from one addr to another (no nop)
572 * @rec: the mcount call site record
573 * @old_addr: the address expected to be currently called to
574 * @addr: the address to change to
575 *
576 * This is a very sensitive operation and great care needs
577 * to be taken by the arch. The operation should carefully
578 * read the location, check to see if what is read is indeed
579 * what we expect it to be, and then on success of the compare,
580 * it should write to the location.
581 *
582 * The code segment at @rec->ip should be a caller to @old_addr
583 *
584 * Return must be:
585 * 0 on success
586 * -EFAULT on error reading the location
587 * -EINVAL on a failed compare of the contents
588 * -EPERM on error writing to the location
589 * Any other value will be considered a failure.
590 */
591extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
592 unsigned long addr);
593#else
594/* Should never be called */
595static inline int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
596 unsigned long addr)
597{
598 return -EINVAL;
599}
600#endif
601
Steven Rostedt31e88902008-11-14 16:21:19 -0800602/* May be defined in arch */
603extern int ftrace_arch_read_dyn_info(char *buf, int size);
Steven Rostedt593eb8a2008-10-23 09:32:59 -0400604
Abhishek Sagarecea6562008-06-21 23:47:53 +0530605extern int skip_trace(unsigned long ip);
Steven Rostedt (Red Hat)a949ae52014-04-24 10:40:12 -0400606extern void ftrace_module_init(struct module *mod);
Jessica Yu7dcd1822016-02-16 17:32:33 -0500607extern void ftrace_module_enable(struct module *mod);
Steven Rostedt (Red Hat)049fb9b2016-01-05 20:32:47 -0500608extern void ftrace_release_mod(struct module *mod);
Abhishek Sagarecea6562008-06-21 23:47:53 +0530609
Steven Rostedtc0719e52008-09-06 01:06:03 -0400610extern void ftrace_disable_daemon(void);
611extern void ftrace_enable_daemon(void);
Steven Rostedt4dc93672012-06-06 13:45:31 -0400612#else /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400613static inline int skip_trace(unsigned long ip) { return 0; }
614static inline int ftrace_force_update(void) { return 0; }
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400615static inline void ftrace_disable_daemon(void) { }
616static inline void ftrace_enable_daemon(void) { }
Jessica Yu7dcd1822016-02-16 17:32:33 -0500617static inline void ftrace_module_init(struct module *mod) { }
618static inline void ftrace_module_enable(struct module *mod) { }
619static inline void ftrace_release_mod(struct module *mod) { }
Tom Zanussi38de93a2013-10-24 08:34:18 -0500620static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
Steven Rostedtf6180772009-02-14 00:40:25 -0500621{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100622 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500623}
Tom Zanussi38de93a2013-10-24 08:34:18 -0500624static inline __init int unregister_ftrace_command(char *cmd_name)
Steven Rostedtf6180772009-02-14 00:40:25 -0500625{
Ingo Molnar97d0bb82009-02-17 11:47:39 +0100626 return -EINVAL;
Steven Rostedtf6180772009-02-14 00:40:25 -0500627}
Sasha Levind88471c2013-01-09 18:09:20 -0500628static inline int ftrace_text_reserved(const void *start, const void *end)
Masami Hiramatsu2cfa1972010-02-02 16:49:11 -0500629{
630 return 0;
631}
Steven Rostedt4dc93672012-06-06 13:45:31 -0400632static inline unsigned long ftrace_location(unsigned long ip)
633{
634 return 0;
635}
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500636
637/*
638 * Again users of functions that have ftrace_ops may not
639 * have them defined when ftrace is not enabled, but these
640 * functions may still be called. Use a macro instead of inline.
641 */
642#define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; })
Steven Rostedt96de37b2012-01-07 17:26:49 -0500643#define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
Masami Hiramatsu647664e2012-06-05 19:28:08 +0900644#define ftrace_set_filter_ip(ops, ip, remove, reset) ({ -ENODEV; })
Jiri Olsa5500fa52012-02-15 15:51:54 +0100645#define ftrace_set_filter(ops, buf, len, reset) ({ -ENODEV; })
646#define ftrace_set_notrace(ops, buf, len, reset) ({ -ENODEV; })
647#define ftrace_free_filter(ops) do { } while (0)
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500648
649static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
650 size_t cnt, loff_t *ppos) { return -ENODEV; }
651static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
652 size_t cnt, loff_t *ppos) { return -ENODEV; }
Steven Rostedtfc13cb02011-12-19 14:41:25 -0500653static inline int
654ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
Steven Rostedt (Red Hat)aec0be22014-11-18 21:14:11 -0500655
656static inline bool is_ftrace_trampoline(unsigned long addr)
657{
658 return false;
659}
Abhishek Sagarecea6562008-06-21 23:47:53 +0530660#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedt352ad252008-05-12 21:20:42 +0200661
Ingo Molnaraeaee8a2008-05-12 21:20:49 +0200662/* totally disable ftrace - can not re-enable after this */
663void ftrace_kill(void);
664
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200665static inline void tracer_disable(void)
666{
Steven Rostedt606576c2008-10-06 19:06:12 -0400667#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnarf43fdad2008-05-12 21:20:43 +0200668 ftrace_enabled = 0;
669#endif
670}
671
Huang Ying37002732008-08-18 16:24:56 +0800672/*
673 * Ftrace disable/restore without lock. Some synchronization mechanism
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700674 * must be used to prevent ftrace_enabled to be changed between
Huang Ying37002732008-08-18 16:24:56 +0800675 * disable/restore.
676 */
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700677static inline int __ftrace_enabled_save(void)
678{
Steven Rostedt606576c2008-10-06 19:06:12 -0400679#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700680 int saved_ftrace_enabled = ftrace_enabled;
681 ftrace_enabled = 0;
682 return saved_ftrace_enabled;
683#else
684 return 0;
685#endif
686}
687
688static inline void __ftrace_enabled_restore(int enabled)
689{
Steven Rostedt606576c2008-10-06 19:06:12 -0400690#ifdef CONFIG_FUNCTION_TRACER
Huang Ying9bdeb7b2008-08-15 00:40:25 -0700691 ftrace_enabled = enabled;
692#endif
693}
694
AKASHI Takahiroeed542d2014-05-20 20:31:04 +0900695/* All archs should have this, but we define it for consistency */
696#ifndef ftrace_return_address0
697# define ftrace_return_address0 __builtin_return_address(0)
698#endif
699
700/* Archs may use other ways for ADDR1 and beyond */
701#ifndef ftrace_return_address
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100702# ifdef CONFIG_FRAME_POINTER
AKASHI Takahiroeed542d2014-05-20 20:31:04 +0900703# define ftrace_return_address(n) __builtin_return_address(n)
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100704# else
AKASHI Takahiroeed542d2014-05-20 20:31:04 +0900705# define ftrace_return_address(n) 0UL
Uwe Kleine-Koenigc79a61f2009-02-27 21:30:03 +0100706# endif
AKASHI Takahiroeed542d2014-05-20 20:31:04 +0900707#endif
708
709#define CALLER_ADDR0 ((unsigned long)ftrace_return_address0)
710#define CALLER_ADDR1 ((unsigned long)ftrace_return_address(1))
711#define CALLER_ADDR2 ((unsigned long)ftrace_return_address(2))
712#define CALLER_ADDR3 ((unsigned long)ftrace_return_address(3))
713#define CALLER_ADDR4 ((unsigned long)ftrace_return_address(4))
714#define CALLER_ADDR5 ((unsigned long)ftrace_return_address(5))
715#define CALLER_ADDR6 ((unsigned long)ftrace_return_address(6))
Steven Rostedt352ad252008-05-12 21:20:42 +0200716
Sebastian Andrzej Siewiorf904f582016-02-26 14:54:56 +0100717static inline unsigned long get_lock_parent_ip(void)
718{
719 unsigned long addr = CALLER_ADDR0;
720
721 if (!in_lock_functions(addr))
722 return addr;
723 addr = CALLER_ADDR1;
724 if (!in_lock_functions(addr))
725 return addr;
726 return CALLER_ADDR2;
727}
728
Steven Rostedt81d68a92008-05-12 21:20:42 +0200729#ifdef CONFIG_IRQSOFF_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100730 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
731 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
Steven Rostedt81d68a92008-05-12 21:20:42 +0200732#else
Steven Rostedt4dbf6bc2010-05-04 11:24:01 -0400733 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
734 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
Steven Rostedt81d68a92008-05-12 21:20:42 +0200735#endif
736
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200737#ifdef CONFIG_PREEMPT_TRACER
Ingo Molnar489f1392008-02-25 13:38:05 +0100738 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
739 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200740#else
Minho Banb02ee9a2012-05-07 11:36:00 +0900741/*
742 * Use defines instead of static inlines because some arches will make code out
743 * of the CALLER_ADDR, when we really want these to be a real nop.
744 */
745# define trace_preempt_on(a0, a1) do { } while (0)
746# define trace_preempt_off(a0, a1) do { } while (0)
Steven Rostedt6cd8a4b2008-05-12 21:20:42 +0200747#endif
748
Steven Rostedt68bf21a2008-08-14 15:45:08 -0400749#ifdef CONFIG_FTRACE_MCOUNT_RECORD
750extern void ftrace_init(void);
751#else
752static inline void ftrace_init(void) { }
753#endif
754
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100755/*
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100756 * Structure that defines an entry function trace.
757 */
758struct ftrace_graph_ent {
759 unsigned long func; /* Current function */
760 int depth;
761};
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400762
Frederic Weisbecker71566a02008-10-31 12:57:20 +0100763/*
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100764 * Structure that defines a return function trace.
765 */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100766struct ftrace_graph_ret {
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100767 unsigned long func; /* Current function */
768 unsigned long long calltime;
769 unsigned long long rettime;
Frederic Weisbecker02310222008-11-17 03:22:41 +0100770 /* Number of functions that overran the depth limit for current task */
771 unsigned long overrun;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100772 int depth;
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100773};
774
Jiri Olsa62b915f2010-04-02 19:01:22 +0200775/* Type of the callback handlers for tracing function graph*/
776typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
777typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
778
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100779#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100780
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400781/* for init task */
Tetsuo Handaf876d342009-04-08 14:05:43 +0900782#define INIT_FTRACE_GRAPH .ret_stack = NULL,
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400783
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100784/*
Steven Rostedt712406a2009-02-09 10:54:03 -0800785 * Stack of return addresses for functions
786 * of a thread.
787 * Used in struct thread_info
788 */
789struct ftrace_ret_stack {
790 unsigned long ret;
791 unsigned long func;
792 unsigned long long calltime;
Steven Rostedta2a16d62009-03-24 23:17:58 -0400793 unsigned long long subtime;
Steven Rostedt71e308a2009-06-18 12:45:08 -0400794 unsigned long fp;
Steven Rostedt712406a2009-02-09 10:54:03 -0800795};
796
797/*
798 * Primary handler of a function return.
799 * It relays on ftrace_return_to_handler.
800 * Defined in entry_32/64.S
801 */
802extern void return_to_handler(void);
803
804extern int
Steven Rostedt71e308a2009-06-18 12:45:08 -0400805ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
806 unsigned long frame_pointer);
Steven Rostedt712406a2009-02-09 10:54:03 -0800807
808/*
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100809 * Sometimes we don't want to trace a function with the function
810 * graph tracer but we want them to keep traced by the usual function
811 * tracer if the function graph tracer is not configured.
812 */
813#define __notrace_funcgraph notrace
814
Namhyung Kim29ad23b2013-10-14 17:24:26 +0900815#define FTRACE_NOTRACE_DEPTH 65536
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100816#define FTRACE_RETFUNC_DEPTH 50
817#define FTRACE_RETSTACK_ALLOC_SIZE 32
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100818extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
819 trace_func_graph_ent_t entryfunc);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100820
Steven Rostedt (Red Hat)1b2f1212014-06-25 10:39:46 -0400821extern bool ftrace_graph_is_dead(void);
Steven Rostedt14a866c2008-12-02 23:50:02 -0500822extern void ftrace_graph_stop(void);
823
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100824/* The current handlers in use */
825extern trace_func_graph_ret_t ftrace_graph_return;
826extern trace_func_graph_ent_t ftrace_graph_entry;
827
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100828extern void unregister_ftrace_graph(void);
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +0100829
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100830extern void ftrace_graph_init_task(struct task_struct *t);
831extern void ftrace_graph_exit_task(struct task_struct *t);
Steven Rostedt868baf02011-02-10 21:26:13 -0500832extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100833
834static inline int task_curr_ret_stack(struct task_struct *t)
835{
836 return t->curr_ret_stack;
837}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100838
839static inline void pause_graph_tracing(void)
840{
841 atomic_inc(&current->tracing_graph_pause);
842}
843
844static inline void unpause_graph_tracing(void)
845{
846 atomic_dec(&current->tracing_graph_pause);
847}
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400848#else /* !CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100849
850#define __notrace_funcgraph
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400851#define INIT_FTRACE_GRAPH
Frederic Weisbecker8b96f012008-12-06 03:40:00 +0100852
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100853static inline void ftrace_graph_init_task(struct task_struct *t) { }
854static inline void ftrace_graph_exit_task(struct task_struct *t) { }
Steven Rostedt868baf02011-02-10 21:26:13 -0500855static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100856
Jiri Olsa62b915f2010-04-02 19:01:22 +0200857static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
858 trace_func_graph_ent_t entryfunc)
859{
860 return -1;
861}
862static inline void unregister_ftrace_graph(void) { }
863
Frederic Weisbecker21a8c462008-12-04 23:51:23 +0100864static inline int task_curr_ret_stack(struct task_struct *tsk)
865{
866 return -1;
867}
Frederic Weisbecker380c4b12008-12-06 03:43:41 +0100868
869static inline void pause_graph_tracing(void) { }
870static inline void unpause_graph_tracing(void) { }
Steven Rostedt5ac9f622009-03-25 20:55:00 -0400871#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbeckercaf4b322008-11-11 07:03:45 +0100872
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500873#ifdef CONFIG_TRACING
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500874
875/* flags for current->trace */
876enum {
877 TSK_TRACE_FL_TRACE_BIT = 0,
878 TSK_TRACE_FL_GRAPH_BIT = 1,
879};
880enum {
881 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
882 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
883};
884
885static inline void set_tsk_trace_trace(struct task_struct *tsk)
886{
887 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
888}
889
890static inline void clear_tsk_trace_trace(struct task_struct *tsk)
891{
892 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
893}
894
895static inline int test_tsk_trace_trace(struct task_struct *tsk)
896{
897 return tsk->trace & TSK_TRACE_FL_TRACE;
898}
899
900static inline void set_tsk_trace_graph(struct task_struct *tsk)
901{
902 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
903}
904
905static inline void clear_tsk_trace_graph(struct task_struct *tsk)
906{
907 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
908}
909
910static inline int test_tsk_trace_graph(struct task_struct *tsk)
911{
912 return tsk->trace & TSK_TRACE_FL_GRAPH;
913}
914
Frederic Weisbeckercecbca92010-04-18 19:08:41 +0200915enum ftrace_dump_mode;
916
917extern enum ftrace_dump_mode ftrace_dump_on_oops;
Steven Rostedt (Red Hat)0daa23022014-12-12 22:27:10 -0500918extern int tracepoint_printk;
Ingo Molnar526211b2009-03-05 10:28:45 +0100919
Steven Rostedt (Red Hat)de7edd32013-06-14 16:21:43 -0400920extern void disable_trace_on_warning(void);
921extern int __disable_trace_on_warning;
922
Steven Rostedt261842b2009-04-16 21:41:52 -0400923#ifdef CONFIG_PREEMPT
924#define INIT_TRACE_RECURSION .trace_recursion = 0,
925#endif
926
Steven Rostedt (Red Hat)de7edd32013-06-14 16:21:43 -0400927#else /* CONFIG_TRACING */
928static inline void disable_trace_on_warning(void) { }
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500929#endif /* CONFIG_TRACING */
930
Steven Rostedt261842b2009-04-16 21:41:52 -0400931#ifndef INIT_TRACE_RECURSION
932#define INIT_TRACE_RECURSION
933#endif
Markus Metzgerb1818742009-01-19 10:31:01 +0100934
Mike Frysingere7b8e672010-01-26 04:40:03 -0500935#ifdef CONFIG_FTRACE_SYSCALLS
936
937unsigned long arch_syscall_addr(int nr);
938
939#endif /* CONFIG_FTRACE_SYSCALLS */
940
Arnaldo Carvalho de Melo16444a82008-05-12 21:20:42 +0200941#endif /* _LINUX_FTRACE_H */