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