1bb730b58SSteven Rostedt (VMware) // SPDX-License-Identifier: GPL-2.0
2bac5fb97STom Zanussi
3bc0c38d1SSteven Rostedt #ifndef _LINUX_KERNEL_TRACE_H
4bc0c38d1SSteven Rostedt #define _LINUX_KERNEL_TRACE_H
5bc0c38d1SSteven Rostedt
6bc0c38d1SSteven Rostedt #include <linux/fs.h>
760063497SArun Sharma #include <linux/atomic.h>
8bc0c38d1SSteven Rostedt #include <linux/sched.h>
9bc0c38d1SSteven Rostedt #include <linux/clocksource.h>
103928a8a2SSteven Rostedt #include <linux/ring_buffer.h>
11bd8ac686SPekka Paalanen #include <linux/mmiotrace.h>
124e5292eaSSteven Rostedt #include <linux/tracepoint.h>
13d13744cdSFrédéric Weisbecker #include <linux/ftrace.h>
142d6425afSDivya Indi #include <linux/trace.h>
1524f1e32cSFrederic Weisbecker #include <linux/hw_breakpoint.h>
169504504cSSteven Rostedt #include <linux/trace_seq.h>
17af658dcaSSteven Rostedt (Red Hat) #include <linux/trace_events.h>
1852f5684cSGideon Israel Dsouza #include <linux/compiler.h>
1960f1d5e3SMasami Hiramatsu #include <linux/glob.h>
2091edde2eSViktor Rosendahl (BMW) #include <linux/irq_work.h>
2191edde2eSViktor Rosendahl (BMW) #include <linux/workqueue.h>
2242d120e2STom Zanussi #include <linux/ctype.h>
23a358f406STanner Love #include <linux/once_lite.h>
249504504cSSteven Rostedt
256954e415SSteven Rostedt (VMware) #include "pid_list.h"
266954e415SSteven Rostedt (VMware)
2712ab74eeSSteven Rostedt #ifdef CONFIG_FTRACE_SYSCALLS
28d6e59579SYang Yang #include <asm/unistd.h> /* For NR_syscalls */
2912ab74eeSSteven Rostedt #include <asm/syscall.h> /* some archs define it here */
3012ab74eeSSteven Rostedt #endif
3112ab74eeSSteven Rostedt
3221ccc9cdSSteven Rostedt (VMware) #define TRACE_MODE_WRITE 0640
3321ccc9cdSSteven Rostedt (VMware) #define TRACE_MODE_READ 0440
3421ccc9cdSSteven Rostedt (VMware)
3572829bc3SThomas Gleixner enum trace_type {
3672829bc3SThomas Gleixner __TRACE_FIRST_TYPE = 0,
3772829bc3SThomas Gleixner
3872829bc3SThomas Gleixner TRACE_FN,
3972829bc3SThomas Gleixner TRACE_CTX,
4072829bc3SThomas Gleixner TRACE_WAKE,
4172829bc3SThomas Gleixner TRACE_STACK,
42dd0e545fSSteven Rostedt TRACE_PRINT,
4348ead020SFrederic Weisbecker TRACE_BPRINT,
44bd8ac686SPekka Paalanen TRACE_MMIO_RW,
45bd8ac686SPekka Paalanen TRACE_MMIO_MAP,
469f029e83SSteven Rostedt TRACE_BRANCH,
47287b6e68SFrederic Weisbecker TRACE_GRAPH_RET,
48287b6e68SFrederic Weisbecker TRACE_GRAPH_ENT,
4902b67518STörök Edwin TRACE_USER_STACK,
50c71a8961SArnaldo Carvalho de Melo TRACE_BLK,
5109ae7234SSteven Rostedt (Red Hat) TRACE_BPUTS,
52e7c15cd8SSteven Rostedt (Red Hat) TRACE_HWLAT,
53bce29ac9SDaniel Bristot de Oliveira TRACE_OSNOISE,
54a955d7eaSDaniel Bristot de Oliveira TRACE_TIMERLAT,
55fa32e855SSteven Rostedt TRACE_RAW_DATA,
56f689e4f2SYordan Karadzhov (VMware) TRACE_FUNC_REPEATS,
5772829bc3SThomas Gleixner
58f0868d1eSSteven Rostedt __TRACE_LAST_TYPE,
5972829bc3SThomas Gleixner };
6072829bc3SThomas Gleixner
6136994e58SFrederic Weisbecker
620a1c49dbSSteven Rostedt #undef __field
630a1c49dbSSteven Rostedt #define __field(type, item) type item;
6436994e58SFrederic Weisbecker
6504ae87a5SPeter Zijlstra #undef __field_fn
6604ae87a5SPeter Zijlstra #define __field_fn(type, item) type item;
6704ae87a5SPeter Zijlstra
68d7315094SSteven Rostedt #undef __field_struct
69d7315094SSteven Rostedt #define __field_struct(type, item) __field(type, item)
70d7315094SSteven Rostedt
71d7315094SSteven Rostedt #undef __field_desc
72d7315094SSteven Rostedt #define __field_desc(type, container, item)
73d7315094SSteven Rostedt
744649079bSSteven Rostedt (VMware) #undef __field_packed
754649079bSSteven Rostedt (VMware) #define __field_packed(type, container, item)
764649079bSSteven Rostedt (VMware)
770a1c49dbSSteven Rostedt #undef __array
780a1c49dbSSteven Rostedt #define __array(type, item, size) type item[size];
790a1c49dbSSteven Rostedt
80e7186af7SSteven Rostedt (Google) /*
81e7186af7SSteven Rostedt (Google) * For backward compatibility, older user space expects to see the
82e7186af7SSteven Rostedt (Google) * kernel_stack event with a fixed size caller field. But today the fix
83e7186af7SSteven Rostedt (Google) * size is ignored by the kernel, and the real structure is dynamic.
84e7186af7SSteven Rostedt (Google) * Expose to user space: "unsigned long caller[8];" but the real structure
85e7186af7SSteven Rostedt (Google) * will be "unsigned long caller[] __counted_by(size)"
86e7186af7SSteven Rostedt (Google) */
87e7186af7SSteven Rostedt (Google) #undef __stack_array
88e7186af7SSteven Rostedt (Google) #define __stack_array(type, item, size, field) type item[] __counted_by(field);
89e7186af7SSteven Rostedt (Google)
90d7315094SSteven Rostedt #undef __array_desc
91d7315094SSteven Rostedt #define __array_desc(type, container, item, size)
92d7315094SSteven Rostedt
930a1c49dbSSteven Rostedt #undef __dynamic_array
940a1c49dbSSteven Rostedt #define __dynamic_array(type, item) type item[];
950a1c49dbSSteven Rostedt
9655de2c0bSMasami Hiramatsu #undef __rel_dynamic_array
9755de2c0bSMasami Hiramatsu #define __rel_dynamic_array(type, item) type item[];
9855de2c0bSMasami Hiramatsu
990a1c49dbSSteven Rostedt #undef F_STRUCT
1000a1c49dbSSteven Rostedt #define F_STRUCT(args...) args
1010a1c49dbSSteven Rostedt
1020a1c49dbSSteven Rostedt #undef FTRACE_ENTRY
10304ae87a5SPeter Zijlstra #define FTRACE_ENTRY(name, struct_name, id, tstruct, print) \
1040a1c49dbSSteven Rostedt struct struct_name { \
1050a1c49dbSSteven Rostedt struct trace_entry ent; \
1060a1c49dbSSteven Rostedt tstruct \
1070a1c49dbSSteven Rostedt }
1080a1c49dbSSteven Rostedt
1090a1c49dbSSteven Rostedt #undef FTRACE_ENTRY_DUP
11004ae87a5SPeter Zijlstra #define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk)
1110a1c49dbSSteven Rostedt
112e59a0bffSJiri Olsa #undef FTRACE_ENTRY_REG
11304ae87a5SPeter Zijlstra #define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, regfn) \
11404ae87a5SPeter Zijlstra FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print))
115e59a0bffSJiri Olsa
116a4a551b8SNamhyung Kim #undef FTRACE_ENTRY_PACKED
11704ae87a5SPeter Zijlstra #define FTRACE_ENTRY_PACKED(name, struct_name, id, tstruct, print) \
11804ae87a5SPeter Zijlstra FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print)) __packed
119a4a551b8SNamhyung Kim
1200a1c49dbSSteven Rostedt #include "trace_entries.h"
1210a1c49dbSSteven Rostedt
12224589e3aSSteven Rostedt (VMware) /* Use this for memory failure errors */
123a358f406STanner Love #define MEM_FAIL(condition, fmt, ...) \
124a358f406STanner Love DO_ONCE_LITE_IF(condition, pr_err, "ERROR: " fmt, ##__VA_ARGS__)
12524589e3aSSteven Rostedt (VMware)
1264ed8f337SMasami Hiramatsu (Google) #define FAULT_STRING "(fault)"
1274ed8f337SMasami Hiramatsu (Google)
12800cf3d67SSteven Rostedt (Google) #define HIST_STACKTRACE_DEPTH 16
12900cf3d67SSteven Rostedt (Google) #define HIST_STACKTRACE_SIZE (HIST_STACKTRACE_DEPTH * sizeof(unsigned long))
13000cf3d67SSteven Rostedt (Google) #define HIST_STACKTRACE_SKIP 5
13100cf3d67SSteven Rostedt (Google)
1320a1c49dbSSteven Rostedt /*
1330a1c49dbSSteven Rostedt * syscalls are special, and need special handling, this is why
1340a1c49dbSSteven Rostedt * they are not included in trace_entries.h
1350a1c49dbSSteven Rostedt */
136bed1ffcaSFrederic Weisbecker struct syscall_trace_enter {
137bed1ffcaSFrederic Weisbecker struct trace_entry ent;
138bed1ffcaSFrederic Weisbecker int nr;
139bed1ffcaSFrederic Weisbecker unsigned long args[];
140bed1ffcaSFrederic Weisbecker };
141bed1ffcaSFrederic Weisbecker
142bed1ffcaSFrederic Weisbecker struct syscall_trace_exit {
143bed1ffcaSFrederic Weisbecker struct trace_entry ent;
144bed1ffcaSFrederic Weisbecker int nr;
14599df5a6aSTom Zanussi long ret;
146bed1ffcaSFrederic Weisbecker };
147bed1ffcaSFrederic Weisbecker
14893ccae7aSMasami Hiramatsu struct kprobe_trace_entry_head {
149413d37d1SMasami Hiramatsu struct trace_entry ent;
150413d37d1SMasami Hiramatsu unsigned long ip;
151413d37d1SMasami Hiramatsu };
152413d37d1SMasami Hiramatsu
1537491e2c4STzvetomir Stoyanov (VMware) struct eprobe_trace_entry_head {
1547491e2c4STzvetomir Stoyanov (VMware) struct trace_entry ent;
1557491e2c4STzvetomir Stoyanov (VMware) };
1567491e2c4STzvetomir Stoyanov (VMware)
15793ccae7aSMasami Hiramatsu struct kretprobe_trace_entry_head {
158413d37d1SMasami Hiramatsu struct trace_entry ent;
159413d37d1SMasami Hiramatsu unsigned long func;
160413d37d1SMasami Hiramatsu unsigned long ret_ip;
161413d37d1SMasami Hiramatsu };
162413d37d1SMasami Hiramatsu
163334e5519SMasami Hiramatsu (Google) struct fentry_trace_entry_head {
164334e5519SMasami Hiramatsu (Google) struct trace_entry ent;
165334e5519SMasami Hiramatsu (Google) unsigned long ip;
166334e5519SMasami Hiramatsu (Google) };
167334e5519SMasami Hiramatsu (Google)
168334e5519SMasami Hiramatsu (Google) struct fexit_trace_entry_head {
169334e5519SMasami Hiramatsu (Google) struct trace_entry ent;
170334e5519SMasami Hiramatsu (Google) unsigned long func;
171334e5519SMasami Hiramatsu (Google) unsigned long ret_ip;
172334e5519SMasami Hiramatsu (Google) };
173334e5519SMasami Hiramatsu (Google)
1745bf9a1eeSPekka Paalanen #define TRACE_BUF_SIZE 1024
175bc0c38d1SSteven Rostedt
1762b6080f2SSteven Rostedt struct trace_array;
1772b6080f2SSteven Rostedt
178bc0c38d1SSteven Rostedt /*
179bc0c38d1SSteven Rostedt * The CPU trace array - it consists of thousands of trace entries
180bc0c38d1SSteven Rostedt * plus some other descriptor data: (for example which task started
181bc0c38d1SSteven Rostedt * the trace, etc.)
182bc0c38d1SSteven Rostedt */
183bc0c38d1SSteven Rostedt struct trace_array_cpu {
184bc0c38d1SSteven Rostedt atomic_t disabled;
1852cadf913SSteven Rostedt void *buffer_page; /* ring buffer spare */
1864e3c3333SIngo Molnar
187438ced17SVaibhav Nagarnaik unsigned long entries;
188bc0c38d1SSteven Rostedt unsigned long saved_latency;
189bc0c38d1SSteven Rostedt unsigned long critical_start;
190bc0c38d1SSteven Rostedt unsigned long critical_end;
191bc0c38d1SSteven Rostedt unsigned long critical_sequence;
192bc0c38d1SSteven Rostedt unsigned long nice;
193bc0c38d1SSteven Rostedt unsigned long policy;
194bc0c38d1SSteven Rostedt unsigned long rt_priority;
1952f26ebd5SSteven Rostedt unsigned long skipped_entries;
196a5a1d1c2SThomas Gleixner u64 preempt_timestamp;
197bc0c38d1SSteven Rostedt pid_t pid;
198d20b92abSEric W. Biederman kuid_t uid;
199bc0c38d1SSteven Rostedt char comm[TASK_COMM_LEN];
2003fdaf80fSSteven Rostedt (Red Hat)
201345ddcc8SSteven Rostedt (Red Hat) #ifdef CONFIG_FUNCTION_TRACER
202717e3f5eSSteven Rostedt (VMware) int ftrace_ignore_pid;
203345ddcc8SSteven Rostedt (Red Hat) #endif
204717e3f5eSSteven Rostedt (VMware) bool ignore_pid;
205bc0c38d1SSteven Rostedt };
206bc0c38d1SSteven Rostedt
2072b6080f2SSteven Rostedt struct tracer;
20837aea98bSSteven Rostedt (Red Hat) struct trace_option_dentry;
2092b6080f2SSteven Rostedt
2101c5eb448SSteven Rostedt (VMware) struct array_buffer {
21112883efbSSteven Rostedt (Red Hat) struct trace_array *tr;
21213292494SSteven Rostedt (VMware) struct trace_buffer *buffer;
21312883efbSSteven Rostedt (Red Hat) struct trace_array_cpu __percpu *data;
214a5a1d1c2SThomas Gleixner u64 time_start;
21512883efbSSteven Rostedt (Red Hat) int cpu;
21612883efbSSteven Rostedt (Red Hat) };
21712883efbSSteven Rostedt (Red Hat)
2189a38a885SSteven Rostedt (Red Hat) #define TRACE_FLAGS_MAX_SIZE 32
2199a38a885SSteven Rostedt (Red Hat)
22037aea98bSSteven Rostedt (Red Hat) struct trace_options {
22137aea98bSSteven Rostedt (Red Hat) struct tracer *tracer;
22237aea98bSSteven Rostedt (Red Hat) struct trace_option_dentry *topts;
22337aea98bSSteven Rostedt (Red Hat) };
22437aea98bSSteven Rostedt (Red Hat)
2256954e415SSteven Rostedt (VMware) struct trace_pid_list *trace_pid_list_alloc(void);
2266954e415SSteven Rostedt (VMware) void trace_pid_list_free(struct trace_pid_list *pid_list);
2276954e415SSteven Rostedt (VMware) bool trace_pid_list_is_set(struct trace_pid_list *pid_list, unsigned int pid);
2286954e415SSteven Rostedt (VMware) int trace_pid_list_set(struct trace_pid_list *pid_list, unsigned int pid);
2296954e415SSteven Rostedt (VMware) int trace_pid_list_clear(struct trace_pid_list *pid_list, unsigned int pid);
2306954e415SSteven Rostedt (VMware) int trace_pid_list_first(struct trace_pid_list *pid_list, unsigned int *pid);
2316954e415SSteven Rostedt (VMware) int trace_pid_list_next(struct trace_pid_list *pid_list, unsigned int pid,
2326954e415SSteven Rostedt (VMware) unsigned int *next);
23349090107SSteven Rostedt (Red Hat)
23427683626SSteven Rostedt (VMware) enum {
23527683626SSteven Rostedt (VMware) TRACE_PIDS = BIT(0),
23627683626SSteven Rostedt (VMware) TRACE_NO_PIDS = BIT(1),
23727683626SSteven Rostedt (VMware) };
23827683626SSteven Rostedt (VMware)
pid_type_enabled(int type,struct trace_pid_list * pid_list,struct trace_pid_list * no_pid_list)23927683626SSteven Rostedt (VMware) static inline bool pid_type_enabled(int type, struct trace_pid_list *pid_list,
24027683626SSteven Rostedt (VMware) struct trace_pid_list *no_pid_list)
24127683626SSteven Rostedt (VMware) {
24227683626SSteven Rostedt (VMware) /* Return true if the pid list in type has pids */
24327683626SSteven Rostedt (VMware) return ((type & TRACE_PIDS) && pid_list) ||
24427683626SSteven Rostedt (VMware) ((type & TRACE_NO_PIDS) && no_pid_list);
24527683626SSteven Rostedt (VMware) }
24627683626SSteven Rostedt (VMware)
still_need_pid_events(int type,struct trace_pid_list * pid_list,struct trace_pid_list * no_pid_list)24727683626SSteven Rostedt (VMware) static inline bool still_need_pid_events(int type, struct trace_pid_list *pid_list,
24827683626SSteven Rostedt (VMware) struct trace_pid_list *no_pid_list)
24927683626SSteven Rostedt (VMware) {
25027683626SSteven Rostedt (VMware) /*
25127683626SSteven Rostedt (VMware) * Turning off what is in @type, return true if the "other"
25227683626SSteven Rostedt (VMware) * pid list, still has pids in it.
25327683626SSteven Rostedt (VMware) */
25427683626SSteven Rostedt (VMware) return (!(type & TRACE_PIDS) && pid_list) ||
25527683626SSteven Rostedt (VMware) (!(type & TRACE_NO_PIDS) && no_pid_list);
25627683626SSteven Rostedt (VMware) }
25727683626SSteven Rostedt (VMware)
258a35873a0STom Zanussi typedef bool (*cond_update_fn_t)(struct trace_array *tr, void *cond_data);
259a35873a0STom Zanussi
260a35873a0STom Zanussi /**
261a35873a0STom Zanussi * struct cond_snapshot - conditional snapshot data and callback
262a35873a0STom Zanussi *
263a35873a0STom Zanussi * The cond_snapshot structure encapsulates a callback function and
264a35873a0STom Zanussi * data associated with the snapshot for a given tracing instance.
265a35873a0STom Zanussi *
266a35873a0STom Zanussi * When a snapshot is taken conditionally, by invoking
267a35873a0STom Zanussi * tracing_snapshot_cond(tr, cond_data), the cond_data passed in is
268a35873a0STom Zanussi * passed in turn to the cond_snapshot.update() function. That data
269a35873a0STom Zanussi * can be compared by the update() implementation with the cond_data
270499f7bb0SQiujun Huang * contained within the struct cond_snapshot instance associated with
271a35873a0STom Zanussi * the trace_array. Because the tr->max_lock is held throughout the
272a35873a0STom Zanussi * update() call, the update() function can directly retrieve the
273a35873a0STom Zanussi * cond_snapshot and cond_data associated with the per-instance
274a35873a0STom Zanussi * snapshot associated with the trace_array.
275a35873a0STom Zanussi *
276a35873a0STom Zanussi * The cond_snapshot.update() implementation can save data to be
277a35873a0STom Zanussi * associated with the snapshot if it decides to, and returns 'true'
278a35873a0STom Zanussi * in that case, or it returns 'false' if the conditional snapshot
279a35873a0STom Zanussi * shouldn't be taken.
280a35873a0STom Zanussi *
281a35873a0STom Zanussi * The cond_snapshot instance is created and associated with the
282a35873a0STom Zanussi * user-defined cond_data by tracing_cond_snapshot_enable().
283a35873a0STom Zanussi * Likewise, the cond_snapshot instance is destroyed and is no longer
284a35873a0STom Zanussi * associated with the trace instance by
285a35873a0STom Zanussi * tracing_cond_snapshot_disable().
286a35873a0STom Zanussi *
287a35873a0STom Zanussi * The method below is required.
288a35873a0STom Zanussi *
289a35873a0STom Zanussi * @update: When a conditional snapshot is invoked, the update()
290a35873a0STom Zanussi * callback function is invoked with the tr->max_lock held. The
291a35873a0STom Zanussi * update() implementation signals whether or not to actually
292a35873a0STom Zanussi * take the snapshot, by returning 'true' if so, 'false' if no
293a35873a0STom Zanussi * snapshot should be taken. Because the max_lock is held for
294a35873a0STom Zanussi * the duration of update(), the implementation is safe to
295499f7bb0SQiujun Huang * directly retrieved and save any implementation data it needs
296a35873a0STom Zanussi * to in association with the snapshot.
297a35873a0STom Zanussi */
298a35873a0STom Zanussi struct cond_snapshot {
299a35873a0STom Zanussi void *cond_data;
300a35873a0STom Zanussi cond_update_fn_t update;
301a35873a0STom Zanussi };
302a35873a0STom Zanussi
303bc0c38d1SSteven Rostedt /*
30420344c54SYordan Karadzhov (VMware) * struct trace_func_repeats - used to keep track of the consecutive
30520344c54SYordan Karadzhov (VMware) * (on the same CPU) calls of a single function.
30620344c54SYordan Karadzhov (VMware) */
30720344c54SYordan Karadzhov (VMware) struct trace_func_repeats {
30820344c54SYordan Karadzhov (VMware) unsigned long ip;
30920344c54SYordan Karadzhov (VMware) unsigned long parent_ip;
31020344c54SYordan Karadzhov (VMware) unsigned long count;
31120344c54SYordan Karadzhov (VMware) u64 ts_last_call;
31220344c54SYordan Karadzhov (VMware) };
31320344c54SYordan Karadzhov (VMware)
31420344c54SYordan Karadzhov (VMware) /*
315bc0c38d1SSteven Rostedt * The trace array - an array of per-CPU trace arrays. This is the
316bc0c38d1SSteven Rostedt * highest level data structure that individual tracers deal with.
317bc0c38d1SSteven Rostedt * They have on/off state as well:
318bc0c38d1SSteven Rostedt */
319bc0c38d1SSteven Rostedt struct trace_array {
320ae63b31eSSteven Rostedt struct list_head list;
321277ba044SSteven Rostedt char *name;
3221c5eb448SSteven Rostedt (VMware) struct array_buffer array_buffer;
32312883efbSSteven Rostedt (Red Hat) #ifdef CONFIG_TRACER_MAX_TRACE
32412883efbSSteven Rostedt (Red Hat) /*
32512883efbSSteven Rostedt (Red Hat) * The max_buffer is used to snapshot the trace when a maximum
32612883efbSSteven Rostedt (Red Hat) * latency is reached, or when the user initiates a snapshot.
32712883efbSSteven Rostedt (Red Hat) * Some tracers will use this to store a maximum trace while
32812883efbSSteven Rostedt (Red Hat) * it continues examining live traces.
32912883efbSSteven Rostedt (Red Hat) *
3301c5eb448SSteven Rostedt (VMware) * The buffers for the max_buffer are set up the same as the array_buffer
33112883efbSSteven Rostedt (Red Hat) * When a snapshot is taken, the buffer of the max_buffer is swapped
3321c5eb448SSteven Rostedt (VMware) * with the buffer of the array_buffer and the buffers are reset for
3331c5eb448SSteven Rostedt (VMware) * the array_buffer so the tracing can continue.
33412883efbSSteven Rostedt (Red Hat) */
3351c5eb448SSteven Rostedt (VMware) struct array_buffer max_buffer;
33645ad21caSSteven Rostedt (Red Hat) bool allocated_snapshot;
337f971cc9aSSteven Rostedt (Red Hat) #endif
338e25e43a4SMasami Hiramatsu (Google) #ifdef CONFIG_TRACER_MAX_TRACE
3396d9b3fa5SSteven Rostedt (Red Hat) unsigned long max_latency;
34091edde2eSViktor Rosendahl (BMW) #ifdef CONFIG_FSNOTIFY
34191edde2eSViktor Rosendahl (BMW) struct dentry *d_max_latency;
34291edde2eSViktor Rosendahl (BMW) struct work_struct fsnotify_work;
34391edde2eSViktor Rosendahl (BMW) struct irq_work fsnotify_irqwork;
34491edde2eSViktor Rosendahl (BMW) #endif
34512883efbSSteven Rostedt (Red Hat) #endif
34649090107SSteven Rostedt (Red Hat) struct trace_pid_list __rcu *filtered_pids;
34727683626SSteven Rostedt (VMware) struct trace_pid_list __rcu *filtered_no_pids;
3480b9b12c1SSteven Rostedt (Red Hat) /*
3490b9b12c1SSteven Rostedt (Red Hat) * max_lock is used to protect the swapping of buffers
3500b9b12c1SSteven Rostedt (Red Hat) * when taking a max snapshot. The buffers themselves are
3510b9b12c1SSteven Rostedt (Red Hat) * protected by per_cpu spinlocks. But the action of the swap
3520b9b12c1SSteven Rostedt (Red Hat) * needs its own lock.
3530b9b12c1SSteven Rostedt (Red Hat) *
3540b9b12c1SSteven Rostedt (Red Hat) * This is defined as a arch_spinlock_t in order to help
3550b9b12c1SSteven Rostedt (Red Hat) * with performance when lockdep debugging is enabled.
3560b9b12c1SSteven Rostedt (Red Hat) *
3570b9b12c1SSteven Rostedt (Red Hat) * It is also used in other places outside the update_max_tr
3580b9b12c1SSteven Rostedt (Red Hat) * so it needs to be defined outside of the
3590b9b12c1SSteven Rostedt (Red Hat) * CONFIG_TRACER_MAX_TRACE.
3600b9b12c1SSteven Rostedt (Red Hat) */
3610b9b12c1SSteven Rostedt (Red Hat) arch_spinlock_t max_lock;
362499e5470SSteven Rostedt int buffer_disabled;
36312ab74eeSSteven Rostedt #ifdef CONFIG_FTRACE_SYSCALLS
36412ab74eeSSteven Rostedt int sys_refcount_enter;
36512ab74eeSSteven Rostedt int sys_refcount_exit;
3667f1d2f82SSteven Rostedt (Red Hat) struct trace_event_file __rcu *enter_syscall_files[NR_syscalls];
3677f1d2f82SSteven Rostedt (Red Hat) struct trace_event_file __rcu *exit_syscall_files[NR_syscalls];
36812ab74eeSSteven Rostedt #endif
3692b6080f2SSteven Rostedt int stop_count;
3702b6080f2SSteven Rostedt int clock_id;
37137aea98bSSteven Rostedt (Red Hat) int nr_topts;
372065e63f9SSteven Rostedt (VMware) bool clear_trace;
37303329f99SSteven Rostedt (VMware) int buffer_percent;
3742f754e77SSteven Rostedt (VMware) unsigned int n_err_log_entries;
3752b6080f2SSteven Rostedt struct tracer *current_trace;
376983f938aSSteven Rostedt (Red Hat) unsigned int trace_flags;
3779a38a885SSteven Rostedt (Red Hat) unsigned char trace_flags_index[TRACE_FLAGS_MAX_SIZE];
378ae63b31eSSteven Rostedt unsigned int flags;
3792b6080f2SSteven Rostedt raw_spinlock_t start_lock;
3802f754e77SSteven Rostedt (VMware) struct list_head err_log;
381ae63b31eSSteven Rostedt struct dentry *dir;
3822b6080f2SSteven Rostedt struct dentry *options;
3832b6080f2SSteven Rostedt struct dentry *percpu_dir;
384*35ee34c0SSteven Rostedt (Google) struct eventfs_inode *event_dir;
38537aea98bSSteven Rostedt (Red Hat) struct trace_options *topts;
386ae63b31eSSteven Rostedt struct list_head systems;
387ae63b31eSSteven Rostedt struct list_head events;
3883dd80953SSteven Rostedt (VMware) struct trace_event_file *trace_marker_file;
389ccfe9e42SAlexander Z Lam cpumask_var_t tracing_cpumask; /* only trace on set CPUs */
390c2489bb7SZheng Yejian /* one per_cpu trace_pipe can be opened by only one user */
391c2489bb7SZheng Yejian cpumask_var_t pipe_cpumask;
392a695cb58SSteven Rostedt (Red Hat) int ref;
3937ef282e0SSteven Rostedt (VMware) int trace_ref;
394f20a5806SSteven Rostedt (Red Hat) #ifdef CONFIG_FUNCTION_TRACER
395f20a5806SSteven Rostedt (Red Hat) struct ftrace_ops *ops;
396345ddcc8SSteven Rostedt (Red Hat) struct trace_pid_list __rcu *function_pids;
397b3b1e6edSSteven Rostedt (VMware) struct trace_pid_list __rcu *function_no_pids;
39804ec7bb6SSteven Rostedt (VMware) #ifdef CONFIG_DYNAMIC_FTRACE
399673feb9dSSteven Rostedt (VMware) /* All of these are protected by the ftrace_lock */
40004ec7bb6SSteven Rostedt (VMware) struct list_head func_probes;
401673feb9dSSteven Rostedt (VMware) struct list_head mod_trace;
402673feb9dSSteven Rostedt (VMware) struct list_head mod_notrace;
40304ec7bb6SSteven Rostedt (VMware) #endif
404f20a5806SSteven Rostedt (Red Hat) /* function tracing enabled */
405f20a5806SSteven Rostedt (Red Hat) int function_enabled;
406f20a5806SSteven Rostedt (Red Hat) #endif
407b94bc80dSSteven Rostedt (VMware) int no_filter_buffering_ref;
408067fe038STom Zanussi struct list_head hist_vars;
409a35873a0STom Zanussi #ifdef CONFIG_TRACER_SNAPSHOT
410a35873a0STom Zanussi struct cond_snapshot *cond_snapshot;
411a35873a0STom Zanussi #endif
41220344c54SYordan Karadzhov (VMware) struct trace_func_repeats __percpu *last_func_repeats;
413bc0c38d1SSteven Rostedt };
414bc0c38d1SSteven Rostedt
415ae63b31eSSteven Rostedt enum {
416ae63b31eSSteven Rostedt TRACE_ARRAY_FL_GLOBAL = (1 << 0)
417ae63b31eSSteven Rostedt };
418ae63b31eSSteven Rostedt
419ae63b31eSSteven Rostedt extern struct list_head ftrace_trace_arrays;
420ae63b31eSSteven Rostedt
421a8227415SAlexander Z Lam extern struct mutex trace_types_lock;
422a8227415SAlexander Z Lam
4238e2e2fa4SSteven Rostedt (Red Hat) extern int trace_array_get(struct trace_array *tr);
4248530dec6SSteven Rostedt (VMware) extern int tracing_check_open_get_tr(struct trace_array *tr);
42589c95fceSTom Zanussi extern struct trace_array *trace_array_find(const char *instance);
42689c95fceSTom Zanussi extern struct trace_array *trace_array_find_get(const char *instance);
4278e2e2fa4SSteven Rostedt (Red Hat)
428d8279bfcSSteven Rostedt (VMware) extern u64 tracing_event_time_stamp(struct trace_buffer *buffer, struct ring_buffer_event *rbe);
429b94bc80dSSteven Rostedt (VMware) extern int tracing_set_filter_buffering(struct trace_array *tr, bool set);
430d71bd34dSTom Zanussi extern int tracing_set_clock(struct trace_array *tr, const char *clockstr);
43100b41452STom Zanussi
432860f9f6bSTom Zanussi extern bool trace_clock_in_ns(struct trace_array *tr);
433860f9f6bSTom Zanussi
434ae63b31eSSteven Rostedt /*
435ae63b31eSSteven Rostedt * The global tracer (top) should be the first trace array added,
436ae63b31eSSteven Rostedt * but we check the flag anyway.
437ae63b31eSSteven Rostedt */
top_trace_array(void)438ae63b31eSSteven Rostedt static inline struct trace_array *top_trace_array(void)
439ae63b31eSSteven Rostedt {
440ae63b31eSSteven Rostedt struct trace_array *tr;
441ae63b31eSSteven Rostedt
442da9c3413SSteven Rostedt (Red Hat) if (list_empty(&ftrace_trace_arrays))
443dc81e5e3SYoshihiro YUNOMAE return NULL;
444dc81e5e3SYoshihiro YUNOMAE
445ae63b31eSSteven Rostedt tr = list_entry(ftrace_trace_arrays.prev,
446ae63b31eSSteven Rostedt typeof(*tr), list);
447ae63b31eSSteven Rostedt WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
448ae63b31eSSteven Rostedt return tr;
449ae63b31eSSteven Rostedt }
450ae63b31eSSteven Rostedt
4517104f300SSteven Rostedt #define FTRACE_CMP_TYPE(var, type) \
4527104f300SSteven Rostedt __builtin_types_compatible_p(typeof(var), type *)
4537104f300SSteven Rostedt
4547104f300SSteven Rostedt #undef IF_ASSIGN
4557104f300SSteven Rostedt #define IF_ASSIGN(var, entry, etype, id) \
4567104f300SSteven Rostedt if (FTRACE_CMP_TYPE(var, etype)) { \
4577104f300SSteven Rostedt var = (typeof(var))(entry); \
458968e5170SNathan Chancellor WARN_ON(id != 0 && (entry)->type != id); \
4597104f300SSteven Rostedt break; \
4607104f300SSteven Rostedt }
4617104f300SSteven Rostedt
4627104f300SSteven Rostedt /* Will cause compile errors if type is not found. */
4637104f300SSteven Rostedt extern void __ftrace_bad_type(void);
4647104f300SSteven Rostedt
4657104f300SSteven Rostedt /*
4667104f300SSteven Rostedt * The trace_assign_type is a verifier that the entry type is
4677104f300SSteven Rostedt * the same as the type being assigned. To add new types simply
4687104f300SSteven Rostedt * add a line with the following format:
4697104f300SSteven Rostedt *
4707104f300SSteven Rostedt * IF_ASSIGN(var, ent, type, id);
4717104f300SSteven Rostedt *
4727104f300SSteven Rostedt * Where "type" is the trace type that includes the trace_entry
4737104f300SSteven Rostedt * as the "ent" item. And "id" is the trace identifier that is
4747104f300SSteven Rostedt * used in the trace_type enum.
4757104f300SSteven Rostedt *
4767104f300SSteven Rostedt * If the type can have more than one id, then use zero.
4777104f300SSteven Rostedt */
4787104f300SSteven Rostedt #define trace_assign_type(var, ent) \
4797104f300SSteven Rostedt do { \
4807104f300SSteven Rostedt IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \
4817104f300SSteven Rostedt IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \
4827104f300SSteven Rostedt IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \
48302b67518STörök Edwin IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
4847104f300SSteven Rostedt IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
48548ead020SFrederic Weisbecker IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
48609ae7234SSteven Rostedt (Red Hat) IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS); \
487e7c15cd8SSteven Rostedt (Red Hat) IF_ASSIGN(var, ent, struct hwlat_entry, TRACE_HWLAT); \
488bce29ac9SDaniel Bristot de Oliveira IF_ASSIGN(var, ent, struct osnoise_entry, TRACE_OSNOISE);\
489a955d7eaSDaniel Bristot de Oliveira IF_ASSIGN(var, ent, struct timerlat_entry, TRACE_TIMERLAT);\
490fa32e855SSteven Rostedt IF_ASSIGN(var, ent, struct raw_data_entry, TRACE_RAW_DATA);\
4917104f300SSteven Rostedt IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \
4927104f300SSteven Rostedt TRACE_MMIO_RW); \
4937104f300SSteven Rostedt IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \
4947104f300SSteven Rostedt TRACE_MMIO_MAP); \
4959f029e83SSteven Rostedt IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
496287b6e68SFrederic Weisbecker IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \
497287b6e68SFrederic Weisbecker TRACE_GRAPH_ENT); \
498287b6e68SFrederic Weisbecker IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \
499287b6e68SFrederic Weisbecker TRACE_GRAPH_RET); \
500f689e4f2SYordan Karadzhov (VMware) IF_ASSIGN(var, ent, struct func_repeats_entry, \
501f689e4f2SYordan Karadzhov (VMware) TRACE_FUNC_REPEATS); \
5027104f300SSteven Rostedt __ftrace_bad_type(); \
5037104f300SSteven Rostedt } while (0)
5042c4f035fSFrederic Weisbecker
505adf9f195SFrederic Weisbecker /*
506adf9f195SFrederic Weisbecker * An option specific to a tracer. This is a boolean value.
507adf9f195SFrederic Weisbecker * The bit is the bit index that sets its value on the
508adf9f195SFrederic Weisbecker * flags value in struct tracer_flags.
509adf9f195SFrederic Weisbecker */
510adf9f195SFrederic Weisbecker struct tracer_opt {
511adf9f195SFrederic Weisbecker const char *name; /* Will appear on the trace_options file */
512adf9f195SFrederic Weisbecker u32 bit; /* Mask assigned in val field in tracer_flags */
513adf9f195SFrederic Weisbecker };
514adf9f195SFrederic Weisbecker
515adf9f195SFrederic Weisbecker /*
516adf9f195SFrederic Weisbecker * The set of specific options for a tracer. Your tracer
517adf9f195SFrederic Weisbecker * have to set the initial value of the flags val.
518adf9f195SFrederic Weisbecker */
519adf9f195SFrederic Weisbecker struct tracer_flags {
520adf9f195SFrederic Weisbecker u32 val;
521adf9f195SFrederic Weisbecker struct tracer_opt *opts;
522d39cdd20SChunyu Hu struct tracer *trace;
523adf9f195SFrederic Weisbecker };
524adf9f195SFrederic Weisbecker
525adf9f195SFrederic Weisbecker /* Makes more easy to define a tracer opt */
526adf9f195SFrederic Weisbecker #define TRACER_OPT(s, b) .name = #s, .bit = b
527adf9f195SFrederic Weisbecker
528034939b6SFrederic Weisbecker
52941d9c0beSSteven Rostedt (Red Hat) struct trace_option_dentry {
53041d9c0beSSteven Rostedt (Red Hat) struct tracer_opt *opt;
53141d9c0beSSteven Rostedt (Red Hat) struct tracer_flags *flags;
53241d9c0beSSteven Rostedt (Red Hat) struct trace_array *tr;
53341d9c0beSSteven Rostedt (Red Hat) struct dentry *entry;
53441d9c0beSSteven Rostedt (Red Hat) };
53541d9c0beSSteven Rostedt (Red Hat)
5366eaaa5d5SFrederic Weisbecker /**
5378434dc93SSteven Rostedt (Red Hat) * struct tracer - a specific tracer and its callbacks to interact with tracefs
5386eaaa5d5SFrederic Weisbecker * @name: the name chosen to select it on the available_tracers file
5396eaaa5d5SFrederic Weisbecker * @init: called when one switches to this tracer (echo name > current_tracer)
5406eaaa5d5SFrederic Weisbecker * @reset: called when one switches to another tracer
54105a724bdSChuyu Hu * @start: called when tracing is unpaused (echo 1 > tracing_on)
54205a724bdSChuyu Hu * @stop: called when tracing is paused (echo 0 > tracing_on)
5436508fa76SStanislav Fomichev * @update_thresh: called when tracing_thresh is updated
5446eaaa5d5SFrederic Weisbecker * @open: called when the trace file is opened
5456eaaa5d5SFrederic Weisbecker * @pipe_open: called when the trace_pipe file is opened
5466eaaa5d5SFrederic Weisbecker * @close: called when the trace file is released
547c521efd1SSteven Rostedt * @pipe_close: called when the trace_pipe file is released
5486eaaa5d5SFrederic Weisbecker * @read: override the default read callback on trace_pipe
5496eaaa5d5SFrederic Weisbecker * @splice_read: override the default splice_read callback on trace_pipe
5506eaaa5d5SFrederic Weisbecker * @selftest: selftest to run on boot (see trace_selftest.c)
5516eaaa5d5SFrederic Weisbecker * @print_headers: override the first lines that describe your columns
5526eaaa5d5SFrederic Weisbecker * @print_line: callback that prints a trace
5536eaaa5d5SFrederic Weisbecker * @set_flag: signals one of your private flags changed (trace_options file)
5546eaaa5d5SFrederic Weisbecker * @flags: your private flags
555bc0c38d1SSteven Rostedt */
556bc0c38d1SSteven Rostedt struct tracer {
557bc0c38d1SSteven Rostedt const char *name;
5581c80025aSFrederic Weisbecker int (*init)(struct trace_array *tr);
559bc0c38d1SSteven Rostedt void (*reset)(struct trace_array *tr);
5609036990dSSteven Rostedt void (*start)(struct trace_array *tr);
5619036990dSSteven Rostedt void (*stop)(struct trace_array *tr);
5626508fa76SStanislav Fomichev int (*update_thresh)(struct trace_array *tr);
563bc0c38d1SSteven Rostedt void (*open)(struct trace_iterator *iter);
564107bad8bSSteven Rostedt void (*pipe_open)(struct trace_iterator *iter);
565bc0c38d1SSteven Rostedt void (*close)(struct trace_iterator *iter);
566c521efd1SSteven Rostedt void (*pipe_close)(struct trace_iterator *iter);
567107bad8bSSteven Rostedt ssize_t (*read)(struct trace_iterator *iter,
568107bad8bSSteven Rostedt struct file *filp, char __user *ubuf,
569107bad8bSSteven Rostedt size_t cnt, loff_t *ppos);
5703c56819bSEduard - Gabriel Munteanu ssize_t (*splice_read)(struct trace_iterator *iter,
5713c56819bSEduard - Gabriel Munteanu struct file *filp,
5723c56819bSEduard - Gabriel Munteanu loff_t *ppos,
5733c56819bSEduard - Gabriel Munteanu struct pipe_inode_info *pipe,
5743c56819bSEduard - Gabriel Munteanu size_t len,
5753c56819bSEduard - Gabriel Munteanu unsigned int flags);
57660a11774SSteven Rostedt #ifdef CONFIG_FTRACE_STARTUP_TEST
57760a11774SSteven Rostedt int (*selftest)(struct tracer *trace,
57860a11774SSteven Rostedt struct trace_array *tr);
57960a11774SSteven Rostedt #endif
5808bba1bf5SMarkus Metzger void (*print_header)(struct seq_file *m);
5812c4f035fSFrederic Weisbecker enum print_line_t (*print_line)(struct trace_iterator *iter);
582adf9f195SFrederic Weisbecker /* If you handled the flag setting, return 0 */
5838c1a49aeSSteven Rostedt (Red Hat) int (*set_flag)(struct trace_array *tr,
5848c1a49aeSSteven Rostedt (Red Hat) u32 old_flags, u32 bit, int set);
585613f04a0SSteven Rostedt (Red Hat) /* Return 0 if OK with change, else return non-zero */
586bf6065b5SSteven Rostedt (Red Hat) int (*flag_changed)(struct trace_array *tr,
587613f04a0SSteven Rostedt (Red Hat) u32 mask, int set);
588bc0c38d1SSteven Rostedt struct tracer *next;
589adf9f195SFrederic Weisbecker struct tracer_flags *flags;
59050512ab5SSteven Rostedt (Red Hat) int enabled;
591f43c738bSHiraku Toyooka bool print_max;
592607e2ea1SSteven Rostedt (Red Hat) bool allow_instances;
59312883efbSSteven Rostedt (Red Hat) #ifdef CONFIG_TRACER_MAX_TRACE
594f43c738bSHiraku Toyooka bool use_max_tr;
59512883efbSSteven Rostedt (Red Hat) #endif
596c7b3ae0bSZiqian SUN (Zamir) /* True if tracer cannot be enabled in kernel param */
597c7b3ae0bSZiqian SUN (Zamir) bool noboot;
598bc0c38d1SSteven Rostedt };
599bc0c38d1SSteven Rostedt
6006d158a81SSteven Rostedt static inline struct ring_buffer_iter *
trace_buffer_iter(struct trace_iterator * iter,int cpu)6016d158a81SSteven Rostedt trace_buffer_iter(struct trace_iterator *iter, int cpu)
6026d158a81SSteven Rostedt {
603f26808baSyuan linyu return iter->buffer_iter ? iter->buffer_iter[cpu] : NULL;
6046d158a81SSteven Rostedt }
6056d158a81SSteven Rostedt
606b6f11df2SArnaldo Carvalho de Melo int tracer_init(struct tracer *t, struct trace_array *tr);
6079036990dSSteven Rostedt int tracing_is_enabled(void);
6081c5eb448SSteven Rostedt (VMware) void tracing_reset_online_cpus(struct array_buffer *buf);
609873c642fSSteven Rostedt (Red Hat) void tracing_reset_all_online_cpus(void);
610e18eb878SSteven Rostedt (Google) void tracing_reset_all_online_cpus_unlocked(void);
611bc0c38d1SSteven Rostedt int tracing_open_generic(struct inode *inode, struct file *filp);
612aa07d71fSSteven Rostedt (VMware) int tracing_open_generic_tr(struct inode *inode, struct file *filp);
613f5ca233eSSteven Rostedt (Google) int tracing_open_file_tr(struct inode *inode, struct file *filp);
614f5ca233eSSteven Rostedt (Google) int tracing_release_file_tr(struct inode *inode, struct file *filp);
615d9a6029dSZheng Yejian int tracing_single_release_file_tr(struct inode *inode, struct file *filp);
6162e86421dSGeyslan G. Bem bool tracing_is_disabled(void);
617ec573508SSteven Rostedt (VMware) bool tracer_tracing_is_on(struct trace_array *tr);
6182290f2c5SSteven Rostedt (VMware) void tracer_tracing_on(struct trace_array *tr);
6192290f2c5SSteven Rostedt (VMware) void tracer_tracing_off(struct trace_array *tr);
6205452af66SFrederic Weisbecker struct dentry *trace_create_file(const char *name,
621f4ae40a6SAl Viro umode_t mode,
6225452af66SFrederic Weisbecker struct dentry *parent,
6235452af66SFrederic Weisbecker void *data,
6245452af66SFrederic Weisbecker const struct file_operations *fops);
6255452af66SFrederic Weisbecker
62622c36b18SWei Yang int tracing_init_dentry(void);
627d618b3e6SIngo Molnar
62851a763ddSArnaldo Carvalho de Melo struct ring_buffer_event;
62951a763ddSArnaldo Carvalho de Melo
630e77405adSSteven Rostedt struct ring_buffer_event *
63113292494SSteven Rostedt (VMware) trace_buffer_lock_reserve(struct trace_buffer *buffer,
6327a4f453bSLi Zefan int type,
63351a763ddSArnaldo Carvalho de Melo unsigned long len,
63436590c50SSebastian Andrzej Siewior unsigned int trace_ctx);
63551a763ddSArnaldo Carvalho de Melo
63645dcd8b8SPekka Paalanen struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
63745dcd8b8SPekka Paalanen struct trace_array_cpu *data);
638c4a8e8beSFrederic Weisbecker
639c4a8e8beSFrederic Weisbecker struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
640c4a8e8beSFrederic Weisbecker int *ent_cpu, u64 *ent_ts);
641c4a8e8beSFrederic Weisbecker
64213292494SSteven Rostedt (VMware) void trace_buffer_unlock_commit_nostack(struct trace_buffer *buffer,
6437ffbd48dSSteven Rostedt struct ring_buffer_event *event);
6447ffbd48dSSteven Rostedt
6459a6944feSSteven Rostedt (VMware) bool trace_is_tracepoint_string(const char *str);
646efbbdaa2SMasami Hiramatsu const char *trace_event_format(struct trace_iterator *iter, const char *fmt);
6479a6944feSSteven Rostedt (VMware) void trace_check_vprintf(struct trace_iterator *iter, const char *fmt,
648bfd5a5e8SDavid Howells va_list ap) __printf(2, 0);
64980a76994SSteven Rostedt (Google) char *trace_iter_expand_format(struct trace_iterator *iter);
650efbbdaa2SMasami Hiramatsu
651955b61e5SJason Wessel int trace_empty(struct trace_iterator *iter);
652955b61e5SJason Wessel
653955b61e5SJason Wessel void *trace_find_next_entry_inc(struct trace_iterator *iter);
654955b61e5SJason Wessel
655955b61e5SJason Wessel void trace_init_global_iter(struct trace_iterator *iter);
656955b61e5SJason Wessel
657955b61e5SJason Wessel void tracing_iter_reset(struct trace_iterator *iter, int cpu);
658955b61e5SJason Wessel
659ecffc8a8SDouglas Anderson unsigned long trace_total_entries_cpu(struct trace_array *tr, int cpu);
660ecffc8a8SDouglas Anderson unsigned long trace_total_entries(struct trace_array *tr);
661ecffc8a8SDouglas Anderson
6626fb44b71SSteven Rostedt void trace_function(struct trace_array *tr,
6636fb44b71SSteven Rostedt unsigned long ip,
6646fb44b71SSteven Rostedt unsigned long parent_ip,
66536590c50SSebastian Andrzej Siewior unsigned int trace_ctx);
6660a772620SJiri Olsa void trace_graph_function(struct trace_array *tr,
6670a772620SJiri Olsa unsigned long ip,
6680a772620SJiri Olsa unsigned long parent_ip,
66936590c50SSebastian Andrzej Siewior unsigned int trace_ctx);
6707e9a49efSJiri Olsa void trace_latency_header(struct seq_file *m);
67162b915f1SJiri Olsa void trace_default_header(struct seq_file *m);
67262b915f1SJiri Olsa void print_trace_header(struct seq_file *m, struct trace_iterator *iter);
673bc0c38d1SSteven Rostedt
674287b6e68SFrederic Weisbecker void trace_graph_return(struct ftrace_graph_ret *trace);
675e49dc19cSSteven Rostedt int trace_graph_entry(struct ftrace_graph_ent *trace);
6761a0799a8SFrederic Weisbecker void set_graph_array(struct trace_array *tr);
6771e9b51c2SMarkus Metzger
67841bc8144SSteven Rostedt void tracing_start_cmdline_record(void);
67941bc8144SSteven Rostedt void tracing_stop_cmdline_record(void);
680d914ba37SJoel Fernandes void tracing_start_tgid_record(void);
681d914ba37SJoel Fernandes void tracing_stop_tgid_record(void);
682d914ba37SJoel Fernandes
683bc0c38d1SSteven Rostedt int register_tracer(struct tracer *type);
684b5130b1eSCarsten Emde int is_tracing_stopped(void);
685955b61e5SJason Wessel
686098c879eSSteven Rostedt (Red Hat) loff_t tracing_lseek(struct file *file, loff_t offset, int whence);
687098c879eSSteven Rostedt (Red Hat)
688955b61e5SJason Wessel extern cpumask_var_t __read_mostly tracing_buffer_mask;
689955b61e5SJason Wessel
690955b61e5SJason Wessel #define for_each_tracing_cpu(cpu) \
691955b61e5SJason Wessel for_each_cpu(cpu, tracing_buffer_mask)
692bc0c38d1SSteven Rostedt
693bc0c38d1SSteven Rostedt extern unsigned long nsecs_to_usecs(unsigned long nsecs);
694bc0c38d1SSteven Rostedt
6950e950173STim Bird extern unsigned long tracing_thresh;
6960e950173STim Bird
6974e267db1SSteven Rostedt /* PID filtering */
69876c813e2SSteven Rostedt (Red Hat)
69976c813e2SSteven Rostedt (Red Hat) extern int pid_max;
70076c813e2SSteven Rostedt (Red Hat)
7014e267db1SSteven Rostedt bool trace_find_filtered_pid(struct trace_pid_list *filtered_pids,
7024e267db1SSteven Rostedt pid_t search_pid);
7034e267db1SSteven Rostedt bool trace_ignore_this_task(struct trace_pid_list *filtered_pids,
704b3b1e6edSSteven Rostedt (VMware) struct trace_pid_list *filtered_no_pids,
7054e267db1SSteven Rostedt struct task_struct *task);
7064e267db1SSteven Rostedt void trace_filter_add_remove_task(struct trace_pid_list *pid_list,
7074e267db1SSteven Rostedt struct task_struct *self,
7084e267db1SSteven Rostedt struct task_struct *task);
7095cc8976bSSteven Rostedt (Red Hat) void *trace_pid_next(struct trace_pid_list *pid_list, void *v, loff_t *pos);
7105cc8976bSSteven Rostedt (Red Hat) void *trace_pid_start(struct trace_pid_list *pid_list, loff_t *pos);
7115cc8976bSSteven Rostedt (Red Hat) int trace_pid_show(struct seq_file *m, void *v);
71276c813e2SSteven Rostedt (Red Hat) int trace_pid_write(struct trace_pid_list *filtered_pids,
71376c813e2SSteven Rostedt (Red Hat) struct trace_pid_list **new_pid_list,
71476c813e2SSteven Rostedt (Red Hat) const char __user *ubuf, size_t cnt);
7154e267db1SSteven Rostedt
7165d4a9dbaSSteven Rostedt #ifdef CONFIG_TRACER_MAX_TRACE
717a35873a0STom Zanussi void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu,
718a35873a0STom Zanussi void *cond_data);
719bc0c38d1SSteven Rostedt void update_max_tr_single(struct trace_array *tr,
720bc0c38d1SSteven Rostedt struct task_struct *tsk, int cpu);
721bc0c38d1SSteven Rostedt
722e25e43a4SMasami Hiramatsu (Google) #ifdef CONFIG_FSNOTIFY
7236880c987SSteven Rostedt (VMware) #define LATENCY_FS_NOTIFY
7246880c987SSteven Rostedt (VMware) #endif
725e25e43a4SMasami Hiramatsu (Google) #endif /* CONFIG_TRACER_MAX_TRACE */
72691edde2eSViktor Rosendahl (BMW)
7276880c987SSteven Rostedt (VMware) #ifdef LATENCY_FS_NOTIFY
72891edde2eSViktor Rosendahl (BMW) void latency_fsnotify(struct trace_array *tr);
72991edde2eSViktor Rosendahl (BMW) #else
latency_fsnotify(struct trace_array * tr)73036b3615dSSteven Rostedt (VMware) static inline void latency_fsnotify(struct trace_array *tr) { }
73191edde2eSViktor Rosendahl (BMW) #endif
73291edde2eSViktor Rosendahl (BMW)
733c0a0d0d3SFrederic Weisbecker #ifdef CONFIG_STACKTRACE
73436590c50SSebastian Andrzej Siewior void __trace_stack(struct trace_array *tr, unsigned int trace_ctx, int skip);
735c0a0d0d3SFrederic Weisbecker #else
__trace_stack(struct trace_array * tr,unsigned int trace_ctx,int skip)73636590c50SSebastian Andrzej Siewior static inline void __trace_stack(struct trace_array *tr, unsigned int trace_ctx,
73736590c50SSebastian Andrzej Siewior int skip)
738c0a0d0d3SFrederic Weisbecker {
739c0a0d0d3SFrederic Weisbecker }
740c0a0d0d3SFrederic Weisbecker #endif /* CONFIG_STACKTRACE */
741c0a0d0d3SFrederic Weisbecker
742c658797fSYordan Karadzhov (VMware) void trace_last_func_repeats(struct trace_array *tr,
743c658797fSYordan Karadzhov (VMware) struct trace_func_repeats *last_info,
744c658797fSYordan Karadzhov (VMware) unsigned int trace_ctx);
745c658797fSYordan Karadzhov (VMware)
746a5a1d1c2SThomas Gleixner extern u64 ftrace_now(int cpu);
747bc0c38d1SSteven Rostedt
7484ca53085SSteven Rostedt extern void trace_find_cmdline(int pid, char comm[]);
749d914ba37SJoel Fernandes extern int trace_find_tgid(int pid);
750c37775d5SSteven Rostedt extern void trace_event_follow_fork(struct trace_array *tr, bool enable);
751f7d48cbdSIngo Molnar
752bc0c38d1SSteven Rostedt #ifdef CONFIG_DYNAMIC_FTRACE
753bc0c38d1SSteven Rostedt extern unsigned long ftrace_update_tot_cnt;
754da537f0aSSteven Rostedt (VMware) extern unsigned long ftrace_number_of_pages;
755da537f0aSSteven Rostedt (VMware) extern unsigned long ftrace_number_of_groups;
75604ec7bb6SSteven Rostedt (VMware) void ftrace_init_trace_array(struct trace_array *tr);
75704ec7bb6SSteven Rostedt (VMware) #else
ftrace_init_trace_array(struct trace_array * tr)75804ec7bb6SSteven Rostedt (VMware) static inline void ftrace_init_trace_array(struct trace_array *tr) { }
759ad97772aSSteven Rostedt #endif
760d05cdb25SSteven Rostedt #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
761d05cdb25SSteven Rostedt extern int DYN_FTRACE_TEST_NAME(void);
76295950c2eSSteven Rostedt #define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
76395950c2eSSteven Rostedt extern int DYN_FTRACE_TEST_NAME2(void);
764bc0c38d1SSteven Rostedt
76555034cd6SSteven Rostedt (Red Hat) extern bool ring_buffer_expanded;
766020e5f85SLi Zefan extern bool tracing_selftest_disabled;
767020e5f85SLi Zefan
76860a11774SSteven Rostedt #ifdef CONFIG_FTRACE_STARTUP_TEST
76960efe21eSMasami Hiramatsu extern void __init disable_tracing_selftest(const char *reason);
77060efe21eSMasami Hiramatsu
77160a11774SSteven Rostedt extern int trace_selftest_startup_function(struct tracer *trace,
77260a11774SSteven Rostedt struct trace_array *tr);
7737447dce9SFrederic Weisbecker extern int trace_selftest_startup_function_graph(struct tracer *trace,
7747447dce9SFrederic Weisbecker struct trace_array *tr);
77560a11774SSteven Rostedt extern int trace_selftest_startup_irqsoff(struct tracer *trace,
77660a11774SSteven Rostedt struct trace_array *tr);
77760a11774SSteven Rostedt extern int trace_selftest_startup_preemptoff(struct tracer *trace,
77860a11774SSteven Rostedt struct trace_array *tr);
77960a11774SSteven Rostedt extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
78060a11774SSteven Rostedt struct trace_array *tr);
78160a11774SSteven Rostedt extern int trace_selftest_startup_wakeup(struct tracer *trace,
78260a11774SSteven Rostedt struct trace_array *tr);
783fb1b6d8bSSteven Noonan extern int trace_selftest_startup_nop(struct tracer *trace,
784fb1b6d8bSSteven Noonan struct trace_array *tr);
78580e5ea45SSteven Rostedt extern int trace_selftest_startup_branch(struct tracer *trace,
78680e5ea45SSteven Rostedt struct trace_array *tr);
7878f768993SSteven Rostedt (Red Hat) /*
7888f768993SSteven Rostedt (Red Hat) * Tracer data references selftest functions that only occur
7898f768993SSteven Rostedt (Red Hat) * on boot up. These can be __init functions. Thus, when selftests
7908f768993SSteven Rostedt (Red Hat) * are enabled, then the tracers need to reference __init functions.
7918f768993SSteven Rostedt (Red Hat) */
7928f768993SSteven Rostedt (Red Hat) #define __tracer_data __refdata
7938f768993SSteven Rostedt (Red Hat) #else
disable_tracing_selftest(const char * reason)79460efe21eSMasami Hiramatsu static inline void __init disable_tracing_selftest(const char *reason)
79560efe21eSMasami Hiramatsu {
79660efe21eSMasami Hiramatsu }
7978f768993SSteven Rostedt (Red Hat) /* Tracers are seldom changed. Optimize when selftests are disabled. */
7988f768993SSteven Rostedt (Red Hat) #define __tracer_data __read_mostly
79960a11774SSteven Rostedt #endif /* CONFIG_FTRACE_STARTUP_TEST */
80060a11774SSteven Rostedt
801c7aafc54SIngo Molnar extern void *head_page(struct trace_array_cpu *data);
802a5a1d1c2SThomas Gleixner extern unsigned long long ns2usecs(u64 nsec);
8031fd8f2a3SFrederic Weisbecker extern int
80440ce74f1SSteven Rostedt trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
80548ead020SFrederic Weisbecker extern int
80640ce74f1SSteven Rostedt trace_vprintk(unsigned long ip, const char *fmt, va_list args);
807659372d3SSteven Rostedt extern int
808659372d3SSteven Rostedt trace_array_vprintk(struct trace_array *tr,
809659372d3SSteven Rostedt unsigned long ip, const char *fmt, va_list args);
81013292494SSteven Rostedt (VMware) int trace_array_printk_buf(struct trace_buffer *buffer,
81112883efbSSteven Rostedt (Red Hat) unsigned long ip, const char *fmt, ...);
812955b61e5SJason Wessel void trace_printk_seq(struct trace_seq *s);
813955b61e5SJason Wessel enum print_line_t print_trace_line(struct trace_iterator *iter);
814c7aafc54SIngo Molnar
8158e1e1df2SByungchul Park extern char trace_find_mark(unsigned long long duration);
8168e1e1df2SByungchul Park
817673feb9dSSteven Rostedt (VMware) struct ftrace_hash;
818673feb9dSSteven Rostedt (VMware)
819673feb9dSSteven Rostedt (VMware) struct ftrace_mod_load {
820673feb9dSSteven Rostedt (VMware) struct list_head list;
821673feb9dSSteven Rostedt (VMware) char *func;
822673feb9dSSteven Rostedt (VMware) char *module;
823673feb9dSSteven Rostedt (VMware) int enable;
824673feb9dSSteven Rostedt (VMware) };
825673feb9dSSteven Rostedt (VMware)
8268c08f0d5SSteven Rostedt (VMware) enum {
8278c08f0d5SSteven Rostedt (VMware) FTRACE_HASH_FL_MOD = (1 << 0),
8288c08f0d5SSteven Rostedt (VMware) };
8298c08f0d5SSteven Rostedt (VMware)
8304046bf02SNamhyung Kim struct ftrace_hash {
8314046bf02SNamhyung Kim unsigned long size_bits;
8324046bf02SNamhyung Kim struct hlist_head *buckets;
8334046bf02SNamhyung Kim unsigned long count;
8348c08f0d5SSteven Rostedt (VMware) unsigned long flags;
8354046bf02SNamhyung Kim struct rcu_head rcu;
8364046bf02SNamhyung Kim };
8374046bf02SNamhyung Kim
8384046bf02SNamhyung Kim struct ftrace_func_entry *
8394046bf02SNamhyung Kim ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip);
8404046bf02SNamhyung Kim
ftrace_hash_empty(struct ftrace_hash * hash)841eb583cd4SArnd Bergmann static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)
8424046bf02SNamhyung Kim {
8438c08f0d5SSteven Rostedt (VMware) return !hash || !(hash->count || (hash->flags & FTRACE_HASH_FL_MOD));
8444046bf02SNamhyung Kim }
8454046bf02SNamhyung Kim
84615e6cb36SFrederic Weisbecker /* Standard output formatting function used for function return traces */
847fb52607aSFrederic Weisbecker #ifdef CONFIG_FUNCTION_GRAPH_TRACER
84862b915f1SJiri Olsa
84962b915f1SJiri Olsa /* Flag options */
85062b915f1SJiri Olsa #define TRACE_GRAPH_PRINT_OVERRUN 0x1
85162b915f1SJiri Olsa #define TRACE_GRAPH_PRINT_CPU 0x2
85262b915f1SJiri Olsa #define TRACE_GRAPH_PRINT_OVERHEAD 0x4
85362b915f1SJiri Olsa #define TRACE_GRAPH_PRINT_PROC 0x8
85462b915f1SJiri Olsa #define TRACE_GRAPH_PRINT_DURATION 0x10
85562b915f1SJiri Olsa #define TRACE_GRAPH_PRINT_ABS_TIME 0x20
8569acd8de6SChangbin Du #define TRACE_GRAPH_PRINT_REL_TIME 0x40
8579acd8de6SChangbin Du #define TRACE_GRAPH_PRINT_IRQS 0x80
8589acd8de6SChangbin Du #define TRACE_GRAPH_PRINT_TAIL 0x100
8599acd8de6SChangbin Du #define TRACE_GRAPH_SLEEP_TIME 0x200
8609acd8de6SChangbin Du #define TRACE_GRAPH_GRAPH_TIME 0x400
861a1be9cccSDonglin Peng #define TRACE_GRAPH_PRINT_RETVAL 0x800
862a1be9cccSDonglin Peng #define TRACE_GRAPH_PRINT_RETVAL_HEX 0x1000
8636fc84ea7SSteven Rostedt (Red Hat) #define TRACE_GRAPH_PRINT_FILL_SHIFT 28
8646fc84ea7SSteven Rostedt (Red Hat) #define TRACE_GRAPH_PRINT_FILL_MASK (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
86562b915f1SJiri Olsa
86655577204SSteven Rostedt (Red Hat) extern void ftrace_graph_sleep_time_control(bool enable);
867c8dd0f45SSteven Rostedt (VMware)
868c8dd0f45SSteven Rostedt (VMware) #ifdef CONFIG_FUNCTION_PROFILER
86955577204SSteven Rostedt (Red Hat) extern void ftrace_graph_graph_time_control(bool enable);
870c8dd0f45SSteven Rostedt (VMware) #else
ftrace_graph_graph_time_control(bool enable)871c8dd0f45SSteven Rostedt (VMware) static inline void ftrace_graph_graph_time_control(bool enable) { }
872c8dd0f45SSteven Rostedt (VMware) #endif
87355577204SSteven Rostedt (Red Hat)
874d7a8d9e9SJiri Olsa extern enum print_line_t
875d7a8d9e9SJiri Olsa print_graph_function_flags(struct trace_iterator *iter, u32 flags);
876d7a8d9e9SJiri Olsa extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
8779d9add34SSteven Rostedt (Red Hat) extern void
8780706f1c4SSteven Rostedt trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
87962b915f1SJiri Olsa extern void graph_trace_open(struct trace_iterator *iter);
88062b915f1SJiri Olsa extern void graph_trace_close(struct trace_iterator *iter);
88162b915f1SJiri Olsa extern int __trace_graph_entry(struct trace_array *tr,
88262b915f1SJiri Olsa struct ftrace_graph_ent *trace,
88336590c50SSebastian Andrzej Siewior unsigned int trace_ctx);
88462b915f1SJiri Olsa extern void __trace_graph_return(struct trace_array *tr,
88562b915f1SJiri Olsa struct ftrace_graph_ret *trace,
88636590c50SSebastian Andrzej Siewior unsigned int trace_ctx);
88762b915f1SJiri Olsa
888ea4e2bc4SSteven Rostedt #ifdef CONFIG_DYNAMIC_FTRACE
88924a9729fSAmol Grover extern struct ftrace_hash __rcu *ftrace_graph_hash;
890fd0e6852SAmol Grover extern struct ftrace_hash __rcu *ftrace_graph_notrace_hash;
891ea4e2bc4SSteven Rostedt
ftrace_graph_addr(struct ftrace_graph_ent * trace)8925cf99a0fSSteven Rostedt (VMware) static inline int ftrace_graph_addr(struct ftrace_graph_ent *trace)
893ea4e2bc4SSteven Rostedt {
8945cf99a0fSSteven Rostedt (VMware) unsigned long addr = trace->func;
895b9b0c831SNamhyung Kim int ret = 0;
89624a9729fSAmol Grover struct ftrace_hash *hash;
897ea4e2bc4SSteven Rostedt
898b9b0c831SNamhyung Kim preempt_disable_notrace();
899ea4e2bc4SSteven Rostedt
90016052dd5SSteven Rostedt (VMware) /*
90116052dd5SSteven Rostedt (VMware) * Have to open code "rcu_dereference_sched()" because the
90216052dd5SSteven Rostedt (VMware) * function graph tracer can be called when RCU is not
90316052dd5SSteven Rostedt (VMware) * "watching".
90454a16ff6SSteven Rostedt (VMware) * Protected with schedule_on_each_cpu(ftrace_sync)
90516052dd5SSteven Rostedt (VMware) */
90624a9729fSAmol Grover hash = rcu_dereference_protected(ftrace_graph_hash, !preemptible());
90724a9729fSAmol Grover
90824a9729fSAmol Grover if (ftrace_hash_empty(hash)) {
909b9b0c831SNamhyung Kim ret = 1;
910b9b0c831SNamhyung Kim goto out;
911b9b0c831SNamhyung Kim }
912b9b0c831SNamhyung Kim
91324a9729fSAmol Grover if (ftrace_lookup_ip(hash, addr)) {
9145cf99a0fSSteven Rostedt (VMware)
9155cf99a0fSSteven Rostedt (VMware) /*
9165cf99a0fSSteven Rostedt (VMware) * This needs to be cleared on the return functions
9175cf99a0fSSteven Rostedt (VMware) * when the depth is zero.
9185cf99a0fSSteven Rostedt (VMware) */
9195cf99a0fSSteven Rostedt (VMware) trace_recursion_set(TRACE_GRAPH_BIT);
9205cf99a0fSSteven Rostedt (VMware) trace_recursion_set_depth(trace->depth);
9215cf99a0fSSteven Rostedt (VMware)
922e4a3f541SSteven Rostedt /*
923e4a3f541SSteven Rostedt * If no irqs are to be traced, but a set_graph_function
924e4a3f541SSteven Rostedt * is set, and called by an interrupt handler, we still
925e4a3f541SSteven Rostedt * want to trace it.
926e4a3f541SSteven Rostedt */
927affc6592SChangbin Du if (in_hardirq())
928e4a3f541SSteven Rostedt trace_recursion_set(TRACE_IRQ_BIT);
929e4a3f541SSteven Rostedt else
930e4a3f541SSteven Rostedt trace_recursion_clear(TRACE_IRQ_BIT);
931b9b0c831SNamhyung Kim ret = 1;
932e4a3f541SSteven Rostedt }
933ea4e2bc4SSteven Rostedt
934b9b0c831SNamhyung Kim out:
935b9b0c831SNamhyung Kim preempt_enable_notrace();
936b9b0c831SNamhyung Kim return ret;
937ea4e2bc4SSteven Rostedt }
93829ad23b0SNamhyung Kim
ftrace_graph_addr_finish(struct ftrace_graph_ret * trace)9395cf99a0fSSteven Rostedt (VMware) static inline void ftrace_graph_addr_finish(struct ftrace_graph_ret *trace)
9405cf99a0fSSteven Rostedt (VMware) {
9415cf99a0fSSteven Rostedt (VMware) if (trace_recursion_test(TRACE_GRAPH_BIT) &&
9425cf99a0fSSteven Rostedt (VMware) trace->depth == trace_recursion_depth())
9435cf99a0fSSteven Rostedt (VMware) trace_recursion_clear(TRACE_GRAPH_BIT);
9445cf99a0fSSteven Rostedt (VMware) }
9455cf99a0fSSteven Rostedt (VMware)
ftrace_graph_notrace_addr(unsigned long addr)94629ad23b0SNamhyung Kim static inline int ftrace_graph_notrace_addr(unsigned long addr)
94729ad23b0SNamhyung Kim {
948b9b0c831SNamhyung Kim int ret = 0;
949fd0e6852SAmol Grover struct ftrace_hash *notrace_hash;
95029ad23b0SNamhyung Kim
951b9b0c831SNamhyung Kim preempt_disable_notrace();
95229ad23b0SNamhyung Kim
95316052dd5SSteven Rostedt (VMware) /*
95416052dd5SSteven Rostedt (VMware) * Have to open code "rcu_dereference_sched()" because the
95516052dd5SSteven Rostedt (VMware) * function graph tracer can be called when RCU is not
95616052dd5SSteven Rostedt (VMware) * "watching".
95754a16ff6SSteven Rostedt (VMware) * Protected with schedule_on_each_cpu(ftrace_sync)
95816052dd5SSteven Rostedt (VMware) */
959fd0e6852SAmol Grover notrace_hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
960fd0e6852SAmol Grover !preemptible());
961fd0e6852SAmol Grover
962fd0e6852SAmol Grover if (ftrace_lookup_ip(notrace_hash, addr))
963b9b0c831SNamhyung Kim ret = 1;
96429ad23b0SNamhyung Kim
965b9b0c831SNamhyung Kim preempt_enable_notrace();
966b9b0c831SNamhyung Kim return ret;
96729ad23b0SNamhyung Kim }
96815e6cb36SFrederic Weisbecker #else
ftrace_graph_addr(struct ftrace_graph_ent * trace)9695cf99a0fSSteven Rostedt (VMware) static inline int ftrace_graph_addr(struct ftrace_graph_ent *trace)
9706b253930SIngo Molnar {
9716b253930SIngo Molnar return 1;
972ea4e2bc4SSteven Rostedt }
97329ad23b0SNamhyung Kim
ftrace_graph_notrace_addr(unsigned long addr)97429ad23b0SNamhyung Kim static inline int ftrace_graph_notrace_addr(unsigned long addr)
97529ad23b0SNamhyung Kim {
97629ad23b0SNamhyung Kim return 0;
97729ad23b0SNamhyung Kim }
ftrace_graph_addr_finish(struct ftrace_graph_ret * trace)9785cf99a0fSSteven Rostedt (VMware) static inline void ftrace_graph_addr_finish(struct ftrace_graph_ret *trace)
9795cf99a0fSSteven Rostedt (VMware) { }
980ea4e2bc4SSteven Rostedt #endif /* CONFIG_DYNAMIC_FTRACE */
9811a414428SSteven Rostedt (Red Hat)
9821a414428SSteven Rostedt (Red Hat) extern unsigned int fgraph_max_depth;
9831a414428SSteven Rostedt (Red Hat)
ftrace_graph_ignore_func(struct ftrace_graph_ent * trace)9841a414428SSteven Rostedt (Red Hat) static inline bool ftrace_graph_ignore_func(struct ftrace_graph_ent *trace)
9851a414428SSteven Rostedt (Red Hat) {
9861a414428SSteven Rostedt (Red Hat) /* trace it when it is-nested-in or is a function enabled. */
9875cf99a0fSSteven Rostedt (VMware) return !(trace_recursion_test(TRACE_GRAPH_BIT) ||
9885cf99a0fSSteven Rostedt (VMware) ftrace_graph_addr(trace)) ||
9891a414428SSteven Rostedt (Red Hat) (trace->depth < 0) ||
9901a414428SSteven Rostedt (Red Hat) (fgraph_max_depth && trace->depth >= fgraph_max_depth);
9911a414428SSteven Rostedt (Red Hat) }
9921a414428SSteven Rostedt (Red Hat)
993ea4e2bc4SSteven Rostedt #else /* CONFIG_FUNCTION_GRAPH_TRACER */
99415e6cb36SFrederic Weisbecker static inline enum print_line_t
print_graph_function_flags(struct trace_iterator * iter,u32 flags)995d7a8d9e9SJiri Olsa print_graph_function_flags(struct trace_iterator *iter, u32 flags)
99615e6cb36SFrederic Weisbecker {
99715e6cb36SFrederic Weisbecker return TRACE_TYPE_UNHANDLED;
99815e6cb36SFrederic Weisbecker }
999ea4e2bc4SSteven Rostedt #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
100015e6cb36SFrederic Weisbecker
1001756d17eeSjolsa@redhat.com extern struct list_head ftrace_pids;
1002804a6851SSteven Rostedt
10031155de47SPaul Mundt #ifdef CONFIG_FUNCTION_TRACER
1004c58b6b03SJosef Bacik
1005c58b6b03SJosef Bacik #define FTRACE_PID_IGNORE -1
1006c58b6b03SJosef Bacik #define FTRACE_PID_TRACE -2
1007c58b6b03SJosef Bacik
100892a68fa0SSteven Rostedt (VMware) struct ftrace_func_command {
100992a68fa0SSteven Rostedt (VMware) struct list_head list;
101092a68fa0SSteven Rostedt (VMware) char *name;
101104ec7bb6SSteven Rostedt (VMware) int (*func)(struct trace_array *tr,
101204ec7bb6SSteven Rostedt (VMware) struct ftrace_hash *hash,
101392a68fa0SSteven Rostedt (VMware) char *func, char *cmd,
101492a68fa0SSteven Rostedt (VMware) char *params, int enable);
101592a68fa0SSteven Rostedt (VMware) };
1016f1ed7c74SSteven Rostedt (Red Hat) extern bool ftrace_filter_param __initdata;
ftrace_trace_task(struct trace_array * tr)1017345ddcc8SSteven Rostedt (Red Hat) static inline int ftrace_trace_task(struct trace_array *tr)
1018804a6851SSteven Rostedt {
1019c58b6b03SJosef Bacik return this_cpu_read(tr->array_buffer.data->ftrace_ignore_pid) !=
1020c58b6b03SJosef Bacik FTRACE_PID_IGNORE;
1021804a6851SSteven Rostedt }
1022e0a413f6SSteven Rostedt extern int ftrace_is_dead(void);
1023591dffdaSSteven Rostedt (Red Hat) int ftrace_create_function_files(struct trace_array *tr,
1024591dffdaSSteven Rostedt (Red Hat) struct dentry *parent);
1025591dffdaSSteven Rostedt (Red Hat) void ftrace_destroy_function_files(struct trace_array *tr);
10264114fbfdSMasami Hiramatsu int ftrace_allocate_ftrace_ops(struct trace_array *tr);
10274114fbfdSMasami Hiramatsu void ftrace_free_ftrace_ops(struct trace_array *tr);
10284104d326SSteven Rostedt (Red Hat) void ftrace_init_global_array_ops(struct trace_array *tr);
10294104d326SSteven Rostedt (Red Hat) void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func);
10304104d326SSteven Rostedt (Red Hat) void ftrace_reset_array_ops(struct trace_array *tr);
1031345ddcc8SSteven Rostedt (Red Hat) void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer);
1032501c2375SSteven Rostedt (Red Hat) void ftrace_init_tracefs_toplevel(struct trace_array *tr,
1033501c2375SSteven Rostedt (Red Hat) struct dentry *d_tracer);
1034d879d0b8SNamhyung Kim void ftrace_clear_pids(struct trace_array *tr);
1035dbeafd0dSSteven Rostedt (VMware) int init_function_trace(void);
10361e10486fSNamhyung Kim void ftrace_pid_follow_fork(struct trace_array *tr, bool enable);
10371155de47SPaul Mundt #else
ftrace_trace_task(struct trace_array * tr)1038345ddcc8SSteven Rostedt (Red Hat) static inline int ftrace_trace_task(struct trace_array *tr)
10391155de47SPaul Mundt {
10401155de47SPaul Mundt return 1;
10411155de47SPaul Mundt }
ftrace_is_dead(void)1042e0a413f6SSteven Rostedt static inline int ftrace_is_dead(void) { return 0; }
1043591dffdaSSteven Rostedt (Red Hat) static inline int
ftrace_create_function_files(struct trace_array * tr,struct dentry * parent)1044591dffdaSSteven Rostedt (Red Hat) ftrace_create_function_files(struct trace_array *tr,
1045591dffdaSSteven Rostedt (Red Hat) struct dentry *parent)
1046591dffdaSSteven Rostedt (Red Hat) {
1047591dffdaSSteven Rostedt (Red Hat) return 0;
1048591dffdaSSteven Rostedt (Red Hat) }
ftrace_allocate_ftrace_ops(struct trace_array * tr)10494114fbfdSMasami Hiramatsu static inline int ftrace_allocate_ftrace_ops(struct trace_array *tr)
10504114fbfdSMasami Hiramatsu {
10514114fbfdSMasami Hiramatsu return 0;
10524114fbfdSMasami Hiramatsu }
ftrace_free_ftrace_ops(struct trace_array * tr)10534114fbfdSMasami Hiramatsu static inline void ftrace_free_ftrace_ops(struct trace_array *tr) { }
ftrace_destroy_function_files(struct trace_array * tr)1054591dffdaSSteven Rostedt (Red Hat) static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
10554104d326SSteven Rostedt (Red Hat) static inline __init void
ftrace_init_global_array_ops(struct trace_array * tr)10564104d326SSteven Rostedt (Red Hat) ftrace_init_global_array_ops(struct trace_array *tr) { }
ftrace_reset_array_ops(struct trace_array * tr)10574104d326SSteven Rostedt (Red Hat) static inline void ftrace_reset_array_ops(struct trace_array *tr) { }
ftrace_init_tracefs(struct trace_array * tr,struct dentry * d)1058345ddcc8SSteven Rostedt (Red Hat) static inline void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d) { }
ftrace_init_tracefs_toplevel(struct trace_array * tr,struct dentry * d)1059501c2375SSteven Rostedt (Red Hat) static inline void ftrace_init_tracefs_toplevel(struct trace_array *tr, struct dentry *d) { }
ftrace_clear_pids(struct trace_array * tr)1060d879d0b8SNamhyung Kim static inline void ftrace_clear_pids(struct trace_array *tr) { }
init_function_trace(void)1061dbeafd0dSSteven Rostedt (VMware) static inline int init_function_trace(void) { return 0; }
ftrace_pid_follow_fork(struct trace_array * tr,bool enable)10621e10486fSNamhyung Kim static inline void ftrace_pid_follow_fork(struct trace_array *tr, bool enable) { }
10634104d326SSteven Rostedt (Red Hat) /* ftace_func_t type is not defined, use macro instead of static inline */
10644104d326SSteven Rostedt (Red Hat) #define ftrace_init_array_ops(tr, func) do { } while (0)
1065591dffdaSSteven Rostedt (Red Hat) #endif /* CONFIG_FUNCTION_TRACER */
1066591dffdaSSteven Rostedt (Red Hat)
1067591dffdaSSteven Rostedt (Red Hat) #if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
1068ec19b859SSteven Rostedt (VMware)
1069ec19b859SSteven Rostedt (VMware) struct ftrace_probe_ops {
1070ec19b859SSteven Rostedt (VMware) void (*func)(unsigned long ip,
1071ec19b859SSteven Rostedt (VMware) unsigned long parent_ip,
1072b5f081b5SSteven Rostedt (VMware) struct trace_array *tr,
1073bca6c8d0SSteven Rostedt (VMware) struct ftrace_probe_ops *ops,
10746e444319SSteven Rostedt (VMware) void *data);
1075ec19b859SSteven Rostedt (VMware) int (*init)(struct ftrace_probe_ops *ops,
1076b5f081b5SSteven Rostedt (VMware) struct trace_array *tr,
10776e444319SSteven Rostedt (VMware) unsigned long ip, void *init_data,
10786e444319SSteven Rostedt (VMware) void **data);
1079ec19b859SSteven Rostedt (VMware) void (*free)(struct ftrace_probe_ops *ops,
1080b5f081b5SSteven Rostedt (VMware) struct trace_array *tr,
10816e444319SSteven Rostedt (VMware) unsigned long ip, void *data);
1082ec19b859SSteven Rostedt (VMware) int (*print)(struct seq_file *m,
1083ec19b859SSteven Rostedt (VMware) unsigned long ip,
1084ec19b859SSteven Rostedt (VMware) struct ftrace_probe_ops *ops,
1085ec19b859SSteven Rostedt (VMware) void *data);
1086ec19b859SSteven Rostedt (VMware) };
1087ec19b859SSteven Rostedt (VMware)
108841794f19SSteven Rostedt (VMware) struct ftrace_func_mapper;
108941794f19SSteven Rostedt (VMware) typedef int (*ftrace_mapper_func)(void *data);
109041794f19SSteven Rostedt (VMware)
109141794f19SSteven Rostedt (VMware) struct ftrace_func_mapper *allocate_ftrace_func_mapper(void);
109241794f19SSteven Rostedt (VMware) void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
109341794f19SSteven Rostedt (VMware) unsigned long ip);
109441794f19SSteven Rostedt (VMware) int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
109541794f19SSteven Rostedt (VMware) unsigned long ip, void *data);
109641794f19SSteven Rostedt (VMware) void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper,
109741794f19SSteven Rostedt (VMware) unsigned long ip);
109841794f19SSteven Rostedt (VMware) void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper,
109941794f19SSteven Rostedt (VMware) ftrace_mapper_func free_func);
110041794f19SSteven Rostedt (VMware)
1101ec19b859SSteven Rostedt (VMware) extern int
110204ec7bb6SSteven Rostedt (VMware) register_ftrace_function_probe(char *glob, struct trace_array *tr,
110304ec7bb6SSteven Rostedt (VMware) struct ftrace_probe_ops *ops, void *data);
1104d3d532d7SSteven Rostedt (VMware) extern int
11057b60f3d8SSteven Rostedt (VMware) unregister_ftrace_function_probe_func(char *glob, struct trace_array *tr,
11067b60f3d8SSteven Rostedt (VMware) struct ftrace_probe_ops *ops);
1107a0e6369eSNaveen N. Rao extern void clear_ftrace_function_probes(struct trace_array *tr);
1108ec19b859SSteven Rostedt (VMware)
110992a68fa0SSteven Rostedt (VMware) int register_ftrace_command(struct ftrace_func_command *cmd);
111092a68fa0SSteven Rostedt (VMware) int unregister_ftrace_command(struct ftrace_func_command *cmd);
111192a68fa0SSteven Rostedt (VMware)
1112591dffdaSSteven Rostedt (Red Hat) void ftrace_create_filter_files(struct ftrace_ops *ops,
1113591dffdaSSteven Rostedt (Red Hat) struct dentry *parent);
1114591dffdaSSteven Rostedt (Red Hat) void ftrace_destroy_filter_files(struct ftrace_ops *ops);
11155c3469cbSMasami Hiramatsu
11165c3469cbSMasami Hiramatsu extern int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
11175c3469cbSMasami Hiramatsu int len, int reset);
11185c3469cbSMasami Hiramatsu extern int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
11195c3469cbSMasami Hiramatsu int len, int reset);
1120591dffdaSSteven Rostedt (Red Hat) #else
112192a68fa0SSteven Rostedt (VMware) struct ftrace_func_command;
112292a68fa0SSteven Rostedt (VMware)
register_ftrace_command(struct ftrace_func_command * cmd)112392a68fa0SSteven Rostedt (VMware) static inline __init int register_ftrace_command(struct ftrace_func_command *cmd)
112492a68fa0SSteven Rostedt (VMware) {
112592a68fa0SSteven Rostedt (VMware) return -EINVAL;
112692a68fa0SSteven Rostedt (VMware) }
unregister_ftrace_command(char * cmd_name)112792a68fa0SSteven Rostedt (VMware) static inline __init int unregister_ftrace_command(char *cmd_name)
112892a68fa0SSteven Rostedt (VMware) {
112992a68fa0SSteven Rostedt (VMware) return -EINVAL;
113092a68fa0SSteven Rostedt (VMware) }
clear_ftrace_function_probes(struct trace_array * tr)11318a49f3e0SSteven Rostedt (VMware) static inline void clear_ftrace_function_probes(struct trace_array *tr)
11328a49f3e0SSteven Rostedt (VMware) {
11338a49f3e0SSteven Rostedt (VMware) }
11348a49f3e0SSteven Rostedt (VMware)
1135591dffdaSSteven Rostedt (Red Hat) /*
1136591dffdaSSteven Rostedt (Red Hat) * The ops parameter passed in is usually undefined.
1137591dffdaSSteven Rostedt (Red Hat) * This must be a macro.
1138591dffdaSSteven Rostedt (Red Hat) */
1139591dffdaSSteven Rostedt (Red Hat) #define ftrace_create_filter_files(ops, parent) do { } while (0)
1140591dffdaSSteven Rostedt (Red Hat) #define ftrace_destroy_filter_files(ops) do { } while (0)
1141591dffdaSSteven Rostedt (Red Hat) #endif /* CONFIG_FUNCTION_TRACER && CONFIG_DYNAMIC_FTRACE */
1142804a6851SSteven Rostedt
1143c6650b2eSYaowei Bai bool ftrace_event_is_function(struct trace_event_call *call);
1144ced39002SJiri Olsa
11454fcdae83SSteven Rostedt /*
1146b63f39eaSjolsa@redhat.com * struct trace_parser - servers for reading the user input separated by spaces
1147b63f39eaSjolsa@redhat.com * @cont: set if the input is not complete - no final space char was found
1148b63f39eaSjolsa@redhat.com * @buffer: holds the parsed user input
11491537a363SDaniel Mack * @idx: user input length
1150b63f39eaSjolsa@redhat.com * @size: buffer size
1151b63f39eaSjolsa@redhat.com */
1152b63f39eaSjolsa@redhat.com struct trace_parser {
1153b63f39eaSjolsa@redhat.com bool cont;
1154b63f39eaSjolsa@redhat.com char *buffer;
1155b63f39eaSjolsa@redhat.com unsigned idx;
1156b63f39eaSjolsa@redhat.com unsigned size;
1157b63f39eaSjolsa@redhat.com };
1158b63f39eaSjolsa@redhat.com
trace_parser_loaded(struct trace_parser * parser)1159b63f39eaSjolsa@redhat.com static inline bool trace_parser_loaded(struct trace_parser *parser)
1160b63f39eaSjolsa@redhat.com {
1161b63f39eaSjolsa@redhat.com return (parser->idx != 0);
1162b63f39eaSjolsa@redhat.com }
1163b63f39eaSjolsa@redhat.com
trace_parser_cont(struct trace_parser * parser)1164b63f39eaSjolsa@redhat.com static inline bool trace_parser_cont(struct trace_parser *parser)
1165b63f39eaSjolsa@redhat.com {
1166b63f39eaSjolsa@redhat.com return parser->cont;
1167b63f39eaSjolsa@redhat.com }
1168b63f39eaSjolsa@redhat.com
trace_parser_clear(struct trace_parser * parser)1169b63f39eaSjolsa@redhat.com static inline void trace_parser_clear(struct trace_parser *parser)
1170b63f39eaSjolsa@redhat.com {
1171b63f39eaSjolsa@redhat.com parser->cont = false;
1172b63f39eaSjolsa@redhat.com parser->idx = 0;
1173b63f39eaSjolsa@redhat.com }
1174b63f39eaSjolsa@redhat.com
1175b63f39eaSjolsa@redhat.com extern int trace_parser_get_init(struct trace_parser *parser, int size);
1176b63f39eaSjolsa@redhat.com extern void trace_parser_put(struct trace_parser *parser);
1177b63f39eaSjolsa@redhat.com extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
1178b63f39eaSjolsa@redhat.com size_t cnt, loff_t *ppos);
1179b63f39eaSjolsa@redhat.com
1180b63f39eaSjolsa@redhat.com /*
1181729358daSSteven Rostedt (Red Hat) * Only create function graph options if function graph is configured.
1182729358daSSteven Rostedt (Red Hat) */
1183729358daSSteven Rostedt (Red Hat) #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1184729358daSSteven Rostedt (Red Hat) # define FGRAPH_FLAGS \
1185729358daSSteven Rostedt (Red Hat) C(DISPLAY_GRAPH, "display-graph"),
1186729358daSSteven Rostedt (Red Hat) #else
1187729358daSSteven Rostedt (Red Hat) # define FGRAPH_FLAGS
1188729358daSSteven Rostedt (Red Hat) #endif
1189729358daSSteven Rostedt (Red Hat)
11904ee4301cSSteven Rostedt (Red Hat) #ifdef CONFIG_BRANCH_TRACER
11914ee4301cSSteven Rostedt (Red Hat) # define BRANCH_FLAGS \
11924ee4301cSSteven Rostedt (Red Hat) C(BRANCH, "branch"),
11934ee4301cSSteven Rostedt (Red Hat) #else
11944ee4301cSSteven Rostedt (Red Hat) # define BRANCH_FLAGS
11954ee4301cSSteven Rostedt (Red Hat) #endif
11964ee4301cSSteven Rostedt (Red Hat)
11978179e8a1SSteven Rostedt (Red Hat) #ifdef CONFIG_FUNCTION_TRACER
11988179e8a1SSteven Rostedt (Red Hat) # define FUNCTION_FLAGS \
11991e10486fSNamhyung Kim C(FUNCTION, "function-trace"), \
12001e10486fSNamhyung Kim C(FUNC_FORK, "function-fork"),
12018179e8a1SSteven Rostedt (Red Hat) # define FUNCTION_DEFAULT_FLAGS TRACE_ITER_FUNCTION
12028179e8a1SSteven Rostedt (Red Hat) #else
12038179e8a1SSteven Rostedt (Red Hat) # define FUNCTION_FLAGS
12048179e8a1SSteven Rostedt (Red Hat) # define FUNCTION_DEFAULT_FLAGS 0UL
12051e10486fSNamhyung Kim # define TRACE_ITER_FUNC_FORK 0UL
12068179e8a1SSteven Rostedt (Red Hat) #endif
12078179e8a1SSteven Rostedt (Red Hat)
120873dddbb5SSteven Rostedt (Red Hat) #ifdef CONFIG_STACKTRACE
120973dddbb5SSteven Rostedt (Red Hat) # define STACK_FLAGS \
121073dddbb5SSteven Rostedt (Red Hat) C(STACKTRACE, "stacktrace"),
121173dddbb5SSteven Rostedt (Red Hat) #else
121273dddbb5SSteven Rostedt (Red Hat) # define STACK_FLAGS
121373dddbb5SSteven Rostedt (Red Hat) #endif
121473dddbb5SSteven Rostedt (Red Hat)
1215729358daSSteven Rostedt (Red Hat) /*
12164fcdae83SSteven Rostedt * trace_iterator_flags is an enumeration that defines bit
12174fcdae83SSteven Rostedt * positions into trace_flags that controls the output.
12184fcdae83SSteven Rostedt *
12194fcdae83SSteven Rostedt * NOTE: These bits must match the trace_options array in
1220a3418a36SSteven Rostedt (Red Hat) * trace.c (this macro guarantees it).
12214fcdae83SSteven Rostedt */
1222a3418a36SSteven Rostedt (Red Hat) #define TRACE_FLAGS \
1223a3418a36SSteven Rostedt (Red Hat) C(PRINT_PARENT, "print-parent"), \
1224a3418a36SSteven Rostedt (Red Hat) C(SYM_OFFSET, "sym-offset"), \
1225a3418a36SSteven Rostedt (Red Hat) C(SYM_ADDR, "sym-addr"), \
1226a3418a36SSteven Rostedt (Red Hat) C(VERBOSE, "verbose"), \
1227a3418a36SSteven Rostedt (Red Hat) C(RAW, "raw"), \
1228a3418a36SSteven Rostedt (Red Hat) C(HEX, "hex"), \
1229a3418a36SSteven Rostedt (Red Hat) C(BIN, "bin"), \
1230a3418a36SSteven Rostedt (Red Hat) C(BLOCK, "block"), \
123180a76994SSteven Rostedt (Google) C(FIELDS, "fields"), \
1232a3418a36SSteven Rostedt (Red Hat) C(PRINTK, "trace_printk"), \
1233a3418a36SSteven Rostedt (Red Hat) C(ANNOTATE, "annotate"), \
1234a3418a36SSteven Rostedt (Red Hat) C(USERSTACKTRACE, "userstacktrace"), \
1235a3418a36SSteven Rostedt (Red Hat) C(SYM_USEROBJ, "sym-userobj"), \
1236a3418a36SSteven Rostedt (Red Hat) C(PRINTK_MSGONLY, "printk-msg-only"), \
1237a3418a36SSteven Rostedt (Red Hat) C(CONTEXT_INFO, "context-info"), /* Print pid/cpu/time */ \
1238a3418a36SSteven Rostedt (Red Hat) C(LATENCY_FMT, "latency-format"), \
1239a3418a36SSteven Rostedt (Red Hat) C(RECORD_CMD, "record-cmd"), \
1240d914ba37SJoel Fernandes C(RECORD_TGID, "record-tgid"), \
1241a3418a36SSteven Rostedt (Red Hat) C(OVERWRITE, "overwrite"), \
1242a3418a36SSteven Rostedt (Red Hat) C(STOP_ON_FREE, "disable_on_free"), \
1243a3418a36SSteven Rostedt (Red Hat) C(IRQ_INFO, "irq-info"), \
1244a3418a36SSteven Rostedt (Red Hat) C(MARKERS, "markers"), \
1245c37775d5SSteven Rostedt C(EVENT_FORK, "event-fork"), \
124606e0a548SSteven Rostedt (VMware) C(PAUSE_ON_TRACE, "pause-on-trace"), \
1247a345a671SMasami Hiramatsu C(HASH_PTR, "hash-ptr"), /* Print hashed pointer */ \
12488179e8a1SSteven Rostedt (Red Hat) FUNCTION_FLAGS \
12494ee4301cSSteven Rostedt (Red Hat) FGRAPH_FLAGS \
125073dddbb5SSteven Rostedt (Red Hat) STACK_FLAGS \
12514ee4301cSSteven Rostedt (Red Hat) BRANCH_FLAGS
1252ce3fed62SSteven Rostedt (Red Hat)
1253a3418a36SSteven Rostedt (Red Hat) /*
1254a3418a36SSteven Rostedt (Red Hat) * By defining C, we can make TRACE_FLAGS a list of bit names
1255a3418a36SSteven Rostedt (Red Hat) * that will define the bits for the flag masks.
1256a3418a36SSteven Rostedt (Red Hat) */
1257a3418a36SSteven Rostedt (Red Hat) #undef C
1258a3418a36SSteven Rostedt (Red Hat) #define C(a, b) TRACE_ITER_##a##_BIT
1259a3418a36SSteven Rostedt (Red Hat)
1260b5e87c05SSteven Rostedt (Red Hat) enum trace_iterator_bits {
1261b5e87c05SSteven Rostedt (Red Hat) TRACE_FLAGS
1262b5e87c05SSteven Rostedt (Red Hat) /* Make sure we don't go more than we have bits for */
1263b5e87c05SSteven Rostedt (Red Hat) TRACE_ITER_LAST_BIT
1264b5e87c05SSteven Rostedt (Red Hat) };
1265a3418a36SSteven Rostedt (Red Hat)
1266a3418a36SSteven Rostedt (Red Hat) /*
1267a3418a36SSteven Rostedt (Red Hat) * By redefining C, we can make TRACE_FLAGS a list of masks that
1268a3418a36SSteven Rostedt (Red Hat) * use the bits as defined above.
1269a3418a36SSteven Rostedt (Red Hat) */
1270a3418a36SSteven Rostedt (Red Hat) #undef C
1271a3418a36SSteven Rostedt (Red Hat) #define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)
1272a3418a36SSteven Rostedt (Red Hat)
1273a3418a36SSteven Rostedt (Red Hat) enum trace_iterator_flags { TRACE_FLAGS };
12744e655519SIngo Molnar
127515e6cb36SFrederic Weisbecker /*
127615e6cb36SFrederic Weisbecker * TRACE_ITER_SYM_MASK masks the options in trace_flags that
127715e6cb36SFrederic Weisbecker * control the output of kernel symbols.
127815e6cb36SFrederic Weisbecker */
127915e6cb36SFrederic Weisbecker #define TRACE_ITER_SYM_MASK \
128015e6cb36SFrederic Weisbecker (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
128115e6cb36SFrederic Weisbecker
128243a15386SFrédéric Weisbecker extern struct tracer nop_trace;
128343a15386SFrédéric Weisbecker
12842ed84eebSSteven Rostedt #ifdef CONFIG_BRANCH_TRACER
12859f029e83SSteven Rostedt extern int enable_branch_tracing(struct trace_array *tr);
12869f029e83SSteven Rostedt extern void disable_branch_tracing(void);
trace_branch_enable(struct trace_array * tr)12879f029e83SSteven Rostedt static inline int trace_branch_enable(struct trace_array *tr)
128852f232cbSSteven Rostedt {
1289983f938aSSteven Rostedt (Red Hat) if (tr->trace_flags & TRACE_ITER_BRANCH)
12909f029e83SSteven Rostedt return enable_branch_tracing(tr);
129152f232cbSSteven Rostedt return 0;
129252f232cbSSteven Rostedt }
trace_branch_disable(void)12939f029e83SSteven Rostedt static inline void trace_branch_disable(void)
129452f232cbSSteven Rostedt {
129552f232cbSSteven Rostedt /* due to races, always disable */
12969f029e83SSteven Rostedt disable_branch_tracing();
129752f232cbSSteven Rostedt }
129852f232cbSSteven Rostedt #else
trace_branch_enable(struct trace_array * tr)12999f029e83SSteven Rostedt static inline int trace_branch_enable(struct trace_array *tr)
130052f232cbSSteven Rostedt {
130152f232cbSSteven Rostedt return 0;
130252f232cbSSteven Rostedt }
trace_branch_disable(void)13039f029e83SSteven Rostedt static inline void trace_branch_disable(void)
130452f232cbSSteven Rostedt {
130552f232cbSSteven Rostedt }
13062ed84eebSSteven Rostedt #endif /* CONFIG_BRANCH_TRACER */
130752f232cbSSteven Rostedt
13081852fcceSSteven Rostedt /* set ring buffers to default size if not already done so */
13091852fcceSSteven Rostedt int tracing_update_buffers(void);
13101852fcceSSteven Rostedt
1311ddeea494SSven Schnelle union trace_synth_field {
1312ddeea494SSven Schnelle u8 as_u8;
1313ddeea494SSven Schnelle u16 as_u16;
1314ddeea494SSven Schnelle u32 as_u32;
1315ddeea494SSven Schnelle u64 as_u64;
1316ddeea494SSven Schnelle struct trace_dynamic_info as_dynamic;
1317ddeea494SSven Schnelle };
1318ddeea494SSven Schnelle
1319cf027f64STom Zanussi struct ftrace_event_field {
1320cf027f64STom Zanussi struct list_head link;
132192edca07SSteven Rostedt const char *name;
132292edca07SSteven Rostedt const char *type;
1323aa38e9fcSLi Zefan int filter_type;
1324cf027f64STom Zanussi int offset;
1325cf027f64STom Zanussi int size;
1326a118e4d1STom Zanussi int is_signed;
1327b6c7abd1SYafang Shao int len;
1328cf027f64STom Zanussi };
1329cf027f64STom Zanussi
133080765597SSteven Rostedt (VMware) struct prog_entry;
133180765597SSteven Rostedt (VMware)
133230e673b2STom Zanussi struct event_filter {
133380765597SSteven Rostedt (VMware) struct prog_entry __rcu *prog;
13348b372562STom Zanussi char *filter_string;
133530e673b2STom Zanussi };
133630e673b2STom Zanussi
1337cfb180f3STom Zanussi struct event_subsystem {
1338cfb180f3STom Zanussi struct list_head list;
1339cfb180f3STom Zanussi const char *name;
13401f9963cbSLi Zefan struct event_filter *filter;
1341e9dbfae5SSteven Rostedt int ref_count;
1342cfb180f3STom Zanussi };
1343cfb180f3STom Zanussi
13447967b3e0SSteven Rostedt (Red Hat) struct trace_subsystem_dir {
1345ae63b31eSSteven Rostedt struct list_head list;
1346ae63b31eSSteven Rostedt struct event_subsystem *subsystem;
1347ae63b31eSSteven Rostedt struct trace_array *tr;
1348*35ee34c0SSteven Rostedt (Google) struct eventfs_inode *ei;
1349ae63b31eSSteven Rostedt int ref_count;
1350ae63b31eSSteven Rostedt int nr_events;
1351ae63b31eSSteven Rostedt };
1352ae63b31eSSteven Rostedt
135365da9a0aSSteven Rostedt (Red Hat) extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
135413292494SSteven Rostedt (VMware) struct trace_buffer *buffer,
135565da9a0aSSteven Rostedt (Red Hat) struct ring_buffer_event *event);
1356fa66ddb8SSteven Rostedt (Red Hat)
1357fa66ddb8SSteven Rostedt (Red Hat) void trace_buffer_unlock_commit_regs(struct trace_array *tr,
135813292494SSteven Rostedt (VMware) struct trace_buffer *buffer,
1359fa66ddb8SSteven Rostedt (Red Hat) struct ring_buffer_event *event,
136036590c50SSebastian Andrzej Siewior unsigned int trcace_ctx,
1361fa66ddb8SSteven Rostedt (Red Hat) struct pt_regs *regs);
136233fddff2SSteven Rostedt (Red Hat)
trace_buffer_unlock_commit(struct trace_array * tr,struct trace_buffer * buffer,struct ring_buffer_event * event,unsigned int trace_ctx)136333fddff2SSteven Rostedt (Red Hat) static inline void trace_buffer_unlock_commit(struct trace_array *tr,
136413292494SSteven Rostedt (VMware) struct trace_buffer *buffer,
136533fddff2SSteven Rostedt (Red Hat) struct ring_buffer_event *event,
136636590c50SSebastian Andrzej Siewior unsigned int trace_ctx)
136733fddff2SSteven Rostedt (Red Hat) {
136836590c50SSebastian Andrzej Siewior trace_buffer_unlock_commit_regs(tr, buffer, event, trace_ctx, NULL);
136933fddff2SSteven Rostedt (Red Hat) }
137033fddff2SSteven Rostedt (Red Hat)
13710fc1b09fSSteven Rostedt (Red Hat) DECLARE_PER_CPU(struct ring_buffer_event *, trace_buffered_event);
13720fc1b09fSSteven Rostedt (Red Hat) DECLARE_PER_CPU(int, trace_buffered_event_cnt);
13730fc1b09fSSteven Rostedt (Red Hat) void trace_buffered_event_disable(void);
13740fc1b09fSSteven Rostedt (Red Hat) void trace_buffered_event_enable(void);
13750fc1b09fSSteven Rostedt (Red Hat)
1376c4846480SSteven Rostedt (Google) void early_enable_events(struct trace_array *tr, char *buf, bool disable_first);
1377c4846480SSteven Rostedt (Google)
13780fc1b09fSSteven Rostedt (Red Hat) static inline void
__trace_event_discard_commit(struct trace_buffer * buffer,struct ring_buffer_event * event)137913292494SSteven Rostedt (VMware) __trace_event_discard_commit(struct trace_buffer *buffer,
13800fc1b09fSSteven Rostedt (Red Hat) struct ring_buffer_event *event)
13810fc1b09fSSteven Rostedt (Red Hat) {
13820fc1b09fSSteven Rostedt (Red Hat) if (this_cpu_read(trace_buffered_event) == event) {
13836c536d76SSteven Rostedt (VMware) /* Simply release the temp buffer and enable preemption */
13840fc1b09fSSteven Rostedt (Red Hat) this_cpu_dec(trace_buffered_event_cnt);
13856c536d76SSteven Rostedt (VMware) preempt_enable_notrace();
13860fc1b09fSSteven Rostedt (Red Hat) return;
13870fc1b09fSSteven Rostedt (Red Hat) }
13886c536d76SSteven Rostedt (VMware) /* ring_buffer_discard_commit() enables preemption */
13890fc1b09fSSteven Rostedt (Red Hat) ring_buffer_discard_commit(buffer, event);
13900fc1b09fSSteven Rostedt (Red Hat) }
13910fc1b09fSSteven Rostedt (Red Hat)
1392dad56ee7SSteven Rostedt (Red Hat) /*
1393dad56ee7SSteven Rostedt (Red Hat) * Helper function for event_trigger_unlock_commit{_regs}().
1394dad56ee7SSteven Rostedt (Red Hat) * If there are event triggers attached to this event that requires
1395499f7bb0SQiujun Huang * filtering against its fields, then they will be called as the
1396dad56ee7SSteven Rostedt (Red Hat) * entry already holds the field information of the current event.
1397dad56ee7SSteven Rostedt (Red Hat) *
1398dad56ee7SSteven Rostedt (Red Hat) * It also checks if the event should be discarded or not.
1399dad56ee7SSteven Rostedt (Red Hat) * It is to be discarded if the event is soft disabled and the
1400dad56ee7SSteven Rostedt (Red Hat) * event was only recorded to process triggers, or if the event
1401dad56ee7SSteven Rostedt (Red Hat) * filter is active and this event did not match the filters.
1402dad56ee7SSteven Rostedt (Red Hat) *
1403dad56ee7SSteven Rostedt (Red Hat) * Returns true if the event is discarded, false otherwise.
1404dad56ee7SSteven Rostedt (Red Hat) */
1405dad56ee7SSteven Rostedt (Red Hat) static inline bool
__event_trigger_test_discard(struct trace_event_file * file,struct trace_buffer * buffer,struct ring_buffer_event * event,void * entry,enum event_trigger_type * tt)1406dad56ee7SSteven Rostedt (Red Hat) __event_trigger_test_discard(struct trace_event_file *file,
140713292494SSteven Rostedt (VMware) struct trace_buffer *buffer,
1408dad56ee7SSteven Rostedt (Red Hat) struct ring_buffer_event *event,
1409dad56ee7SSteven Rostedt (Red Hat) void *entry,
1410dad56ee7SSteven Rostedt (Red Hat) enum event_trigger_type *tt)
1411dad56ee7SSteven Rostedt (Red Hat) {
1412dad56ee7SSteven Rostedt (Red Hat) unsigned long eflags = file->flags;
1413dad56ee7SSteven Rostedt (Red Hat)
1414dad56ee7SSteven Rostedt (Red Hat) if (eflags & EVENT_FILE_FL_TRIGGER_COND)
1415b47e3302SSteven Rostedt (VMware) *tt = event_triggers_call(file, buffer, entry, event);
1416dad56ee7SSteven Rostedt (Red Hat)
1417a55f224fSSteven Rostedt (VMware) if (likely(!(file->flags & (EVENT_FILE_FL_SOFT_DISABLED |
1418a55f224fSSteven Rostedt (VMware) EVENT_FILE_FL_FILTERED |
1419a55f224fSSteven Rostedt (VMware) EVENT_FILE_FL_PID_FILTER))))
1420a55f224fSSteven Rostedt (VMware) return false;
1421a55f224fSSteven Rostedt (VMware)
1422a55f224fSSteven Rostedt (VMware) if (file->flags & EVENT_FILE_FL_SOFT_DISABLED)
1423a55f224fSSteven Rostedt (VMware) goto discard;
1424a55f224fSSteven Rostedt (VMware)
1425a55f224fSSteven Rostedt (VMware) if (file->flags & EVENT_FILE_FL_FILTERED &&
1426a55f224fSSteven Rostedt (VMware) !filter_match_preds(file->filter, entry))
1427a55f224fSSteven Rostedt (VMware) goto discard;
1428a55f224fSSteven Rostedt (VMware)
1429a55f224fSSteven Rostedt (VMware) if ((file->flags & EVENT_FILE_FL_PID_FILTER) &&
1430a55f224fSSteven Rostedt (VMware) trace_event_ignore_this_pid(file))
1431a55f224fSSteven Rostedt (VMware) goto discard;
1432dad56ee7SSteven Rostedt (Red Hat)
14339cbb1506SSteven Rostedt (Red Hat) return false;
1434a55f224fSSteven Rostedt (VMware) discard:
1435a55f224fSSteven Rostedt (VMware) __trace_event_discard_commit(buffer, event);
1436a55f224fSSteven Rostedt (VMware) return true;
14379cbb1506SSteven Rostedt (Red Hat) }
14389cbb1506SSteven Rostedt (Red Hat)
1439dad56ee7SSteven Rostedt (Red Hat) /**
1440dad56ee7SSteven Rostedt (Red Hat) * event_trigger_unlock_commit - handle triggers and finish event commit
1441f2cc020dSIngo Molnar * @file: The file pointer associated with the event
1442dad56ee7SSteven Rostedt (Red Hat) * @buffer: The ring buffer that the event is being written to
1443dad56ee7SSteven Rostedt (Red Hat) * @event: The event meta data in the ring buffer
1444dad56ee7SSteven Rostedt (Red Hat) * @entry: The event itself
144536590c50SSebastian Andrzej Siewior * @trace_ctx: The tracing context flags.
1446dad56ee7SSteven Rostedt (Red Hat) *
1447dad56ee7SSteven Rostedt (Red Hat) * This is a helper function to handle triggers that require data
1448dad56ee7SSteven Rostedt (Red Hat) * from the event itself. It also tests the event against filters and
1449dad56ee7SSteven Rostedt (Red Hat) * if the event is soft disabled and should be discarded.
1450dad56ee7SSteven Rostedt (Red Hat) */
1451dad56ee7SSteven Rostedt (Red Hat) static inline void
event_trigger_unlock_commit(struct trace_event_file * file,struct trace_buffer * buffer,struct ring_buffer_event * event,void * entry,unsigned int trace_ctx)1452dad56ee7SSteven Rostedt (Red Hat) event_trigger_unlock_commit(struct trace_event_file *file,
145313292494SSteven Rostedt (VMware) struct trace_buffer *buffer,
1454dad56ee7SSteven Rostedt (Red Hat) struct ring_buffer_event *event,
145536590c50SSebastian Andrzej Siewior void *entry, unsigned int trace_ctx)
1456dad56ee7SSteven Rostedt (Red Hat) {
1457dad56ee7SSteven Rostedt (Red Hat) enum event_trigger_type tt = ETT_NONE;
1458dad56ee7SSteven Rostedt (Red Hat)
1459dad56ee7SSteven Rostedt (Red Hat) if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
146036590c50SSebastian Andrzej Siewior trace_buffer_unlock_commit(file->tr, buffer, event, trace_ctx);
1461dad56ee7SSteven Rostedt (Red Hat)
1462dad56ee7SSteven Rostedt (Red Hat) if (tt)
1463c94e45bcSSteven Rostedt (VMware) event_triggers_post_call(file, tt);
1464dad56ee7SSteven Rostedt (Red Hat) }
1465dad56ee7SSteven Rostedt (Red Hat)
146661e9dea2SSteven Rostedt #define FILTER_PRED_INVALID ((unsigned short)-1)
146761e9dea2SSteven Rostedt #define FILTER_PRED_IS_RIGHT (1 << 15)
146843cd4145SSteven Rostedt #define FILTER_PRED_FOLD (1 << 15)
146961e9dea2SSteven Rostedt
1470bf93f9edSSteven Rostedt /*
1471bf93f9edSSteven Rostedt * The max preds is the size of unsigned short with
1472bf93f9edSSteven Rostedt * two flags at the MSBs. One bit is used for both the IS_RIGHT
1473bf93f9edSSteven Rostedt * and FOLD flags. The other is reserved.
1474bf93f9edSSteven Rostedt *
1475bf93f9edSSteven Rostedt * 2^14 preds is way more than enough.
1476bf93f9edSSteven Rostedt */
1477bf93f9edSSteven Rostedt #define MAX_FILTER_PRED 16384
14784a3d27e9SSteven Rostedt
14797ce7e424STom Zanussi struct filter_pred;
14801889d209SFrederic Weisbecker struct regex;
14817ce7e424STom Zanussi
14821889d209SFrederic Weisbecker typedef int (*regex_match_func)(char *str, struct regex *r, int len);
14831889d209SFrederic Weisbecker
14843f6fe06dSFrederic Weisbecker enum regex_type {
1485b0f1a59aSLi Zefan MATCH_FULL = 0,
14863f6fe06dSFrederic Weisbecker MATCH_FRONT_ONLY,
14873f6fe06dSFrederic Weisbecker MATCH_MIDDLE_ONLY,
14883f6fe06dSFrederic Weisbecker MATCH_END_ONLY,
148960f1d5e3SMasami Hiramatsu MATCH_GLOB,
1490f79b3f33SSteven Rostedt (VMware) MATCH_INDEX,
14913f6fe06dSFrederic Weisbecker };
14923f6fe06dSFrederic Weisbecker
14931889d209SFrederic Weisbecker struct regex {
14941889d209SFrederic Weisbecker char pattern[MAX_FILTER_STR_VAL];
14951889d209SFrederic Weisbecker int len;
14961889d209SFrederic Weisbecker int field_len;
14971889d209SFrederic Weisbecker regex_match_func match;
14981889d209SFrederic Weisbecker };
14991889d209SFrederic Weisbecker
is_string_field(struct ftrace_event_field * field)15004ef56902STom Zanussi static inline bool is_string_field(struct ftrace_event_field *field)
15014ef56902STom Zanussi {
15024ef56902STom Zanussi return field->filter_type == FILTER_DYN_STRING ||
150305770dd0SMasami Hiramatsu field->filter_type == FILTER_RDYN_STRING ||
15044ef56902STom Zanussi field->filter_type == FILTER_STATIC_STRING ||
15054c738413SSteven Rostedt (VMware) field->filter_type == FILTER_PTR_STRING ||
15064c738413SSteven Rostedt (VMware) field->filter_type == FILTER_COMM;
15074ef56902STom Zanussi }
15084ef56902STom Zanussi
is_function_field(struct ftrace_event_field * field)15094ef56902STom Zanussi static inline bool is_function_field(struct ftrace_event_field *field)
15104ef56902STom Zanussi {
15114ef56902STom Zanussi return field->filter_type == FILTER_TRACE_FN;
15124ef56902STom Zanussi }
15134ef56902STom Zanussi
15143f6fe06dSFrederic Weisbecker extern enum regex_type
15153f6fe06dSFrederic Weisbecker filter_parse_regex(char *buff, int len, char **search, int *not);
15167f1d2f82SSteven Rostedt (Red Hat) extern void print_event_filter(struct trace_event_file *file,
15174bda2d51STom Zanussi struct trace_seq *s);
15187f1d2f82SSteven Rostedt (Red Hat) extern int apply_event_filter(struct trace_event_file *file,
15198b372562STom Zanussi char *filter_string);
15207967b3e0SSteven Rostedt (Red Hat) extern int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
15218b372562STom Zanussi char *filter_string);
15228b372562STom Zanussi extern void print_subsystem_event_filter(struct event_subsystem *system,
1523ac1adc55STom Zanussi struct trace_seq *s);
1524aa38e9fcSLi Zefan extern int filter_assign_type(const char *type);
15251e144d73SSteven Rostedt (VMware) extern int create_event_filter(struct trace_array *tr,
15261e144d73SSteven Rostedt (VMware) struct trace_event_call *call,
1527bac5fb97STom Zanussi char *filter_str, bool set_str,
1528bac5fb97STom Zanussi struct event_filter **filterp);
1529bac5fb97STom Zanussi extern void free_event_filter(struct event_filter *filter);
15307ce7e424STom Zanussi
1531b3a8c6fdSzhangwei(Jovi) struct ftrace_event_field *
15322425bcb9SSteven Rostedt (Red Hat) trace_find_event_field(struct trace_event_call *call, char *name);
15332e33af02SSteven Rostedt
1534e870e9a1SLi Zefan extern void trace_event_enable_cmd_record(bool enable);
1535d914ba37SJoel Fernandes extern void trace_event_enable_tgid_record(bool enable);
1536d914ba37SJoel Fernandes
153758b92547SSteven Rostedt (VMware) extern int event_trace_init(void);
15383bb06eb6SSteven Rostedt (Google) extern int init_events(void);
1539277ba044SSteven Rostedt extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
15400c8916c3SSteven Rostedt extern int event_trace_del_tracer(struct trace_array *tr);
1541720dee53SMasami Hiramatsu extern void __trace_early_add_events(struct trace_array *tr);
1542e870e9a1SLi Zefan
15433c96529cSSteven Rostedt (VMware) extern struct trace_event_file *__find_event_file(struct trace_array *tr,
15443c96529cSSteven Rostedt (VMware) const char *system,
15453c96529cSSteven Rostedt (VMware) const char *event);
15467f1d2f82SSteven Rostedt (Red Hat) extern struct trace_event_file *find_event_file(struct trace_array *tr,
15477862ad18STom Zanussi const char *system,
15487862ad18STom Zanussi const char *event);
15497862ad18STom Zanussi
event_file_data(struct file * filp)155085f2b082STom Zanussi static inline void *event_file_data(struct file *filp)
155185f2b082STom Zanussi {
15526aa7de05SMark Rutland return READ_ONCE(file_inode(filp)->i_private);
155385f2b082STom Zanussi }
155485f2b082STom Zanussi
155520c8928aSLi Zefan extern struct mutex event_mutex;
1556a59fd602SSteven Rostedt extern struct list_head ftrace_events;
1557ac199db0SPeter Zijlstra
155885f2b082STom Zanussi extern const struct file_operations event_trigger_fops;
15597ef224d1STom Zanussi extern const struct file_operations event_hist_fops;
15602d19bd79STom Zanussi extern const struct file_operations event_hist_debug_fops;
15616c3edaf9SCong Wang extern const struct file_operations event_inject_fops;
15627ef224d1STom Zanussi
15637ef224d1STom Zanussi #ifdef CONFIG_HIST_TRIGGERS
15647ef224d1STom Zanussi extern int register_trigger_hist_cmd(void);
1565d0bad49bSTom Zanussi extern int register_trigger_hist_enable_disable_cmds(void);
15667ef224d1STom Zanussi #else
register_trigger_hist_cmd(void)15677ef224d1STom Zanussi static inline int register_trigger_hist_cmd(void) { return 0; }
register_trigger_hist_enable_disable_cmds(void)1568d0bad49bSTom Zanussi static inline int register_trigger_hist_enable_disable_cmds(void) { return 0; }
15697ef224d1STom Zanussi #endif
157085f2b082STom Zanussi
157185f2b082STom Zanussi extern int register_trigger_cmds(void);
157285f2b082STom Zanussi extern void clear_event_triggers(struct trace_array *tr);
157385f2b082STom Zanussi
15747491e2c4STzvetomir Stoyanov (VMware) enum {
15757491e2c4STzvetomir Stoyanov (VMware) EVENT_TRIGGER_FL_PROBE = BIT(0),
15767491e2c4STzvetomir Stoyanov (VMware) };
15777491e2c4STzvetomir Stoyanov (VMware)
157885f2b082STom Zanussi struct event_trigger_data {
157985f2b082STom Zanussi unsigned long count;
158085f2b082STom Zanussi int ref;
15817491e2c4STzvetomir Stoyanov (VMware) int flags;
158285f2b082STom Zanussi struct event_trigger_ops *ops;
158385f2b082STom Zanussi struct event_command *cmd_ops;
1584d8a30f20SSteven Rostedt (Red Hat) struct event_filter __rcu *filter;
158585f2b082STom Zanussi char *filter_str;
158685f2b082STom Zanussi void *private_data;
1587104f2810STom Zanussi bool paused;
1588db1388b4STom Zanussi bool paused_tmp;
158985f2b082STom Zanussi struct list_head list;
1590db1388b4STom Zanussi char *name;
1591db1388b4STom Zanussi struct list_head named_list;
1592db1388b4STom Zanussi struct event_trigger_data *named_data;
159385f2b082STom Zanussi };
159485f2b082STom Zanussi
1595d0bad49bSTom Zanussi /* Avoid typos */
1596d0bad49bSTom Zanussi #define ENABLE_EVENT_STR "enable_event"
1597d0bad49bSTom Zanussi #define DISABLE_EVENT_STR "disable_event"
1598d0bad49bSTom Zanussi #define ENABLE_HIST_STR "enable_hist"
1599d0bad49bSTom Zanussi #define DISABLE_HIST_STR "disable_hist"
1600d0bad49bSTom Zanussi
1601d0bad49bSTom Zanussi struct enable_trigger_data {
1602d0bad49bSTom Zanussi struct trace_event_file *file;
1603d0bad49bSTom Zanussi bool enable;
1604d0bad49bSTom Zanussi bool hist;
1605d0bad49bSTom Zanussi };
1606d0bad49bSTom Zanussi
1607d0bad49bSTom Zanussi extern int event_enable_trigger_print(struct seq_file *m,
1608d0bad49bSTom Zanussi struct event_trigger_data *data);
160947670541STom Zanussi extern void event_enable_trigger_free(struct event_trigger_data *data);
16109ec5a7d1STom Zanussi extern int event_enable_trigger_parse(struct event_command *cmd_ops,
1611d0bad49bSTom Zanussi struct trace_event_file *file,
1612e1f187d0STom Zanussi char *glob, char *cmd,
1613e1f187d0STom Zanussi char *param_and_filter);
1614d0bad49bSTom Zanussi extern int event_enable_register_trigger(char *glob,
1615d0bad49bSTom Zanussi struct event_trigger_data *data,
1616d0bad49bSTom Zanussi struct trace_event_file *file);
1617d0bad49bSTom Zanussi extern void event_enable_unregister_trigger(char *glob,
1618d0bad49bSTom Zanussi struct event_trigger_data *test,
1619d0bad49bSTom Zanussi struct trace_event_file *file);
1620ab4bf008STom Zanussi extern void trigger_data_free(struct event_trigger_data *data);
162147670541STom Zanussi extern int event_trigger_init(struct event_trigger_data *data);
1622ab4bf008STom Zanussi extern int trace_event_trigger_enable_disable(struct trace_event_file *file,
1623ab4bf008STom Zanussi int trigger_enable);
1624ab4bf008STom Zanussi extern void update_cond_flag(struct trace_event_file *file);
1625ab4bf008STom Zanussi extern int set_trigger_filter(char *filter_str,
1626ab4bf008STom Zanussi struct event_trigger_data *trigger_data,
1627ab4bf008STom Zanussi struct trace_event_file *file);
1628db1388b4STom Zanussi extern struct event_trigger_data *find_named_trigger(const char *name);
1629db1388b4STom Zanussi extern bool is_named_trigger(struct event_trigger_data *test);
1630db1388b4STom Zanussi extern int save_named_trigger(const char *name,
1631db1388b4STom Zanussi struct event_trigger_data *data);
1632db1388b4STom Zanussi extern void del_named_trigger(struct event_trigger_data *data);
1633db1388b4STom Zanussi extern void pause_named_trigger(struct event_trigger_data *data);
1634db1388b4STom Zanussi extern void unpause_named_trigger(struct event_trigger_data *data);
1635db1388b4STom Zanussi extern void set_named_trigger_data(struct event_trigger_data *data,
1636db1388b4STom Zanussi struct event_trigger_data *named_data);
1637067fe038STom Zanussi extern struct event_trigger_data *
1638067fe038STom Zanussi get_named_trigger_data(struct event_trigger_data *data);
1639ab4bf008STom Zanussi extern int register_event_command(struct event_command *cmd);
1640d0bad49bSTom Zanussi extern int unregister_event_command(struct event_command *cmd);
1641d0bad49bSTom Zanussi extern int register_trigger_hist_enable_disable_cmds(void);
164286599dbeSTom Zanussi extern bool event_trigger_check_remove(const char *glob);
164386599dbeSTom Zanussi extern bool event_trigger_empty_param(const char *param);
164486599dbeSTom Zanussi extern int event_trigger_separate_filter(char *param_and_filter, char **param,
164586599dbeSTom Zanussi char **filter, bool param_required);
164686599dbeSTom Zanussi extern struct event_trigger_data *
164786599dbeSTom Zanussi event_trigger_alloc(struct event_command *cmd_ops,
164886599dbeSTom Zanussi char *cmd,
164986599dbeSTom Zanussi char *param,
165086599dbeSTom Zanussi void *private_data);
165186599dbeSTom Zanussi extern int event_trigger_parse_num(char *trigger,
165286599dbeSTom Zanussi struct event_trigger_data *trigger_data);
165386599dbeSTom Zanussi extern int event_trigger_set_filter(struct event_command *cmd_ops,
165486599dbeSTom Zanussi struct trace_event_file *file,
165586599dbeSTom Zanussi char *param,
165686599dbeSTom Zanussi struct event_trigger_data *trigger_data);
165786599dbeSTom Zanussi extern void event_trigger_reset_filter(struct event_command *cmd_ops,
165886599dbeSTom Zanussi struct event_trigger_data *trigger_data);
165986599dbeSTom Zanussi extern int event_trigger_register(struct event_command *cmd_ops,
166086599dbeSTom Zanussi struct trace_event_file *file,
166186599dbeSTom Zanussi char *glob,
1662b8cc44a4STom Zanussi struct event_trigger_data *trigger_data);
1663b8cc44a4STom Zanussi extern void event_trigger_unregister(struct event_command *cmd_ops,
1664b8cc44a4STom Zanussi struct trace_event_file *file,
1665b8cc44a4STom Zanussi char *glob,
1666b8cc44a4STom Zanussi struct event_trigger_data *trigger_data);
1667ab4bf008STom Zanussi
16689034c87dSSteven Rostedt (Google) extern void event_file_get(struct trace_event_file *file);
16699034c87dSSteven Rostedt (Google) extern void event_file_put(struct trace_event_file *file);
16709034c87dSSteven Rostedt (Google)
167185f2b082STom Zanussi /**
167285f2b082STom Zanussi * struct event_trigger_ops - callbacks for trace event triggers
167385f2b082STom Zanussi *
167485f2b082STom Zanussi * The methods in this structure provide per-event trigger hooks for
167585f2b082STom Zanussi * various trigger operations.
167685f2b082STom Zanussi *
1677fb339e53STom Zanussi * The @init and @free methods are used during trigger setup and
1678fb339e53STom Zanussi * teardown, typically called from an event_command's @parse()
1679fb339e53STom Zanussi * function implementation.
1680fb339e53STom Zanussi *
1681fb339e53STom Zanussi * The @print method is used to print the trigger spec.
1682fb339e53STom Zanussi *
1683fb339e53STom Zanussi * The @trigger method is the function that actually implements the
1684fb339e53STom Zanussi * trigger and is called in the context of the triggering event
1685fb339e53STom Zanussi * whenever that event occurs.
1686fb339e53STom Zanussi *
168785f2b082STom Zanussi * All the methods below, except for @init() and @free(), must be
168885f2b082STom Zanussi * implemented.
168985f2b082STom Zanussi *
1690fb339e53STom Zanussi * @trigger: The trigger 'probe' function called when the triggering
169185f2b082STom Zanussi * event occurs. The data passed into this callback is the data
169285f2b082STom Zanussi * that was supplied to the event_command @reg() function that
1693c4a59230STom Zanussi * registered the trigger (see struct event_command) along with
1694c4a59230STom Zanussi * the trace record, rec.
169585f2b082STom Zanussi *
169685f2b082STom Zanussi * @init: An optional initialization function called for the trigger
169785f2b082STom Zanussi * when the trigger is registered (via the event_command reg()
169885f2b082STom Zanussi * function). This can be used to perform per-trigger
169985f2b082STom Zanussi * initialization such as incrementing a per-trigger reference
170085f2b082STom Zanussi * count, for instance. This is usually implemented by the
170185f2b082STom Zanussi * generic utility function @event_trigger_init() (see
170285f2b082STom Zanussi * trace_event_triggers.c).
170385f2b082STom Zanussi *
170485f2b082STom Zanussi * @free: An optional de-initialization function called for the
170585f2b082STom Zanussi * trigger when the trigger is unregistered (via the
170685f2b082STom Zanussi * event_command @reg() function). This can be used to perform
170785f2b082STom Zanussi * per-trigger de-initialization such as decrementing a
170885f2b082STom Zanussi * per-trigger reference count and freeing corresponding trigger
170985f2b082STom Zanussi * data, for instance. This is usually implemented by the
171085f2b082STom Zanussi * generic utility function @event_trigger_free() (see
171185f2b082STom Zanussi * trace_event_triggers.c).
171285f2b082STom Zanussi *
171385f2b082STom Zanussi * @print: The callback function invoked to have the trigger print
171485f2b082STom Zanussi * itself. This is usually implemented by a wrapper function
171585f2b082STom Zanussi * that calls the generic utility function @event_trigger_print()
171685f2b082STom Zanussi * (see trace_event_triggers.c).
171785f2b082STom Zanussi */
171885f2b082STom Zanussi struct event_trigger_ops {
1719fb339e53STom Zanussi void (*trigger)(struct event_trigger_data *data,
1720fb339e53STom Zanussi struct trace_buffer *buffer,
1721fb339e53STom Zanussi void *rec,
17221ac4f51cSTom Zanussi struct ring_buffer_event *rbe);
172347670541STom Zanussi int (*init)(struct event_trigger_data *data);
172447670541STom Zanussi void (*free)(struct event_trigger_data *data);
172585f2b082STom Zanussi int (*print)(struct seq_file *m,
172685f2b082STom Zanussi struct event_trigger_data *data);
172785f2b082STom Zanussi };
172885f2b082STom Zanussi
172985f2b082STom Zanussi /**
173085f2b082STom Zanussi * struct event_command - callbacks and data members for event commands
173185f2b082STom Zanussi *
173285f2b082STom Zanussi * Event commands are invoked by users by writing the command name
173385f2b082STom Zanussi * into the 'trigger' file associated with a trace event. The
173485f2b082STom Zanussi * parameters associated with a specific invocation of an event
173585f2b082STom Zanussi * command are used to create an event trigger instance, which is
173685f2b082STom Zanussi * added to the list of trigger instances associated with that trace
173785f2b082STom Zanussi * event. When the event is hit, the set of triggers associated with
173885f2b082STom Zanussi * that event is invoked.
173985f2b082STom Zanussi *
174085f2b082STom Zanussi * The data members in this structure provide per-event command data
174185f2b082STom Zanussi * for various event commands.
174285f2b082STom Zanussi *
174385f2b082STom Zanussi * All the data members below, except for @post_trigger, must be set
174485f2b082STom Zanussi * for each event command.
174585f2b082STom Zanussi *
174685f2b082STom Zanussi * @name: The unique name that identifies the event command. This is
174785f2b082STom Zanussi * the name used when setting triggers via trigger files.
174885f2b082STom Zanussi *
174985f2b082STom Zanussi * @trigger_type: A unique id that identifies the event command
175085f2b082STom Zanussi * 'type'. This value has two purposes, the first to ensure that
175185f2b082STom Zanussi * only one trigger of the same type can be set at a given time
175285f2b082STom Zanussi * for a particular event e.g. it doesn't make sense to have both
175385f2b082STom Zanussi * a traceon and traceoff trigger attached to a single event at
175485f2b082STom Zanussi * the same time, so traceon and traceoff have the same type
175585f2b082STom Zanussi * though they have different names. The @trigger_type value is
175685f2b082STom Zanussi * also used as a bit value for deferring the actual trigger
175785f2b082STom Zanussi * action until after the current event is finished. Some
175885f2b082STom Zanussi * commands need to do this if they themselves log to the trace
175985f2b082STom Zanussi * buffer (see the @post_trigger() member below). @trigger_type
176085f2b082STom Zanussi * values are defined by adding new values to the trigger_type
1761af658dcaSSteven Rostedt (Red Hat) * enum in include/linux/trace_events.h.
176285f2b082STom Zanussi *
1763353206f5SSteven Rostedt (Red Hat) * @flags: See the enum event_command_flags below.
1764a5863daeSTom Zanussi *
1765a88e1cfbSTom Zanussi * All the methods below, except for @set_filter() and @unreg_all(),
1766a88e1cfbSTom Zanussi * must be implemented.
176785f2b082STom Zanussi *
17689ec5a7d1STom Zanussi * @parse: The callback function responsible for parsing and
176985f2b082STom Zanussi * registering the trigger written to the 'trigger' file by the
177085f2b082STom Zanussi * user. It allocates the trigger instance and registers it with
177185f2b082STom Zanussi * the appropriate trace event. It makes use of the other
177285f2b082STom Zanussi * event_command callback functions to orchestrate this, and is
177385f2b082STom Zanussi * usually implemented by the generic utility function
177485f2b082STom Zanussi * @event_trigger_callback() (see trace_event_triggers.c).
177585f2b082STom Zanussi *
177685f2b082STom Zanussi * @reg: Adds the trigger to the list of triggers associated with the
177785f2b082STom Zanussi * event, and enables the event trigger itself, after
177885f2b082STom Zanussi * initializing it (via the event_trigger_ops @init() function).
177985f2b082STom Zanussi * This is also where commands can use the @trigger_type value to
178085f2b082STom Zanussi * make the decision as to whether or not multiple instances of
178185f2b082STom Zanussi * the trigger should be allowed. This is usually implemented by
178285f2b082STom Zanussi * the generic utility function @register_trigger() (see
178385f2b082STom Zanussi * trace_event_triggers.c).
178485f2b082STom Zanussi *
178585f2b082STom Zanussi * @unreg: Removes the trigger from the list of triggers associated
178685f2b082STom Zanussi * with the event, and disables the event trigger itself, after
178785f2b082STom Zanussi * initializing it (via the event_trigger_ops @free() function).
178885f2b082STom Zanussi * This is usually implemented by the generic utility function
178985f2b082STom Zanussi * @unregister_trigger() (see trace_event_triggers.c).
179085f2b082STom Zanussi *
1791a88e1cfbSTom Zanussi * @unreg_all: An optional function called to remove all the triggers
1792a88e1cfbSTom Zanussi * from the list of triggers associated with the event. Called
1793a88e1cfbSTom Zanussi * when a trigger file is opened in truncate mode.
1794a88e1cfbSTom Zanussi *
179585f2b082STom Zanussi * @set_filter: An optional function called to parse and set a filter
179685f2b082STom Zanussi * for the trigger. If no @set_filter() method is set for the
179785f2b082STom Zanussi * event command, filters set by the user for the command will be
179885f2b082STom Zanussi * ignored. This is usually implemented by the generic utility
179985f2b082STom Zanussi * function @set_trigger_filter() (see trace_event_triggers.c).
180085f2b082STom Zanussi *
180185f2b082STom Zanussi * @get_trigger_ops: The callback function invoked to retrieve the
180285f2b082STom Zanussi * event_trigger_ops implementation associated with the command.
18039ec5a7d1STom Zanussi * This callback function allows a single event_command to
18049ec5a7d1STom Zanussi * support multiple trigger implementations via different sets of
18059ec5a7d1STom Zanussi * event_trigger_ops, depending on the value of the @param
18069ec5a7d1STom Zanussi * string.
180785f2b082STom Zanussi */
180885f2b082STom Zanussi struct event_command {
180985f2b082STom Zanussi struct list_head list;
181085f2b082STom Zanussi char *name;
181185f2b082STom Zanussi enum event_trigger_type trigger_type;
1812353206f5SSteven Rostedt (Red Hat) int flags;
18139ec5a7d1STom Zanussi int (*parse)(struct event_command *cmd_ops,
18147f1d2f82SSteven Rostedt (Red Hat) struct trace_event_file *file,
18159ec5a7d1STom Zanussi char *glob, char *cmd,
18169ec5a7d1STom Zanussi char *param_and_filter);
181785f2b082STom Zanussi int (*reg)(char *glob,
181885f2b082STom Zanussi struct event_trigger_data *data,
18197f1d2f82SSteven Rostedt (Red Hat) struct trace_event_file *file);
182085f2b082STom Zanussi void (*unreg)(char *glob,
182185f2b082STom Zanussi struct event_trigger_data *data,
18227f1d2f82SSteven Rostedt (Red Hat) struct trace_event_file *file);
1823a88e1cfbSTom Zanussi void (*unreg_all)(struct trace_event_file *file);
182485f2b082STom Zanussi int (*set_filter)(char *filter_str,
182585f2b082STom Zanussi struct event_trigger_data *data,
18267f1d2f82SSteven Rostedt (Red Hat) struct trace_event_file *file);
182785f2b082STom Zanussi struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
182885f2b082STom Zanussi };
182985f2b082STom Zanussi
1830353206f5SSteven Rostedt (Red Hat) /**
1831353206f5SSteven Rostedt (Red Hat) * enum event_command_flags - flags for struct event_command
1832353206f5SSteven Rostedt (Red Hat) *
1833353206f5SSteven Rostedt (Red Hat) * @POST_TRIGGER: A flag that says whether or not this command needs
1834353206f5SSteven Rostedt (Red Hat) * to have its action delayed until after the current event has
1835353206f5SSteven Rostedt (Red Hat) * been closed. Some triggers need to avoid being invoked while
1836353206f5SSteven Rostedt (Red Hat) * an event is currently in the process of being logged, since
1837353206f5SSteven Rostedt (Red Hat) * the trigger may itself log data into the trace buffer. Thus
1838353206f5SSteven Rostedt (Red Hat) * we make sure the current event is committed before invoking
1839353206f5SSteven Rostedt (Red Hat) * those triggers. To do that, the trigger invocation is split
1840353206f5SSteven Rostedt (Red Hat) * in two - the first part checks the filter using the current
1841353206f5SSteven Rostedt (Red Hat) * trace record; if a command has the @post_trigger flag set, it
1842353206f5SSteven Rostedt (Red Hat) * sets a bit for itself in the return value, otherwise it
1843353206f5SSteven Rostedt (Red Hat) * directly invokes the trigger. Once all commands have been
1844353206f5SSteven Rostedt (Red Hat) * either invoked or set their return flag, the current record is
1845353206f5SSteven Rostedt (Red Hat) * either committed or discarded. At that point, if any commands
1846353206f5SSteven Rostedt (Red Hat) * have deferred their triggers, those commands are finally
1847353206f5SSteven Rostedt (Red Hat) * invoked following the close of the current event. In other
1848353206f5SSteven Rostedt (Red Hat) * words, if the event_trigger_ops @func() probe implementation
1849353206f5SSteven Rostedt (Red Hat) * itself logs to the trace buffer, this flag should be set,
1850353206f5SSteven Rostedt (Red Hat) * otherwise it can be left unspecified.
1851353206f5SSteven Rostedt (Red Hat) *
1852353206f5SSteven Rostedt (Red Hat) * @NEEDS_REC: A flag that says whether or not this command needs
1853353206f5SSteven Rostedt (Red Hat) * access to the trace record in order to perform its function,
1854353206f5SSteven Rostedt (Red Hat) * regardless of whether or not it has a filter associated with
1855353206f5SSteven Rostedt (Red Hat) * it (filters make a trigger require access to the trace record
1856353206f5SSteven Rostedt (Red Hat) * but are not always present).
1857353206f5SSteven Rostedt (Red Hat) */
1858353206f5SSteven Rostedt (Red Hat) enum event_command_flags {
1859353206f5SSteven Rostedt (Red Hat) EVENT_CMD_FL_POST_TRIGGER = 1,
1860353206f5SSteven Rostedt (Red Hat) EVENT_CMD_FL_NEEDS_REC = 2,
1861353206f5SSteven Rostedt (Red Hat) };
1862353206f5SSteven Rostedt (Red Hat)
event_command_post_trigger(struct event_command * cmd_ops)1863353206f5SSteven Rostedt (Red Hat) static inline bool event_command_post_trigger(struct event_command *cmd_ops)
1864353206f5SSteven Rostedt (Red Hat) {
1865353206f5SSteven Rostedt (Red Hat) return cmd_ops->flags & EVENT_CMD_FL_POST_TRIGGER;
1866353206f5SSteven Rostedt (Red Hat) }
1867353206f5SSteven Rostedt (Red Hat)
event_command_needs_rec(struct event_command * cmd_ops)1868353206f5SSteven Rostedt (Red Hat) static inline bool event_command_needs_rec(struct event_command *cmd_ops)
1869353206f5SSteven Rostedt (Red Hat) {
1870353206f5SSteven Rostedt (Red Hat) return cmd_ops->flags & EVENT_CMD_FL_NEEDS_REC;
1871353206f5SSteven Rostedt (Red Hat) }
1872353206f5SSteven Rostedt (Red Hat)
18737f1d2f82SSteven Rostedt (Red Hat) extern int trace_event_enable_disable(struct trace_event_file *file,
187485f2b082STom Zanussi int enable, int soft_disable);
187593e31ffbSTom Zanussi extern int tracing_alloc_snapshot(void);
1876a35873a0STom Zanussi extern void tracing_snapshot_cond(struct trace_array *tr, void *cond_data);
1877a35873a0STom Zanussi extern int tracing_snapshot_cond_enable(struct trace_array *tr, void *cond_data, cond_update_fn_t update);
1878a35873a0STom Zanussi
1879a35873a0STom Zanussi extern int tracing_snapshot_cond_disable(struct trace_array *tr);
1880a35873a0STom Zanussi extern void *tracing_cond_snapshot_data(struct trace_array *tr);
188185f2b082STom Zanussi
1882e9fb2b6dSSteven Rostedt extern const char *__start___trace_bprintk_fmt[];
1883e9fb2b6dSSteven Rostedt extern const char *__stop___trace_bprintk_fmt[];
1884e9fb2b6dSSteven Rostedt
1885102c9323SSteven Rostedt (Red Hat) extern const char *__start___tracepoint_str[];
1886102c9323SSteven Rostedt (Red Hat) extern const char *__stop___tracepoint_str[];
1887102c9323SSteven Rostedt (Red Hat)
1888b9f9108cSSteven Rostedt (Red Hat) void trace_printk_control(bool enabled);
188981698831SSteven Rostedt void trace_printk_start_comm(void);
1890613f04a0SSteven Rostedt (Red Hat) int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
18912b6080f2SSteven Rostedt int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);
189207d777feSSteven Rostedt
18935c3469cbSMasami Hiramatsu /* Used from boot time tracer */
18945c3469cbSMasami Hiramatsu extern int trace_set_options(struct trace_array *tr, char *option);
18955c3469cbSMasami Hiramatsu extern int tracing_set_tracer(struct trace_array *tr, const char *buf);
18965c3469cbSMasami Hiramatsu extern ssize_t tracing_resize_ring_buffer(struct trace_array *tr,
18975c3469cbSMasami Hiramatsu unsigned long size, int cpu_id);
18985c3469cbSMasami Hiramatsu extern int tracing_set_cpumask(struct trace_array *tr,
18995c3469cbSMasami Hiramatsu cpumask_var_t tracing_cpumask_new);
19005c3469cbSMasami Hiramatsu
19015c3469cbSMasami Hiramatsu
19027e465baaSTom Zanussi #define MAX_EVENT_NAME_LEN 64
19037e465baaSTom Zanussi
19047e465baaSTom Zanussi extern ssize_t trace_parse_run_command(struct file *file,
19057e465baaSTom Zanussi const char __user *buffer, size_t count, loff_t *ppos,
1906d262271dSMasami Hiramatsu int (*createfn)(const char *));
19077e465baaSTom Zanussi
19088a062902STom Zanussi extern unsigned int err_pos(char *cmd, const char *str);
19092f754e77SSteven Rostedt (VMware) extern void tracing_log_err(struct trace_array *tr,
19102f754e77SSteven Rostedt (VMware) const char *loc, const char *cmd,
19111581a884STom Zanussi const char **errs, u8 type, u16 pos);
19128a062902STom Zanussi
1913ca268da6SSteven Rostedt (Red Hat) /*
1914ca268da6SSteven Rostedt (Red Hat) * Normal trace_printk() and friends allocates special buffers
1915ca268da6SSteven Rostedt (Red Hat) * to do the manipulation, as well as saves the print formats
1916ca268da6SSteven Rostedt (Red Hat) * into sections to display. But the trace infrastructure wants
1917ca268da6SSteven Rostedt (Red Hat) * to use these without the added overhead at the price of being
1918ca268da6SSteven Rostedt (Red Hat) * a bit slower (used mainly for warnings, where we don't care
1919ca268da6SSteven Rostedt (Red Hat) * about performance). The internal_trace_puts() is for such
1920ca268da6SSteven Rostedt (Red Hat) * a purpose.
1921ca268da6SSteven Rostedt (Red Hat) */
1922ca268da6SSteven Rostedt (Red Hat) #define internal_trace_puts(str) __trace_puts(_THIS_IP_, str, strlen(str))
1923ca268da6SSteven Rostedt (Red Hat)
19244e5292eaSSteven Rostedt #undef FTRACE_ENTRY
192504ae87a5SPeter Zijlstra #define FTRACE_ENTRY(call, struct_name, id, tstruct, print) \
19262425bcb9SSteven Rostedt (Red Hat) extern struct trace_event_call \
192752f5684cSGideon Israel Dsouza __aligned(4) event_##call;
19284e5292eaSSteven Rostedt #undef FTRACE_ENTRY_DUP
192904ae87a5SPeter Zijlstra #define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print) \
193004ae87a5SPeter Zijlstra FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
1931a4a551b8SNamhyung Kim #undef FTRACE_ENTRY_PACKED
193204ae87a5SPeter Zijlstra #define FTRACE_ENTRY_PACKED(call, struct_name, id, tstruct, print) \
193304ae87a5SPeter Zijlstra FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
1934a4a551b8SNamhyung Kim
19354e5292eaSSteven Rostedt #include "trace_entries.h"
1936e1112b4dSTom Zanussi
19376e48b550SMark Brown #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_FUNCTION_TRACER)
19382425bcb9SSteven Rostedt (Red Hat) int perf_ftrace_event_register(struct trace_event_call *call,
1939ced39002SJiri Olsa enum trace_reg type, void *data);
1940ced39002SJiri Olsa #else
1941ced39002SJiri Olsa #define perf_ftrace_event_register NULL
19426e48b550SMark Brown #endif
1943ced39002SJiri Olsa
19445f893b26SSteven Rostedt (Red Hat) #ifdef CONFIG_FTRACE_SYSCALLS
19455f893b26SSteven Rostedt (Red Hat) void init_ftrace_syscalls(void);
1946dbfeaa7aSTom Zanussi const char *get_syscall_name(int syscall);
19475f893b26SSteven Rostedt (Red Hat) #else
init_ftrace_syscalls(void)19485f893b26SSteven Rostedt (Red Hat) static inline void init_ftrace_syscalls(void) { }
get_syscall_name(int syscall)1949dbfeaa7aSTom Zanussi static inline const char *get_syscall_name(int syscall)
1950dbfeaa7aSTom Zanussi {
1951dbfeaa7aSTom Zanussi return NULL;
1952dbfeaa7aSTom Zanussi }
19535f893b26SSteven Rostedt (Red Hat) #endif
19545f893b26SSteven Rostedt (Red Hat)
19555f893b26SSteven Rostedt (Red Hat) #ifdef CONFIG_EVENT_TRACING
19565f893b26SSteven Rostedt (Red Hat) void trace_event_init(void);
1957f57a4143SJeremy Linton void trace_event_eval_update(struct trace_eval_map **map, int len);
19585c3469cbSMasami Hiramatsu /* Used from boot time tracer */
19595c3469cbSMasami Hiramatsu extern int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set);
19605c3469cbSMasami Hiramatsu extern int trigger_process_regex(struct trace_event_file *file, char *buff);
19615f893b26SSteven Rostedt (Red Hat) #else
trace_event_init(void)19625f893b26SSteven Rostedt (Red Hat) static inline void __init trace_event_init(void) { }
trace_event_eval_update(struct trace_eval_map ** map,int len)1963f57a4143SJeremy Linton static inline void trace_event_eval_update(struct trace_eval_map **map, int len) { }
19645f893b26SSteven Rostedt (Red Hat) #endif
19655f893b26SSteven Rostedt (Red Hat)
19662824f503SSteven Rostedt (VMware) #ifdef CONFIG_TRACER_SNAPSHOT
19672824f503SSteven Rostedt (VMware) void tracing_snapshot_instance(struct trace_array *tr);
19682824f503SSteven Rostedt (VMware) int tracing_alloc_snapshot_instance(struct trace_array *tr);
19692824f503SSteven Rostedt (VMware) #else
tracing_snapshot_instance(struct trace_array * tr)19702824f503SSteven Rostedt (VMware) static inline void tracing_snapshot_instance(struct trace_array *tr) { }
tracing_alloc_snapshot_instance(struct trace_array * tr)19712824f503SSteven Rostedt (VMware) static inline int tracing_alloc_snapshot_instance(struct trace_array *tr)
19722824f503SSteven Rostedt (VMware) {
19732824f503SSteven Rostedt (VMware) return 0;
19742824f503SSteven Rostedt (VMware) }
19752824f503SSteven Rostedt (VMware) #endif
19762824f503SSteven Rostedt (VMware)
19773f1756dcSSteven Rostedt (VMware) #ifdef CONFIG_PREEMPT_TRACER
19783f1756dcSSteven Rostedt (VMware) void tracer_preempt_on(unsigned long a0, unsigned long a1);
19793f1756dcSSteven Rostedt (VMware) void tracer_preempt_off(unsigned long a0, unsigned long a1);
19803f1756dcSSteven Rostedt (VMware) #else
tracer_preempt_on(unsigned long a0,unsigned long a1)19813f1756dcSSteven Rostedt (VMware) static inline void tracer_preempt_on(unsigned long a0, unsigned long a1) { }
tracer_preempt_off(unsigned long a0,unsigned long a1)19823f1756dcSSteven Rostedt (VMware) static inline void tracer_preempt_off(unsigned long a0, unsigned long a1) { }
19833f1756dcSSteven Rostedt (VMware) #endif
19843f1756dcSSteven Rostedt (VMware) #ifdef CONFIG_IRQSOFF_TRACER
19853f1756dcSSteven Rostedt (VMware) void tracer_hardirqs_on(unsigned long a0, unsigned long a1);
19863f1756dcSSteven Rostedt (VMware) void tracer_hardirqs_off(unsigned long a0, unsigned long a1);
19873f1756dcSSteven Rostedt (VMware) #else
tracer_hardirqs_on(unsigned long a0,unsigned long a1)19883f1756dcSSteven Rostedt (VMware) static inline void tracer_hardirqs_on(unsigned long a0, unsigned long a1) { }
tracer_hardirqs_off(unsigned long a0,unsigned long a1)19893f1756dcSSteven Rostedt (VMware) static inline void tracer_hardirqs_off(unsigned long a0, unsigned long a1) { }
19903f1756dcSSteven Rostedt (VMware) #endif
19913f1756dcSSteven Rostedt (VMware)
19920c97bf86SMiguel Ojeda /*
19930c97bf86SMiguel Ojeda * Reset the state of the trace_iterator so that it can read consumed data.
19940c97bf86SMiguel Ojeda * Normally, the trace_iterator is used for reading the data when it is not
19950c97bf86SMiguel Ojeda * consumed, and must retain state.
19960c97bf86SMiguel Ojeda */
trace_iterator_reset(struct trace_iterator * iter)19970c97bf86SMiguel Ojeda static __always_inline void trace_iterator_reset(struct trace_iterator *iter)
19980c97bf86SMiguel Ojeda {
1999dba87967SXiu Jianfeng memset_startat(iter, 0, seq);
20000c97bf86SMiguel Ojeda iter->pos = -1;
20010c97bf86SMiguel Ojeda }
20020c97bf86SMiguel Ojeda
200342d120e2STom Zanussi /* Check the name is good for event/group/fields */
__is_good_name(const char * name,bool hash_ok)2004575b76cbSSteven Rostedt (Google) static inline bool __is_good_name(const char *name, bool hash_ok)
200542d120e2STom Zanussi {
2006575b76cbSSteven Rostedt (Google) if (!isalpha(*name) && *name != '_' && (!hash_ok || *name != '-'))
200742d120e2STom Zanussi return false;
200842d120e2STom Zanussi while (*++name != '\0') {
2009575b76cbSSteven Rostedt (Google) if (!isalpha(*name) && !isdigit(*name) && *name != '_' &&
2010575b76cbSSteven Rostedt (Google) (!hash_ok || *name != '-'))
201142d120e2STom Zanussi return false;
201242d120e2STom Zanussi }
201342d120e2STom Zanussi return true;
201442d120e2STom Zanussi }
201542d120e2STom Zanussi
2016575b76cbSSteven Rostedt (Google) /* Check the name is good for event/group/fields */
is_good_name(const char * name)2017575b76cbSSteven Rostedt (Google) static inline bool is_good_name(const char *name)
2018575b76cbSSteven Rostedt (Google) {
2019575b76cbSSteven Rostedt (Google) return __is_good_name(name, false);
2020575b76cbSSteven Rostedt (Google) }
2021575b76cbSSteven Rostedt (Google)
2022575b76cbSSteven Rostedt (Google) /* Check the name is good for system */
is_good_system_name(const char * name)2023575b76cbSSteven Rostedt (Google) static inline bool is_good_system_name(const char *name)
2024575b76cbSSteven Rostedt (Google) {
2025575b76cbSSteven Rostedt (Google) return __is_good_name(name, true);
2026575b76cbSSteven Rostedt (Google) }
2027575b76cbSSteven Rostedt (Google)
20287491e2c4STzvetomir Stoyanov (VMware) /* Convert certain expected symbols into '_' when generating event names */
sanitize_event_name(char * name)20297491e2c4STzvetomir Stoyanov (VMware) static inline void sanitize_event_name(char *name)
20307491e2c4STzvetomir Stoyanov (VMware) {
20317491e2c4STzvetomir Stoyanov (VMware) while (*name++ != '\0')
20327491e2c4STzvetomir Stoyanov (VMware) if (*name == ':' || *name == '.')
20337491e2c4STzvetomir Stoyanov (VMware) *name = '_';
20347491e2c4STzvetomir Stoyanov (VMware) }
20357491e2c4STzvetomir Stoyanov (VMware)
2036bc87cf0aSDaniel Bristot de Oliveira /*
2037bc87cf0aSDaniel Bristot de Oliveira * This is a generic way to read and write a u64 value from a file in tracefs.
2038bc87cf0aSDaniel Bristot de Oliveira *
2039bc87cf0aSDaniel Bristot de Oliveira * The value is stored on the variable pointed by *val. The value needs
2040bc87cf0aSDaniel Bristot de Oliveira * to be at least *min and at most *max. The write is protected by an
2041bc87cf0aSDaniel Bristot de Oliveira * existing *lock.
2042bc87cf0aSDaniel Bristot de Oliveira */
2043bc87cf0aSDaniel Bristot de Oliveira struct trace_min_max_param {
2044bc87cf0aSDaniel Bristot de Oliveira struct mutex *lock;
2045bc87cf0aSDaniel Bristot de Oliveira u64 *val;
2046bc87cf0aSDaniel Bristot de Oliveira u64 *min;
2047bc87cf0aSDaniel Bristot de Oliveira u64 *max;
2048bc87cf0aSDaniel Bristot de Oliveira };
2049bc87cf0aSDaniel Bristot de Oliveira
2050bc87cf0aSDaniel Bristot de Oliveira #define U64_STR_SIZE 24 /* 20 digits max */
2051bc87cf0aSDaniel Bristot de Oliveira
2052bc87cf0aSDaniel Bristot de Oliveira extern const struct file_operations trace_min_max_fops;
2053bc87cf0aSDaniel Bristot de Oliveira
2054102227b9SDaniel Bristot de Oliveira #ifdef CONFIG_RV
2055102227b9SDaniel Bristot de Oliveira extern int rv_init_interface(void);
2056102227b9SDaniel Bristot de Oliveira #else
rv_init_interface(void)2057102227b9SDaniel Bristot de Oliveira static inline int rv_init_interface(void)
2058102227b9SDaniel Bristot de Oliveira {
2059102227b9SDaniel Bristot de Oliveira return 0;
2060102227b9SDaniel Bristot de Oliveira }
2061102227b9SDaniel Bristot de Oliveira #endif
2062102227b9SDaniel Bristot de Oliveira
2063bc0c38d1SSteven Rostedt #endif /* _LINUX_KERNEL_TRACE_H */
2064