1
2
3#ifndef _LINUX_KERNEL_TRACE_H
4#define _LINUX_KERNEL_TRACE_H
5
6#include <linux/fs.h>
7#include <linux/atomic.h>
8#include <linux/sched.h>
9#include <linux/clocksource.h>
10#include <linux/ring_buffer.h>
11#include <linux/mmiotrace.h>
12#include <linux/tracepoint.h>
13#include <linux/ftrace.h>
14#include <linux/hw_breakpoint.h>
15#include <linux/trace_seq.h>
16#include <linux/trace_events.h>
17#include <linux/compiler.h>
18#include <linux/trace_seq.h>
19#include <linux/glob.h>
20
21#ifdef CONFIG_FTRACE_SYSCALLS
22#include <asm/unistd.h>
23#include <asm/syscall.h>
24#endif
25
26enum trace_type {
27 __TRACE_FIRST_TYPE = 0,
28
29 TRACE_FN,
30 TRACE_CTX,
31 TRACE_WAKE,
32 TRACE_STACK,
33 TRACE_PRINT,
34 TRACE_BPRINT,
35 TRACE_MMIO_RW,
36 TRACE_MMIO_MAP,
37 TRACE_BRANCH,
38 TRACE_GRAPH_RET,
39 TRACE_GRAPH_ENT,
40 TRACE_USER_STACK,
41 TRACE_BLK,
42 TRACE_BPUTS,
43 TRACE_HWLAT,
44 TRACE_RAW_DATA,
45
46 __TRACE_LAST_TYPE,
47};
48
49
50#undef __field
51#define __field(type, item) type item;
52
53#undef __field_struct
54#define __field_struct(type, item) __field(type, item)
55
56#undef __field_desc
57#define __field_desc(type, container, item)
58
59#undef __array
60#define __array(type, item, size) type item[size];
61
62#undef __array_desc
63#define __array_desc(type, container, item, size)
64
65#undef __dynamic_array
66#define __dynamic_array(type, item) type item[];
67
68#undef F_STRUCT
69#define F_STRUCT(args...) args
70
71#undef FTRACE_ENTRY
72#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter) \
73 struct struct_name { \
74 struct trace_entry ent; \
75 tstruct \
76 }
77
78#undef FTRACE_ENTRY_DUP
79#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
80
81#undef FTRACE_ENTRY_REG
82#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
83 filter, regfn) \
84 FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
85 filter)
86
87#undef FTRACE_ENTRY_PACKED
88#define FTRACE_ENTRY_PACKED(name, struct_name, id, tstruct, print, \
89 filter) \
90 FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
91 filter) __packed
92
93#include "trace_entries.h"
94
95
96
97
98
99struct syscall_trace_enter {
100 struct trace_entry ent;
101 int nr;
102 unsigned long args[];
103};
104
105struct syscall_trace_exit {
106 struct trace_entry ent;
107 int nr;
108 long ret;
109};
110
111struct kprobe_trace_entry_head {
112 struct trace_entry ent;
113 unsigned long ip;
114};
115
116struct kretprobe_trace_entry_head {
117 struct trace_entry ent;
118 unsigned long func;
119 unsigned long ret_ip;
120};
121
122
123
124
125
126
127
128
129
130
131enum trace_flag_type {
132 TRACE_FLAG_IRQS_OFF = 0x01,
133 TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
134 TRACE_FLAG_NEED_RESCHED = 0x04,
135 TRACE_FLAG_HARDIRQ = 0x08,
136 TRACE_FLAG_SOFTIRQ = 0x10,
137 TRACE_FLAG_PREEMPT_RESCHED = 0x20,
138 TRACE_FLAG_NMI = 0x40,
139};
140
141#define TRACE_BUF_SIZE 1024
142
143struct trace_array;
144
145
146
147
148
149
150struct trace_array_cpu {
151 atomic_t disabled;
152 void *buffer_page;
153
154 unsigned long entries;
155 unsigned long saved_latency;
156 unsigned long critical_start;
157 unsigned long critical_end;
158 unsigned long critical_sequence;
159 unsigned long nice;
160 unsigned long policy;
161 unsigned long rt_priority;
162 unsigned long skipped_entries;
163 u64 preempt_timestamp;
164 pid_t pid;
165 kuid_t uid;
166 char comm[TASK_COMM_LEN];
167
168 bool ignore_pid;
169#ifdef CONFIG_FUNCTION_TRACER
170 bool ftrace_ignore_pid;
171#endif
172};
173
174struct tracer;
175struct trace_option_dentry;
176
177struct trace_buffer {
178 struct trace_array *tr;
179 struct ring_buffer *buffer;
180 struct trace_array_cpu __percpu *data;
181 u64 time_start;
182 int cpu;
183};
184
185#define TRACE_FLAGS_MAX_SIZE 32
186
187struct trace_options {
188 struct tracer *tracer;
189 struct trace_option_dentry *topts;
190};
191
192struct trace_pid_list {
193 int pid_max;
194 unsigned long *pids;
195};
196
197
198
199
200
201
202struct trace_array {
203 struct list_head list;
204 char *name;
205 struct trace_buffer trace_buffer;
206#ifdef CONFIG_TRACER_MAX_TRACE
207
208
209
210
211
212
213
214
215
216
217
218 struct trace_buffer max_buffer;
219 bool allocated_snapshot;
220#endif
221#if defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER)
222 unsigned long max_latency;
223#endif
224 struct trace_pid_list __rcu *filtered_pids;
225
226
227
228
229
230
231
232
233
234
235
236
237
238 arch_spinlock_t max_lock;
239 int buffer_disabled;
240#ifdef CONFIG_FTRACE_SYSCALLS
241 int sys_refcount_enter;
242 int sys_refcount_exit;
243 struct trace_event_file __rcu *enter_syscall_files[NR_syscalls];
244 struct trace_event_file __rcu *exit_syscall_files[NR_syscalls];
245#endif
246 int stop_count;
247 int clock_id;
248 int nr_topts;
249 bool clear_trace;
250 struct tracer *current_trace;
251 unsigned int trace_flags;
252 unsigned char trace_flags_index[TRACE_FLAGS_MAX_SIZE];
253 unsigned int flags;
254 raw_spinlock_t start_lock;
255 struct dentry *dir;
256 struct dentry *options;
257 struct dentry *percpu_dir;
258 struct dentry *event_dir;
259 struct trace_options *topts;
260 struct list_head systems;
261 struct list_head events;
262 cpumask_var_t tracing_cpumask;
263 int ref;
264#ifdef CONFIG_FUNCTION_TRACER
265 struct ftrace_ops *ops;
266 struct trace_pid_list __rcu *function_pids;
267#ifdef CONFIG_DYNAMIC_FTRACE
268
269 struct list_head func_probes;
270 struct list_head mod_trace;
271 struct list_head mod_notrace;
272#endif
273
274 int function_enabled;
275#endif
276 int time_stamp_abs_ref;
277 struct list_head hist_vars;
278};
279
280enum {
281 TRACE_ARRAY_FL_GLOBAL = (1 << 0)
282};
283
284extern struct list_head ftrace_trace_arrays;
285
286extern struct mutex trace_types_lock;
287
288extern int trace_array_get(struct trace_array *tr);
289extern void trace_array_put(struct trace_array *tr);
290
291extern int tracing_set_time_stamp_abs(struct trace_array *tr, bool abs);
292extern int tracing_set_clock(struct trace_array *tr, const char *clockstr);
293
294extern bool trace_clock_in_ns(struct trace_array *tr);
295
296
297
298
299
300static inline struct trace_array *top_trace_array(void)
301{
302 struct trace_array *tr;
303
304 if (list_empty(&ftrace_trace_arrays))
305 return NULL;
306
307 tr = list_entry(ftrace_trace_arrays.prev,
308 typeof(*tr), list);
309 WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
310 return tr;
311}
312
313#define FTRACE_CMP_TYPE(var, type) \
314 __builtin_types_compatible_p(typeof(var), type *)
315
316#undef IF_ASSIGN
317#define IF_ASSIGN(var, entry, etype, id) \
318 if (FTRACE_CMP_TYPE(var, etype)) { \
319 var = (typeof(var))(entry); \
320 WARN_ON(id && (entry)->type != id); \
321 break; \
322 }
323
324
325extern void __ftrace_bad_type(void);
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340#define trace_assign_type(var, ent) \
341 do { \
342 IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \
343 IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \
344 IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \
345 IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
346 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
347 IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
348 IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \
349 IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \
350 IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\
351 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \
352 TRACE_MMIO_RW); \
353 IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \
354 TRACE_MMIO_MAP); \
355 IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
356 IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \
357 TRACE_GRAPH_ENT); \
358 IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \
359 TRACE_GRAPH_RET); \
360 __ftrace_bad_type(); \
361 } while (0)
362
363
364
365
366
367
368struct tracer_opt {
369 const char *name;
370 u32 bit;
371};
372
373
374
375
376
377struct tracer_flags {
378 u32 val;
379 struct tracer_opt *opts;
380 struct tracer *trace;
381};
382
383
384#define TRACER_OPT(s, b) .name = #s, .bit = b
385
386
387struct trace_option_dentry {
388 struct tracer_opt *opt;
389 struct tracer_flags *flags;
390 struct trace_array *tr;
391 struct dentry *entry;
392};
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414struct tracer {
415 const char *name;
416 int (*init)(struct trace_array *tr);
417 void (*reset)(struct trace_array *tr);
418 void (*start)(struct trace_array *tr);
419 void (*stop)(struct trace_array *tr);
420 int (*update_thresh)(struct trace_array *tr);
421 void (*open)(struct trace_iterator *iter);
422 void (*pipe_open)(struct trace_iterator *iter);
423 void (*close)(struct trace_iterator *iter);
424 void (*pipe_close)(struct trace_iterator *iter);
425 ssize_t (*read)(struct trace_iterator *iter,
426 struct file *filp, char __user *ubuf,
427 size_t cnt, loff_t *ppos);
428 ssize_t (*splice_read)(struct trace_iterator *iter,
429 struct file *filp,
430 loff_t *ppos,
431 struct pipe_inode_info *pipe,
432 size_t len,
433 unsigned int flags);
434#ifdef CONFIG_FTRACE_STARTUP_TEST
435 int (*selftest)(struct tracer *trace,
436 struct trace_array *tr);
437#endif
438 void (*print_header)(struct seq_file *m);
439 enum print_line_t (*print_line)(struct trace_iterator *iter);
440
441 int (*set_flag)(struct trace_array *tr,
442 u32 old_flags, u32 bit, int set);
443
444 int (*flag_changed)(struct trace_array *tr,
445 u32 mask, int set);
446 struct tracer *next;
447 struct tracer_flags *flags;
448 int enabled;
449 int ref;
450 bool print_max;
451 bool allow_instances;
452#ifdef CONFIG_TRACER_MAX_TRACE
453 bool use_max_tr;
454#endif
455
456 bool noboot;
457};
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487enum {
488 TRACE_BUFFER_BIT,
489 TRACE_BUFFER_NMI_BIT,
490 TRACE_BUFFER_IRQ_BIT,
491 TRACE_BUFFER_SIRQ_BIT,
492
493
494 TRACE_FTRACE_BIT,
495 TRACE_FTRACE_NMI_BIT,
496 TRACE_FTRACE_IRQ_BIT,
497 TRACE_FTRACE_SIRQ_BIT,
498
499
500 TRACE_INTERNAL_BIT,
501 TRACE_INTERNAL_NMI_BIT,
502 TRACE_INTERNAL_IRQ_BIT,
503 TRACE_INTERNAL_SIRQ_BIT,
504
505 TRACE_BRANCH_BIT,
506
507
508
509
510
511
512
513 TRACE_IRQ_BIT,
514};
515
516#define trace_recursion_set(bit) do { (current)->trace_recursion |= (1<<(bit)); } while (0)
517#define trace_recursion_clear(bit) do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
518#define trace_recursion_test(bit) ((current)->trace_recursion & (1<<(bit)))
519
520#define TRACE_CONTEXT_BITS 4
521
522#define TRACE_FTRACE_START TRACE_FTRACE_BIT
523#define TRACE_FTRACE_MAX ((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)
524
525#define TRACE_LIST_START TRACE_INTERNAL_BIT
526#define TRACE_LIST_MAX ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
527
528#define TRACE_CONTEXT_MASK TRACE_LIST_MAX
529
530static __always_inline int trace_get_context_bit(void)
531{
532 int bit;
533
534 if (in_interrupt()) {
535 if (in_nmi())
536 bit = 0;
537
538 else if (in_irq())
539 bit = 1;
540 else
541 bit = 2;
542 } else
543 bit = 3;
544
545 return bit;
546}
547
548static __always_inline int trace_test_and_set_recursion(int start, int max)
549{
550 unsigned int val = current->trace_recursion;
551 int bit;
552
553
554 if ((val & TRACE_CONTEXT_MASK) > max)
555 return 0;
556
557 bit = trace_get_context_bit() + start;
558 if (unlikely(val & (1 << bit)))
559 return -1;
560
561 val |= 1 << bit;
562 current->trace_recursion = val;
563 barrier();
564
565 return bit;
566}
567
568static __always_inline void trace_clear_recursion(int bit)
569{
570 unsigned int val = current->trace_recursion;
571
572 if (!bit)
573 return;
574
575 bit = 1 << bit;
576 val &= ~bit;
577
578 barrier();
579 current->trace_recursion = val;
580}
581
582static inline struct ring_buffer_iter *
583trace_buffer_iter(struct trace_iterator *iter, int cpu)
584{
585 if (iter->buffer_iter && iter->buffer_iter[cpu])
586 return iter->buffer_iter[cpu];
587 return NULL;
588}
589
590int tracer_init(struct tracer *t, struct trace_array *tr);
591int tracing_is_enabled(void);
592void tracing_reset(struct trace_buffer *buf, int cpu);
593void tracing_reset_online_cpus(struct trace_buffer *buf);
594void tracing_reset_current(int cpu);
595void tracing_reset_all_online_cpus(void);
596int tracing_open_generic(struct inode *inode, struct file *filp);
597bool tracing_is_disabled(void);
598int tracer_tracing_is_on(struct trace_array *tr);
599void tracer_tracing_on(struct trace_array *tr);
600void tracer_tracing_off(struct trace_array *tr);
601struct dentry *trace_create_file(const char *name,
602 umode_t mode,
603 struct dentry *parent,
604 void *data,
605 const struct file_operations *fops);
606
607struct dentry *tracing_init_dentry(void);
608
609struct ring_buffer_event;
610
611struct ring_buffer_event *
612trace_buffer_lock_reserve(struct ring_buffer *buffer,
613 int type,
614 unsigned long len,
615 unsigned long flags,
616 int pc);
617
618struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
619 struct trace_array_cpu *data);
620
621struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
622 int *ent_cpu, u64 *ent_ts);
623
624void trace_buffer_unlock_commit_nostack(struct ring_buffer *buffer,
625 struct ring_buffer_event *event);
626
627int trace_empty(struct trace_iterator *iter);
628
629void *trace_find_next_entry_inc(struct trace_iterator *iter);
630
631void trace_init_global_iter(struct trace_iterator *iter);
632
633void tracing_iter_reset(struct trace_iterator *iter, int cpu);
634
635void trace_function(struct trace_array *tr,
636 unsigned long ip,
637 unsigned long parent_ip,
638 unsigned long flags, int pc);
639void trace_graph_function(struct trace_array *tr,
640 unsigned long ip,
641 unsigned long parent_ip,
642 unsigned long flags, int pc);
643void trace_latency_header(struct seq_file *m);
644void trace_default_header(struct seq_file *m);
645void print_trace_header(struct seq_file *m, struct trace_iterator *iter);
646int trace_empty(struct trace_iterator *iter);
647
648void trace_graph_return(struct ftrace_graph_ret *trace);
649int trace_graph_entry(struct ftrace_graph_ent *trace);
650void set_graph_array(struct trace_array *tr);
651
652void tracing_start_cmdline_record(void);
653void tracing_stop_cmdline_record(void);
654void tracing_start_tgid_record(void);
655void tracing_stop_tgid_record(void);
656
657int register_tracer(struct tracer *type);
658int is_tracing_stopped(void);
659
660loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
661
662extern cpumask_var_t __read_mostly tracing_buffer_mask;
663
664#define for_each_tracing_cpu(cpu) \
665 for_each_cpu(cpu, tracing_buffer_mask)
666
667extern unsigned long nsecs_to_usecs(unsigned long nsecs);
668
669extern unsigned long tracing_thresh;
670
671
672
673extern int pid_max;
674
675bool trace_find_filtered_pid(struct trace_pid_list *filtered_pids,
676 pid_t search_pid);
677bool trace_ignore_this_task(struct trace_pid_list *filtered_pids,
678 struct task_struct *task);
679void trace_filter_add_remove_task(struct trace_pid_list *pid_list,
680 struct task_struct *self,
681 struct task_struct *task);
682void *trace_pid_next(struct trace_pid_list *pid_list, void *v, loff_t *pos);
683void *trace_pid_start(struct trace_pid_list *pid_list, loff_t *pos);
684int trace_pid_show(struct seq_file *m, void *v);
685void trace_free_pid_list(struct trace_pid_list *pid_list);
686int trace_pid_write(struct trace_pid_list *filtered_pids,
687 struct trace_pid_list **new_pid_list,
688 const char __user *ubuf, size_t cnt);
689
690#ifdef CONFIG_TRACER_MAX_TRACE
691void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
692void update_max_tr_single(struct trace_array *tr,
693 struct task_struct *tsk, int cpu);
694#endif
695
696#ifdef CONFIG_STACKTRACE
697void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
698 int pc);
699
700void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
701 int pc);
702#else
703static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
704 unsigned long flags, int pc)
705{
706}
707
708static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
709 int skip, int pc)
710{
711}
712#endif
713
714extern u64 ftrace_now(int cpu);
715
716extern void trace_find_cmdline(int pid, char comm[]);
717extern int trace_find_tgid(int pid);
718extern void trace_event_follow_fork(struct trace_array *tr, bool enable);
719
720#ifdef CONFIG_DYNAMIC_FTRACE
721extern unsigned long ftrace_update_tot_cnt;
722void ftrace_init_trace_array(struct trace_array *tr);
723#else
724static inline void ftrace_init_trace_array(struct trace_array *tr) { }
725#endif
726#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
727extern int DYN_FTRACE_TEST_NAME(void);
728#define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
729extern int DYN_FTRACE_TEST_NAME2(void);
730
731extern bool ring_buffer_expanded;
732extern bool tracing_selftest_disabled;
733
734#ifdef CONFIG_FTRACE_STARTUP_TEST
735extern int trace_selftest_startup_function(struct tracer *trace,
736 struct trace_array *tr);
737extern int trace_selftest_startup_function_graph(struct tracer *trace,
738 struct trace_array *tr);
739extern int trace_selftest_startup_irqsoff(struct tracer *trace,
740 struct trace_array *tr);
741extern int trace_selftest_startup_preemptoff(struct tracer *trace,
742 struct trace_array *tr);
743extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
744 struct trace_array *tr);
745extern int trace_selftest_startup_wakeup(struct tracer *trace,
746 struct trace_array *tr);
747extern int trace_selftest_startup_nop(struct tracer *trace,
748 struct trace_array *tr);
749extern int trace_selftest_startup_branch(struct tracer *trace,
750 struct trace_array *tr);
751
752
753
754
755
756#define __tracer_data __refdata
757#else
758
759#define __tracer_data __read_mostly
760#endif
761
762extern void *head_page(struct trace_array_cpu *data);
763extern unsigned long long ns2usecs(u64 nsec);
764extern int
765trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
766extern int
767trace_vprintk(unsigned long ip, const char *fmt, va_list args);
768extern int
769trace_array_vprintk(struct trace_array *tr,
770 unsigned long ip, const char *fmt, va_list args);
771int trace_array_printk(struct trace_array *tr,
772 unsigned long ip, const char *fmt, ...);
773int trace_array_printk_buf(struct ring_buffer *buffer,
774 unsigned long ip, const char *fmt, ...);
775void trace_printk_seq(struct trace_seq *s);
776enum print_line_t print_trace_line(struct trace_iterator *iter);
777
778extern char trace_find_mark(unsigned long long duration);
779
780struct ftrace_hash;
781
782struct ftrace_mod_load {
783 struct list_head list;
784 char *func;
785 char *module;
786 int enable;
787};
788
789enum {
790 FTRACE_HASH_FL_MOD = (1 << 0),
791};
792
793struct ftrace_hash {
794 unsigned long size_bits;
795 struct hlist_head *buckets;
796 unsigned long count;
797 unsigned long flags;
798 struct rcu_head rcu;
799};
800
801struct ftrace_func_entry *
802ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip);
803
804static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)
805{
806 return !hash || !(hash->count || (hash->flags & FTRACE_HASH_FL_MOD));
807}
808
809
810#ifdef CONFIG_FUNCTION_GRAPH_TRACER
811
812
813#define TRACE_GRAPH_PRINT_OVERRUN 0x1
814#define TRACE_GRAPH_PRINT_CPU 0x2
815#define TRACE_GRAPH_PRINT_OVERHEAD 0x4
816#define TRACE_GRAPH_PRINT_PROC 0x8
817#define TRACE_GRAPH_PRINT_DURATION 0x10
818#define TRACE_GRAPH_PRINT_ABS_TIME 0x20
819#define TRACE_GRAPH_PRINT_IRQS 0x40
820#define TRACE_GRAPH_PRINT_TAIL 0x80
821#define TRACE_GRAPH_SLEEP_TIME 0x100
822#define TRACE_GRAPH_GRAPH_TIME 0x200
823#define TRACE_GRAPH_PRINT_FILL_SHIFT 28
824#define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
825
826extern void ftrace_graph_sleep_time_control(bool enable);
827extern void ftrace_graph_graph_time_control(bool enable);
828
829extern enum print_line_t
830print_graph_function_flags(struct trace_iterator *iter, u32 flags);
831extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
832extern void
833trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
834extern void graph_trace_open(struct trace_iterator *iter);
835extern void graph_trace_close(struct trace_iterator *iter);
836extern int __trace_graph_entry(struct trace_array *tr,
837 struct ftrace_graph_ent *trace,
838 unsigned long flags, int pc);
839extern void __trace_graph_return(struct trace_array *tr,
840 struct ftrace_graph_ret *trace,
841 unsigned long flags, int pc);
842
843#ifdef CONFIG_DYNAMIC_FTRACE
844extern struct ftrace_hash *ftrace_graph_hash;
845extern struct ftrace_hash *ftrace_graph_notrace_hash;
846
847static inline int ftrace_graph_addr(unsigned long addr)
848{
849 int ret = 0;
850
851 preempt_disable_notrace();
852
853 if (ftrace_hash_empty(ftrace_graph_hash)) {
854 ret = 1;
855 goto out;
856 }
857
858 if (ftrace_lookup_ip(ftrace_graph_hash, addr)) {
859
860
861
862
863
864 if (in_irq())
865 trace_recursion_set(TRACE_IRQ_BIT);
866 else
867 trace_recursion_clear(TRACE_IRQ_BIT);
868 ret = 1;
869 }
870
871out:
872 preempt_enable_notrace();
873 return ret;
874}
875
876static inline int ftrace_graph_notrace_addr(unsigned long addr)
877{
878 int ret = 0;
879
880 preempt_disable_notrace();
881
882 if (ftrace_lookup_ip(ftrace_graph_notrace_hash, addr))
883 ret = 1;
884
885 preempt_enable_notrace();
886 return ret;
887}
888#else
889static inline int ftrace_graph_addr(unsigned long addr)
890{
891 return 1;
892}
893
894static inline int ftrace_graph_notrace_addr(unsigned long addr)
895{
896 return 0;
897}
898#endif
899
900extern unsigned int fgraph_max_depth;
901
902static inline bool ftrace_graph_ignore_func(struct ftrace_graph_ent *trace)
903{
904
905 return !(trace->depth || ftrace_graph_addr(trace->func)) ||
906 (trace->depth < 0) ||
907 (fgraph_max_depth && trace->depth >= fgraph_max_depth);
908}
909
910#else
911static inline enum print_line_t
912print_graph_function_flags(struct trace_iterator *iter, u32 flags)
913{
914 return TRACE_TYPE_UNHANDLED;
915}
916#endif
917
918extern struct list_head ftrace_pids;
919
920#ifdef CONFIG_FUNCTION_TRACER
921struct ftrace_func_command {
922 struct list_head list;
923 char *name;
924 int (*func)(struct trace_array *tr,
925 struct ftrace_hash *hash,
926 char *func, char *cmd,
927 char *params, int enable);
928};
929extern bool ftrace_filter_param __initdata;
930static inline int ftrace_trace_task(struct trace_array *tr)
931{
932 return !this_cpu_read(tr->trace_buffer.data->ftrace_ignore_pid);
933}
934extern int ftrace_is_dead(void);
935int ftrace_create_function_files(struct trace_array *tr,
936 struct dentry *parent);
937void ftrace_destroy_function_files(struct trace_array *tr);
938void ftrace_init_global_array_ops(struct trace_array *tr);
939void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func);
940void ftrace_reset_array_ops(struct trace_array *tr);
941int using_ftrace_ops_list_func(void);
942void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer);
943void ftrace_init_tracefs_toplevel(struct trace_array *tr,
944 struct dentry *d_tracer);
945void ftrace_clear_pids(struct trace_array *tr);
946int init_function_trace(void);
947void ftrace_pid_follow_fork(struct trace_array *tr, bool enable);
948#else
949static inline int ftrace_trace_task(struct trace_array *tr)
950{
951 return 1;
952}
953static inline int ftrace_is_dead(void) { return 0; }
954static inline int
955ftrace_create_function_files(struct trace_array *tr,
956 struct dentry *parent)
957{
958 return 0;
959}
960static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
961static inline __init void
962ftrace_init_global_array_ops(struct trace_array *tr) { }
963static inline void ftrace_reset_array_ops(struct trace_array *tr) { }
964static inline void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d) { }
965static inline void ftrace_init_tracefs_toplevel(struct trace_array *tr, struct dentry *d) { }
966static inline void ftrace_clear_pids(struct trace_array *tr) { }
967static inline int init_function_trace(void) { return 0; }
968static inline void ftrace_pid_follow_fork(struct trace_array *tr, bool enable) { }
969
970#define ftrace_init_array_ops(tr, func) do { } while (0)
971#endif
972
973#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
974
975struct ftrace_probe_ops {
976 void (*func)(unsigned long ip,
977 unsigned long parent_ip,
978 struct trace_array *tr,
979 struct ftrace_probe_ops *ops,
980 void *data);
981 int (*init)(struct ftrace_probe_ops *ops,
982 struct trace_array *tr,
983 unsigned long ip, void *init_data,
984 void **data);
985 void (*free)(struct ftrace_probe_ops *ops,
986 struct trace_array *tr,
987 unsigned long ip, void *data);
988 int (*print)(struct seq_file *m,
989 unsigned long ip,
990 struct ftrace_probe_ops *ops,
991 void *data);
992};
993
994struct ftrace_func_mapper;
995typedef int (*ftrace_mapper_func)(void *data);
996
997struct ftrace_func_mapper *allocate_ftrace_func_mapper(void);
998void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
999 unsigned long ip);
1000int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
1001 unsigned long ip, void *data);
1002void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper,
1003 unsigned long ip);
1004void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper,
1005 ftrace_mapper_func free_func);
1006
1007extern int
1008register_ftrace_function_probe(char *glob, struct trace_array *tr,
1009 struct ftrace_probe_ops *ops, void *data);
1010extern int
1011unregister_ftrace_function_probe_func(char *glob, struct trace_array *tr,
1012 struct ftrace_probe_ops *ops);
1013extern void clear_ftrace_function_probes(struct trace_array *tr);
1014
1015int register_ftrace_command(struct ftrace_func_command *cmd);
1016int unregister_ftrace_command(struct ftrace_func_command *cmd);
1017
1018void ftrace_create_filter_files(struct ftrace_ops *ops,
1019 struct dentry *parent);
1020void ftrace_destroy_filter_files(struct ftrace_ops *ops);
1021#else
1022struct ftrace_func_command;
1023
1024static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
1025{
1026 return -EINVAL;
1027}
1028static inline __init int unregister_ftrace_command(char *cmd_name)
1029{
1030 return -EINVAL;
1031}
1032static inline void clear_ftrace_function_probes(struct trace_array *tr)
1033{
1034}
1035
1036
1037
1038
1039
1040#define ftrace_create_filter_files(ops, parent) do { } while (0)
1041#define ftrace_destroy_filter_files(ops) do { } while (0)
1042#endif
1043
1044bool ftrace_event_is_function(struct trace_event_call *call);
1045
1046
1047
1048
1049
1050
1051
1052
1053struct trace_parser {
1054 bool cont;
1055 char *buffer;
1056 unsigned idx;
1057 unsigned size;
1058};
1059
1060static inline bool trace_parser_loaded(struct trace_parser *parser)
1061{
1062 return (parser->idx != 0);
1063}
1064
1065static inline bool trace_parser_cont(struct trace_parser *parser)
1066{
1067 return parser->cont;
1068}
1069
1070static inline void trace_parser_clear(struct trace_parser *parser)
1071{
1072 parser->cont = false;
1073 parser->idx = 0;
1074}
1075
1076extern int trace_parser_get_init(struct trace_parser *parser, int size);
1077extern void trace_parser_put(struct trace_parser *parser);
1078extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
1079 size_t cnt, loff_t *ppos);
1080
1081
1082
1083
1084#ifdef CONFIG_FUNCTION_GRAPH_TRACER
1085# define FGRAPH_FLAGS \
1086 C(DISPLAY_GRAPH, "display-graph"),
1087#else
1088# define FGRAPH_FLAGS
1089#endif
1090
1091#ifdef CONFIG_BRANCH_TRACER
1092# define BRANCH_FLAGS \
1093 C(BRANCH, "branch"),
1094#else
1095# define BRANCH_FLAGS
1096#endif
1097
1098#ifdef CONFIG_FUNCTION_TRACER
1099# define FUNCTION_FLAGS \
1100 C(FUNCTION, "function-trace"), \
1101 C(FUNC_FORK, "function-fork"),
1102# define FUNCTION_DEFAULT_FLAGS TRACE_ITER_FUNCTION
1103#else
1104# define FUNCTION_FLAGS
1105# define FUNCTION_DEFAULT_FLAGS 0UL
1106# define TRACE_ITER_FUNC_FORK 0UL
1107#endif
1108
1109#ifdef CONFIG_STACKTRACE
1110# define STACK_FLAGS \
1111 C(STACKTRACE, "stacktrace"),
1112#else
1113# define STACK_FLAGS
1114#endif
1115
1116
1117
1118
1119
1120
1121
1122
1123#define TRACE_FLAGS \
1124 C(PRINT_PARENT, "print-parent"), \
1125 C(SYM_OFFSET, "sym-offset"), \
1126 C(SYM_ADDR, "sym-addr"), \
1127 C(VERBOSE, "verbose"), \
1128 C(RAW, "raw"), \
1129 C(HEX, "hex"), \
1130 C(BIN, "bin"), \
1131 C(BLOCK, "block"), \
1132 C(PRINTK, "trace_printk"), \
1133 C(ANNOTATE, "annotate"), \
1134 C(USERSTACKTRACE, "userstacktrace"), \
1135 C(SYM_USEROBJ, "sym-userobj"), \
1136 C(PRINTK_MSGONLY, "printk-msg-only"), \
1137 C(CONTEXT_INFO, "context-info"), \
1138 C(LATENCY_FMT, "latency-format"), \
1139 C(RECORD_CMD, "record-cmd"), \
1140 C(RECORD_TGID, "record-tgid"), \
1141 C(OVERWRITE, "overwrite"), \
1142 C(STOP_ON_FREE, "disable_on_free"), \
1143 C(IRQ_INFO, "irq-info"), \
1144 C(MARKERS, "markers"), \
1145 C(EVENT_FORK, "event-fork"), \
1146 FUNCTION_FLAGS \
1147 FGRAPH_FLAGS \
1148 STACK_FLAGS \
1149 BRANCH_FLAGS
1150
1151
1152
1153
1154
1155#undef C
1156#define C(a, b) TRACE_ITER_##a##_BIT
1157
1158enum trace_iterator_bits {
1159 TRACE_FLAGS
1160
1161 TRACE_ITER_LAST_BIT
1162};
1163
1164
1165
1166
1167
1168#undef C
1169#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
1170
1171enum trace_iterator_flags { TRACE_FLAGS };
1172
1173
1174
1175
1176
1177#define TRACE_ITER_SYM_MASK \
1178 (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
1179
1180extern struct tracer nop_trace;
1181
1182#ifdef CONFIG_BRANCH_TRACER
1183extern int enable_branch_tracing(struct trace_array *tr);
1184extern void disable_branch_tracing(void);
1185static inline int trace_branch_enable(struct trace_array *tr)
1186{
1187 if (tr->trace_flags & TRACE_ITER_BRANCH)
1188 return enable_branch_tracing(tr);
1189 return 0;
1190}
1191static inline void trace_branch_disable(void)
1192{
1193
1194 disable_branch_tracing();
1195}
1196#else
1197static inline int trace_branch_enable(struct trace_array *tr)
1198{
1199 return 0;
1200}
1201static inline void trace_branch_disable(void)
1202{
1203}
1204#endif
1205
1206
1207int tracing_update_buffers(void);
1208
1209struct ftrace_event_field {
1210 struct list_head link;
1211 const char *name;
1212 const char *type;
1213 int filter_type;
1214 int offset;
1215 int size;
1216 int is_signed;
1217};
1218
1219struct prog_entry;
1220
1221struct event_filter {
1222 struct prog_entry __rcu *prog;
1223 char *filter_string;
1224};
1225
1226struct event_subsystem {
1227 struct list_head list;
1228 const char *name;
1229 struct event_filter *filter;
1230 int ref_count;
1231};
1232
1233struct trace_subsystem_dir {
1234 struct list_head list;
1235 struct event_subsystem *subsystem;
1236 struct trace_array *tr;
1237 struct dentry *entry;
1238 int ref_count;
1239 int nr_events;
1240};
1241
1242extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
1243 struct ring_buffer *buffer,
1244 struct ring_buffer_event *event);
1245
1246void trace_buffer_unlock_commit_regs(struct trace_array *tr,
1247 struct ring_buffer *buffer,
1248 struct ring_buffer_event *event,
1249 unsigned long flags, int pc,
1250 struct pt_regs *regs);
1251
1252static inline void trace_buffer_unlock_commit(struct trace_array *tr,
1253 struct ring_buffer *buffer,
1254 struct ring_buffer_event *event,
1255 unsigned long flags, int pc)
1256{
1257 trace_buffer_unlock_commit_regs(tr, buffer, event, flags, pc, NULL);
1258}
1259
1260DECLARE_PER_CPU(struct ring_buffer_event *, trace_buffered_event);
1261DECLARE_PER_CPU(int, trace_buffered_event_cnt);
1262void trace_buffered_event_disable(void);
1263void trace_buffered_event_enable(void);
1264
1265static inline void
1266__trace_event_discard_commit(struct ring_buffer *buffer,
1267 struct ring_buffer_event *event)
1268{
1269 if (this_cpu_read(trace_buffered_event) == event) {
1270
1271 this_cpu_dec(trace_buffered_event_cnt);
1272 return;
1273 }
1274 ring_buffer_discard_commit(buffer, event);
1275}
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290static inline bool
1291__event_trigger_test_discard(struct trace_event_file *file,
1292 struct ring_buffer *buffer,
1293 struct ring_buffer_event *event,
1294 void *entry,
1295 enum event_trigger_type *tt)
1296{
1297 unsigned long eflags = file->flags;
1298
1299 if (eflags & EVENT_FILE_FL_TRIGGER_COND)
1300 *tt = event_triggers_call(file, entry, event);
1301
1302 if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags) ||
1303 (unlikely(file->flags & EVENT_FILE_FL_FILTERED) &&
1304 !filter_match_preds(file->filter, entry))) {
1305 __trace_event_discard_commit(buffer, event);
1306 return true;
1307 }
1308
1309 return false;
1310}
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325static inline void
1326event_trigger_unlock_commit(struct trace_event_file *file,
1327 struct ring_buffer *buffer,
1328 struct ring_buffer_event *event,
1329 void *entry, unsigned long irq_flags, int pc)
1330{
1331 enum event_trigger_type tt = ETT_NONE;
1332
1333 if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
1334 trace_buffer_unlock_commit(file->tr, buffer, event, irq_flags, pc);
1335
1336 if (tt)
1337 event_triggers_post_call(file, tt, entry, event);
1338}
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356static inline void
1357event_trigger_unlock_commit_regs(struct trace_event_file *file,
1358 struct ring_buffer *buffer,
1359 struct ring_buffer_event *event,
1360 void *entry, unsigned long irq_flags, int pc,
1361 struct pt_regs *regs)
1362{
1363 enum event_trigger_type tt = ETT_NONE;
1364
1365 if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
1366 trace_buffer_unlock_commit_regs(file->tr, buffer, event,
1367 irq_flags, pc, regs);
1368
1369 if (tt)
1370 event_triggers_post_call(file, tt, entry, event);
1371}
1372
1373#define FILTER_PRED_INVALID ((unsigned short)-1)
1374#define FILTER_PRED_IS_RIGHT (1 << 15)
1375#define FILTER_PRED_FOLD (1 << 15)
1376
1377
1378
1379
1380
1381
1382
1383
1384#define MAX_FILTER_PRED 16384
1385
1386struct filter_pred;
1387struct regex;
1388
1389typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
1390
1391typedef int (*regex_match_func)(char *str, struct regex *r, int len);
1392
1393enum regex_type {
1394 MATCH_FULL = 0,
1395 MATCH_FRONT_ONLY,
1396 MATCH_MIDDLE_ONLY,
1397 MATCH_END_ONLY,
1398 MATCH_GLOB,
1399};
1400
1401struct regex {
1402 char pattern[MAX_FILTER_STR_VAL];
1403 int len;
1404 int field_len;
1405 regex_match_func match;
1406};
1407
1408struct filter_pred {
1409 filter_pred_fn_t fn;
1410 u64 val;
1411 struct regex regex;
1412 unsigned short *ops;
1413 struct ftrace_event_field *field;
1414 int offset;
1415 int not;
1416 int op;
1417};
1418
1419static inline bool is_string_field(struct ftrace_event_field *field)
1420{
1421 return field->filter_type == FILTER_DYN_STRING ||
1422 field->filter_type == FILTER_STATIC_STRING ||
1423 field->filter_type == FILTER_PTR_STRING ||
1424 field->filter_type == FILTER_COMM;
1425}
1426
1427static inline bool is_function_field(struct ftrace_event_field *field)
1428{
1429 return field->filter_type == FILTER_TRACE_FN;
1430}
1431
1432extern enum regex_type
1433filter_parse_regex(char *buff, int len, char **search, int *not);
1434extern void print_event_filter(struct trace_event_file *file,
1435 struct trace_seq *s);
1436extern int apply_event_filter(struct trace_event_file *file,
1437 char *filter_string);
1438extern int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
1439 char *filter_string);
1440extern void print_subsystem_event_filter(struct event_subsystem *system,
1441 struct trace_seq *s);
1442extern int filter_assign_type(const char *type);
1443extern int create_event_filter(struct trace_event_call *call,
1444 char *filter_str, bool set_str,
1445 struct event_filter **filterp);
1446extern void free_event_filter(struct event_filter *filter);
1447
1448struct ftrace_event_field *
1449trace_find_event_field(struct trace_event_call *call, char *name);
1450
1451extern void trace_event_enable_cmd_record(bool enable);
1452extern void trace_event_enable_tgid_record(bool enable);
1453
1454extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
1455extern int event_trace_del_tracer(struct trace_array *tr);
1456
1457extern struct trace_event_file *find_event_file(struct trace_array *tr,
1458 const char *system,
1459 const char *event);
1460
1461static inline void *event_file_data(struct file *filp)
1462{
1463 return READ_ONCE(file_inode(filp)->i_private);
1464}
1465
1466extern struct mutex event_mutex;
1467extern struct list_head ftrace_events;
1468
1469extern const struct file_operations event_trigger_fops;
1470extern const struct file_operations event_hist_fops;
1471
1472#ifdef CONFIG_HIST_TRIGGERS
1473extern int register_trigger_hist_cmd(void);
1474extern int register_trigger_hist_enable_disable_cmds(void);
1475#else
1476static inline int register_trigger_hist_cmd(void) { return 0; }
1477static inline int register_trigger_hist_enable_disable_cmds(void) { return 0; }
1478#endif
1479
1480extern int register_trigger_cmds(void);
1481extern void clear_event_triggers(struct trace_array *tr);
1482
1483struct event_trigger_data {
1484 unsigned long count;
1485 int ref;
1486 struct event_trigger_ops *ops;
1487 struct event_command *cmd_ops;
1488 struct event_filter __rcu *filter;
1489 char *filter_str;
1490 void *private_data;
1491 bool paused;
1492 bool paused_tmp;
1493 struct list_head list;
1494 char *name;
1495 struct list_head named_list;
1496 struct event_trigger_data *named_data;
1497};
1498
1499
1500#define ENABLE_EVENT_STR "enable_event"
1501#define DISABLE_EVENT_STR "disable_event"
1502#define ENABLE_HIST_STR "enable_hist"
1503#define DISABLE_HIST_STR "disable_hist"
1504
1505struct enable_trigger_data {
1506 struct trace_event_file *file;
1507 bool enable;
1508 bool hist;
1509};
1510
1511extern int event_enable_trigger_print(struct seq_file *m,
1512 struct event_trigger_ops *ops,
1513 struct event_trigger_data *data);
1514extern void event_enable_trigger_free(struct event_trigger_ops *ops,
1515 struct event_trigger_data *data);
1516extern int event_enable_trigger_func(struct event_command *cmd_ops,
1517 struct trace_event_file *file,
1518 char *glob, char *cmd, char *param);
1519extern int event_enable_register_trigger(char *glob,
1520 struct event_trigger_ops *ops,
1521 struct event_trigger_data *data,
1522 struct trace_event_file *file);
1523extern void event_enable_unregister_trigger(char *glob,
1524 struct event_trigger_ops *ops,
1525 struct event_trigger_data *test,
1526 struct trace_event_file *file);
1527extern void trigger_data_free(struct event_trigger_data *data);
1528extern int event_trigger_init(struct event_trigger_ops *ops,
1529 struct event_trigger_data *data);
1530extern int trace_event_trigger_enable_disable(struct trace_event_file *file,
1531 int trigger_enable);
1532extern void update_cond_flag(struct trace_event_file *file);
1533extern void unregister_trigger(char *glob, struct event_trigger_ops *ops,
1534 struct event_trigger_data *test,
1535 struct trace_event_file *file);
1536extern int set_trigger_filter(char *filter_str,
1537 struct event_trigger_data *trigger_data,
1538 struct trace_event_file *file);
1539extern struct event_trigger_data *find_named_trigger(const char *name);
1540extern bool is_named_trigger(struct event_trigger_data *test);
1541extern int save_named_trigger(const char *name,
1542 struct event_trigger_data *data);
1543extern void del_named_trigger(struct event_trigger_data *data);
1544extern void pause_named_trigger(struct event_trigger_data *data);
1545extern void unpause_named_trigger(struct event_trigger_data *data);
1546extern void set_named_trigger_data(struct event_trigger_data *data,
1547 struct event_trigger_data *named_data);
1548extern struct event_trigger_data *
1549get_named_trigger_data(struct event_trigger_data *data);
1550extern int register_event_command(struct event_command *cmd);
1551extern int unregister_event_command(struct event_command *cmd);
1552extern int register_trigger_hist_enable_disable_cmds(void);
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591struct event_trigger_ops {
1592 void (*func)(struct event_trigger_data *data,
1593 void *rec,
1594 struct ring_buffer_event *rbe);
1595 int (*init)(struct event_trigger_ops *ops,
1596 struct event_trigger_data *data);
1597 void (*free)(struct event_trigger_ops *ops,
1598 struct event_trigger_data *data);
1599 int (*print)(struct seq_file *m,
1600 struct event_trigger_ops *ops,
1601 struct event_trigger_data *data);
1602};
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679struct event_command {
1680 struct list_head list;
1681 char *name;
1682 enum event_trigger_type trigger_type;
1683 int flags;
1684 int (*func)(struct event_command *cmd_ops,
1685 struct trace_event_file *file,
1686 char *glob, char *cmd, char *params);
1687 int (*reg)(char *glob,
1688 struct event_trigger_ops *ops,
1689 struct event_trigger_data *data,
1690 struct trace_event_file *file);
1691 void (*unreg)(char *glob,
1692 struct event_trigger_ops *ops,
1693 struct event_trigger_data *data,
1694 struct trace_event_file *file);
1695 void (*unreg_all)(struct trace_event_file *file);
1696 int (*set_filter)(char *filter_str,
1697 struct event_trigger_data *data,
1698 struct trace_event_file *file);
1699 struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
1700};
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730enum event_command_flags {
1731 EVENT_CMD_FL_POST_TRIGGER = 1,
1732 EVENT_CMD_FL_NEEDS_REC = 2,
1733};
1734
1735static inline bool event_command_post_trigger(struct event_command *cmd_ops)
1736{
1737 return cmd_ops->flags & EVENT_CMD_FL_POST_TRIGGER;
1738}
1739
1740static inline bool event_command_needs_rec(struct event_command *cmd_ops)
1741{
1742 return cmd_ops->flags & EVENT_CMD_FL_NEEDS_REC;
1743}
1744
1745extern int trace_event_enable_disable(struct trace_event_file *file,
1746 int enable, int soft_disable);
1747extern int tracing_alloc_snapshot(void);
1748
1749extern const char *__start___trace_bprintk_fmt[];
1750extern const char *__stop___trace_bprintk_fmt[];
1751
1752extern const char *__start___tracepoint_str[];
1753extern const char *__stop___tracepoint_str[];
1754
1755void trace_printk_control(bool enabled);
1756void trace_printk_init_buffers(void);
1757void trace_printk_start_comm(void);
1758int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
1759int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);
1760
1761#define MAX_EVENT_NAME_LEN 64
1762
1763extern int trace_run_command(const char *buf, int (*createfn)(int, char**));
1764extern ssize_t trace_parse_run_command(struct file *file,
1765 const char __user *buffer, size_t count, loff_t *ppos,
1766 int (*createfn)(int, char**));
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777#define internal_trace_puts(str) __trace_puts(_THIS_IP_, str, strlen(str))
1778
1779#undef FTRACE_ENTRY
1780#define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter) \
1781 extern struct trace_event_call \
1782 __aligned(4) event_##call;
1783#undef FTRACE_ENTRY_DUP
1784#define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print, filter) \
1785 FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
1786 filter)
1787#undef FTRACE_ENTRY_PACKED
1788#define FTRACE_ENTRY_PACKED(call, struct_name, id, tstruct, print, filter) \
1789 FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
1790 filter)
1791
1792#include "trace_entries.h"
1793
1794#if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
1795int perf_ftrace_event_register(struct trace_event_call *call,
1796 enum trace_reg type, void *data);
1797#else
1798#define perf_ftrace_event_register NULL
1799#endif
1800
1801#ifdef CONFIG_FTRACE_SYSCALLS
1802void init_ftrace_syscalls(void);
1803const char *get_syscall_name(int syscall);
1804#else
1805static inline void init_ftrace_syscalls(void) { }
1806static inline const char *get_syscall_name(int syscall)
1807{
1808 return NULL;
1809}
1810#endif
1811
1812#ifdef CONFIG_EVENT_TRACING
1813void trace_event_init(void);
1814void trace_event_eval_update(struct trace_eval_map **map, int len);
1815#else
1816static inline void __init trace_event_init(void) { }
1817static inline void trace_event_eval_update(struct trace_eval_map **map, int len) { }
1818#endif
1819
1820#ifdef CONFIG_TRACER_SNAPSHOT
1821void tracing_snapshot_instance(struct trace_array *tr);
1822int tracing_alloc_snapshot_instance(struct trace_array *tr);
1823#else
1824static inline void tracing_snapshot_instance(struct trace_array *tr) { }
1825static inline int tracing_alloc_snapshot_instance(struct trace_array *tr)
1826{
1827 return 0;
1828}
1829#endif
1830
1831extern struct trace_iterator *tracepoint_print_iter;
1832
1833#endif
1834