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 !ARCH_SUPPORTS_FTRACE_OPS
37# define FTRACE_FORCE_LIST_FUNC 1
38#else
39# define FTRACE_FORCE_LIST_FUNC 0
40#endif
41
42
43#ifdef CONFIG_TRACING
44void trace_init(void);
45#else
46static inline void trace_init(void) { }
47#endif
48
49struct module;
50struct ftrace_hash;
51
52#ifdef CONFIG_FUNCTION_TRACER
53
54extern int ftrace_enabled;
55extern int
56ftrace_enable_sysctl(struct ctl_table *table, int write,
57 void __user *buffer, size_t *lenp,
58 loff_t *ppos);
59
60struct ftrace_ops;
61
62typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
63 struct ftrace_ops *op, struct pt_regs *regs);
64
65ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121enum {
122 FTRACE_OPS_FL_ENABLED = 1 << 0,
123 FTRACE_OPS_FL_DYNAMIC = 1 << 1,
124 FTRACE_OPS_FL_CONTROL = 1 << 2,
125 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,
131 FTRACE_OPS_FL_ADDING = 1 << 9,
132 FTRACE_OPS_FL_REMOVING = 1 << 10,
133 FTRACE_OPS_FL_MODIFYING = 1 << 11,
134 FTRACE_OPS_FL_ALLOC_TRAMP = 1 << 12,
135 FTRACE_OPS_FL_IPMODIFY = 1 << 13,
136 FTRACE_OPS_FL_PID = 1 << 14,
137};
138
139#ifdef CONFIG_DYNAMIC_FTRACE
140
141struct ftrace_ops_hash {
142 struct ftrace_hash *notrace_hash;
143 struct ftrace_hash *filter_hash;
144 struct mutex regex_lock;
145};
146#endif
147
148
149
150
151
152
153
154
155
156
157
158
159struct ftrace_ops {
160 ftrace_func_t func;
161 struct ftrace_ops *next;
162 unsigned long flags;
163 void *private;
164 ftrace_func_t saved_func;
165 int __percpu *disabled;
166#ifdef CONFIG_DYNAMIC_FTRACE
167 int nr_trampolines;
168 struct ftrace_ops_hash local_hash;
169 struct ftrace_ops_hash *func_hash;
170 struct ftrace_ops_hash old_hash;
171 unsigned long trampoline;
172 unsigned long trampoline_size;
173#endif
174};
175
176
177
178
179enum ftrace_tracing_type_t {
180 FTRACE_TYPE_ENTER = 0,
181 FTRACE_TYPE_RETURN,
182};
183
184
185extern enum ftrace_tracing_type_t ftrace_tracing_type;
186
187
188
189
190
191
192
193
194int register_ftrace_function(struct ftrace_ops *ops);
195int unregister_ftrace_function(struct ftrace_ops *ops);
196void clear_ftrace_function(void);
197
198
199
200
201
202
203
204
205
206
207static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
208{
209 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
210 return;
211
212 (*this_cpu_ptr(ops->disabled))--;
213}
214
215
216
217
218
219
220
221
222
223
224static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
225{
226 if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
227 return;
228
229 (*this_cpu_ptr(ops->disabled))++;
230}
231
232
233
234
235
236
237
238
239
240
241static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
242{
243 WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL));
244 return *this_cpu_ptr(ops->disabled);
245}
246
247extern void ftrace_stub(unsigned long a0, unsigned long a1,
248 struct ftrace_ops *op, struct pt_regs *regs);
249
250#else
251
252
253
254
255#define register_ftrace_function(ops) ({ 0; })
256#define unregister_ftrace_function(ops) ({ 0; })
257static inline int ftrace_nr_registered_ops(void)
258{
259 return 0;
260}
261static inline void clear_ftrace_function(void) { }
262static inline void ftrace_kill(void) { }
263#endif
264
265#ifdef CONFIG_STACK_TRACER
266extern int stack_tracer_enabled;
267int
268stack_trace_sysctl(struct ctl_table *table, int write,
269 void __user *buffer, size_t *lenp,
270 loff_t *ppos);
271#endif
272
273struct ftrace_func_command {
274 struct list_head list;
275 char *name;
276 int (*func)(struct ftrace_hash *hash,
277 char *func, char *cmd,
278 char *params, int enable);
279};
280
281#ifdef CONFIG_DYNAMIC_FTRACE
282
283int ftrace_arch_code_modify_prepare(void);
284int ftrace_arch_code_modify_post_process(void);
285
286struct dyn_ftrace;
287
288void ftrace_bug(int err, struct dyn_ftrace *rec);
289
290struct seq_file;
291
292struct ftrace_probe_ops {
293 void (*func)(unsigned long ip,
294 unsigned long parent_ip,
295 void **data);
296 int (*init)(struct ftrace_probe_ops *ops,
297 unsigned long ip, void **data);
298 void (*free)(struct ftrace_probe_ops *ops,
299 unsigned long ip, void **data);
300 int (*print)(struct seq_file *m,
301 unsigned long ip,
302 struct ftrace_probe_ops *ops,
303 void *data);
304};
305
306extern int
307register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
308 void *data);
309extern void
310unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
311 void *data);
312extern void
313unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
314extern void unregister_ftrace_function_probe_all(char *glob);
315
316extern int ftrace_text_reserved(const void *start, const void *end);
317
318extern int ftrace_nr_registered_ops(void);
319
320bool is_ftrace_trampoline(unsigned long addr);
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340enum {
341 FTRACE_FL_ENABLED = (1UL << 31),
342 FTRACE_FL_REGS = (1UL << 30),
343 FTRACE_FL_REGS_EN = (1UL << 29),
344 FTRACE_FL_TRAMP = (1UL << 28),
345 FTRACE_FL_TRAMP_EN = (1UL << 27),
346 FTRACE_FL_IPMODIFY = (1UL << 26),
347};
348
349#define FTRACE_REF_MAX_SHIFT 26
350#define FTRACE_FL_BITS 6
351#define FTRACE_FL_MASKED_BITS ((1UL << FTRACE_FL_BITS) - 1)
352#define FTRACE_FL_MASK (FTRACE_FL_MASKED_BITS << FTRACE_REF_MAX_SHIFT)
353#define FTRACE_REF_MAX ((1UL << FTRACE_REF_MAX_SHIFT) - 1)
354
355#define ftrace_rec_count(rec) ((rec)->flags & ~FTRACE_FL_MASK)
356
357struct dyn_ftrace {
358 unsigned long ip;
359 unsigned long flags;
360 struct dyn_arch_ftrace arch;
361};
362
363int ftrace_force_update(void);
364int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
365 int remove, int reset);
366int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
367 int len, int reset);
368int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
369 int len, int reset);
370void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
371void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
372void ftrace_free_filter(struct ftrace_ops *ops);
373
374int register_ftrace_command(struct ftrace_func_command *cmd);
375int unregister_ftrace_command(struct ftrace_func_command *cmd);
376
377enum {
378 FTRACE_UPDATE_CALLS = (1 << 0),
379 FTRACE_DISABLE_CALLS = (1 << 1),
380 FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
381 FTRACE_START_FUNC_RET = (1 << 3),
382 FTRACE_STOP_FUNC_RET = (1 << 4),
383};
384
385
386
387
388
389
390
391
392
393
394
395
396enum {
397 FTRACE_UPDATE_IGNORE,
398 FTRACE_UPDATE_MAKE_CALL,
399 FTRACE_UPDATE_MODIFY_CALL,
400 FTRACE_UPDATE_MAKE_NOP,
401};
402
403enum {
404 FTRACE_ITER_FILTER = (1 << 0),
405 FTRACE_ITER_NOTRACE = (1 << 1),
406 FTRACE_ITER_PRINTALL = (1 << 2),
407 FTRACE_ITER_DO_HASH = (1 << 3),
408 FTRACE_ITER_HASH = (1 << 4),
409 FTRACE_ITER_ENABLED = (1 << 5),
410};
411
412void arch_ftrace_update_code(int command);
413
414struct ftrace_rec_iter;
415
416struct ftrace_rec_iter *ftrace_rec_iter_start(void);
417struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
418struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
419
420#define for_ftrace_rec_iter(iter) \
421 for (iter = ftrace_rec_iter_start(); \
422 iter; \
423 iter = ftrace_rec_iter_next(iter))
424
425
426int ftrace_update_record(struct dyn_ftrace *rec, int enable);
427int ftrace_test_record(struct dyn_ftrace *rec, int enable);
428void ftrace_run_stop_machine(int command);
429unsigned long ftrace_location(unsigned long ip);
430unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec);
431unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec);
432
433extern ftrace_func_t ftrace_trace_function;
434
435int ftrace_regex_open(struct ftrace_ops *ops, int flag,
436 struct inode *inode, struct file *file);
437ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
438 size_t cnt, loff_t *ppos);
439ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
440 size_t cnt, loff_t *ppos);
441int ftrace_regex_release(struct inode *inode, struct file *file);
442
443void __init
444ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
445
446
447extern int ftrace_ip_converted(unsigned long ip);
448extern int ftrace_dyn_arch_init(void);
449extern void ftrace_replace_code(int enable);
450extern int ftrace_update_ftrace_func(ftrace_func_t func);
451extern void ftrace_caller(void);
452extern void ftrace_regs_caller(void);
453extern void ftrace_call(void);
454extern void ftrace_regs_call(void);
455extern void mcount_call(void);
456
457void ftrace_modify_all_code(int command);
458
459#ifndef FTRACE_ADDR
460#define FTRACE_ADDR ((unsigned long)ftrace_caller)
461#endif
462
463#ifndef FTRACE_GRAPH_ADDR
464#define FTRACE_GRAPH_ADDR ((unsigned long)ftrace_graph_caller)
465#endif
466
467#ifndef FTRACE_REGS_ADDR
468#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
469# define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller)
470#else
471# define FTRACE_REGS_ADDR FTRACE_ADDR
472#endif
473#endif
474
475
476
477
478
479
480
481#ifndef FTRACE_GRAPH_TRAMP_ADDR
482#define FTRACE_GRAPH_TRAMP_ADDR ((unsigned long) 0)
483#endif
484
485#ifdef CONFIG_FUNCTION_GRAPH_TRACER
486extern void ftrace_graph_caller(void);
487extern int ftrace_enable_ftrace_graph_caller(void);
488extern int ftrace_disable_ftrace_graph_caller(void);
489#else
490static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
491static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
492#endif
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515extern int ftrace_make_nop(struct module *mod,
516 struct dyn_ftrace *rec, unsigned long addr);
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
539
540#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
563 unsigned long addr);
564#else
565
566static inline int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
567 unsigned long addr)
568{
569 return -EINVAL;
570}
571#endif
572
573
574extern int ftrace_arch_read_dyn_info(char *buf, int size);
575
576extern int skip_trace(unsigned long ip);
577extern void ftrace_module_init(struct module *mod);
578
579extern void ftrace_disable_daemon(void);
580extern void ftrace_enable_daemon(void);
581#else
582static inline int skip_trace(unsigned long ip) { return 0; }
583static inline int ftrace_force_update(void) { return 0; }
584static inline void ftrace_disable_daemon(void) { }
585static inline void ftrace_enable_daemon(void) { }
586static inline void ftrace_release_mod(struct module *mod) {}
587static inline void ftrace_module_init(struct module *mod) {}
588static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
589{
590 return -EINVAL;
591}
592static inline __init int unregister_ftrace_command(char *cmd_name)
593{
594 return -EINVAL;
595}
596static inline int ftrace_text_reserved(const void *start, const void *end)
597{
598 return 0;
599}
600static inline unsigned long ftrace_location(unsigned long ip)
601{
602 return 0;
603}
604
605
606
607
608
609
610#define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; })
611#define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
612#define ftrace_set_filter_ip(ops, ip, remove, reset) ({ -ENODEV; })
613#define ftrace_set_filter(ops, buf, len, reset) ({ -ENODEV; })
614#define ftrace_set_notrace(ops, buf, len, reset) ({ -ENODEV; })
615#define ftrace_free_filter(ops) do { } while (0)
616
617static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
618 size_t cnt, loff_t *ppos) { return -ENODEV; }
619static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
620 size_t cnt, loff_t *ppos) { return -ENODEV; }
621static inline int
622ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
623
624static inline bool is_ftrace_trampoline(unsigned long addr)
625{
626 return false;
627}
628#endif
629
630
631void ftrace_kill(void);
632
633static inline void tracer_disable(void)
634{
635#ifdef CONFIG_FUNCTION_TRACER
636 ftrace_enabled = 0;
637#endif
638}
639
640
641
642
643
644
645static inline int __ftrace_enabled_save(void)
646{
647#ifdef CONFIG_FUNCTION_TRACER
648 int saved_ftrace_enabled = ftrace_enabled;
649 ftrace_enabled = 0;
650 return saved_ftrace_enabled;
651#else
652 return 0;
653#endif
654}
655
656static inline void __ftrace_enabled_restore(int enabled)
657{
658#ifdef CONFIG_FUNCTION_TRACER
659 ftrace_enabled = enabled;
660#endif
661}
662
663
664#ifndef ftrace_return_address0
665# define ftrace_return_address0 __builtin_return_address(0)
666#endif
667
668
669#ifndef ftrace_return_address
670# ifdef CONFIG_FRAME_POINTER
671# define ftrace_return_address(n) __builtin_return_address(n)
672# else
673# define ftrace_return_address(n) 0UL
674# endif
675#endif
676
677#define CALLER_ADDR0 ((unsigned long)ftrace_return_address0)
678#define CALLER_ADDR1 ((unsigned long)ftrace_return_address(1))
679#define CALLER_ADDR2 ((unsigned long)ftrace_return_address(2))
680#define CALLER_ADDR3 ((unsigned long)ftrace_return_address(3))
681#define CALLER_ADDR4 ((unsigned long)ftrace_return_address(4))
682#define CALLER_ADDR5 ((unsigned long)ftrace_return_address(5))
683#define CALLER_ADDR6 ((unsigned long)ftrace_return_address(6))
684
685#ifdef CONFIG_IRQSOFF_TRACER
686 extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
687 extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
688#else
689 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
690 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
691#endif
692
693#ifdef CONFIG_PREEMPT_TRACER
694 extern void trace_preempt_on(unsigned long a0, unsigned long a1);
695 extern void trace_preempt_off(unsigned long a0, unsigned long a1);
696#else
697
698
699
700
701# define trace_preempt_on(a0, a1) do { } while (0)
702# define trace_preempt_off(a0, a1) do { } while (0)
703#endif
704
705#ifdef CONFIG_FTRACE_MCOUNT_RECORD
706extern void ftrace_init(void);
707#else
708static inline void ftrace_init(void) { }
709#endif
710
711
712
713
714struct ftrace_graph_ent {
715 unsigned long func;
716 int depth;
717};
718
719
720
721
722struct ftrace_graph_ret {
723 unsigned long func;
724 unsigned long long calltime;
725 unsigned long long rettime;
726
727 unsigned long overrun;
728 int depth;
729};
730
731
732typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *);
733typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *);
734
735#ifdef CONFIG_FUNCTION_GRAPH_TRACER
736
737
738#define INIT_FTRACE_GRAPH .ret_stack = NULL,
739
740
741
742
743
744
745struct ftrace_ret_stack {
746 unsigned long ret;
747 unsigned long func;
748 unsigned long long calltime;
749 unsigned long long subtime;
750 unsigned long fp;
751};
752
753
754
755
756
757
758extern void return_to_handler(void);
759
760extern int
761ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
762 unsigned long frame_pointer);
763
764
765
766
767
768
769#define __notrace_funcgraph notrace
770
771
772
773
774
775#define __irq_entry __attribute__((__section__(".irqentry.text")))
776
777
778extern char __irqentry_text_start[];
779extern char __irqentry_text_end[];
780
781#define FTRACE_NOTRACE_DEPTH 65536
782#define FTRACE_RETFUNC_DEPTH 50
783#define FTRACE_RETSTACK_ALLOC_SIZE 32
784extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
785 trace_func_graph_ent_t entryfunc);
786
787extern bool ftrace_graph_is_dead(void);
788extern void ftrace_graph_stop(void);
789
790
791extern trace_func_graph_ret_t ftrace_graph_return;
792extern trace_func_graph_ent_t ftrace_graph_entry;
793
794extern void unregister_ftrace_graph(void);
795
796extern void ftrace_graph_init_task(struct task_struct *t);
797extern void ftrace_graph_exit_task(struct task_struct *t);
798extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
799
800static inline int task_curr_ret_stack(struct task_struct *t)
801{
802 return t->curr_ret_stack;
803}
804
805static inline void pause_graph_tracing(void)
806{
807 atomic_inc(¤t->tracing_graph_pause);
808}
809
810static inline void unpause_graph_tracing(void)
811{
812 atomic_dec(¤t->tracing_graph_pause);
813}
814#else
815
816#define __notrace_funcgraph
817#define __irq_entry
818#define INIT_FTRACE_GRAPH
819
820static inline void ftrace_graph_init_task(struct task_struct *t) { }
821static inline void ftrace_graph_exit_task(struct task_struct *t) { }
822static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { }
823
824static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
825 trace_func_graph_ent_t entryfunc)
826{
827 return -1;
828}
829static inline void unregister_ftrace_graph(void) { }
830
831static inline int task_curr_ret_stack(struct task_struct *tsk)
832{
833 return -1;
834}
835
836static inline void pause_graph_tracing(void) { }
837static inline void unpause_graph_tracing(void) { }
838#endif
839
840#ifdef CONFIG_TRACING
841
842
843enum {
844 TSK_TRACE_FL_TRACE_BIT = 0,
845 TSK_TRACE_FL_GRAPH_BIT = 1,
846};
847enum {
848 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
849 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
850};
851
852static inline void set_tsk_trace_trace(struct task_struct *tsk)
853{
854 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
855}
856
857static inline void clear_tsk_trace_trace(struct task_struct *tsk)
858{
859 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
860}
861
862static inline int test_tsk_trace_trace(struct task_struct *tsk)
863{
864 return tsk->trace & TSK_TRACE_FL_TRACE;
865}
866
867static inline void set_tsk_trace_graph(struct task_struct *tsk)
868{
869 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
870}
871
872static inline void clear_tsk_trace_graph(struct task_struct *tsk)
873{
874 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
875}
876
877static inline int test_tsk_trace_graph(struct task_struct *tsk)
878{
879 return tsk->trace & TSK_TRACE_FL_GRAPH;
880}
881
882enum ftrace_dump_mode;
883
884extern enum ftrace_dump_mode ftrace_dump_on_oops;
885extern int tracepoint_printk;
886
887extern void disable_trace_on_warning(void);
888extern int __disable_trace_on_warning;
889
890#ifdef CONFIG_PREEMPT
891#define INIT_TRACE_RECURSION .trace_recursion = 0,
892#endif
893
894#else
895static inline void disable_trace_on_warning(void) { }
896#endif
897
898#ifndef INIT_TRACE_RECURSION
899#define INIT_TRACE_RECURSION
900#endif
901
902#ifdef CONFIG_FTRACE_SYSCALLS
903
904unsigned long arch_syscall_addr(int nr);
905
906#endif
907
908#endif
909