blob: 429fdfc3baf59e018d0e198062f894642af8a5bc [file] [log] [blame]
Tom Zanussibac5fb92013-10-24 08:59:29 -05001
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -04002#ifndef _LINUX_TRACE_EVENT_H
3#define _LINUX_TRACE_EVENT_H
Steven Rostedt97f20252009-04-13 11:20:49 -04004
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;
Alexei Starovoitov25415172015-03-25 12:49:20 -070016struct bpf_prog;
Steven Rostedt97f20252009-04-13 11:20:49 -040017
Steven Rostedtbe74b732009-05-26 20:25:22 +020018struct trace_print_flags {
19 unsigned long mask;
20 const char *name;
21};
22
liubo2fc1b6f2011-04-19 09:35:28 +080023struct trace_print_flags_u64 {
24 unsigned long long mask;
25 const char *name;
26};
27
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -040028const char *trace_print_flags_seq(struct trace_seq *p, const char *delim,
29 unsigned long flags,
30 const struct trace_print_flags *flag_array);
Steven Rostedtbe74b732009-05-26 20:25:22 +020031
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -040032const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val,
33 const struct trace_print_flags *symbol_array);
Steven Rostedt0f4fc292009-05-20 19:21:47 -040034
liubo2fc1b6f2011-04-19 09:35:28 +080035#if BITS_PER_LONG == 32
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -040036const char *trace_print_symbols_seq_u64(struct trace_seq *p,
37 unsigned long long val,
38 const struct trace_print_flags_u64
liubo2fc1b6f2011-04-19 09:35:28 +080039 *symbol_array);
40#endif
41
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -040042const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
43 unsigned int bitmask_size);
Steven Rostedt (Red Hat)4449bf92014-05-06 13:10:24 -040044
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -040045const char *trace_print_hex_seq(struct trace_seq *p,
46 const unsigned char *buf, int len);
Kei Tokunaga5a2e3992010-04-01 20:40:58 +090047
Steven Rostedt (Red Hat)645df982015-05-04 18:12:44 -040048const char *trace_print_array_seq(struct trace_seq *p,
Alex Bennéeac01ce12015-04-29 16:18:46 +010049 const void *buf, int count,
Dave Martin6ea22482015-01-28 12:48:53 +000050 size_t el_size);
51
Li Zefanf71130d2013-02-21 10:32:38 +080052struct trace_iterator;
53struct trace_event;
54
Steven Rostedt (Red Hat)892c5052015-05-05 14:18:11 -040055int trace_raw_output_prep(struct trace_iterator *iter,
56 struct trace_event *event);
Li Zefanf71130d2013-02-21 10:32:38 +080057
Steven Rostedt97f20252009-04-13 11:20:49 -040058/*
59 * The trace entry - the most basic unit of tracing. This is what
60 * is printed in the end as a single line in the trace output, such as:
61 *
62 * bash-15816 [01] 235.197585: idle_cpu <- irq_enter
63 */
64struct trace_entry {
Steven Rostedt89ec0de2009-03-26 11:03:29 -040065 unsigned short type;
Steven Rostedt97f20252009-04-13 11:20:49 -040066 unsigned char flags;
67 unsigned char preempt_count;
68 int pid;
Steven Rostedt97f20252009-04-13 11:20:49 -040069};
70
Steven Rostedt (Red Hat)609a7402015-05-13 13:44:36 -040071#define TRACE_EVENT_TYPE_MAX \
Steven Rostedt89ec0de2009-03-26 11:03:29 -040072 ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
73
Steven Rostedt97f20252009-04-13 11:20:49 -040074/*
75 * Trace iterator - used by printout routines who present trace
76 * results to users and which routines might sleep, etc:
77 */
78struct trace_iterator {
79 struct trace_array *tr;
80 struct tracer *trace;
Steven Rostedt (Red Hat)12883ef2013-03-05 09:24:35 -050081 struct trace_buffer *trace_buffer;
Steven Rostedt97f20252009-04-13 11:20:49 -040082 void *private;
83 int cpu_file;
84 struct mutex mutex;
Steven Rostedt6d158a82012-06-27 20:46:14 -040085 struct ring_buffer_iter **buffer_iter;
Steven Rostedt112f38a72009-06-01 15:16:05 -040086 unsigned long iter_flags;
Steven Rostedt97f20252009-04-13 11:20:49 -040087
Lai Jiangshanbc289ae2010-06-03 18:26:24 +080088 /* trace_seq for __print_flags() and __print_symbolic() etc. */
89 struct trace_seq tmp_seq;
90
Andrew Vagined5467d2013-08-02 21:16:43 +040091 cpumask_var_t started;
92
93 /* it's true when current open file is snapshot */
94 bool snapshot;
95
Steven Rostedt97f20252009-04-13 11:20:49 -040096 /* The below is zeroed out in pipe_read */
97 struct trace_seq seq;
98 struct trace_entry *ent;
Steven Rostedtbc21b472010-03-31 19:49:26 -040099 unsigned long lost_events;
Steven Rostedta63ce5b2009-12-07 09:11:39 -0500100 int leftover;
Steven Rostedt4a9bd3f2011-07-14 16:36:53 -0400101 int ent_size;
Steven Rostedt97f20252009-04-13 11:20:49 -0400102 int cpu;
103 u64 ts;
104
Steven Rostedt97f20252009-04-13 11:20:49 -0400105 loff_t pos;
106 long idx;
107
Andrew Vagined5467d2013-08-02 21:16:43 +0400108 /* All new field here will be zeroed out in pipe_read */
Steven Rostedt97f20252009-04-13 11:20:49 -0400109};
110
David Sharp8be07092012-11-13 12:18:22 -0800111enum trace_iter_flags {
112 TRACE_FILE_LAT_FMT = 1,
113 TRACE_FILE_ANNOTATE = 2,
114 TRACE_FILE_TIME_IN_NS = 4,
115};
116
Steven Rostedt97f20252009-04-13 11:20:49 -0400117
118typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
Steven Rostedta9a57762010-04-22 18:46:14 -0400119 int flags, struct trace_event *event);
120
121struct trace_event_functions {
Steven Rostedt97f20252009-04-13 11:20:49 -0400122 trace_print_func trace;
123 trace_print_func raw;
124 trace_print_func hex;
125 trace_print_func binary;
126};
127
Steven Rostedta9a57762010-04-22 18:46:14 -0400128struct trace_event {
129 struct hlist_node node;
130 struct list_head list;
131 int type;
132 struct trace_event_functions *funcs;
133};
134
Steven Rostedt (Red Hat)9023c932015-05-05 09:39:12 -0400135extern int register_trace_event(struct trace_event *event);
136extern int unregister_trace_event(struct trace_event *event);
Steven Rostedt97f20252009-04-13 11:20:49 -0400137
138/* Return values for print_line callback */
139enum print_line_t {
140 TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */
141 TRACE_TYPE_HANDLED = 1,
142 TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */
143 TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */
144};
145
Steven Rostedt (Red Hat)19a7fe22014-11-12 10:29:54 -0500146/*
147 * Several functions return TRACE_TYPE_PARTIAL_LINE if the trace_seq
148 * overflowed, and TRACE_TYPE_HANDLED otherwise. This helper function
149 * simplifies those functions and keeps them in sync.
150 */
151static inline enum print_line_t trace_handle_return(struct trace_seq *s)
152{
153 return trace_seq_has_overflowed(s) ?
154 TRACE_TYPE_PARTIAL_LINE : TRACE_TYPE_HANDLED;
155}
156
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200157void tracing_generic_entry_update(struct trace_entry *entry,
158 unsigned long flags,
159 int pc);
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400160struct trace_event_file;
Steven Rostedtccb469a2012-08-02 10:32:10 -0400161
162struct ring_buffer_event *
163trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400164 struct trace_event_file *trace_file,
Steven Rostedtccb469a2012-08-02 10:32:10 -0400165 int type, unsigned long len,
166 unsigned long flags, int pc);
Steven Rostedt97f20252009-04-13 11:20:49 -0400167struct ring_buffer_event *
Steven Rostedte77405a2009-09-02 14:17:06 -0400168trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
169 int type, unsigned long len,
Steven Rostedt97f20252009-04-13 11:20:49 -0400170 unsigned long flags, int pc);
Steven Rostedt (Red Hat)b7f0c952015-09-25 17:38:44 -0400171void trace_buffer_unlock_commit(struct trace_array *tr,
172 struct ring_buffer *buffer,
Steven Rostedt0d5c6e12012-11-01 20:54:21 -0400173 struct ring_buffer_event *event,
174 unsigned long flags, int pc);
Steven Rostedt (Red Hat)b7f0c952015-09-25 17:38:44 -0400175void trace_buffer_unlock_commit_regs(struct trace_array *tr,
176 struct ring_buffer *buffer,
Steven Rostedt0d5c6e12012-11-01 20:54:21 -0400177 struct ring_buffer_event *event,
178 unsigned long flags, int pc,
179 struct pt_regs *regs);
Steven Rostedte77405a2009-09-02 14:17:06 -0400180void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
181 struct ring_buffer_event *event);
Steven Rostedt97f20252009-04-13 11:20:49 -0400182
183void tracing_record_cmdline(struct task_struct *tsk);
184
Steven Rostedt (Red Hat)892c5052015-05-05 14:18:11 -0400185int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
Steven Rostedt1d6bae92012-08-09 19:16:14 -0400186
Li Zefan1f9963c2009-07-20 10:20:53 +0800187struct event_filter;
188
Steven Rostedt22392912010-04-21 12:27:06 -0400189enum trace_reg {
190 TRACE_REG_REGISTER,
191 TRACE_REG_UNREGISTER,
Jiri Olsa37d73992012-03-14 00:03:02 +0100192#ifdef CONFIG_PERF_EVENTS
Steven Rostedt22392912010-04-21 12:27:06 -0400193 TRACE_REG_PERF_REGISTER,
194 TRACE_REG_PERF_UNREGISTER,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100195 TRACE_REG_PERF_OPEN,
196 TRACE_REG_PERF_CLOSE,
Jiri Olsa489c75c2012-02-15 15:51:50 +0100197 TRACE_REG_PERF_ADD,
198 TRACE_REG_PERF_DEL,
Jiri Olsa37d73992012-03-14 00:03:02 +0100199#endif
Steven Rostedt22392912010-04-21 12:27:06 -0400200};
201
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400202struct trace_event_call;
Steven Rostedt22392912010-04-21 12:27:06 -0400203
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400204struct trace_event_class {
Steven Rostedt (Red Hat)acd388f2015-03-31 14:37:12 -0400205 const char *system;
Steven Rostedt22392912010-04-21 12:27:06 -0400206 void *probe;
207#ifdef CONFIG_PERF_EVENTS
208 void *perf_probe;
209#endif
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400210 int (*reg)(struct trace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100211 enum trace_reg type, void *data);
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400212 int (*define_fields)(struct trace_event_call *);
213 struct list_head *(*get_fields)(struct trace_event_call *);
Steven Rostedt2e33af02010-04-22 10:35:55 -0400214 struct list_head fields;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400215 int (*raw_init)(struct trace_event_call *);
Steven Rostedt8f082012010-04-20 10:47:33 -0400216};
217
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400218extern int trace_event_reg(struct trace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100219 enum trace_reg type, void *data);
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400220
Steven Rostedt (Red Hat)3f795dc2015-05-05 13:18:46 -0400221struct trace_event_buffer {
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400222 struct ring_buffer *buffer;
223 struct ring_buffer_event *event;
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400224 struct trace_event_file *trace_file;
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400225 void *entry;
226 unsigned long flags;
227 int pc;
228};
229
Steven Rostedt (Red Hat)3f795dc2015-05-05 13:18:46 -0400230void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400231 struct trace_event_file *trace_file,
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400232 unsigned long len);
233
Steven Rostedt (Red Hat)3f795dc2015-05-05 13:18:46 -0400234void trace_event_buffer_commit(struct trace_event_buffer *fbuffer);
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400235
Steven Rostedt553552c2010-04-23 11:12:36 -0400236enum {
Steven Rostedt553552c2010-04-23 11:12:36 -0400237 TRACE_EVENT_FL_FILTERED_BIT,
Frederic Weisbecker61c32652010-11-18 01:39:17 +0100238 TRACE_EVENT_FL_CAP_ANY_BIT,
Li Zefan27b14b52011-11-01 09:09:35 +0800239 TRACE_EVENT_FL_NO_SET_FILTER_BIT,
Steven Rostedt9b637762012-05-10 15:55:43 -0400240 TRACE_EVENT_FL_IGNORE_ENABLE_BIT,
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500241 TRACE_EVENT_FL_WAS_ENABLED_BIT,
Tom Zanussif306cc82013-10-24 08:34:17 -0500242 TRACE_EVENT_FL_USE_CALL_FILTER_BIT,
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400243 TRACE_EVENT_FL_TRACEPOINT_BIT,
Alexei Starovoitov72cbbc82015-03-25 12:49:19 -0700244 TRACE_EVENT_FL_KPROBE_BIT,
Wang Nan04a22fa2015-07-01 02:13:50 +0000245 TRACE_EVENT_FL_UPROBE_BIT,
Steven Rostedt553552c2010-04-23 11:12:36 -0400246};
247
Steven Rostedtae63b312012-05-03 23:09:03 -0400248/*
249 * Event flags:
250 * FILTERED - The event has a filter attached
251 * CAP_ANY - Any user can enable for perf
252 * NO_SET_FILTER - Set when filter has error and is to be ignored
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400253 * IGNORE_ENABLE - For trace internal events, do not enable with debugfs file
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500254 * WAS_ENABLED - Set and stays set when an event was ever enabled
255 * (used for module unloading, if a module event is enabled,
256 * it is best to clear the buffers that used it).
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400257 * USE_CALL_FILTER - For trace internal events, don't use file filter
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400258 * TRACEPOINT - Event is a tracepoint
Alexei Starovoitov72cbbc82015-03-25 12:49:19 -0700259 * KPROBE - Event is a kprobe
Wang Nan04a22fa2015-07-01 02:13:50 +0000260 * UPROBE - Event is a uprobe
Steven Rostedtae63b312012-05-03 23:09:03 -0400261 */
Steven Rostedt553552c2010-04-23 11:12:36 -0400262enum {
Li Zefane870e9a2010-07-02 11:07:32 +0800263 TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT),
Frederic Weisbecker61c32652010-11-18 01:39:17 +0100264 TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT),
Li Zefan27b14b52011-11-01 09:09:35 +0800265 TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT),
Steven Rostedt9b637762012-05-10 15:55:43 -0400266 TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT),
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500267 TRACE_EVENT_FL_WAS_ENABLED = (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT),
Tom Zanussif306cc82013-10-24 08:34:17 -0500268 TRACE_EVENT_FL_USE_CALL_FILTER = (1 << TRACE_EVENT_FL_USE_CALL_FILTER_BIT),
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400269 TRACE_EVENT_FL_TRACEPOINT = (1 << TRACE_EVENT_FL_TRACEPOINT_BIT),
Alexei Starovoitov72cbbc82015-03-25 12:49:19 -0700270 TRACE_EVENT_FL_KPROBE = (1 << TRACE_EVENT_FL_KPROBE_BIT),
Wang Nan04a22fa2015-07-01 02:13:50 +0000271 TRACE_EVENT_FL_UPROBE = (1 << TRACE_EVENT_FL_UPROBE_BIT),
Steven Rostedt553552c2010-04-23 11:12:36 -0400272};
273
Wang Nan04a22fa2015-07-01 02:13:50 +0000274#define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE)
275
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400276struct trace_event_call {
Steven Rostedta59fd602009-04-10 13:52:20 -0400277 struct list_head list;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400278 struct trace_event_class *class;
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400279 union {
280 char *name;
281 /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
282 struct tracepoint *tp;
283 };
Steven Rostedt80decc72010-04-23 10:00:22 -0400284 struct trace_event event;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -0400285 char *print_fmt;
Li Zefan1f9963c2009-07-20 10:20:53 +0800286 struct event_filter *filter;
Steven Rostedt6d723732009-04-10 14:53:50 -0400287 void *mod;
Jason Baron69fd4f02009-08-10 16:52:44 -0400288 void *data;
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400289 /*
290 * bit 0: filter_active
291 * bit 1: allow trace by non root (cap any)
292 * bit 2: failed to apply filter
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400293 * bit 3: trace internal event (do not enable)
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400294 * bit 4: Event was enabled by module
Tom Zanussif306cc82013-10-24 08:34:17 -0500295 * bit 5: use call filter rather than file filter
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400296 * bit 6: Event is a tracepoint
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400297 */
Steven Rostedtae63b312012-05-03 23:09:03 -0400298 int flags; /* static flags of different events */
299
300#ifdef CONFIG_PERF_EVENTS
301 int perf_refcount;
302 struct hlist_head __percpu *perf_events;
Alexei Starovoitov25415172015-03-25 12:49:20 -0700303 struct bpf_prog *prog;
Peter Zijlstrad5b5f392013-11-14 16:23:04 +0100304
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400305 int (*perf_perm)(struct trace_event_call *,
Peter Zijlstrad5b5f392013-11-14 16:23:04 +0100306 struct perf_event *);
Steven Rostedtae63b312012-05-03 23:09:03 -0400307#endif
308};
309
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400310static inline const char *
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -0400311trace_event_name(struct trace_event_call *call)
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400312{
313 if (call->flags & TRACE_EVENT_FL_TRACEPOINT)
314 return call->tp ? call->tp->name : NULL;
315 else
316 return call->name;
317}
318
Steven Rostedtae63b312012-05-03 23:09:03 -0400319struct trace_array;
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -0400320struct trace_subsystem_dir;
Steven Rostedtae63b312012-05-03 23:09:03 -0400321
322enum {
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400323 EVENT_FILE_FL_ENABLED_BIT,
324 EVENT_FILE_FL_RECORDED_CMD_BIT,
325 EVENT_FILE_FL_FILTERED_BIT,
326 EVENT_FILE_FL_NO_SET_FILTER_BIT,
327 EVENT_FILE_FL_SOFT_MODE_BIT,
328 EVENT_FILE_FL_SOFT_DISABLED_BIT,
329 EVENT_FILE_FL_TRIGGER_MODE_BIT,
330 EVENT_FILE_FL_TRIGGER_COND_BIT,
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400331 EVENT_FILE_FL_PID_FILTER_BIT,
Steven Rostedtae63b312012-05-03 23:09:03 -0400332};
333
334/*
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400335 * Event file flags:
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400336 * ENABLED - The event is enabled
Steven Rostedtae63b312012-05-03 23:09:03 -0400337 * RECORDED_CMD - The comms should be recorded at sched_switch
Tom Zanussif306cc82013-10-24 08:34:17 -0500338 * FILTERED - The event has a filter attached
339 * NO_SET_FILTER - Set when filter has error and is to be ignored
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400340 * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED
341 * SOFT_DISABLED - When set, do not trace the event (even though its
342 * tracepoint may be enabled)
Tom Zanussi85f2b082013-10-24 08:59:24 -0500343 * TRIGGER_MODE - When set, invoke the triggers associated with the event
Tom Zanussibac5fb92013-10-24 08:59:29 -0500344 * TRIGGER_COND - When set, one or more triggers has an associated filter
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400345 * PID_FILTER - When set, the event is filtered based on pid
Steven Rostedtae63b312012-05-03 23:09:03 -0400346 */
347enum {
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400348 EVENT_FILE_FL_ENABLED = (1 << EVENT_FILE_FL_ENABLED_BIT),
349 EVENT_FILE_FL_RECORDED_CMD = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT),
350 EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT),
351 EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT),
352 EVENT_FILE_FL_SOFT_MODE = (1 << EVENT_FILE_FL_SOFT_MODE_BIT),
353 EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT),
354 EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT),
355 EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT),
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400356 EVENT_FILE_FL_PID_FILTER = (1 << EVENT_FILE_FL_PID_FILTER_BIT),
Steven Rostedtae63b312012-05-03 23:09:03 -0400357};
358
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400359struct trace_event_file {
Steven Rostedtae63b312012-05-03 23:09:03 -0400360 struct list_head list;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400361 struct trace_event_call *event_call;
Tom Zanussif306cc82013-10-24 08:34:17 -0500362 struct event_filter *filter;
Steven Rostedtae63b312012-05-03 23:09:03 -0400363 struct dentry *dir;
364 struct trace_array *tr;
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -0400365 struct trace_subsystem_dir *system;
Tom Zanussi85f2b082013-10-24 08:59:24 -0500366 struct list_head triggers;
Steven Rostedt97f20252009-04-13 11:20:49 -0400367
Steven Rostedt553552c2010-04-23 11:12:36 -0400368 /*
369 * 32 bit flags:
Steven Rostedt (Red Hat)57d01ad2013-03-12 12:38:06 -0400370 * bit 0: enabled
371 * bit 1: enabled cmd record
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400372 * bit 2: enable/disable with the soft disable bit
373 * bit 3: soft disabled
Tom Zanussi85f2b082013-10-24 08:59:24 -0500374 * bit 4: trigger enabled
Steven Rostedt553552c2010-04-23 11:12:36 -0400375 *
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400376 * Note: The bits must be set atomically to prevent races
377 * from other writers. Reads of flags do not need to be in
378 * sync as they occur in critical sections. But the way flags
Steven Rostedtae63b312012-05-03 23:09:03 -0400379 * is currently used, these changes do not affect the code
Steven Rostedt1eaa4782010-05-14 10:19:13 -0400380 * except that when a change is made, it may have a slight
381 * delay in propagating the changes to other CPUs due to
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400382 * caching and such. Which is mostly OK ;-)
Steven Rostedt553552c2010-04-23 11:12:36 -0400383 */
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400384 unsigned long flags;
Masami Hiramatsu1cf4c072013-05-09 14:44:29 +0900385 atomic_t sm_ref; /* soft-mode reference counter */
Tom Zanussi85f2b082013-10-24 08:59:24 -0500386 atomic_t tm_ref; /* trigger-mode reference counter */
Steven Rostedt97f20252009-04-13 11:20:49 -0400387};
388
Frederic Weisbecker53cf810b2010-11-18 02:11:42 +0100389#define __TRACE_EVENT_FLAGS(name, value) \
390 static int __init trace_init_flags_##name(void) \
391 { \
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400392 event_##name.flags |= value; \
Frederic Weisbecker53cf810b2010-11-18 02:11:42 +0100393 return 0; \
394 } \
395 early_initcall(trace_init_flags_##name);
396
Peter Zijlstrad5b5f392013-11-14 16:23:04 +0100397#define __TRACE_EVENT_PERF_PERM(name, expr...) \
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400398 static int perf_perm_##name(struct trace_event_call *tp_event, \
Peter Zijlstrad5b5f392013-11-14 16:23:04 +0100399 struct perf_event *p_event) \
400 { \
401 return ({ expr; }); \
402 } \
403 static int __init trace_init_perf_perm_##name(void) \
404 { \
405 event_##name.perf_perm = &perf_perm_##name; \
406 return 0; \
407 } \
408 early_initcall(trace_init_perf_perm_##name);
409
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100410#define PERF_MAX_TRACE_SIZE 2048
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200411
Steven Rostedt16bb8eb2009-09-12 19:04:54 -0400412#define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */
Steven Rostedt97f20252009-04-13 11:20:49 -0400413
Tom Zanussi85f2b082013-10-24 08:59:24 -0500414enum event_trigger_type {
415 ETT_NONE = (0),
Tom Zanussi2a2df322013-10-24 08:59:25 -0500416 ETT_TRACE_ONOFF = (1 << 0),
Tom Zanussi93e31ff2013-10-24 08:59:26 -0500417 ETT_SNAPSHOT = (1 << 1),
Tom Zanussif21ecbb2013-10-24 08:59:27 -0500418 ETT_STACKTRACE = (1 << 2),
Tom Zanussi7862ad12013-10-24 08:59:28 -0500419 ETT_EVENT_ENABLE = (1 << 3),
Tom Zanussi85f2b082013-10-24 08:59:24 -0500420};
421
Li Zefan6fb29152009-10-15 11:21:42 +0800422extern int filter_match_preds(struct event_filter *filter, void *rec);
Tom Zanussif306cc82013-10-24 08:34:17 -0500423
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400424extern int filter_check_discard(struct trace_event_file *file, void *rec,
Tom Zanussif306cc82013-10-24 08:34:17 -0500425 struct ring_buffer *buffer,
426 struct ring_buffer_event *event);
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400427extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
Tom Zanussif306cc82013-10-24 08:34:17 -0500428 struct ring_buffer *buffer,
429 struct ring_buffer_event *event);
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400430extern enum event_trigger_type event_triggers_call(struct trace_event_file *file,
Tom Zanussibac5fb92013-10-24 08:59:29 -0500431 void *rec);
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400432extern void event_triggers_post_call(struct trace_event_file *file,
Tom Zanussibac5fb92013-10-24 08:59:29 -0500433 enum event_trigger_type tt);
Steven Rostedt97f20252009-04-13 11:20:49 -0400434
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400435bool trace_event_ignore_this_pid(struct trace_event_file *trace_file);
436
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500437/**
Steven Rostedt (Red Hat)09a50592015-05-13 15:21:25 -0400438 * trace_trigger_soft_disabled - do triggers and test if soft disabled
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500439 * @file: The file pointer of the event to test
440 *
441 * If any triggers without filters are attached to this event, they
442 * will be called here. If the event is soft disabled and has no
443 * triggers that require testing the fields, it will return true,
444 * otherwise false.
445 */
446static inline bool
Steven Rostedt (Red Hat)09a50592015-05-13 15:21:25 -0400447trace_trigger_soft_disabled(struct trace_event_file *file)
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500448{
449 unsigned long eflags = file->flags;
450
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400451 if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {
452 if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500453 event_triggers_call(file, NULL);
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400454 if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500455 return true;
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400456 if (eflags & EVENT_FILE_FL_PID_FILTER)
457 return trace_event_ignore_this_pid(file);
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500458 }
459 return false;
460}
461
462/*
463 * Helper function for event_trigger_unlock_commit{_regs}().
464 * If there are event triggers attached to this event that requires
465 * filtering against its fields, then they wil be called as the
466 * entry already holds the field information of the current event.
467 *
468 * It also checks if the event should be discarded or not.
469 * It is to be discarded if the event is soft disabled and the
470 * event was only recorded to process triggers, or if the event
471 * filter is active and this event did not match the filters.
472 *
473 * Returns true if the event is discarded, false otherwise.
474 */
475static inline bool
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400476__event_trigger_test_discard(struct trace_event_file *file,
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500477 struct ring_buffer *buffer,
478 struct ring_buffer_event *event,
479 void *entry,
480 enum event_trigger_type *tt)
481{
482 unsigned long eflags = file->flags;
483
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400484 if (eflags & EVENT_FILE_FL_TRIGGER_COND)
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500485 *tt = event_triggers_call(file, entry);
486
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400487 if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags))
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500488 ring_buffer_discard_commit(buffer, event);
489 else if (!filter_check_discard(file, entry, buffer, event))
490 return false;
491
492 return true;
493}
494
495/**
496 * event_trigger_unlock_commit - handle triggers and finish event commit
497 * @file: The file pointer assoctiated to the event
498 * @buffer: The ring buffer that the event is being written to
499 * @event: The event meta data in the ring buffer
500 * @entry: The event itself
501 * @irq_flags: The state of the interrupts at the start of the event
502 * @pc: The state of the preempt count at the start of the event.
503 *
504 * This is a helper function to handle triggers that require data
505 * from the event itself. It also tests the event against filters and
506 * if the event is soft disabled and should be discarded.
507 */
508static inline void
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400509event_trigger_unlock_commit(struct trace_event_file *file,
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500510 struct ring_buffer *buffer,
511 struct ring_buffer_event *event,
512 void *entry, unsigned long irq_flags, int pc)
513{
514 enum event_trigger_type tt = ETT_NONE;
515
516 if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
Steven Rostedt (Red Hat)b7f0c952015-09-25 17:38:44 -0400517 trace_buffer_unlock_commit(file->tr, buffer, event, irq_flags, pc);
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500518
519 if (tt)
520 event_triggers_post_call(file, tt);
521}
522
523/**
524 * event_trigger_unlock_commit_regs - handle triggers and finish event commit
525 * @file: The file pointer assoctiated to the event
526 * @buffer: The ring buffer that the event is being written to
527 * @event: The event meta data in the ring buffer
528 * @entry: The event itself
529 * @irq_flags: The state of the interrupts at the start of the event
530 * @pc: The state of the preempt count at the start of the event.
531 *
532 * This is a helper function to handle triggers that require data
533 * from the event itself. It also tests the event against filters and
534 * if the event is soft disabled and should be discarded.
535 *
536 * Same as event_trigger_unlock_commit() but calls
537 * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
538 */
539static inline void
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400540event_trigger_unlock_commit_regs(struct trace_event_file *file,
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500541 struct ring_buffer *buffer,
542 struct ring_buffer_event *event,
543 void *entry, unsigned long irq_flags, int pc,
544 struct pt_regs *regs)
545{
546 enum event_trigger_type tt = ETT_NONE;
547
548 if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
Steven Rostedt (Red Hat)b7f0c952015-09-25 17:38:44 -0400549 trace_buffer_unlock_commit_regs(file->tr, buffer, event,
Steven Rostedt (Red Hat)13a1e4a2014-01-06 21:32:10 -0500550 irq_flags, pc, regs);
551
552 if (tt)
553 event_triggers_post_call(file, tt);
554}
555
Wang Nan098d2162015-07-01 02:13:49 +0000556#ifdef CONFIG_BPF_EVENTS
Alexei Starovoitov25415172015-03-25 12:49:20 -0700557unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx);
558#else
559static inline unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx)
560{
561 return 1;
562}
563#endif
564
Li Zefan43b51ea2009-08-07 10:33:22 +0800565enum {
566 FILTER_OTHER = 0,
567 FILTER_STATIC_STRING,
568 FILTER_DYN_STRING,
Li Zefan87a342f2009-08-07 10:33:43 +0800569 FILTER_PTR_STRING,
Jiri Olsa02aa3162012-02-15 15:51:53 +0100570 FILTER_TRACE_FN,
Li Zefan43b51ea2009-08-07 10:33:22 +0800571};
572
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400573extern int trace_event_raw_init(struct trace_event_call *call);
574extern int trace_define_field(struct trace_event_call *call, const char *type,
Frederic Weisbeckeraeaeae12009-08-27 05:09:51 +0200575 const char *name, int offset, int size,
576 int is_signed, int filter_type);
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400577extern int trace_add_event_call(struct trace_event_call *call);
578extern int trace_remove_event_call(struct trace_event_call *call);
Steven Rostedt97f20252009-04-13 11:20:49 -0400579
Steven Rostedt (Red Hat)d2802d02013-04-19 17:10:27 -0400580#define is_signed_type(type) (((type)(-1)) < (type)1)
Steven Rostedt97f20252009-04-13 11:20:49 -0400581
Steven Rostedt4671c792009-05-08 16:27:41 -0400582int trace_set_clr_event(const char *system, const char *event, int set);
583
Steven Rostedt97f20252009-04-13 11:20:49 -0400584/*
585 * The double __builtin_constant_p is because gcc will give us an error
586 * if we try to allocate the static variable to fmt if it is not a
587 * constant. Even with the outer if statement optimizing out.
588 */
589#define event_trace_printk(ip, fmt, args...) \
590do { \
591 __trace_printk_check_format(fmt, ##args); \
592 tracing_record_cmdline(current); \
593 if (__builtin_constant_p(fmt)) { \
594 static const char *trace_printk_fmt \
595 __attribute__((section("__trace_printk_fmt"))) = \
596 __builtin_constant_p(fmt) ? fmt : NULL; \
597 \
598 __trace_bprintk(ip, trace_printk_fmt, ##args); \
599 } else \
600 __trace_printk(ip, fmt, ##args); \
601} while (0)
602
Li Zefan07b139c2009-12-21 14:27:35 +0800603#ifdef CONFIG_PERF_EVENTS
Li Zefan6fb29152009-10-15 11:21:42 +0800604struct perf_event;
Frederic Weisbeckerc5306652010-03-03 07:16:16 +0100605
606DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);
607
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200608extern int perf_trace_init(struct perf_event *event);
609extern void perf_trace_destroy(struct perf_event *event);
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200610extern int perf_trace_add(struct perf_event *event, int flags);
611extern void perf_trace_del(struct perf_event *event, int flags);
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200612extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
Li Zefan6fb29152009-10-15 11:21:42 +0800613 char *filter_str);
614extern void ftrace_profile_free_filter(struct perf_event *event);
Peter Zijlstrab7e2ece2010-05-19 10:52:27 +0200615extern void *perf_trace_buf_prepare(int size, unsigned short type,
Peter Zijlstra (Intel)86038c52014-12-16 12:47:34 +0100616 struct pt_regs **regs, int *rctxp);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800617
618static inline void
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100619perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400620 u64 count, struct pt_regs *regs, void *head,
621 struct task_struct *task)
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800622{
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400623 perf_tp_event(addr, count, raw_data, size, regs, head, rctx, task);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800624}
Li Zefan6fb29152009-10-15 11:21:42 +0800625#endif
626
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400627#endif /* _LINUX_TRACE_EVENT_H */