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