1
2
3
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
24
25
26
27#ifndef ARCH_SUPPORTS_FTRACE_OPS
28#define ARCH_SUPPORTS_FTRACE_OPS 0
29#endif
30
31
32
33
34
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
44struct module;
45struct ftrace_hash;
46
47#ifdef CONFIG_FUNCTION_TRACER
48
49extern int ftrace_enabled;
50extern int
51ftrace_enable_sysctl(struct ctl_table *table, int write,
52 void __user *buffer, size_t *lenp,
53 loff_t *ppos);
54
55struct ftrace_ops;
56
57typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
58 struct ftrace_ops *op, struct pt_regs *regs);
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96enum {
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
108struct 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
120extern int function_trace_stop;
121
122
123
124
125enum ftrace_tracing_type_t {
126 FTRACE_TYPE_ENTER = 0,
127 FTRACE_TYPE_RETURN,
128};
129
130
131extern enum ftrace_tracing_type_t ftrace_tracing_type;
132
133
134
135
136
137
138
139
140
141static inline void ftrace_stop(void)
142{
143 function_trace_stop = 1;
144}
145
146
147
148
149
150
151
152
153
154static inline void ftrace_start(void)
155{
156 function_trace_stop = 0;
157}
158
159
160
161
162
163
164
165
166int register_ftrace_function(struct ftrace_ops *ops);
167int unregister_ftrace_function(struct ftrace_ops *ops);
168void clear_ftrace_function(void);
169
170
171
172
173
174
175
176
177
178
179static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
180{
181 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
182 return;
183
184 (*this_cpu_ptr(ops->disabled))--;
185}
186
187
188
189
190
191
192
193
194
195
196static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
197{
198 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
199 return;
200
201 (*this_cpu_ptr(ops->disabled))++;
202}
203
204
205
206
207
208
209
210
211
212
213static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
214{
215 WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL));
216 return *this_cpu_ptr(ops->disabled);
217}
218
219extern void ftrace_stub(unsigned long a0, unsigned long a1,
220 struct ftrace_ops *op, struct pt_regs *regs);
221
222#else
223
224
225
226
227#define register_ftrace_function(ops) ({ 0; })
228#define unregister_ftrace_function(ops) ({ 0; })
229static inline int ftrace_nr_registered_ops(void)
230{
231 return 0;
232}
233static inline void clear_ftrace_function(void) { }
234static inline void ftrace_kill(void) { }
235static inline void ftrace_stop(void) { }
236static inline void ftrace_start(void) { }
237#endif
238
239#ifdef CONFIG_STACK_TRACER
240extern int stack_tracer_enabled;
241int
242stack_trace_sysctl(struct ctl_table *table, int write,
243 void __user *buffer, size_t *lenp,
244 loff_t *ppos);
245#endif
246
247struct 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
257int ftrace_arch_code_modify_prepare(void);
258int ftrace_arch_code_modify_post_process(void);
259
260void ftrace_bug(int err, unsigned long ip);
261
262struct seq_file;
263
264struct 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
278extern int
279register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
280 void *data);
281extern void
282unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
283 void *data);
284extern void
285unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
286extern void unregister_ftrace_function_probe_all(char *glob);
287
288extern int ftrace_text_reserved(void *start, void *end);
289
290extern int ftrace_nr_registered_ops(void);
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309enum {
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
318struct dyn_ftrace {
319 union {
320 unsigned long ip;
321 struct dyn_ftrace *freelist;
322 };
323 unsigned long flags;
324 struct dyn_arch_ftrace arch;
325};
326
327int ftrace_force_update(void);
328int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
329 int remove, int reset);
330int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
331 int len, int reset);
332int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
333 int len, int reset);
334void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
335void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
336void ftrace_free_filter(struct ftrace_ops *ops);
337
338int register_ftrace_command(struct ftrace_func_command *cmd);
339int unregister_ftrace_command(struct ftrace_func_command *cmd);
340
341enum {
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
351
352
353
354
355
356
357
358
359
360
361enum {
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
369enum {
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
378void arch_ftrace_update_code(int command);
379
380struct ftrace_rec_iter;
381
382struct ftrace_rec_iter *ftrace_rec_iter_start(void);
383struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
384struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
385
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
392int ftrace_update_record(struct dyn_ftrace *rec, int enable);
393int ftrace_test_record(struct dyn_ftrace *rec, int enable);
394void ftrace_run_stop_machine(int command);
395unsigned long ftrace_location(unsigned long ip);
396
397extern ftrace_func_t ftrace_trace_function;
398
399int ftrace_regex_open(struct ftrace_ops *ops, int flag,
400 struct inode *inode, struct file *file);
401ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
402 size_t cnt, loff_t *ppos);
403ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
404 size_t cnt, loff_t *ppos);
405int ftrace_regex_release(struct inode *inode, struct file *file);
406
407void __init
408ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
409
410
411extern int ftrace_ip_converted(unsigned long ip);
412extern int ftrace_dyn_arch_init(void *data);
413extern void ftrace_replace_code(int enable);
414extern int ftrace_update_ftrace_func(ftrace_func_t func);
415extern void ftrace_caller(void);
416extern void ftrace_regs_caller(void);
417extern void ftrace_call(void);
418extern void ftrace_regs_call(void);
419extern void mcount_call(void);
420
421void 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
436extern void ftrace_graph_caller(void);
437extern int ftrace_enable_ftrace_graph_caller(void);
438extern int ftrace_disable_ftrace_graph_caller(void);
439#else
440static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
441static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
442#endif
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465extern int ftrace_make_nop(struct module *mod,
466 struct dyn_ftrace *rec, unsigned long addr);
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
489
490#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
513 unsigned long addr);
514#else
515
516static inline int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
517 unsigned long addr)
518{
519 return -EINVAL;
520}
521#endif
522
523
524extern int ftrace_arch_read_dyn_info(char *buf, int size);
525
526extern int skip_trace(unsigned long ip);
527
528extern void ftrace_disable_daemon(void);
529extern void ftrace_enable_daemon(void);
530#else
531static inline int skip_trace(unsigned long ip) { return 0; }
532static inline int ftrace_force_update(void) { return 0; }
533static inline void ftrace_disable_daemon(void) { }
534static inline void ftrace_enable_daemon(void) { }
535static inline void ftrace_release_mod(struct module *mod) {}
536static inline int register_ftrace_command(struct ftrace_func_command *cmd)
537{
538 return -EINVAL;
539}
540static inline int unregister_ftrace_command(char *cmd_name)
541{
542 return -EINVAL;
543}
544static inline int ftrace_text_reserved(void *start, void *end)
545{
546 return 0;
547}
548static inline unsigned long ftrace_location(unsigned long ip)
549{
550 return 0;
551}
552
553
554
555
556
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
565static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
566 size_t cnt, loff_t *ppos) { return -ENODEV; }
567static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
568 size_t cnt, loff_t *ppos) { return -ENODEV; }
569static inline int
570ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
571#endif
572
573loff_t ftrace_filter_lseek(struct file *file, loff_t offset, int whence);
574
575
576void ftrace_kill(void);
577
578static inline void tracer_disable(void)
579{
580#ifdef CONFIG_FUNCTION_TRACER
581 ftrace_enabled = 0;
582#endif
583}
584
585
586
587
588
589
590static 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
601static 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
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
642
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
649extern void ftrace_init(void);
650#else
651static inline void ftrace_init(void) { }
652#endif
653
654
655
656
657struct ftrace_graph_ent {
658 unsigned long func;
659 int depth;
660};
661
662
663
664
665struct ftrace_graph_ret {
666 unsigned long func;
667 unsigned long long calltime;
668 unsigned long long rettime;
669
670 unsigned long overrun;
671 int depth;
672};
673
674
675typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *);
676typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *);
677
678#ifdef CONFIG_FUNCTION_GRAPH_TRACER
679
680
681#define INIT_FTRACE_GRAPH .ret_stack = NULL,
682
683
684
685
686
687
688struct 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
698
699
700
701extern void return_to_handler(void);
702
703extern int
704ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
705 unsigned long frame_pointer);
706
707
708
709
710
711
712#define __notrace_funcgraph notrace
713
714
715
716
717
718#define __irq_entry __attribute__((__section__(".irqentry.text")))
719
720
721extern char __irqentry_text_start[];
722extern char __irqentry_text_end[];
723
724#define FTRACE_RETFUNC_DEPTH 50
725#define FTRACE_RETSTACK_ALLOC_SIZE 32
726extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
727 trace_func_graph_ent_t entryfunc);
728
729extern void ftrace_graph_stop(void);
730
731
732extern trace_func_graph_ret_t ftrace_graph_return;
733extern trace_func_graph_ent_t ftrace_graph_entry;
734
735extern void unregister_ftrace_graph(void);
736
737extern void ftrace_graph_init_task(struct task_struct *t);
738extern void ftrace_graph_exit_task(struct task_struct *t);
739extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
740
741static inline int task_curr_ret_stack(struct task_struct *t)
742{
743 return t->curr_ret_stack;
744}
745
746static inline void pause_graph_tracing(void)
747{
748 atomic_inc(¤t->tracing_graph_pause);
749}
750
751static inline void unpause_graph_tracing(void)
752{
753 atomic_dec(¤t->tracing_graph_pause);
754}
755#else
756
757#define __notrace_funcgraph
758#define __irq_entry
759#define INIT_FTRACE_GRAPH
760
761static inline void ftrace_graph_init_task(struct task_struct *t) { }
762static inline void ftrace_graph_exit_task(struct task_struct *t) { }
763static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
764
765static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
766 trace_func_graph_ent_t entryfunc)
767{
768 return -1;
769}
770static inline void unregister_ftrace_graph(void) { }
771
772static inline int task_curr_ret_stack(struct task_struct *tsk)
773{
774 return -1;
775}
776
777static inline void pause_graph_tracing(void) { }
778static inline void unpause_graph_tracing(void) { }
779#endif
780
781#ifdef CONFIG_TRACING
782
783
784enum {
785 TSK_TRACE_FL_TRACE_BIT = 0,
786 TSK_TRACE_FL_GRAPH_BIT = 1,
787};
788enum {
789 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
790 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
791};
792
793static inline void set_tsk_trace_trace(struct task_struct *tsk)
794{
795 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
796}
797
798static inline void clear_tsk_trace_trace(struct task_struct *tsk)
799{
800 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
801}
802
803static inline int test_tsk_trace_trace(struct task_struct *tsk)
804{
805 return tsk->trace & TSK_TRACE_FL_TRACE;
806}
807
808static inline void set_tsk_trace_graph(struct task_struct *tsk)
809{
810 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
811}
812
813static inline void clear_tsk_trace_graph(struct task_struct *tsk)
814{
815 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
816}
817
818static inline int test_tsk_trace_graph(struct task_struct *tsk)
819{
820 return tsk->trace & TSK_TRACE_FL_GRAPH;
821}
822
823enum ftrace_dump_mode;
824
825extern enum ftrace_dump_mode ftrace_dump_on_oops;
826
827extern void disable_trace_on_warning(void);
828extern int __disable_trace_on_warning;
829
830#ifdef CONFIG_PREEMPT
831#define INIT_TRACE_RECURSION .trace_recursion = 0,
832#endif
833
834#else
835static inline void disable_trace_on_warning(void) { }
836#endif
837
838#ifndef INIT_TRACE_RECURSION
839#define INIT_TRACE_RECURSION
840#endif
841
842#ifdef CONFIG_FTRACE_SYSCALLS
843
844unsigned long arch_syscall_addr(int nr);
845
846#endif
847
848#endif
849