blob: 28672e87e9100c7a02e36e47db2317e0a46d3313 [file] [log] [blame]
Tom Zanussibac5fb92013-10-24 08:59:29 -05001
Steven Rostedt97f20252009-04-13 11:20:49 -04002#ifndef _LINUX_FTRACE_EVENT_H
3#define _LINUX_FTRACE_EVENT_H
4
Steven Rostedt97f20252009-04-13 11:20:49 -04005#include <linux/ring_buffer.h>
Steven Rostedt16bb8eb2009-09-12 19:04:54 -04006#include <linux/trace_seq.h>
Steven Rostedtbe74b732009-05-26 20:25:22 +02007#include <linux/percpu.h>
Frederic Weisbecker20ab44252009-09-18 06:10:28 +02008#include <linux/hardirq.h>
Xiao Guangrong430ad5a2010-01-28 09:32:29 +08009#include <linux/perf_event.h>
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -040010#include <linux/tracepoint.h>
Steven Rostedt97f20252009-04-13 11:20:49 -040011
12struct trace_array;
Steven Rostedt (Red Hat)12883ef2013-03-05 09:24:35 -050013struct trace_buffer;
Steven Rostedt97f20252009-04-13 11:20:49 -040014struct tracer;
Steven Rostedt6d723732009-04-10 14:53:50 -040015struct dentry;
Steven Rostedt97f20252009-04-13 11:20:49 -040016
Steven Rostedtbe74b732009-05-26 20:25:22 +020017struct trace_print_flags {
18 unsigned long mask;
19 const char *name;
20};
21
liubo2fc1b6f2011-04-19 09:35:28 +080022struct trace_print_flags_u64 {
23 unsigned long long mask;
24 const char *name;
25};
26
Steven Rostedtbe74b732009-05-26 20:25:22 +020027const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
28 unsigned long flags,
29 const struct trace_print_flags *flag_array);
30
Steven Rostedt0f4fc292009-05-20 19:21:47 -040031const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
32 const struct trace_print_flags *symbol_array);
33
liubo2fc1b6f2011-04-19 09:35:28 +080034#if BITS_PER_LONG == 32
35const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
36 unsigned long long val,
37 const struct trace_print_flags_u64
38 *symbol_array);
39#endif
40
Steven Rostedt (Red Hat)4449bf92014-05-06 13:10:24 -040041const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
42 unsigned int bitmask_size);
43
Kei Tokunaga5a2e3992010-04-01 20:40:58 +090044const char *ftrace_print_hex_seq(struct trace_seq *p,
45 const unsigned char *buf, int len);
46
Li Zefanf71130d2013-02-21 10:32:38 +080047struct trace_iterator;
48struct trace_event;
49
50int ftrace_raw_output_prep(struct trace_iterator *iter,
51 struct trace_event *event);
52
Steven Rostedt97f20252009-04-13 11:20:49 -040053/*
54 * The trace entry - the most basic unit of tracing. This is what
55 * is printed in the end as a single line in the trace output, such as:
56 *
57 * bash-15816 [01] 235.197585: idle_cpu <- irq_enter
58 */
59struct trace_entry {
Steven Rostedt89ec0de2009-03-26 11:03:29 -040060 unsigned short type;
Steven Rostedt97f20252009-04-13 11:20:49 -040061 unsigned char flags;
62 unsigned char preempt_count;
63 int pid;
Steven Rostedt97f20252009-04-13 11:20:49 -040064};
65
Steven Rostedt89ec0de2009-03-26 11:03:29 -040066#define FTRACE_MAX_EVENT \
67 ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
68
Steven Rostedt97f20252009-04-13 11:20:49 -040069/*
70 * Trace iterator - used by printout routines who present trace
71 * results to users and which routines might sleep, etc:
72 */
73struct trace_iterator {
74 struct trace_array *tr;
75 struct tracer *trace;
Steven Rostedt (Red Hat)12883ef2013-03-05 09:24:35 -050076 struct trace_buffer *trace_buffer;
Steven Rostedt97f20252009-04-13 11:20:49 -040077 void *private;
78 int cpu_file;
79 struct mutex mutex;
Steven Rostedt6d158a82012-06-27 20:46:14 -040080 struct ring_buffer_iter **buffer_iter;
Steven Rostedt112f38a72009-06-01 15:16:05 -040081 unsigned long iter_flags;
Steven Rostedt97f20252009-04-13 11:20:49 -040082
Lai Jiangshanbc289ae2010-06-03 18:26:24 +080083 /* trace_seq for __print_flags() and __print_symbolic() etc. */
84 struct trace_seq tmp_seq;
85
Andrew Vagined5467d2013-08-02 21:16:43 +040086 cpumask_var_t started;
87
88 /* it's true when current open file is snapshot */
89 bool snapshot;
90
Steven Rostedt97f20252009-04-13 11:20:49 -040091 /* The below is zeroed out in pipe_read */
92 struct trace_seq seq;
93 struct trace_entry *ent;
Steven Rostedtbc21b472010-03-31 19:49:26 -040094 unsigned long lost_events;
Steven Rostedta63ce5b2009-12-07 09:11:39 -050095 int leftover;
Steven Rostedt4a9bd3f2011-07-14 16:36:53 -040096 int ent_size;
Steven Rostedt97f20252009-04-13 11:20:49 -040097 int cpu;
98 u64 ts;
99
Steven Rostedt97f20252009-04-13 11:20:49 -0400100 loff_t pos;
101 long idx;
102
Andrew Vagined5467d2013-08-02 21:16:43 +0400103 /* All new field here will be zeroed out in pipe_read */
Steven Rostedt97f20252009-04-13 11:20:49 -0400104};
105
David Sharp8be07092012-11-13 12:18:22 -0800106enum trace_iter_flags {
107 TRACE_FILE_LAT_FMT = 1,
108 TRACE_FILE_ANNOTATE = 2,
109 TRACE_FILE_TIME_IN_NS = 4,
110};
111
Steven Rostedt97f20252009-04-13 11:20:49 -0400112
113typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
Steven Rostedta9a57762010-04-22 18:46:14 -0400114 int flags, struct trace_event *event);
115
116struct trace_event_functions {
Steven Rostedt97f20252009-04-13 11:20:49 -0400117 trace_print_func trace;
118 trace_print_func raw;
119 trace_print_func hex;
120 trace_print_func binary;
121};
122
Steven Rostedta9a57762010-04-22 18:46:14 -0400123struct trace_event {
124 struct hlist_node node;
125 struct list_head list;
126 int type;
127 struct trace_event_functions *funcs;
128};
129
Steven Rostedt97f20252009-04-13 11:20:49 -0400130extern int register_ftrace_event(struct trace_event *event);
131extern int unregister_ftrace_event(struct trace_event *event);
132
133/* Return values for print_line callback */
134enum print_line_t {
135 TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */
136 TRACE_TYPE_HANDLED = 1,
137 TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */
138 TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */
139};
140
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200141void tracing_generic_entry_update(struct trace_entry *entry,
142 unsigned long flags,
143 int pc);
Steven Rostedtccb469a2012-08-02 10:32:10 -0400144struct ftrace_event_file;
145
146struct ring_buffer_event *
147trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
148 struct ftrace_event_file *ftrace_file,
149 int type, unsigned long len,
150 unsigned long flags, int pc);
Steven Rostedt97f20252009-04-13 11:20:49 -0400151struct ring_buffer_event *
Steven Rostedte77405a2009-09-02 14:17:06 -0400152trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
153 int type, unsigned long len,
Steven Rostedt97f20252009-04-13 11:20:49 -0400154 unsigned long flags, int pc);
Steven Rostedte77405a2009-09-02 14:17:06 -0400155void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
156 struct ring_buffer_event *event,
Steven Rostedt97f20252009-04-13 11:20:49 -0400157 unsigned long flags, int pc);
Steven Rostedt0d5c6e12012-11-01 20:54:21 -0400158void trace_buffer_unlock_commit(struct ring_buffer *buffer,
159 struct ring_buffer_event *event,
160 unsigned long flags, int pc);
161void trace_buffer_unlock_commit_regs(struct ring_buffer *buffer,
162 struct ring_buffer_event *event,
163 unsigned long flags, int pc,
164 struct pt_regs *regs);
Steven Rostedte77405a2009-09-02 14:17:06 -0400165void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
166 struct ring_buffer_event *event);
Steven Rostedt97f20252009-04-13 11:20:49 -0400167
168void tracing_record_cmdline(struct task_struct *tsk);
169
Steven Rostedt1d6bae92012-08-09 19:16:14 -0400170int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
171
Li Zefan1f9963c2009-07-20 10:20:53 +0800172struct event_filter;
173
Steven Rostedt22392912010-04-21 12:27:06 -0400174enum trace_reg {
175 TRACE_REG_REGISTER,
176 TRACE_REG_UNREGISTER,
Jiri Olsa37d73992012-03-14 00:03:02 +0100177#ifdef CONFIG_PERF_EVENTS
Steven Rostedt22392912010-04-21 12:27:06 -0400178 TRACE_REG_PERF_REGISTER,
179 TRACE_REG_PERF_UNREGISTER,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100180 TRACE_REG_PERF_OPEN,
181 TRACE_REG_PERF_CLOSE,
Jiri Olsa489c75c2012-02-15 15:51:50 +0100182 TRACE_REG_PERF_ADD,
183 TRACE_REG_PERF_DEL,
Jiri Olsa37d73992012-03-14 00:03:02 +0100184#endif
Steven Rostedt22392912010-04-21 12:27:06 -0400185};
186
187struct ftrace_event_call;
188
Steven Rostedt8f082012010-04-20 10:47:33 -0400189struct ftrace_event_class {
190 char *system;
Steven Rostedt22392912010-04-21 12:27:06 -0400191 void *probe;
192#ifdef CONFIG_PERF_EVENTS
193 void *perf_probe;
194#endif
195 int (*reg)(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100196 enum trace_reg type, void *data);
Steven Rostedt2e33af02010-04-22 10:35:55 -0400197 int (*define_fields)(struct ftrace_event_call *);
198 struct list_head *(*get_fields)(struct ftrace_event_call *);
199 struct list_head fields;
Steven Rostedt0405ab82010-04-22 11:46:44 -0400200 int (*raw_init)(struct ftrace_event_call *);
Steven Rostedt8f082012010-04-20 10:47:33 -0400201};
202
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400203extern int ftrace_event_reg(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100204 enum trace_reg type, void *data);
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400205
Steven Rostedt1d6bae92012-08-09 19:16:14 -0400206int ftrace_output_event(struct trace_iterator *iter, struct ftrace_event_call *event,
207 char *fmt, ...);
208
Steven Rostedt35bb4392012-08-09 22:26:46 -0400209int ftrace_event_define_field(struct ftrace_event_call *call,
210 char *type, int len, char *item, int offset,
211 int field_size, int sign, int filter);
212
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400213struct ftrace_event_buffer {
214 struct ring_buffer *buffer;
215 struct ring_buffer_event *event;
216 struct ftrace_event_file *ftrace_file;
217 void *entry;
218 unsigned long flags;
219 int pc;
220};
221
222void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer,
223 struct ftrace_event_file *ftrace_file,
224 unsigned long len);
225
226void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer);
227
Steven Rostedt (Red Hat)bc4c4262014-03-21 08:23:38 -0400228int ftrace_event_define_field(struct ftrace_event_call *call,
229 char *type, int len, char *item, int offset,
230 int field_size, int sign, int filter);
231
Steven Rostedt553552c2010-04-23 11:12:36 -0400232enum {
Steven Rostedt553552c2010-04-23 11:12:36 -0400233 TRACE_EVENT_FL_FILTERED_BIT,
Frederic Weisbecker61c32652010-11-18 01:39:17 +0100234 TRACE_EVENT_FL_CAP_ANY_BIT,
Li Zefan27b14b52011-11-01 09:09:35 +0800235 TRACE_EVENT_FL_NO_SET_FILTER_BIT,
Steven Rostedt9b637762012-05-10 15:55:43 -0400236 TRACE_EVENT_FL_IGNORE_ENABLE_BIT,
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500237 TRACE_EVENT_FL_WAS_ENABLED_BIT,
Tom Zanussif306cc82013-10-24 08:34:17 -0500238 TRACE_EVENT_FL_USE_CALL_FILTER_BIT,
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400239 TRACE_EVENT_FL_TRACEPOINT_BIT,
Steven Rostedt553552c2010-04-23 11:12:36 -0400240};
241
Steven Rostedtae63b312012-05-03 23:09:03 -0400242/*
243 * Event flags:
244 * FILTERED - The event has a filter attached
245 * CAP_ANY - Any user can enable for perf
246 * NO_SET_FILTER - Set when filter has error and is to be ignored
Steven Rostedt (Red Hat)2a30c112013-03-04 22:27:04 -0500247 * IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500248 * WAS_ENABLED - Set and stays set when an event was ever enabled
249 * (used for module unloading, if a module event is enabled,
250 * it is best to clear the buffers that used it).
Tom Zanussif306cc82013-10-24 08:34:17 -0500251 * USE_CALL_FILTER - For ftrace internal events, don't use file filter
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400252 * TRACEPOINT - Event is a tracepoint
Steven Rostedtae63b312012-05-03 23:09:03 -0400253 */
Steven Rostedt553552c2010-04-23 11:12:36 -0400254enum {
Li Zefane870e9a2010-07-02 11:07:32 +0800255 TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT),
Frederic Weisbecker61c32652010-11-18 01:39:17 +0100256 TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT),
Li Zefan27b14b52011-11-01 09:09:35 +0800257 TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT),
Steven Rostedt9b637762012-05-10 15:55:43 -0400258 TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT),
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500259 TRACE_EVENT_FL_WAS_ENABLED = (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT),
Tom Zanussif306cc82013-10-24 08:34:17 -0500260 TRACE_EVENT_FL_USE_CALL_FILTER = (1 << TRACE_EVENT_FL_USE_CALL_FILTER_BIT),
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400261 TRACE_EVENT_FL_TRACEPOINT = (1 << TRACE_EVENT_FL_TRACEPOINT_BIT),
Steven Rostedt553552c2010-04-23 11:12:36 -0400262};
263
Steven Rostedt97f20252009-04-13 11:20:49 -0400264struct ftrace_event_call {
Steven Rostedta59fd602009-04-10 13:52:20 -0400265 struct list_head list;
Steven Rostedt8f082012010-04-20 10:47:33 -0400266 struct ftrace_event_class *class;
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400267 union {
268 char *name;
269 /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
270 struct tracepoint *tp;
271 };
Steven Rostedt80decc72010-04-23 10:00:22 -0400272 struct trace_event event;
Lai Jiangshan509e7602009-12-15 15:39:42 +0800273 const char *print_fmt;
Li Zefan1f9963c2009-07-20 10:20:53 +0800274 struct event_filter *filter;
Steven Rostedt6d723732009-04-10 14:53:50 -0400275 void *mod;
Jason Baron69fd4f02009-08-10 16:52:44 -0400276 void *data;
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400277 /*
278 * bit 0: filter_active
279 * bit 1: allow trace by non root (cap any)
280 * bit 2: failed to apply filter
281 * bit 3: ftrace internal event (do not enable)
282 * bit 4: Event was enabled by module
Tom Zanussif306cc82013-10-24 08:34:17 -0500283 * bit 5: use call filter rather than file filter
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400284 * bit 6: Event is a tracepoint
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400285 */
Steven Rostedtae63b312012-05-03 23:09:03 -0400286 int flags; /* static flags of different events */
287
288#ifdef CONFIG_PERF_EVENTS
289 int perf_refcount;
290 struct hlist_head __percpu *perf_events;
Peter Zijlstrad5b5f392013-11-14 16:23:04 +0100291
292 int (*perf_perm)(struct ftrace_event_call *,
293 struct perf_event *);
Steven Rostedtae63b312012-05-03 23:09:03 -0400294#endif
295};
296
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400297static inline const char *
298ftrace_event_name(struct ftrace_event_call *call)
299{
300 if (call->flags & TRACE_EVENT_FL_TRACEPOINT)
301 return call->tp ? call->tp->name : NULL;
302 else
303 return call->name;
304}
305
Steven Rostedtae63b312012-05-03 23:09:03 -0400306struct trace_array;
307struct ftrace_subsystem_dir;
308
309enum {
310 FTRACE_EVENT_FL_ENABLED_BIT,
311 FTRACE_EVENT_FL_RECORDED_CMD_BIT,
Tom Zanussif306cc82013-10-24 08:34:17 -0500312 FTRACE_EVENT_FL_FILTERED_BIT,
313 FTRACE_EVENT_FL_NO_SET_FILTER_BIT,
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400314 FTRACE_EVENT_FL_SOFT_MODE_BIT,
315 FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
Tom Zanussi85f2b082013-10-24 08:59:24 -0500316 FTRACE_EVENT_FL_TRIGGER_MODE_BIT,
Tom Zanussibac5fb92013-10-24 08:59:29 -0500317 FTRACE_EVENT_FL_TRIGGER_COND_BIT,
Steven Rostedtae63b312012-05-03 23:09:03 -0400318};
319
320/*
321 * Ftrace event file flags:
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400322 * ENABLED - The event is enabled
Steven Rostedtae63b312012-05-03 23:09:03 -0400323 * RECORDED_CMD - The comms should be recorded at sched_switch
Tom Zanussif306cc82013-10-24 08:34:17 -0500324 * FILTERED - The event has a filter attached
325 * NO_SET_FILTER - Set when filter has error and is to be ignored
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400326 * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED
327 * SOFT_DISABLED - When set, do not trace the event (even though its
328 * tracepoint may be enabled)
Tom Zanussi85f2b082013-10-24 08:59:24 -0500329 * TRIGGER_MODE - When set, invoke the triggers associated with the event
Tom Zanussibac5fb92013-10-24 08:59:29 -0500330 * TRIGGER_COND - When set, one or more triggers has an associated filter
Steven Rostedtae63b312012-05-03 23:09:03 -0400331 */
332enum {
333 FTRACE_EVENT_FL_ENABLED = (1 << FTRACE_EVENT_FL_ENABLED_BIT),
334 FTRACE_EVENT_FL_RECORDED_CMD = (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),
Tom Zanussif306cc82013-10-24 08:34:17 -0500335 FTRACE_EVENT_FL_FILTERED = (1 << FTRACE_EVENT_FL_FILTERED_BIT),
336 FTRACE_EVENT_FL_NO_SET_FILTER = (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400337 FTRACE_EVENT_FL_SOFT_MODE = (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),
338 FTRACE_EVENT_FL_SOFT_DISABLED = (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),
Tom Zanussi85f2b082013-10-24 08:59:24 -0500339 FTRACE_EVENT_FL_TRIGGER_MODE = (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),
Tom Zanussibac5fb92013-10-24 08:59:29 -0500340 FTRACE_EVENT_FL_TRIGGER_COND = (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),
Steven Rostedtae63b312012-05-03 23:09:03 -0400341};
342
343struct ftrace_event_file {
344 struct list_head list;
345 struct ftrace_event_call *event_call;
Tom Zanussif306cc82013-10-24 08:34:17 -0500346 struct event_filter *filter;
Steven Rostedtae63b312012-05-03 23:09:03 -0400347 struct dentry *dir;
348 struct trace_array *tr;
349 struct ftrace_subsystem_dir *system;
Tom Zanussi85f2b082013-10-24 08:59:24 -0500350 struct list_head triggers;
Steven Rostedt97f20252009-04-13 11:20:49 -0400351
Steven Rostedt553552c2010-04-23 11:12:36 -0400352 /*
353 * 32 bit flags:
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400354 * bit 0: enabled
355 * bit 1: enabled cmd record
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400356 * bit 2: enable/disable with the soft disable bit
357 * bit 3: soft disabled
Tom Zanussi85f2b082013-10-24 08:59:24 -0500358 * bit 4: trigger enabled
Steven Rostedt553552c2010-04-23 11:12:36 -0400359 *
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400360 * Note: The bits must be set atomically to prevent races
361 * from other writers. Reads of flags do not need to be in
362 * sync as they occur in critical sections. But the way flags
Steven Rostedtae63b312012-05-03 23:09:03 -0400363 * is currently used, these changes do not affect the code
Steven Rostedt1eaa4782010-05-14 10:19:13 -0400364 * except that when a change is made, it may have a slight
365 * delay in propagating the changes to other CPUs due to
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400366 * caching and such. Which is mostly OK ;-)
Steven Rostedt553552c2010-04-23 11:12:36 -0400367 */
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400368 unsigned long flags;
Masami Hiramatsu1cf4c072013-05-09 14:44:29 +0900369 atomic_t sm_ref; /* soft-mode reference counter */
Tom Zanussi85f2b082013-10-24 08:59:24 -0500370 atomic_t tm_ref; /* trigger-mode reference counter */
Steven Rostedt97f20252009-04-13 11:20:49 -0400371};
372
Frederic Weisbecker53cf810b2010-11-18 02:11:42 +0100373#define __TRACE_EVENT_FLAGS(name, value) \
374 static int __init trace_init_flags_##name(void) \
375 { \
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400376 event_##name.flags |= value; \
Frederic Weisbecker53cf810b2010-11-18 02:11:42 +0100377 return 0; \
378 } \
379 early_initcall(trace_init_flags_##name);
380
Peter Zijlstrad5b5f392013-11-14 16:23:04 +0100381#define __TRACE_EVENT_PERF_PERM(name, expr...) \
382 static int perf_perm_##name(struct ftrace_event_call *tp_event, \
383 struct perf_event *p_event) \
384 { \
385 return ({ expr; }); \
386 } \
387 static int __init trace_init_perf_perm_##name(void) \
388 { \
389 event_##name.perf_perm = &perf_perm_##name; \
390 return 0; \
391 } \
392 early_initcall(trace_init_perf_perm_##name);
393
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100394#define PERF_MAX_TRACE_SIZE 2048
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200395
Steven Rostedt16bb8eb2009-09-12 19:04:54 -0400396#define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */
Steven Rostedt97f20252009-04-13 11:20:49 -0400397
Tom Zanussi85f2b082013-10-24 08:59:24 -0500398enum event_trigger_type {
399 ETT_NONE = (0),
Tom Zanussi2a2df322013-10-24 08:59:25 -0500400 ETT_TRACE_ONOFF = (1 << 0),
Tom Zanussi93e31ff2013-10-24 08:59:26 -0500401 ETT_SNAPSHOT = (1 << 1),
Tom Zanussif21ecbb2013-10-24 08:59:27 -0500402 ETT_STACKTRACE = (1 << 2),
Tom Zanussi7862ad12013-10-24 08:59:28 -0500403 ETT_EVENT_ENABLE = (1 << 3),
Tom Zanussi85f2b082013-10-24 08:59:24 -0500404};
405
Li Zefan6fb29152009-10-15 11:21:42 +0800406extern int filter_match_preds(struct event_filter *filter, void *rec);
Tom Zanussif306cc82013-10-24 08:34:17 -0500407
408extern int filter_check_discard(struct ftrace_event_file *file, void *rec,
409 struct ring_buffer *buffer,
410 struct ring_buffer_event *event);
411extern int call_filter_check_discard(struct ftrace_event_call *call, void *rec,
412 struct ring_buffer *buffer,
413 struct ring_buffer_event *event);
Tom Zanussibac5fb92013-10-24 08:59:29 -0500414extern enum event_trigger_type event_triggers_call(struct ftrace_event_file *file,
415 void *rec);
416extern void event_triggers_post_call(struct ftrace_event_file *file,
417 enum event_trigger_type tt);
Steven Rostedt97f20252009-04-13 11:20:49 -0400418
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500419/**
420 * ftrace_trigger_soft_disabled - do triggers and test if soft disabled
421 * @file: The file pointer of the event to test
422 *
423 * If any triggers without filters are attached to this event, they
424 * will be called here. If the event is soft disabled and has no
425 * triggers that require testing the fields, it will return true,
426 * otherwise false.
427 */
428static inline bool
429ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
430{
431 unsigned long eflags = file->flags;
432
433 if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
434 if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
435 event_triggers_call(file, NULL);
436 if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
437 return true;
438 }
439 return false;
440}
441
442/*
443 * Helper function for event_trigger_unlock_commit{_regs}().
444 * If there are event triggers attached to this event that requires
445 * filtering against its fields, then they wil be called as the
446 * entry already holds the field information of the current event.
447 *
448 * It also checks if the event should be discarded or not.
449 * It is to be discarded if the event is soft disabled and the
450 * event was only recorded to process triggers, or if the event
451 * filter is active and this event did not match the filters.
452 *
453 * Returns true if the event is discarded, false otherwise.
454 */
455static inline bool
456__event_trigger_test_discard(struct ftrace_event_file *file,
457 struct ring_buffer *buffer,
458 struct ring_buffer_event *event,
459 void *entry,
460 enum event_trigger_type *tt)
461{
462 unsigned long eflags = file->flags;
463
464 if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
465 *tt = event_triggers_call(file, entry);
466
467 if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags))
468 ring_buffer_discard_commit(buffer, event);
469 else if (!filter_check_discard(file, entry, buffer, event))
470 return false;
471
472 return true;
473}
474
475/**
476 * event_trigger_unlock_commit - handle triggers and finish event commit
477 * @file: The file pointer assoctiated to the event
478 * @buffer: The ring buffer that the event is being written to
479 * @event: The event meta data in the ring buffer
480 * @entry: The event itself
481 * @irq_flags: The state of the interrupts at the start of the event
482 * @pc: The state of the preempt count at the start of the event.
483 *
484 * This is a helper function to handle triggers that require data
485 * from the event itself. It also tests the event against filters and
486 * if the event is soft disabled and should be discarded.
487 */
488static inline void
489event_trigger_unlock_commit(struct ftrace_event_file *file,
490 struct ring_buffer *buffer,
491 struct ring_buffer_event *event,
492 void *entry, unsigned long irq_flags, int pc)
493{
494 enum event_trigger_type tt = ETT_NONE;
495
496 if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
497 trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
498
499 if (tt)
500 event_triggers_post_call(file, tt);
501}
502
503/**
504 * event_trigger_unlock_commit_regs - handle triggers and finish event commit
505 * @file: The file pointer assoctiated to the event
506 * @buffer: The ring buffer that the event is being written to
507 * @event: The event meta data in the ring buffer
508 * @entry: The event itself
509 * @irq_flags: The state of the interrupts at the start of the event
510 * @pc: The state of the preempt count at the start of the event.
511 *
512 * This is a helper function to handle triggers that require data
513 * from the event itself. It also tests the event against filters and
514 * if the event is soft disabled and should be discarded.
515 *
516 * Same as event_trigger_unlock_commit() but calls
517 * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
518 */
519static inline void
520event_trigger_unlock_commit_regs(struct ftrace_event_file *file,
521 struct ring_buffer *buffer,
522 struct ring_buffer_event *event,
523 void *entry, unsigned long irq_flags, int pc,
524 struct pt_regs *regs)
525{
526 enum event_trigger_type tt = ETT_NONE;
527
528 if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
529 trace_buffer_unlock_commit_regs(buffer, event,
530 irq_flags, pc, regs);
531
532 if (tt)
533 event_triggers_post_call(file, tt);
534}
535
Li Zefan43b51ea2009-08-07 10:33:22 +0800536enum {
537 FILTER_OTHER = 0,
538 FILTER_STATIC_STRING,
539 FILTER_DYN_STRING,
Li Zefan87a342f2009-08-07 10:33:43 +0800540 FILTER_PTR_STRING,
Jiri Olsa02aa3162012-02-15 15:51:53 +0100541 FILTER_TRACE_FN,
Li Zefan43b51ea2009-08-07 10:33:22 +0800542};
543
Li Zefan87d9b4e2009-12-08 11:14:20 +0800544extern int trace_event_raw_init(struct ftrace_event_call *call);
Frederic Weisbeckeraeaeae12009-08-27 05:09:51 +0200545extern int trace_define_field(struct ftrace_event_call *call, const char *type,
546 const char *name, int offset, int size,
547 int is_signed, int filter_type);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -0400548extern int trace_add_event_call(struct ftrace_event_call *call);
Oleg Nesterov2816c552013-07-29 19:50:33 +0200549extern int trace_remove_event_call(struct ftrace_event_call *call);
Steven Rostedt97f20252009-04-13 11:20:49 -0400550
Steven Rostedt (Red Hat)d2802d02013-04-19 17:10:27 -0400551#define is_signed_type(type) (((type)(-1)) < (type)1)
Steven Rostedt97f20252009-04-13 11:20:49 -0400552
Steven Rostedt4671c792009-05-08 16:27:41 -0400553int trace_set_clr_event(const char *system, const char *event, int set);
554
Steven Rostedt97f20252009-04-13 11:20:49 -0400555/*
556 * The double __builtin_constant_p is because gcc will give us an error
557 * if we try to allocate the static variable to fmt if it is not a
558 * constant. Even with the outer if statement optimizing out.
559 */
560#define event_trace_printk(ip, fmt, args...) \
561do { \
562 __trace_printk_check_format(fmt, ##args); \
563 tracing_record_cmdline(current); \
564 if (__builtin_constant_p(fmt)) { \
565 static const char *trace_printk_fmt \
566 __attribute__((section("__trace_printk_fmt"))) = \
567 __builtin_constant_p(fmt) ? fmt : NULL; \
568 \
569 __trace_bprintk(ip, trace_printk_fmt, ##args); \
570 } else \
571 __trace_printk(ip, fmt, ##args); \
572} while (0)
573
Li Zefan07b139c2009-12-21 14:27:35 +0800574#ifdef CONFIG_PERF_EVENTS
Li Zefan6fb29152009-10-15 11:21:42 +0800575struct perf_event;
Frederic Weisbeckerc5306652010-03-03 07:16:16 +0100576
577DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);
578
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200579extern int perf_trace_init(struct perf_event *event);
580extern void perf_trace_destroy(struct perf_event *event);
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200581extern int perf_trace_add(struct perf_event *event, int flags);
582extern void perf_trace_del(struct perf_event *event, int flags);
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200583extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
Li Zefan6fb29152009-10-15 11:21:42 +0800584 char *filter_str);
585extern void ftrace_profile_free_filter(struct perf_event *event);
Peter Zijlstrab7e2ece2010-05-19 10:52:27 +0200586extern void *perf_trace_buf_prepare(int size, unsigned short type,
587 struct pt_regs *regs, int *rctxp);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800588
589static inline void
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100590perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400591 u64 count, struct pt_regs *regs, void *head,
592 struct task_struct *task)
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800593{
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400594 perf_tp_event(addr, count, raw_data, size, regs, head, rctx, task);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800595}
Li Zefan6fb29152009-10-15 11:21:42 +0800596#endif
597
Steven Rostedt97f20252009-04-13 11:20:49 -0400598#endif /* _LINUX_FTRACE_EVENT_H */