Branch data Line data Source code
1 : : /*
2 : : * Ftrace header. For implementation details beyond the random comments
3 : : * scattered below, see: Documentation/trace/ftrace-design.txt
4 : : */
5 : :
6 : : #ifndef _LINUX_FTRACE_H
7 : : #define _LINUX_FTRACE_H
8 : :
9 : : #include <linux/trace_clock.h>
10 : : #include <linux/kallsyms.h>
11 : : #include <linux/linkage.h>
12 : : #include <linux/bitops.h>
13 : : #include <linux/ptrace.h>
14 : : #include <linux/ktime.h>
15 : : #include <linux/sched.h>
16 : : #include <linux/types.h>
17 : : #include <linux/init.h>
18 : : #include <linux/fs.h>
19 : :
20 : : #include <asm/ftrace.h>
21 : :
22 : : /*
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 : :
31 : : /*
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 : :
44 : : struct module;
45 : : struct ftrace_hash;
46 : :
47 : : #ifdef CONFIG_FUNCTION_TRACER
48 : :
49 : : extern int ftrace_enabled;
50 : : extern int
51 : : ftrace_enable_sysctl(struct ctl_table *table, int write,
52 : : void __user *buffer, size_t *lenp,
53 : : loff_t *ppos);
54 : :
55 : : struct ftrace_ops;
56 : :
57 : : typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
58 : : struct ftrace_ops *op, struct pt_regs *regs);
59 : :
60 : : /*
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
74 : : * 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
77 : : * (CONFIG_DYNAMIC_FTRACE_WITH_REGS is not defined), then the
78 : : * 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.
88 : : * 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.
92 : : * STUB - The ftrace_ops is just a place holder.
93 : : * INITIALIZED - The ftrace_ops has already been initialized (first use time
94 : : * register_ftrace_function() is called, it will initialized the ops)
95 : : */
96 : : enum {
97 : : 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,
103 : : FTRACE_OPS_FL_RECURSION_SAFE = 1 << 6,
104 : : FTRACE_OPS_FL_STUB = 1 << 7,
105 : : FTRACE_OPS_FL_INITIALIZED = 1 << 8,
106 : : };
107 : :
108 : : struct ftrace_ops {
109 : : ftrace_func_t func;
110 : : struct ftrace_ops *next;
111 : : unsigned long flags;
112 : : int __percpu *disabled;
113 : : #ifdef CONFIG_DYNAMIC_FTRACE
114 : : struct ftrace_hash *notrace_hash;
115 : : struct ftrace_hash *filter_hash;
116 : : struct mutex regex_lock;
117 : : #endif
118 : : };
119 : :
120 : : extern int function_trace_stop;
121 : :
122 : : /*
123 : : * Type of the current tracing.
124 : : */
125 : : enum 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 */
131 : : extern enum ftrace_tracing_type_t ftrace_tracing_type;
132 : :
133 : : /**
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 : : */
141 : : static inline void ftrace_stop(void)
142 : : {
143 : 0 : 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 : : */
154 : : static inline void ftrace_start(void)
155 : : {
156 : 0 : function_trace_stop = 0;
157 : : }
158 : :
159 : : /*
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 : : */
166 : : int register_ftrace_function(struct ftrace_ops *ops);
167 : : int unregister_ftrace_function(struct ftrace_ops *ops);
168 : : void clear_ftrace_function(void);
169 : :
170 : : /**
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 : : */
179 : : static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
180 : : {
181 [ # # ][ # # ]: 0 : if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
[ # # ][ # # ]
182 : : return;
183 : :
184 : 0 : (*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 : : */
196 : : static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
197 : : {
198 [ # # ][ # # ]: 0 : if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
[ # # ][ # # ]
199 : : return;
200 : :
201 : 0 : (*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 : : */
213 : : static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
214 : : {
215 [ # # ][ # # ]: 0 : WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL));
[ # # ]
216 : 0 : return *this_cpu_ptr(ops->disabled);
217 : : }
218 : :
219 : : extern void ftrace_stub(unsigned long a0, unsigned long a1,
220 : : struct ftrace_ops *op, struct pt_regs *regs);
221 : :
222 : : #else /* !CONFIG_FUNCTION_TRACER */
223 : : /*
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; })
229 : : static inline int ftrace_nr_registered_ops(void)
230 : : {
231 : : return 0;
232 : : }
233 : : static inline void clear_ftrace_function(void) { }
234 : : static inline void ftrace_kill(void) { }
235 : : static inline void ftrace_stop(void) { }
236 : : static inline void ftrace_start(void) { }
237 : : #endif /* CONFIG_FUNCTION_TRACER */
238 : :
239 : : #ifdef CONFIG_STACK_TRACER
240 : : extern int stack_tracer_enabled;
241 : : int
242 : : stack_trace_sysctl(struct ctl_table *table, int write,
243 : : void __user *buffer, size_t *lenp,
244 : : loff_t *ppos);
245 : : #endif
246 : :
247 : : struct ftrace_func_command {
248 : : struct list_head list;
249 : : char *name;
250 : : int (*func)(struct ftrace_hash *hash,
251 : : char *func, char *cmd,
252 : : char *params, int enable);
253 : : };
254 : :
255 : : #ifdef CONFIG_DYNAMIC_FTRACE
256 : :
257 : : int ftrace_arch_code_modify_prepare(void);
258 : : int ftrace_arch_code_modify_post_process(void);
259 : :
260 : : void ftrace_bug(int err, unsigned long ip);
261 : :
262 : : struct seq_file;
263 : :
264 : : struct ftrace_probe_ops {
265 : : void (*func)(unsigned long ip,
266 : : unsigned long parent_ip,
267 : : void **data);
268 : : 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);
272 : : int (*print)(struct seq_file *m,
273 : : unsigned long ip,
274 : : struct ftrace_probe_ops *ops,
275 : : void *data);
276 : : };
277 : :
278 : : extern int
279 : : register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
280 : : void *data);
281 : : extern void
282 : : unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
283 : : void *data);
284 : : extern void
285 : : unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
286 : : extern void unregister_ftrace_function_probe_all(char *glob);
287 : :
288 : : extern int ftrace_text_reserved(void *start, void *end);
289 : :
290 : : extern int ftrace_nr_registered_ops(void);
291 : :
292 : : /*
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 : : */
309 : : enum {
310 : : FTRACE_FL_ENABLED = (1UL << 29),
311 : : FTRACE_FL_REGS = (1UL << 30),
312 : : FTRACE_FL_REGS_EN = (1UL << 31)
313 : : };
314 : :
315 : : #define FTRACE_FL_MASK (0x7UL << 29)
316 : : #define FTRACE_REF_MAX ((1UL << 29) - 1)
317 : :
318 : : struct dyn_ftrace {
319 : : union {
320 : : unsigned long ip; /* address of mcount call-site */
321 : : struct dyn_ftrace *freelist;
322 : : };
323 : : unsigned long flags;
324 : : struct dyn_arch_ftrace arch;
325 : : };
326 : :
327 : : int ftrace_force_update(void);
328 : : int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
329 : : int remove, int reset);
330 : : int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
331 : : int len, int reset);
332 : : int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
333 : : int len, int reset);
334 : : void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
335 : : void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
336 : : void ftrace_free_filter(struct ftrace_ops *ops);
337 : :
338 : : int register_ftrace_command(struct ftrace_func_command *cmd);
339 : : int unregister_ftrace_command(struct ftrace_func_command *cmd);
340 : :
341 : : enum {
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 : :
349 : : /*
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 : : */
361 : : enum {
362 : : FTRACE_UPDATE_IGNORE,
363 : : FTRACE_UPDATE_MAKE_CALL,
364 : : FTRACE_UPDATE_MODIFY_CALL,
365 : : FTRACE_UPDATE_MODIFY_CALL_REGS,
366 : : FTRACE_UPDATE_MAKE_NOP,
367 : : };
368 : :
369 : : enum {
370 : : FTRACE_ITER_FILTER = (1 << 0),
371 : : FTRACE_ITER_NOTRACE = (1 << 1),
372 : : FTRACE_ITER_PRINTALL = (1 << 2),
373 : : FTRACE_ITER_DO_HASH = (1 << 3),
374 : : FTRACE_ITER_HASH = (1 << 4),
375 : : FTRACE_ITER_ENABLED = (1 << 5),
376 : : };
377 : :
378 : : void arch_ftrace_update_code(int command);
379 : :
380 : : struct ftrace_rec_iter;
381 : :
382 : : struct ftrace_rec_iter *ftrace_rec_iter_start(void);
383 : : struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
384 : : struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
385 : :
386 : : #define for_ftrace_rec_iter(iter) \
387 : : for (iter = ftrace_rec_iter_start(); \
388 : : iter; \
389 : : iter = ftrace_rec_iter_next(iter))
390 : :
391 : :
392 : : int ftrace_update_record(struct dyn_ftrace *rec, int enable);
393 : : int ftrace_test_record(struct dyn_ftrace *rec, int enable);
394 : : void ftrace_run_stop_machine(int command);
395 : : unsigned long ftrace_location(unsigned long ip);
396 : :
397 : : extern ftrace_func_t ftrace_trace_function;
398 : :
399 : : int ftrace_regex_open(struct ftrace_ops *ops, int flag,
400 : : struct inode *inode, struct file *file);
401 : : ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
402 : : size_t cnt, loff_t *ppos);
403 : : ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
404 : : size_t cnt, loff_t *ppos);
405 : : int ftrace_regex_release(struct inode *inode, struct file *file);
406 : :
407 : : void __init
408 : : ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
409 : :
410 : : /* defined in arch */
411 : : extern int ftrace_ip_converted(unsigned long ip);
412 : : extern int ftrace_dyn_arch_init(void *data);
413 : : extern void ftrace_replace_code(int enable);
414 : : extern int ftrace_update_ftrace_func(ftrace_func_t func);
415 : : extern void ftrace_caller(void);
416 : : extern void ftrace_regs_caller(void);
417 : : extern void ftrace_call(void);
418 : : extern void ftrace_regs_call(void);
419 : : extern void mcount_call(void);
420 : :
421 : : void ftrace_modify_all_code(int command);
422 : :
423 : : #ifndef FTRACE_ADDR
424 : : #define FTRACE_ADDR ((unsigned long)ftrace_caller)
425 : : #endif
426 : :
427 : : #ifndef FTRACE_REGS_ADDR
428 : : #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
429 : : # define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller)
430 : : #else
431 : : # define FTRACE_REGS_ADDR FTRACE_ADDR
432 : : #endif
433 : : #endif
434 : :
435 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
436 : : extern void ftrace_graph_caller(void);
437 : : extern int ftrace_enable_ftrace_graph_caller(void);
438 : : extern int ftrace_disable_ftrace_graph_caller(void);
439 : : #else
440 : : static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
441 : : static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
442 : : #endif
443 : :
444 : : /**
445 : : * ftrace_make_nop - convert code into nop
446 : : * @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
449 : : *
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 : : *
456 : : * The code segment at @rec->ip should be a caller to @addr
457 : : *
458 : : * 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 : : */
465 : : extern 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 : : */
488 : : extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
489 : :
490 : : #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
491 : : /**
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 : : */
512 : : extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
513 : : unsigned long addr);
514 : : #else
515 : : /* Should never be called */
516 : : static 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 : :
523 : : /* May be defined in arch */
524 : : extern int ftrace_arch_read_dyn_info(char *buf, int size);
525 : :
526 : : extern int skip_trace(unsigned long ip);
527 : :
528 : : extern void ftrace_disable_daemon(void);
529 : : extern void ftrace_enable_daemon(void);
530 : : #else /* CONFIG_DYNAMIC_FTRACE */
531 : : static inline int skip_trace(unsigned long ip) { return 0; }
532 : : static inline int ftrace_force_update(void) { return 0; }
533 : : static inline void ftrace_disable_daemon(void) { }
534 : : static inline void ftrace_enable_daemon(void) { }
535 : : static inline void ftrace_release_mod(struct module *mod) {}
536 : : static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
537 : : {
538 : : return -EINVAL;
539 : : }
540 : : static inline __init int unregister_ftrace_command(char *cmd_name)
541 : : {
542 : : return -EINVAL;
543 : : }
544 : : static inline int ftrace_text_reserved(void *start, void *end)
545 : : {
546 : : return 0;
547 : : }
548 : : static inline unsigned long ftrace_location(unsigned long ip)
549 : : {
550 : : return 0;
551 : : }
552 : :
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; })
559 : : #define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
560 : : #define ftrace_set_filter_ip(ops, ip, remove, reset) ({ -ENODEV; })
561 : : #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)
564 : :
565 : : static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
566 : : size_t cnt, loff_t *ppos) { return -ENODEV; }
567 : : static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
568 : : size_t cnt, loff_t *ppos) { return -ENODEV; }
569 : : static inline int
570 : : ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
571 : : #endif /* CONFIG_DYNAMIC_FTRACE */
572 : :
573 : : loff_t ftrace_filter_lseek(struct file *file, loff_t offset, int whence);
574 : :
575 : : /* totally disable ftrace - can not re-enable after this */
576 : : void ftrace_kill(void);
577 : :
578 : : static inline void tracer_disable(void)
579 : : {
580 : : #ifdef CONFIG_FUNCTION_TRACER
581 : : ftrace_enabled = 0;
582 : : #endif
583 : : }
584 : :
585 : : /*
586 : : * Ftrace disable/restore without lock. Some synchronization mechanism
587 : : * must be used to prevent ftrace_enabled to be changed between
588 : : * disable/restore.
589 : : */
590 : : static inline int __ftrace_enabled_save(void)
591 : : {
592 : : #ifdef CONFIG_FUNCTION_TRACER
593 : : int saved_ftrace_enabled = ftrace_enabled;
594 : : ftrace_enabled = 0;
595 : : return saved_ftrace_enabled;
596 : : #else
597 : : return 0;
598 : : #endif
599 : : }
600 : :
601 : : static inline void __ftrace_enabled_restore(int enabled)
602 : : {
603 : : #ifdef CONFIG_FUNCTION_TRACER
604 : : ftrace_enabled = enabled;
605 : : #endif
606 : : }
607 : :
608 : : #ifndef HAVE_ARCH_CALLER_ADDR
609 : : # ifdef CONFIG_FRAME_POINTER
610 : : # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
611 : : # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
612 : : # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
613 : : # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
614 : : # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
615 : : # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
616 : : # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
617 : : # else
618 : : # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
619 : : # define CALLER_ADDR1 0UL
620 : : # define CALLER_ADDR2 0UL
621 : : # define CALLER_ADDR3 0UL
622 : : # define CALLER_ADDR4 0UL
623 : : # define CALLER_ADDR5 0UL
624 : : # define CALLER_ADDR6 0UL
625 : : # endif
626 : : #endif /* ifndef HAVE_ARCH_CALLER_ADDR */
627 : :
628 : : #ifdef CONFIG_IRQSOFF_TRACER
629 : : extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
630 : : extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
631 : : #else
632 : : static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
633 : : static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
634 : : #endif
635 : :
636 : : #ifdef CONFIG_PREEMPT_TRACER
637 : : extern void trace_preempt_on(unsigned long a0, unsigned long a1);
638 : : extern void trace_preempt_off(unsigned long a0, unsigned long a1);
639 : : #else
640 : : /*
641 : : * Use defines instead of static inlines because some arches will make code out
642 : : * of the CALLER_ADDR, when we really want these to be a real nop.
643 : : */
644 : : # define trace_preempt_on(a0, a1) do { } while (0)
645 : : # define trace_preempt_off(a0, a1) do { } while (0)
646 : : #endif
647 : :
648 : : #ifdef CONFIG_FTRACE_MCOUNT_RECORD
649 : : extern void ftrace_init(void);
650 : : #else
651 : : static inline void ftrace_init(void) { }
652 : : #endif
653 : :
654 : : /*
655 : : * Structure that defines an entry function trace.
656 : : */
657 : : struct ftrace_graph_ent {
658 : : unsigned long func; /* Current function */
659 : : int depth;
660 : : };
661 : :
662 : : /*
663 : : * Structure that defines a return function trace.
664 : : */
665 : : struct ftrace_graph_ret {
666 : : unsigned long func; /* Current function */
667 : : unsigned long long calltime;
668 : : unsigned long long rettime;
669 : : /* Number of functions that overran the depth limit for current task */
670 : : unsigned long overrun;
671 : : int depth;
672 : : };
673 : :
674 : : /* Type of the callback handlers for tracing function graph*/
675 : : typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
676 : : typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
677 : :
678 : : #ifdef CONFIG_FUNCTION_GRAPH_TRACER
679 : :
680 : : /* for init task */
681 : : #define INIT_FTRACE_GRAPH .ret_stack = NULL,
682 : :
683 : : /*
684 : : * Stack of return addresses for functions
685 : : * of a thread.
686 : : * Used in struct thread_info
687 : : */
688 : : struct ftrace_ret_stack {
689 : : unsigned long ret;
690 : : unsigned long func;
691 : : unsigned long long calltime;
692 : : unsigned long long subtime;
693 : : unsigned long fp;
694 : : };
695 : :
696 : : /*
697 : : * Primary handler of a function return.
698 : : * It relays on ftrace_return_to_handler.
699 : : * Defined in entry_32/64.S
700 : : */
701 : : extern void return_to_handler(void);
702 : :
703 : : extern int
704 : : ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
705 : : unsigned long frame_pointer);
706 : :
707 : : /*
708 : : * Sometimes we don't want to trace a function with the function
709 : : * graph tracer but we want them to keep traced by the usual function
710 : : * tracer if the function graph tracer is not configured.
711 : : */
712 : : #define __notrace_funcgraph notrace
713 : :
714 : : /*
715 : : * We want to which function is an entrypoint of a hardirq.
716 : : * That will help us to put a signal on output.
717 : : */
718 : : #define __irq_entry __attribute__((__section__(".irqentry.text")))
719 : :
720 : : /* Limits of hardirq entrypoints */
721 : : extern char __irqentry_text_start[];
722 : : extern char __irqentry_text_end[];
723 : :
724 : : #define FTRACE_NOTRACE_DEPTH 65536
725 : : #define FTRACE_RETFUNC_DEPTH 50
726 : : #define FTRACE_RETSTACK_ALLOC_SIZE 32
727 : : extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
728 : : trace_func_graph_ent_t entryfunc);
729 : :
730 : : extern void ftrace_graph_stop(void);
731 : :
732 : : /* The current handlers in use */
733 : : extern trace_func_graph_ret_t ftrace_graph_return;
734 : : extern trace_func_graph_ent_t ftrace_graph_entry;
735 : :
736 : : extern void unregister_ftrace_graph(void);
737 : :
738 : : extern void ftrace_graph_init_task(struct task_struct *t);
739 : : extern void ftrace_graph_exit_task(struct task_struct *t);
740 : : extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
741 : :
742 : : static inline int task_curr_ret_stack(struct task_struct *t)
743 : : {
744 : : return t->curr_ret_stack;
745 : : }
746 : :
747 : : static inline void pause_graph_tracing(void)
748 : : {
749 : : atomic_inc(¤t->tracing_graph_pause);
750 : : }
751 : :
752 : : static inline void unpause_graph_tracing(void)
753 : : {
754 : : atomic_dec(¤t->tracing_graph_pause);
755 : : }
756 : : #else /* !CONFIG_FUNCTION_GRAPH_TRACER */
757 : :
758 : : #define __notrace_funcgraph
759 : : #define __irq_entry
760 : : #define INIT_FTRACE_GRAPH
761 : :
762 : : static inline void ftrace_graph_init_task(struct task_struct *t) { }
763 : : static inline void ftrace_graph_exit_task(struct task_struct *t) { }
764 : : static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
765 : :
766 : : static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
767 : : trace_func_graph_ent_t entryfunc)
768 : : {
769 : : return -1;
770 : : }
771 : : static inline void unregister_ftrace_graph(void) { }
772 : :
773 : : static inline int task_curr_ret_stack(struct task_struct *tsk)
774 : : {
775 : : return -1;
776 : : }
777 : :
778 : : static inline void pause_graph_tracing(void) { }
779 : : static inline void unpause_graph_tracing(void) { }
780 : : #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
781 : :
782 : : #ifdef CONFIG_TRACING
783 : :
784 : : /* flags for current->trace */
785 : : enum {
786 : : TSK_TRACE_FL_TRACE_BIT = 0,
787 : : TSK_TRACE_FL_GRAPH_BIT = 1,
788 : : };
789 : : enum {
790 : : TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
791 : : TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
792 : : };
793 : :
794 : : static inline void set_tsk_trace_trace(struct task_struct *tsk)
795 : : {
796 : 0 : set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
797 : : }
798 : :
799 : : static inline void clear_tsk_trace_trace(struct task_struct *tsk)
800 : : {
801 : 0 : clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
802 : : }
803 : :
804 : : static inline int test_tsk_trace_trace(struct task_struct *tsk)
805 : : {
806 : 0 : return tsk->trace & TSK_TRACE_FL_TRACE;
807 : : }
808 : :
809 : : static inline void set_tsk_trace_graph(struct task_struct *tsk)
810 : : {
811 : : set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
812 : : }
813 : :
814 : : static inline void clear_tsk_trace_graph(struct task_struct *tsk)
815 : : {
816 : : clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
817 : : }
818 : :
819 : : static inline int test_tsk_trace_graph(struct task_struct *tsk)
820 : : {
821 : : return tsk->trace & TSK_TRACE_FL_GRAPH;
822 : : }
823 : :
824 : : enum ftrace_dump_mode;
825 : :
826 : : extern enum ftrace_dump_mode ftrace_dump_on_oops;
827 : :
828 : : extern void disable_trace_on_warning(void);
829 : : extern int __disable_trace_on_warning;
830 : :
831 : : #ifdef CONFIG_PREEMPT
832 : : #define INIT_TRACE_RECURSION .trace_recursion = 0,
833 : : #endif
834 : :
835 : : #else /* CONFIG_TRACING */
836 : : static inline void disable_trace_on_warning(void) { }
837 : : #endif /* CONFIG_TRACING */
838 : :
839 : : #ifndef INIT_TRACE_RECURSION
840 : : #define INIT_TRACE_RECURSION
841 : : #endif
842 : :
843 : : #ifdef CONFIG_FTRACE_SYSCALLS
844 : :
845 : : unsigned long arch_syscall_addr(int nr);
846 : :
847 : : #endif /* CONFIG_FTRACE_SYSCALLS */
848 : :
849 : : #endif /* _LINUX_FTRACE_H */
|
