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