blob: 6e735d4771f8ad9ddd971ee1806f904d7e44e176 [file] [log] [blame]
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001#ifndef _LINUX_KERNEL_TRACE_H
2#define _LINUX_KERNEL_TRACE_H
3
4#include <linux/fs.h>
5#include <asm/atomic.h>
6#include <linux/sched.h>
7#include <linux/clocksource.h>
Steven Rostedt3928a8a2008-09-29 23:02:41 -04008#include <linux/ring_buffer.h>
Pekka Paalanenbd8ac682008-05-12 21:20:57 +02009#include <linux/mmiotrace.h>
Frédéric Weisbeckerd13744c2008-09-23 11:32:08 +010010#include <linux/ftrace.h>
Frederic Weisbecker3f5ec132008-11-11 23:21:31 +010011#include <trace/boot.h>
Zhaolei02af61b2009-04-10 14:26:18 +080012#include <linux/kmemtrace.h>
Frederic Weisbecker12922112009-02-07 22:16:12 +010013#include <trace/power.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020014
Steven Rostedt95045042009-04-11 12:59:57 -040015#include <linux/trace_seq.h>
Steven Rostedt97f20252009-04-13 11:20:49 -040016#include <linux/ftrace_event.h>
Steven Rostedt95045042009-04-11 12:59:57 -040017
Thomas Gleixner72829bc2008-05-23 21:37:28 +020018enum trace_type {
19 __TRACE_FIRST_TYPE = 0,
20
21 TRACE_FN,
22 TRACE_CTX,
23 TRACE_WAKE,
24 TRACE_STACK,
Steven Rostedtdd0e5452008-08-01 12:26:41 -040025 TRACE_PRINT,
Frederic Weisbecker48ead022009-03-12 18:24:49 +010026 TRACE_BPRINT,
Thomas Gleixner72829bc2008-05-23 21:37:28 +020027 TRACE_SPECIAL,
Pekka Paalanenbd8ac682008-05-12 21:20:57 +020028 TRACE_MMIO_RW,
29 TRACE_MMIO_MAP,
Steven Rostedt9f029e82008-11-12 15:24:24 -050030 TRACE_BRANCH,
Frederic Weisbecker74239072008-11-11 23:24:42 +010031 TRACE_BOOT_CALL,
32 TRACE_BOOT_RET,
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010033 TRACE_GRAPH_RET,
34 TRACE_GRAPH_ENT,
Török Edwin02b67512008-11-22 13:28:47 +020035 TRACE_USER_STACK,
Markus Metzgera93751c2008-12-11 13:53:26 +010036 TRACE_HW_BRANCHES,
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +010037 TRACE_SYSCALL_ENTER,
38 TRACE_SYSCALL_EXIT,
Frederic Weisbecker36994e52008-12-29 13:42:23 -080039 TRACE_KMEM_ALLOC,
40 TRACE_KMEM_FREE,
Arjan van de Venf3f47a62008-11-23 16:49:58 -080041 TRACE_POWER,
Arnaldo Carvalho de Meloc71a8962009-01-23 12:06:27 -020042 TRACE_BLK,
Thomas Gleixner72829bc2008-05-23 21:37:28 +020043
Steven Rostedtf0868d12008-12-23 23:24:12 -050044 __TRACE_LAST_TYPE,
Thomas Gleixner72829bc2008-05-23 21:37:28 +020045};
46
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020047/*
48 * Function trace entry - function address and parent function addres:
49 */
50struct ftrace_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -040051 struct trace_entry ent;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020052 unsigned long ip;
53 unsigned long parent_ip;
54};
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +010055
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010056/* Function call entry */
57struct ftrace_graph_ent_entry {
Frederic Weisbeckerb91facc2009-02-06 18:30:44 +010058 struct trace_entry ent;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010059 struct ftrace_graph_ent graph_ent;
60};
61
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +010062/* Function return entry */
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010063struct ftrace_graph_ret_entry {
Frederic Weisbeckerb91facc2009-02-06 18:30:44 +010064 struct trace_entry ent;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010065 struct ftrace_graph_ret ret;
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +010066};
Frédéric Weisbeckerd13744c2008-09-23 11:32:08 +010067extern struct tracer boot_tracer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020068
69/*
70 * Context switch trace entry - which task (and prio) we switched from/to:
71 */
72struct ctx_switch_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -040073 struct trace_entry ent;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020074 unsigned int prev_pid;
75 unsigned char prev_prio;
76 unsigned char prev_state;
77 unsigned int next_pid;
78 unsigned char next_prio;
Peter Zijlstrabac524d2008-05-12 21:20:53 +020079 unsigned char next_state;
Peter Zijlstra80b5e942008-09-04 10:24:16 +020080 unsigned int next_cpu;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020081};
82
83/*
Ingo Molnarf0a920d2008-05-12 21:20:47 +020084 * Special (free-form) trace entry:
85 */
86struct special_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -040087 struct trace_entry ent;
Ingo Molnarf0a920d2008-05-12 21:20:47 +020088 unsigned long arg1;
89 unsigned long arg2;
90 unsigned long arg3;
91};
92
93/*
Ingo Molnar86387f72008-05-12 21:20:51 +020094 * Stack-trace entry:
95 */
96
Ingo Molnar74f4e362008-05-12 21:21:15 +020097#define FTRACE_STACK_ENTRIES 8
Ingo Molnar86387f72008-05-12 21:20:51 +020098
99struct stack_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -0400100 struct trace_entry ent;
Ingo Molnar86387f72008-05-12 21:20:51 +0200101 unsigned long caller[FTRACE_STACK_ENTRIES];
102};
103
Török Edwin02b67512008-11-22 13:28:47 +0200104struct userstack_entry {
105 struct trace_entry ent;
106 unsigned long caller[FTRACE_STACK_ENTRIES];
107};
108
Ingo Molnar86387f72008-05-12 21:20:51 +0200109/*
Ingo Molnar5e1607a2009-03-05 10:24:48 +0100110 * trace_printk entry:
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400111 */
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100112struct bprint_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -0400113 struct trace_entry ent;
Ingo Molnar9de36822009-03-06 17:52:03 +0100114 unsigned long ip;
Frederic Weisbecker769b0442009-03-06 17:21:49 +0100115 const char *fmt;
Ingo Molnar9de36822009-03-06 17:52:03 +0100116 u32 buf[];
Lai Jiangshan1427cdf2009-03-06 17:21:47 +0100117};
Lai Jiangshan1427cdf2009-03-06 17:21:47 +0100118
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100119struct print_entry {
120 struct trace_entry ent;
121 unsigned long ip;
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100122 char buf[];
123};
124
Steven Rostedt777e2082008-09-29 23:02:42 -0400125#define TRACE_OLD_SIZE 88
126
127struct trace_field_cont {
128 unsigned char type;
129 /* Temporary till we get rid of this completely */
130 char buf[TRACE_OLD_SIZE - 1];
131};
132
133struct trace_mmiotrace_rw {
134 struct trace_entry ent;
135 struct mmiotrace_rw rw;
136};
137
138struct trace_mmiotrace_map {
139 struct trace_entry ent;
140 struct mmiotrace_map map;
141};
142
Frederic Weisbecker74239072008-11-11 23:24:42 +0100143struct trace_boot_call {
Steven Rostedt777e2082008-09-29 23:02:42 -0400144 struct trace_entry ent;
Frederic Weisbecker74239072008-11-11 23:24:42 +0100145 struct boot_trace_call boot_call;
146};
147
148struct trace_boot_ret {
149 struct trace_entry ent;
150 struct boot_trace_ret boot_ret;
Steven Rostedt777e2082008-09-29 23:02:42 -0400151};
152
Steven Rostedt52f232c2008-11-12 00:14:40 -0500153#define TRACE_FUNC_SIZE 30
154#define TRACE_FILE_SIZE 20
Steven Rostedt9f029e82008-11-12 15:24:24 -0500155struct trace_branch {
Steven Rostedt52f232c2008-11-12 00:14:40 -0500156 struct trace_entry ent;
157 unsigned line;
158 char func[TRACE_FUNC_SIZE+1];
159 char file[TRACE_FILE_SIZE+1];
160 char correct;
161};
162
Markus Metzgera93751c2008-12-11 13:53:26 +0100163struct hw_branch_entry {
Markus Metzger1e9b51c2008-11-25 09:24:15 +0100164 struct trace_entry ent;
Markus Metzgera93751c2008-12-11 13:53:26 +0100165 u64 from;
166 u64 to;
Markus Metzger1e9b51c2008-11-25 09:24:15 +0100167};
168
Arjan van de Venf3f47a62008-11-23 16:49:58 -0800169struct trace_power {
170 struct trace_entry ent;
171 struct power_trace state_data;
172};
173
Eduard - Gabriel Munteanuca2b84cb2009-03-23 15:12:24 +0200174enum kmemtrace_type_id {
175 KMEMTRACE_TYPE_KMALLOC = 0, /* kmalloc() or kfree(). */
176 KMEMTRACE_TYPE_CACHE, /* kmem_cache_*(). */
177 KMEMTRACE_TYPE_PAGES, /* __get_free_pages() and friends. */
178};
179
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800180struct kmemtrace_alloc_entry {
181 struct trace_entry ent;
182 enum kmemtrace_type_id type_id;
183 unsigned long call_site;
184 const void *ptr;
185 size_t bytes_req;
186 size_t bytes_alloc;
187 gfp_t gfp_flags;
188 int node;
189};
190
191struct kmemtrace_free_entry {
192 struct trace_entry ent;
193 enum kmemtrace_type_id type_id;
194 unsigned long call_site;
195 const void *ptr;
196};
197
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100198struct syscall_trace_enter {
199 struct trace_entry ent;
200 int nr;
201 unsigned long args[];
202};
203
204struct syscall_trace_exit {
205 struct trace_entry ent;
206 int nr;
207 unsigned long ret;
208};
209
210
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400211/*
Pekka Paalanenfc5e27a2008-09-16 22:02:27 +0300212 * trace_flag_type is an enumeration that holds different
213 * states when a trace occurs. These are:
Steven Rostedt92444892008-10-24 09:42:59 -0400214 * IRQS_OFF - interrupts were disabled
Ingo Molnar9de36822009-03-06 17:52:03 +0100215 * IRQS_NOSUPPORT - arch does not support irqs_disabled_flags
Steven Rostedt92444892008-10-24 09:42:59 -0400216 * NEED_RESCED - reschedule is requested
217 * HARDIRQ - inside an interrupt handler
218 * SOFTIRQ - inside a softirq handler
Pekka Paalanenfc5e27a2008-09-16 22:02:27 +0300219 */
220enum trace_flag_type {
221 TRACE_FLAG_IRQS_OFF = 0x01,
Steven Rostedt92444892008-10-24 09:42:59 -0400222 TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
223 TRACE_FLAG_NEED_RESCHED = 0x04,
224 TRACE_FLAG_HARDIRQ = 0x08,
225 TRACE_FLAG_SOFTIRQ = 0x10,
Pekka Paalanenfc5e27a2008-09-16 22:02:27 +0300226};
227
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +0300228#define TRACE_BUF_SIZE 1024
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200229
230/*
231 * The CPU trace array - it consists of thousands of trace entries
232 * plus some other descriptor data: (for example which task started
233 * the trace, etc.)
234 */
235struct trace_array_cpu {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200236 atomic_t disabled;
Steven Rostedt2cadf912008-12-01 22:20:19 -0500237 void *buffer_page; /* ring buffer spare */
Ingo Molnar4e3c3332008-05-12 21:20:45 +0200238
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200239 /* these fields get copied into max-trace: */
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200240 unsigned long trace_idx;
Steven Rostedt53d0aa72008-05-12 21:21:01 +0200241 unsigned long overrun;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200242 unsigned long saved_latency;
243 unsigned long critical_start;
244 unsigned long critical_end;
245 unsigned long critical_sequence;
246 unsigned long nice;
247 unsigned long policy;
248 unsigned long rt_priority;
249 cycle_t preempt_timestamp;
250 pid_t pid;
251 uid_t uid;
252 char comm[TASK_COMM_LEN];
253};
254
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200255/*
256 * The trace array - an array of per-CPU trace arrays. This is the
257 * highest level data structure that individual tracers deal with.
258 * They have on/off state as well:
259 */
260struct trace_array {
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400261 struct ring_buffer *buffer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200262 unsigned long entries;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200263 int cpu;
264 cycle_t time_start;
Steven Rostedtb3806b42008-05-12 21:20:46 +0200265 struct task_struct *waiter;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200266 struct trace_array_cpu *data[NR_CPUS];
267};
268
Steven Rostedt7104f302008-10-01 10:52:51 -0400269#define FTRACE_CMP_TYPE(var, type) \
270 __builtin_types_compatible_p(typeof(var), type *)
271
272#undef IF_ASSIGN
273#define IF_ASSIGN(var, entry, etype, id) \
274 if (FTRACE_CMP_TYPE(var, etype)) { \
275 var = (typeof(var))(entry); \
276 WARN_ON(id && (entry)->type != id); \
277 break; \
278 }
279
280/* Will cause compile errors if type is not found. */
281extern void __ftrace_bad_type(void);
282
283/*
284 * The trace_assign_type is a verifier that the entry type is
285 * the same as the type being assigned. To add new types simply
286 * add a line with the following format:
287 *
288 * IF_ASSIGN(var, ent, type, id);
289 *
290 * Where "type" is the trace type that includes the trace_entry
291 * as the "ent" item. And "id" is the trace identifier that is
292 * used in the trace_type enum.
293 *
294 * If the type can have more than one id, then use zero.
295 */
296#define trace_assign_type(var, ent) \
297 do { \
298 IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \
299 IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \
Steven Rostedt7104f302008-10-01 10:52:51 -0400300 IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \
Török Edwin02b67512008-11-22 13:28:47 +0200301 IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
Steven Rostedt7104f302008-10-01 10:52:51 -0400302 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100303 IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
Steven Rostedt7104f302008-10-01 10:52:51 -0400304 IF_ASSIGN(var, ent, struct special_entry, 0); \
305 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \
306 TRACE_MMIO_RW); \
307 IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \
308 TRACE_MMIO_MAP); \
Frederic Weisbecker74239072008-11-11 23:24:42 +0100309 IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
310 IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
Steven Rostedt9f029e82008-11-12 15:24:24 -0500311 IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100312 IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \
313 TRACE_GRAPH_ENT); \
314 IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \
315 TRACE_GRAPH_RET); \
Markus Metzgera93751c2008-12-11 13:53:26 +0100316 IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
Ingo Molnar9de36822009-03-06 17:52:03 +0100317 IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800318 IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry, \
319 TRACE_KMEM_ALLOC); \
320 IF_ASSIGN(var, ent, struct kmemtrace_free_entry, \
321 TRACE_KMEM_FREE); \
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100322 IF_ASSIGN(var, ent, struct syscall_trace_enter, \
323 TRACE_SYSCALL_ENTER); \
324 IF_ASSIGN(var, ent, struct syscall_trace_exit, \
325 TRACE_SYSCALL_EXIT); \
Steven Rostedt7104f302008-10-01 10:52:51 -0400326 __ftrace_bad_type(); \
327 } while (0)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +0200328
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100329/*
330 * An option specific to a tracer. This is a boolean value.
331 * The bit is the bit index that sets its value on the
332 * flags value in struct tracer_flags.
333 */
334struct tracer_opt {
Ingo Molnar9de36822009-03-06 17:52:03 +0100335 const char *name; /* Will appear on the trace_options file */
336 u32 bit; /* Mask assigned in val field in tracer_flags */
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100337};
338
339/*
340 * The set of specific options for a tracer. Your tracer
341 * have to set the initial value of the flags val.
342 */
343struct tracer_flags {
344 u32 val;
Ingo Molnar9de36822009-03-06 17:52:03 +0100345 struct tracer_opt *opts;
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100346};
347
348/* Makes more easy to define a tracer opt */
349#define TRACER_OPT(s, b) .name = #s, .bit = b
350
Frederic Weisbecker034939b2009-01-08 10:03:56 -0800351
Frederic Weisbecker6eaaa5d2009-02-11 02:25:00 +0100352/**
353 * struct tracer - a specific tracer and its callbacks to interact with debugfs
354 * @name: the name chosen to select it on the available_tracers file
355 * @init: called when one switches to this tracer (echo name > current_tracer)
356 * @reset: called when one switches to another tracer
357 * @start: called when tracing is unpaused (echo 1 > tracing_enabled)
358 * @stop: called when tracing is paused (echo 0 > tracing_enabled)
359 * @open: called when the trace file is opened
360 * @pipe_open: called when the trace_pipe file is opened
361 * @wait_pipe: override how the user waits for traces on trace_pipe
362 * @close: called when the trace file is released
363 * @read: override the default read callback on trace_pipe
364 * @splice_read: override the default splice_read callback on trace_pipe
365 * @selftest: selftest to run on boot (see trace_selftest.c)
366 * @print_headers: override the first lines that describe your columns
367 * @print_line: callback that prints a trace
368 * @set_flag: signals one of your private flags changed (trace_options file)
369 * @flags: your private flags
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200370 */
371struct tracer {
372 const char *name;
Frederic Weisbecker1c800252008-11-16 05:57:26 +0100373 int (*init)(struct trace_array *tr);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200374 void (*reset)(struct trace_array *tr);
Steven Rostedt90369902008-11-05 16:05:44 -0500375 void (*start)(struct trace_array *tr);
376 void (*stop)(struct trace_array *tr);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200377 void (*open)(struct trace_iterator *iter);
Steven Rostedt107bad82008-05-12 21:21:01 +0200378 void (*pipe_open)(struct trace_iterator *iter);
Frederic Weisbecker6eaaa5d2009-02-11 02:25:00 +0100379 void (*wait_pipe)(struct trace_iterator *iter);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200380 void (*close)(struct trace_iterator *iter);
Steven Rostedt107bad82008-05-12 21:21:01 +0200381 ssize_t (*read)(struct trace_iterator *iter,
382 struct file *filp, char __user *ubuf,
383 size_t cnt, loff_t *ppos);
Eduard - Gabriel Munteanu3c568192009-02-09 08:15:56 +0200384 ssize_t (*splice_read)(struct trace_iterator *iter,
385 struct file *filp,
386 loff_t *ppos,
387 struct pipe_inode_info *pipe,
388 size_t len,
389 unsigned int flags);
Steven Rostedt60a11772008-05-12 21:20:44 +0200390#ifdef CONFIG_FTRACE_STARTUP_TEST
391 int (*selftest)(struct tracer *trace,
392 struct trace_array *tr);
393#endif
Markus Metzger8bba1bf2008-11-25 09:12:31 +0100394 void (*print_header)(struct seq_file *m);
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +0200395 enum print_line_t (*print_line)(struct trace_iterator *iter);
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100396 /* If you handled the flag setting, return 0 */
397 int (*set_flag)(u32 old_flags, u32 bit, int set);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200398 struct tracer *next;
399 int print_max;
Ingo Molnar9de36822009-03-06 17:52:03 +0100400 struct tracer_flags *flags;
Frederic Weisbecker034939b2009-01-08 10:03:56 -0800401 struct tracer_stat *stats;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200402};
403
Steven Rostedtf9520752009-03-02 14:04:40 -0500404
Frederic Weisbeckerb04cc6b2009-02-25 03:22:28 +0100405#define TRACE_PIPE_ALL_CPU -1
406
Arnaldo Carvalho de Melob6f11df2009-02-05 18:02:00 -0200407int tracer_init(struct tracer *t, struct trace_array *tr);
Steven Rostedt90369902008-11-05 16:05:44 -0500408int tracing_is_enabled(void);
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300409void trace_wake_up(void);
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400410void tracing_reset(struct trace_array *tr, int cpu);
Pekka J Enberg213cc062008-12-19 12:08:39 +0200411void tracing_reset_online_cpus(struct trace_array *tr);
Steven Rostedt9456f0f2009-05-06 21:54:09 -0400412void tracing_reset_current(int cpu);
413void tracing_reset_current_online_cpus(void);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200414int tracing_open_generic(struct inode *inode, struct file *filp);
Frederic Weisbecker5452af62009-03-27 00:25:38 +0100415struct dentry *trace_create_file(const char *name,
416 mode_t mode,
417 struct dentry *parent,
418 void *data,
419 const struct file_operations *fops);
420
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200421struct dentry *tracing_init_dentry(void);
Ingo Molnard618b3e2008-05-12 21:20:49 +0200422void init_tracer_sysprof_debugfs(struct dentry *d_tracer);
423
Arnaldo Carvalho de Melo51a763d2009-02-05 16:14:13 -0200424struct ring_buffer_event;
425
426struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
Li Zefan7a4f4532009-04-22 16:53:34 +0800427 int type,
Arnaldo Carvalho de Melo51a763d2009-02-05 16:14:13 -0200428 unsigned long len,
429 unsigned long flags,
430 int pc);
431void trace_buffer_unlock_commit(struct trace_array *tr,
432 struct ring_buffer_event *event,
433 unsigned long flags, int pc);
434
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300435struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
436 struct trace_array_cpu *data);
Frederic Weisbeckerc4a8e8b2009-02-02 20:29:21 -0200437
438struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
439 int *ent_cpu, u64 *ent_ts);
440
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300441void tracing_generic_entry_update(struct trace_entry *entry,
Steven Rostedt38697052008-10-01 13:14:09 -0400442 unsigned long flags,
443 int pc);
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300444
Frederic Weisbecker6eaaa5d2009-02-11 02:25:00 +0100445void default_wait_pipe(struct trace_iterator *iter);
446void poll_wait_pipe(struct trace_iterator *iter);
447
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200448void ftrace(struct trace_array *tr,
449 struct trace_array_cpu *data,
450 unsigned long ip,
451 unsigned long parent_ip,
Steven Rostedt38697052008-10-01 13:14:09 -0400452 unsigned long flags, int pc);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200453void tracing_sched_switch_trace(struct trace_array *tr,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200454 struct task_struct *prev,
455 struct task_struct *next,
Steven Rostedt38697052008-10-01 13:14:09 -0400456 unsigned long flags, int pc);
Ingo Molnar57422792008-05-12 21:20:51 +0200457
458void tracing_sched_wakeup_trace(struct trace_array *tr,
Ingo Molnar57422792008-05-12 21:20:51 +0200459 struct task_struct *wakee,
460 struct task_struct *cur,
Steven Rostedt38697052008-10-01 13:14:09 -0400461 unsigned long flags, int pc);
Ingo Molnarf0a920d2008-05-12 21:20:47 +0200462void trace_special(struct trace_array *tr,
463 struct trace_array_cpu *data,
464 unsigned long arg1,
465 unsigned long arg2,
Steven Rostedt38697052008-10-01 13:14:09 -0400466 unsigned long arg3, int pc);
Steven Rostedt6fb44b72008-05-12 21:20:49 +0200467void trace_function(struct trace_array *tr,
Steven Rostedt6fb44b72008-05-12 21:20:49 +0200468 unsigned long ip,
469 unsigned long parent_ip,
Steven Rostedt38697052008-10-01 13:14:09 -0400470 unsigned long flags, int pc);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200471
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100472void trace_graph_return(struct ftrace_graph_ret *trace);
Steven Rostedte49dc192008-12-02 23:50:05 -0500473int trace_graph_entry(struct ftrace_graph_ent *trace);
Markus Metzger1e9b51c2008-11-25 09:24:15 +0100474
Steven Rostedt41bc8142008-05-22 11:49:22 -0400475void tracing_start_cmdline_record(void);
476void tracing_stop_cmdline_record(void);
Steven Rostedte168e052008-11-07 22:36:02 -0500477void tracing_sched_switch_assign_trace(struct trace_array *tr);
478void tracing_stop_sched_switch_record(void);
479void tracing_start_sched_switch_record(void);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200480int register_tracer(struct tracer *type);
481void unregister_tracer(struct tracer *type);
482
483extern unsigned long nsecs_to_usecs(unsigned long nsecs);
484
485extern unsigned long tracing_max_latency;
486extern unsigned long tracing_thresh;
487
488void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
489void update_max_tr_single(struct trace_array *tr,
490 struct task_struct *tsk, int cpu);
491
Steven Rostedt53614992009-01-15 19:12:40 -0500492void __trace_stack(struct trace_array *tr,
Steven Rostedt53614992009-01-15 19:12:40 -0500493 unsigned long flags,
494 int skip, int pc);
495
Ingo Molnare309b412008-05-12 21:20:51 +0200496extern cycle_t ftrace_now(int cpu);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200497
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200498#ifdef CONFIG_CONTEXT_SWITCH_TRACER
499typedef void
500(*tracer_switch_func_t)(void *private,
Mathieu Desnoyers5b82a1b2008-05-12 21:21:10 +0200501 void *__rq,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200502 struct task_struct *prev,
503 struct task_struct *next);
504
505struct tracer_switch_ops {
506 tracer_switch_func_t func;
507 void *private;
508 struct tracer_switch_ops *next;
509};
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200510#endif /* CONFIG_CONTEXT_SWITCH_TRACER */
511
Steven Rostedt4ca530852009-03-16 19:20:15 -0400512extern void trace_find_cmdline(int pid, char comm[]);
Ingo Molnarf7d48cb2008-12-29 13:02:17 +0100513
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200514#ifdef CONFIG_DYNAMIC_FTRACE
515extern unsigned long ftrace_update_tot_cnt;
Steven Rostedtd05cdb22008-05-12 21:20:54 +0200516#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
517extern int DYN_FTRACE_TEST_NAME(void);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200518#endif
519
Steven Rostedt60a11772008-05-12 21:20:44 +0200520#ifdef CONFIG_FTRACE_STARTUP_TEST
Steven Rostedt60a11772008-05-12 21:20:44 +0200521extern int trace_selftest_startup_function(struct tracer *trace,
522 struct trace_array *tr);
Frederic Weisbecker7447dce2009-02-07 21:33:57 +0100523extern int trace_selftest_startup_function_graph(struct tracer *trace,
524 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200525extern int trace_selftest_startup_irqsoff(struct tracer *trace,
526 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200527extern int trace_selftest_startup_preemptoff(struct tracer *trace,
528 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200529extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
530 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200531extern int trace_selftest_startup_wakeup(struct tracer *trace,
532 struct trace_array *tr);
Steven Noonanfb1b6d82008-09-19 03:06:43 -0700533extern int trace_selftest_startup_nop(struct tracer *trace,
534 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200535extern int trace_selftest_startup_sched_switch(struct tracer *trace,
536 struct trace_array *tr);
Ingo Molnara6dd24f2008-05-12 21:20:47 +0200537extern int trace_selftest_startup_sysprof(struct tracer *trace,
538 struct trace_array *tr);
Steven Rostedt80e5ea42008-11-12 15:24:24 -0500539extern int trace_selftest_startup_branch(struct tracer *trace,
540 struct trace_array *tr);
Markus Metzger321bb5e2009-03-13 10:50:27 +0100541extern int trace_selftest_startup_hw_branches(struct tracer *trace,
542 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200543#endif /* CONFIG_FTRACE_STARTUP_TEST */
544
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200545extern void *head_page(struct trace_array_cpu *data);
Lai Jiangshancf8e3472009-03-30 13:48:00 +0800546extern unsigned long long ns2usecs(cycle_t nsec);
Frederic Weisbecker1fd8f2a2008-12-03 23:45:11 +0100547extern int
Steven Rostedt40ce74f2009-03-19 14:03:53 -0400548trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100549extern int
Steven Rostedt40ce74f2009-03-19 14:03:53 -0400550trace_vprintk(unsigned long ip, const char *fmt, va_list args);
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200551
Ingo Molnar4e655512008-05-12 21:20:52 +0200552extern unsigned long trace_flags;
553
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100554/* Standard output formatting function used for function return traces */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100555#ifdef CONFIG_FUNCTION_GRAPH_TRACER
556extern enum print_line_t print_graph_function(struct trace_iterator *iter);
Steven Rostedt0706f1c2009-03-23 23:12:58 -0400557extern enum print_line_t
558trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500559
560#ifdef CONFIG_DYNAMIC_FTRACE
561/* TODO: make this variable */
562#define FTRACE_GRAPH_MAX_FUNCS 32
563extern int ftrace_graph_count;
564extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
565
566static inline int ftrace_graph_addr(unsigned long addr)
567{
568 int i;
569
570 if (!ftrace_graph_count || test_tsk_trace_graph(current))
571 return 1;
572
573 for (i = 0; i < ftrace_graph_count; i++) {
574 if (addr == ftrace_graph_funcs[i])
575 return 1;
576 }
577
578 return 0;
579}
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100580#else
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500581static inline int ftrace_trace_addr(unsigned long addr)
582{
Ingo Molnar6b253932008-12-04 09:18:28 +0100583 return 1;
584}
585static inline int ftrace_graph_addr(unsigned long addr)
586{
587 return 1;
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500588}
589#endif /* CONFIG_DYNAMIC_FTRACE */
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500590#else /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100591static inline enum print_line_t
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100592print_graph_function(struct trace_iterator *iter)
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100593{
594 return TRACE_TYPE_UNHANDLED;
595}
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500596#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100597
Steven Rostedt978f3a42008-12-04 00:26:40 -0500598extern struct pid *ftrace_pid_trace;
Steven Rostedt804a6852008-12-03 15:36:59 -0500599
600static inline int ftrace_trace_task(struct task_struct *task)
601{
Frederic Weisbecker77d683f2008-12-04 23:49:47 +0100602 if (!ftrace_pid_trace)
Steven Rostedt804a6852008-12-03 15:36:59 -0500603 return 1;
604
605 return test_tsk_trace_trace(task);
606}
607
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200608/*
609 * trace_iterator_flags is an enumeration that defines bit
610 * positions into trace_flags that controls the output.
611 *
612 * NOTE: These bits must match the trace_options array in
613 * trace.c.
614 */
Ingo Molnar4e655512008-05-12 21:20:52 +0200615enum trace_iterator_flags {
616 TRACE_ITER_PRINT_PARENT = 0x01,
617 TRACE_ITER_SYM_OFFSET = 0x02,
618 TRACE_ITER_SYM_ADDR = 0x04,
619 TRACE_ITER_VERBOSE = 0x08,
620 TRACE_ITER_RAW = 0x10,
621 TRACE_ITER_HEX = 0x20,
622 TRACE_ITER_BIN = 0x40,
623 TRACE_ITER_BLOCK = 0x80,
624 TRACE_ITER_STACKTRACE = 0x100,
Ingo Molnar4ac3ba42008-05-12 21:20:52 +0200625 TRACE_ITER_SCHED_TREE = 0x200,
Peter Zijlstraf09ce572008-09-04 10:24:14 +0200626 TRACE_ITER_PRINTK = 0x400,
Steven Rostedtb2a866f2008-11-03 23:15:57 -0500627 TRACE_ITER_PREEMPTONLY = 0x800,
Steven Rostedt9f029e82008-11-12 15:24:24 -0500628 TRACE_ITER_BRANCH = 0x1000,
Steven Rostedt12ef7d42008-11-12 17:52:38 -0500629 TRACE_ITER_ANNOTATE = 0x2000,
Török Edwinb54d3de2008-11-22 13:28:48 +0200630 TRACE_ITER_USERSTACKTRACE = 0x4000,
Frederic Weisbecker66896a82008-12-13 20:18:13 +0100631 TRACE_ITER_SYM_USEROBJ = 0x8000,
Frederic Weisbeckerc4a8e8b2009-02-02 20:29:21 -0200632 TRACE_ITER_PRINTK_MSGONLY = 0x10000,
Steven Rostedtc032ef642009-03-04 20:34:24 -0500633 TRACE_ITER_CONTEXT_INFO = 0x20000, /* Print pid/cpu/time */
634 TRACE_ITER_LATENCY_FMT = 0x40000,
Steven Rostedtaf4617b2009-03-17 18:09:55 -0400635 TRACE_ITER_GLOBAL_CLK = 0x80000,
Steven Rostedtbe6f1642009-03-24 11:06:24 -0400636 TRACE_ITER_SLEEP_TIME = 0x100000,
Steven Rostedta2a16d62009-03-24 23:17:58 -0400637 TRACE_ITER_GRAPH_TIME = 0x200000,
Ingo Molnar4e655512008-05-12 21:20:52 +0200638};
639
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100640/*
641 * TRACE_ITER_SYM_MASK masks the options in trace_flags that
642 * control the output of kernel symbols.
643 */
644#define TRACE_ITER_SYM_MASK \
645 (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
646
Frédéric Weisbecker43a15382008-09-21 20:16:30 +0200647extern struct tracer nop_trace;
648
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500649/**
650 * ftrace_preempt_disable - disable preemption scheduler safe
651 *
652 * When tracing can happen inside the scheduler, there exists
653 * cases that the tracing might happen before the need_resched
654 * flag is checked. If this happens and the tracer calls
655 * preempt_enable (after a disable), a schedule might take place
656 * causing an infinite recursion.
657 *
Wenji Huang57794a92009-02-06 17:33:27 +0800658 * To prevent this, we read the need_resched flag before
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500659 * disabling preemption. When we want to enable preemption we
660 * check the flag, if it is set, then we call preempt_enable_no_resched.
661 * Otherwise, we call preempt_enable.
662 *
Wenji Huang57794a92009-02-06 17:33:27 +0800663 * The rational for doing the above is that if need_resched is set
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500664 * and we have yet to reschedule, we are either in an atomic location
665 * (where we do not need to check for scheduling) or we are inside
666 * the scheduler and do not want to resched.
667 */
668static inline int ftrace_preempt_disable(void)
669{
670 int resched;
671
672 resched = need_resched();
673 preempt_disable_notrace();
674
675 return resched;
676}
677
678/**
679 * ftrace_preempt_enable - enable preemption scheduler safe
680 * @resched: the return value from ftrace_preempt_disable
681 *
682 * This is a scheduler safe way to enable preemption and not miss
683 * any preemption checks. The disabled saved the state of preemption.
Wenji Huang57794a92009-02-06 17:33:27 +0800684 * If resched is set, then we are either inside an atomic or
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500685 * are inside the scheduler (we would have already scheduled
686 * otherwise). In this case, we do not want to call normal
687 * preempt_enable, but preempt_enable_no_resched instead.
688 */
689static inline void ftrace_preempt_enable(int resched)
690{
691 if (resched)
692 preempt_enable_no_resched_notrace();
693 else
694 preempt_enable_notrace();
695}
696
Steven Rostedt2ed84ee2008-11-12 15:24:24 -0500697#ifdef CONFIG_BRANCH_TRACER
Steven Rostedt9f029e82008-11-12 15:24:24 -0500698extern int enable_branch_tracing(struct trace_array *tr);
699extern void disable_branch_tracing(void);
700static inline int trace_branch_enable(struct trace_array *tr)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500701{
Steven Rostedt9f029e82008-11-12 15:24:24 -0500702 if (trace_flags & TRACE_ITER_BRANCH)
703 return enable_branch_tracing(tr);
Steven Rostedt52f232c2008-11-12 00:14:40 -0500704 return 0;
705}
Steven Rostedt9f029e82008-11-12 15:24:24 -0500706static inline void trace_branch_disable(void)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500707{
708 /* due to races, always disable */
Steven Rostedt9f029e82008-11-12 15:24:24 -0500709 disable_branch_tracing();
Steven Rostedt52f232c2008-11-12 00:14:40 -0500710}
711#else
Steven Rostedt9f029e82008-11-12 15:24:24 -0500712static inline int trace_branch_enable(struct trace_array *tr)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500713{
714 return 0;
715}
Steven Rostedt9f029e82008-11-12 15:24:24 -0500716static inline void trace_branch_disable(void)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500717{
718}
Steven Rostedt2ed84ee2008-11-12 15:24:24 -0500719#endif /* CONFIG_BRANCH_TRACER */
Steven Rostedt52f232c2008-11-12 00:14:40 -0500720
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400721/* set ring buffers to default size if not already done so */
722int tracing_update_buffers(void);
723
Steven Rostedtfd994982009-02-28 02:41:25 -0500724/* trace event type bit fields, not numeric */
725enum {
726 TRACE_EVENT_TYPE_PRINTF = 1,
727 TRACE_EVENT_TYPE_RAW = 2,
728};
729
Tom Zanussicf027f62009-03-22 03:30:39 -0500730struct ftrace_event_field {
731 struct list_head link;
732 char *name;
733 char *type;
734 int offset;
735 int size;
Tom Zanussia118e4d2009-04-28 03:04:53 -0500736 int is_signed;
Tom Zanussicf027f62009-03-22 03:30:39 -0500737};
738
Tom Zanussi30e673b2009-04-28 03:04:47 -0500739struct event_filter {
740 int n_preds;
741 struct filter_pred **preds;
Tom Zanussi8b372562009-04-28 03:04:59 -0500742 char *filter_string;
Tom Zanussi30e673b2009-04-28 03:04:47 -0500743};
744
Tom Zanussicfb180f2009-03-22 03:31:17 -0500745struct event_subsystem {
746 struct list_head list;
747 const char *name;
748 struct dentry *entry;
Tom Zanussi30e673b2009-04-28 03:04:47 -0500749 void *filter;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500750};
751
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500752struct filter_pred;
753
Tom Zanussi8b372562009-04-28 03:04:59 -0500754typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event,
755 int val1, int val2);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500756
757struct filter_pred {
758 filter_pred_fn_t fn;
759 u64 val;
Tom Zanussi0a19e532009-04-13 03:17:50 -0500760 char str_val[MAX_FILTER_STR_VAL];
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500761 int str_len;
762 char *field_name;
763 int offset;
764 int not;
Tom Zanussi8b372562009-04-28 03:04:59 -0500765 int op;
766 int pop_n;
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500767};
768
Tom Zanussi8b372562009-04-28 03:04:59 -0500769extern void print_event_filter(struct ftrace_event_call *call,
Tom Zanussi4bda2d52009-03-24 02:14:31 -0500770 struct trace_seq *s);
Tom Zanussi8b372562009-04-28 03:04:59 -0500771extern int apply_event_filter(struct ftrace_event_call *call,
772 char *filter_string);
773extern int apply_subsystem_event_filter(struct event_subsystem *system,
774 char *filter_string);
775extern void print_subsystem_event_filter(struct event_subsystem *system,
Tom Zanussiac1adc52009-04-17 00:27:08 -0500776 struct trace_seq *s);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500777
Tom Zanussieb02ce02009-04-08 03:15:54 -0500778static inline int
Tom Zanussie1112b42009-03-31 00:48:49 -0500779filter_check_discard(struct ftrace_event_call *call, void *rec,
Tom Zanussieb02ce02009-04-08 03:15:54 -0500780 struct ring_buffer *buffer,
Tom Zanussie1112b42009-03-31 00:48:49 -0500781 struct ring_buffer_event *event)
782{
Tom Zanussi30e673b2009-04-28 03:04:47 -0500783 if (unlikely(call->filter_active) && !filter_match_preds(call, rec)) {
Tom Zanussieb02ce02009-04-08 03:15:54 -0500784 ring_buffer_discard_commit(buffer, event);
785 return 1;
786 }
787
788 return 0;
Tom Zanussie1112b42009-03-31 00:48:49 -0500789}
790
Tom Zanussi8b372562009-04-28 03:04:59 -0500791#define DEFINE_COMPARISON_PRED(type) \
792static int filter_pred_##type(struct filter_pred *pred, void *event, \
793 int val1, int val2) \
794{ \
795 type *addr = (type *)(event + pred->offset); \
796 type val = (type)pred->val; \
797 int match = 0; \
798 \
799 switch (pred->op) { \
800 case OP_LT: \
801 match = (*addr < val); \
802 break; \
803 case OP_LE: \
804 match = (*addr <= val); \
805 break; \
806 case OP_GT: \
807 match = (*addr > val); \
808 break; \
809 case OP_GE: \
810 match = (*addr >= val); \
811 break; \
812 default: \
813 break; \
814 } \
815 \
816 return match; \
817}
818
819#define DEFINE_EQUALITY_PRED(size) \
820static int filter_pred_##size(struct filter_pred *pred, void *event, \
821 int val1, int val2) \
822{ \
823 u##size *addr = (u##size *)(event + pred->offset); \
824 u##size val = (u##size)pred->val; \
825 int match; \
826 \
827 match = (val == *addr) ^ pred->not; \
828 \
829 return match; \
830}
831
Li Zefan20c89282009-05-06 10:33:45 +0800832extern struct mutex event_mutex;
Steven Rostedta59fd602009-04-10 13:52:20 -0400833extern struct list_head ftrace_events;
Peter Zijlstraac199db2009-03-19 20:26:15 +0100834
Steven Rostedte9fb2b62009-03-12 14:19:25 -0400835extern const char *__start___trace_bprintk_fmt[];
836extern const char *__stop___trace_bprintk_fmt[];
837
Tom Zanussie1112b42009-03-31 00:48:49 -0500838#undef TRACE_EVENT_FORMAT
839#define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt) \
840 extern struct ftrace_event_call event_##call;
Tom Zanussie45f2e22009-03-31 00:49:16 -0500841#undef TRACE_EVENT_FORMAT_NOFILTER
842#define TRACE_EVENT_FORMAT_NOFILTER(call, proto, args, fmt, tstruct, tpfmt)
Tom Zanussie1112b42009-03-31 00:48:49 -0500843#include "trace_event_types.h"
844
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200845#endif /* _LINUX_KERNEL_TRACE_H */