blob: cbc168f1e43db4e78e41a990cd5b0265cf9a96d4 [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>
Frederic Weisbecker36994e52008-12-29 13:42:23 -080012#include <trace/kmemtrace.h>
Frederic Weisbecker12922112009-02-07 22:16:12 +010013#include <trace/power.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020014
Thomas Gleixner72829bc2008-05-23 21:37:28 +020015enum trace_type {
16 __TRACE_FIRST_TYPE = 0,
17
18 TRACE_FN,
19 TRACE_CTX,
20 TRACE_WAKE,
21 TRACE_STACK,
Steven Rostedtdd0e5452008-08-01 12:26:41 -040022 TRACE_PRINT,
Frederic Weisbecker48ead022009-03-12 18:24:49 +010023 TRACE_BPRINT,
Thomas Gleixner72829bc2008-05-23 21:37:28 +020024 TRACE_SPECIAL,
Pekka Paalanenbd8ac682008-05-12 21:20:57 +020025 TRACE_MMIO_RW,
26 TRACE_MMIO_MAP,
Steven Rostedt9f029e82008-11-12 15:24:24 -050027 TRACE_BRANCH,
Frederic Weisbecker74239072008-11-11 23:24:42 +010028 TRACE_BOOT_CALL,
29 TRACE_BOOT_RET,
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010030 TRACE_GRAPH_RET,
31 TRACE_GRAPH_ENT,
Török Edwin02b67512008-11-22 13:28:47 +020032 TRACE_USER_STACK,
Markus Metzgera93751c2008-12-11 13:53:26 +010033 TRACE_HW_BRANCHES,
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +010034 TRACE_SYSCALL_ENTER,
35 TRACE_SYSCALL_EXIT,
Frederic Weisbecker36994e52008-12-29 13:42:23 -080036 TRACE_KMEM_ALLOC,
37 TRACE_KMEM_FREE,
Arjan van de Venf3f47a62008-11-23 16:49:58 -080038 TRACE_POWER,
Arnaldo Carvalho de Meloc71a8962009-01-23 12:06:27 -020039 TRACE_BLK,
Thomas Gleixner72829bc2008-05-23 21:37:28 +020040
Steven Rostedtf0868d12008-12-23 23:24:12 -050041 __TRACE_LAST_TYPE,
Thomas Gleixner72829bc2008-05-23 21:37:28 +020042};
43
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020044/*
Steven Rostedt777e2082008-09-29 23:02:42 -040045 * The trace entry - the most basic unit of tracing. This is what
46 * is printed in the end as a single line in the trace output, such as:
47 *
48 * bash-15816 [01] 235.197585: idle_cpu <- irq_enter
49 */
50struct trace_entry {
51 unsigned char type;
Steven Rostedt777e2082008-09-29 23:02:42 -040052 unsigned char flags;
53 unsigned char preempt_count;
54 int pid;
Török Edwin02b67512008-11-22 13:28:47 +020055 int tgid;
Steven Rostedt777e2082008-09-29 23:02:42 -040056};
57
58/*
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020059 * Function trace entry - function address and parent function addres:
60 */
61struct ftrace_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -040062 struct trace_entry ent;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020063 unsigned long ip;
64 unsigned long parent_ip;
65};
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +010066
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010067/* Function call entry */
68struct ftrace_graph_ent_entry {
Frederic Weisbeckerb91facc2009-02-06 18:30:44 +010069 struct trace_entry ent;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010070 struct ftrace_graph_ent graph_ent;
71};
72
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +010073/* Function return entry */
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010074struct ftrace_graph_ret_entry {
Frederic Weisbeckerb91facc2009-02-06 18:30:44 +010075 struct trace_entry ent;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +010076 struct ftrace_graph_ret ret;
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +010077};
Frédéric Weisbeckerd13744c2008-09-23 11:32:08 +010078extern struct tracer boot_tracer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020079
80/*
81 * Context switch trace entry - which task (and prio) we switched from/to:
82 */
83struct ctx_switch_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -040084 struct trace_entry ent;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020085 unsigned int prev_pid;
86 unsigned char prev_prio;
87 unsigned char prev_state;
88 unsigned int next_pid;
89 unsigned char next_prio;
Peter Zijlstrabac524d2008-05-12 21:20:53 +020090 unsigned char next_state;
Peter Zijlstra80b5e942008-09-04 10:24:16 +020091 unsigned int next_cpu;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020092};
93
94/*
Ingo Molnarf0a920d2008-05-12 21:20:47 +020095 * Special (free-form) trace entry:
96 */
97struct special_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -040098 struct trace_entry ent;
Ingo Molnarf0a920d2008-05-12 21:20:47 +020099 unsigned long arg1;
100 unsigned long arg2;
101 unsigned long arg3;
102};
103
104/*
Ingo Molnar86387f72008-05-12 21:20:51 +0200105 * Stack-trace entry:
106 */
107
Ingo Molnar74f4e362008-05-12 21:21:15 +0200108#define FTRACE_STACK_ENTRIES 8
Ingo Molnar86387f72008-05-12 21:20:51 +0200109
110struct stack_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -0400111 struct trace_entry ent;
Ingo Molnar86387f72008-05-12 21:20:51 +0200112 unsigned long caller[FTRACE_STACK_ENTRIES];
113};
114
Török Edwin02b67512008-11-22 13:28:47 +0200115struct userstack_entry {
116 struct trace_entry ent;
117 unsigned long caller[FTRACE_STACK_ENTRIES];
118};
119
Ingo Molnar86387f72008-05-12 21:20:51 +0200120/*
Ingo Molnar5e1607a2009-03-05 10:24:48 +0100121 * trace_printk entry:
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400122 */
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100123struct bprint_entry {
Steven Rostedt777e2082008-09-29 23:02:42 -0400124 struct trace_entry ent;
Ingo Molnar9de36822009-03-06 17:52:03 +0100125 unsigned long ip;
Frederic Weisbecker769b0442009-03-06 17:21:49 +0100126 const char *fmt;
Ingo Molnar9de36822009-03-06 17:52:03 +0100127 u32 buf[];
Lai Jiangshan1427cdf2009-03-06 17:21:47 +0100128};
Lai Jiangshan1427cdf2009-03-06 17:21:47 +0100129
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100130struct print_entry {
131 struct trace_entry ent;
132 unsigned long ip;
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100133 char buf[];
134};
135
Steven Rostedt777e2082008-09-29 23:02:42 -0400136#define TRACE_OLD_SIZE 88
137
138struct trace_field_cont {
139 unsigned char type;
140 /* Temporary till we get rid of this completely */
141 char buf[TRACE_OLD_SIZE - 1];
142};
143
144struct trace_mmiotrace_rw {
145 struct trace_entry ent;
146 struct mmiotrace_rw rw;
147};
148
149struct trace_mmiotrace_map {
150 struct trace_entry ent;
151 struct mmiotrace_map map;
152};
153
Frederic Weisbecker74239072008-11-11 23:24:42 +0100154struct trace_boot_call {
Steven Rostedt777e2082008-09-29 23:02:42 -0400155 struct trace_entry ent;
Frederic Weisbecker74239072008-11-11 23:24:42 +0100156 struct boot_trace_call boot_call;
157};
158
159struct trace_boot_ret {
160 struct trace_entry ent;
161 struct boot_trace_ret boot_ret;
Steven Rostedt777e2082008-09-29 23:02:42 -0400162};
163
Steven Rostedt52f232c2008-11-12 00:14:40 -0500164#define TRACE_FUNC_SIZE 30
165#define TRACE_FILE_SIZE 20
Steven Rostedt9f029e82008-11-12 15:24:24 -0500166struct trace_branch {
Steven Rostedt52f232c2008-11-12 00:14:40 -0500167 struct trace_entry ent;
168 unsigned line;
169 char func[TRACE_FUNC_SIZE+1];
170 char file[TRACE_FILE_SIZE+1];
171 char correct;
172};
173
Markus Metzgera93751c2008-12-11 13:53:26 +0100174struct hw_branch_entry {
Markus Metzger1e9b51c2008-11-25 09:24:15 +0100175 struct trace_entry ent;
Markus Metzgera93751c2008-12-11 13:53:26 +0100176 u64 from;
177 u64 to;
Markus Metzger1e9b51c2008-11-25 09:24:15 +0100178};
179
Arjan van de Venf3f47a62008-11-23 16:49:58 -0800180struct trace_power {
181 struct trace_entry ent;
182 struct power_trace state_data;
183};
184
Eduard - Gabriel Munteanuca2b84cb2009-03-23 15:12:24 +0200185enum kmemtrace_type_id {
186 KMEMTRACE_TYPE_KMALLOC = 0, /* kmalloc() or kfree(). */
187 KMEMTRACE_TYPE_CACHE, /* kmem_cache_*(). */
188 KMEMTRACE_TYPE_PAGES, /* __get_free_pages() and friends. */
189};
190
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800191struct kmemtrace_alloc_entry {
192 struct trace_entry ent;
193 enum kmemtrace_type_id type_id;
194 unsigned long call_site;
195 const void *ptr;
196 size_t bytes_req;
197 size_t bytes_alloc;
198 gfp_t gfp_flags;
199 int node;
200};
201
202struct kmemtrace_free_entry {
203 struct trace_entry ent;
204 enum kmemtrace_type_id type_id;
205 unsigned long call_site;
206 const void *ptr;
207};
208
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100209struct syscall_trace_enter {
210 struct trace_entry ent;
211 int nr;
212 unsigned long args[];
213};
214
215struct syscall_trace_exit {
216 struct trace_entry ent;
217 int nr;
218 unsigned long ret;
219};
220
221
Steven Rostedtdd0e5452008-08-01 12:26:41 -0400222/*
Pekka Paalanenfc5e27a2008-09-16 22:02:27 +0300223 * trace_flag_type is an enumeration that holds different
224 * states when a trace occurs. These are:
Steven Rostedt92444892008-10-24 09:42:59 -0400225 * IRQS_OFF - interrupts were disabled
Ingo Molnar9de36822009-03-06 17:52:03 +0100226 * IRQS_NOSUPPORT - arch does not support irqs_disabled_flags
Steven Rostedt92444892008-10-24 09:42:59 -0400227 * NEED_RESCED - reschedule is requested
228 * HARDIRQ - inside an interrupt handler
229 * SOFTIRQ - inside a softirq handler
Pekka Paalanenfc5e27a2008-09-16 22:02:27 +0300230 */
231enum trace_flag_type {
232 TRACE_FLAG_IRQS_OFF = 0x01,
Steven Rostedt92444892008-10-24 09:42:59 -0400233 TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
234 TRACE_FLAG_NEED_RESCHED = 0x04,
235 TRACE_FLAG_HARDIRQ = 0x08,
236 TRACE_FLAG_SOFTIRQ = 0x10,
Pekka Paalanenfc5e27a2008-09-16 22:02:27 +0300237};
238
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +0300239#define TRACE_BUF_SIZE 1024
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200240
241/*
242 * The CPU trace array - it consists of thousands of trace entries
243 * plus some other descriptor data: (for example which task started
244 * the trace, etc.)
245 */
246struct trace_array_cpu {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200247 atomic_t disabled;
Steven Rostedt2cadf912008-12-01 22:20:19 -0500248 void *buffer_page; /* ring buffer spare */
Ingo Molnar4e3c3332008-05-12 21:20:45 +0200249
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200250 /* these fields get copied into max-trace: */
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200251 unsigned long trace_idx;
Steven Rostedt53d0aa72008-05-12 21:21:01 +0200252 unsigned long overrun;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200253 unsigned long saved_latency;
254 unsigned long critical_start;
255 unsigned long critical_end;
256 unsigned long critical_sequence;
257 unsigned long nice;
258 unsigned long policy;
259 unsigned long rt_priority;
260 cycle_t preempt_timestamp;
261 pid_t pid;
262 uid_t uid;
263 char comm[TASK_COMM_LEN];
264};
265
266struct trace_iterator;
267
268/*
269 * The trace array - an array of per-CPU trace arrays. This is the
270 * highest level data structure that individual tracers deal with.
271 * They have on/off state as well:
272 */
273struct trace_array {
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400274 struct ring_buffer *buffer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200275 unsigned long entries;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200276 int cpu;
277 cycle_t time_start;
Steven Rostedtb3806b42008-05-12 21:20:46 +0200278 struct task_struct *waiter;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200279 struct trace_array_cpu *data[NR_CPUS];
280};
281
Steven Rostedt7104f302008-10-01 10:52:51 -0400282#define FTRACE_CMP_TYPE(var, type) \
283 __builtin_types_compatible_p(typeof(var), type *)
284
285#undef IF_ASSIGN
286#define IF_ASSIGN(var, entry, etype, id) \
287 if (FTRACE_CMP_TYPE(var, etype)) { \
288 var = (typeof(var))(entry); \
289 WARN_ON(id && (entry)->type != id); \
290 break; \
291 }
292
293/* Will cause compile errors if type is not found. */
294extern void __ftrace_bad_type(void);
295
296/*
297 * The trace_assign_type is a verifier that the entry type is
298 * the same as the type being assigned. To add new types simply
299 * add a line with the following format:
300 *
301 * IF_ASSIGN(var, ent, type, id);
302 *
303 * Where "type" is the trace type that includes the trace_entry
304 * as the "ent" item. And "id" is the trace identifier that is
305 * used in the trace_type enum.
306 *
307 * If the type can have more than one id, then use zero.
308 */
309#define trace_assign_type(var, ent) \
310 do { \
311 IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \
312 IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \
Steven Rostedt7104f302008-10-01 10:52:51 -0400313 IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \
Török Edwin02b67512008-11-22 13:28:47 +0200314 IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
Steven Rostedt7104f302008-10-01 10:52:51 -0400315 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100316 IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
Steven Rostedt7104f302008-10-01 10:52:51 -0400317 IF_ASSIGN(var, ent, struct special_entry, 0); \
318 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \
319 TRACE_MMIO_RW); \
320 IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \
321 TRACE_MMIO_MAP); \
Frederic Weisbecker74239072008-11-11 23:24:42 +0100322 IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
323 IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
Steven Rostedt9f029e82008-11-12 15:24:24 -0500324 IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100325 IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \
326 TRACE_GRAPH_ENT); \
327 IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \
328 TRACE_GRAPH_RET); \
Markus Metzgera93751c2008-12-11 13:53:26 +0100329 IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
Ingo Molnar9de36822009-03-06 17:52:03 +0100330 IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800331 IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry, \
332 TRACE_KMEM_ALLOC); \
333 IF_ASSIGN(var, ent, struct kmemtrace_free_entry, \
334 TRACE_KMEM_FREE); \
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100335 IF_ASSIGN(var, ent, struct syscall_trace_enter, \
336 TRACE_SYSCALL_ENTER); \
337 IF_ASSIGN(var, ent, struct syscall_trace_exit, \
338 TRACE_SYSCALL_EXIT); \
Steven Rostedt7104f302008-10-01 10:52:51 -0400339 __ftrace_bad_type(); \
340 } while (0)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +0200341
342/* Return values for print_line callback */
343enum print_line_t {
344 TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */
345 TRACE_TYPE_HANDLED = 1,
Frederic Weisbeckerb91facc2009-02-06 18:30:44 +0100346 TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */
347 TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +0200348};
349
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100350
351/*
352 * An option specific to a tracer. This is a boolean value.
353 * The bit is the bit index that sets its value on the
354 * flags value in struct tracer_flags.
355 */
356struct tracer_opt {
Ingo Molnar9de36822009-03-06 17:52:03 +0100357 const char *name; /* Will appear on the trace_options file */
358 u32 bit; /* Mask assigned in val field in tracer_flags */
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100359};
360
361/*
362 * The set of specific options for a tracer. Your tracer
363 * have to set the initial value of the flags val.
364 */
365struct tracer_flags {
366 u32 val;
Ingo Molnar9de36822009-03-06 17:52:03 +0100367 struct tracer_opt *opts;
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100368};
369
370/* Makes more easy to define a tracer opt */
371#define TRACER_OPT(s, b) .name = #s, .bit = b
372
Frederic Weisbecker034939b2009-01-08 10:03:56 -0800373
Frederic Weisbecker6eaaa5d2009-02-11 02:25:00 +0100374/**
375 * struct tracer - a specific tracer and its callbacks to interact with debugfs
376 * @name: the name chosen to select it on the available_tracers file
377 * @init: called when one switches to this tracer (echo name > current_tracer)
378 * @reset: called when one switches to another tracer
379 * @start: called when tracing is unpaused (echo 1 > tracing_enabled)
380 * @stop: called when tracing is paused (echo 0 > tracing_enabled)
381 * @open: called when the trace file is opened
382 * @pipe_open: called when the trace_pipe file is opened
383 * @wait_pipe: override how the user waits for traces on trace_pipe
384 * @close: called when the trace file is released
385 * @read: override the default read callback on trace_pipe
386 * @splice_read: override the default splice_read callback on trace_pipe
387 * @selftest: selftest to run on boot (see trace_selftest.c)
388 * @print_headers: override the first lines that describe your columns
389 * @print_line: callback that prints a trace
390 * @set_flag: signals one of your private flags changed (trace_options file)
391 * @flags: your private flags
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200392 */
393struct tracer {
394 const char *name;
Frederic Weisbecker1c800252008-11-16 05:57:26 +0100395 int (*init)(struct trace_array *tr);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200396 void (*reset)(struct trace_array *tr);
Steven Rostedt90369902008-11-05 16:05:44 -0500397 void (*start)(struct trace_array *tr);
398 void (*stop)(struct trace_array *tr);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200399 void (*open)(struct trace_iterator *iter);
Steven Rostedt107bad82008-05-12 21:21:01 +0200400 void (*pipe_open)(struct trace_iterator *iter);
Frederic Weisbecker6eaaa5d2009-02-11 02:25:00 +0100401 void (*wait_pipe)(struct trace_iterator *iter);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200402 void (*close)(struct trace_iterator *iter);
Steven Rostedt107bad82008-05-12 21:21:01 +0200403 ssize_t (*read)(struct trace_iterator *iter,
404 struct file *filp, char __user *ubuf,
405 size_t cnt, loff_t *ppos);
Eduard - Gabriel Munteanu3c568192009-02-09 08:15:56 +0200406 ssize_t (*splice_read)(struct trace_iterator *iter,
407 struct file *filp,
408 loff_t *ppos,
409 struct pipe_inode_info *pipe,
410 size_t len,
411 unsigned int flags);
Steven Rostedt60a11772008-05-12 21:20:44 +0200412#ifdef CONFIG_FTRACE_STARTUP_TEST
413 int (*selftest)(struct tracer *trace,
414 struct trace_array *tr);
415#endif
Markus Metzger8bba1bf2008-11-25 09:12:31 +0100416 void (*print_header)(struct seq_file *m);
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +0200417 enum print_line_t (*print_line)(struct trace_iterator *iter);
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100418 /* If you handled the flag setting, return 0 */
419 int (*set_flag)(u32 old_flags, u32 bit, int set);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200420 struct tracer *next;
421 int print_max;
Ingo Molnar9de36822009-03-06 17:52:03 +0100422 struct tracer_flags *flags;
Frederic Weisbecker034939b2009-01-08 10:03:56 -0800423 struct tracer_stat *stats;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200424};
425
Steven Rostedt214023c2008-05-12 21:20:46 +0200426struct trace_seq {
427 unsigned char buffer[PAGE_SIZE];
428 unsigned int len;
Pekka Paalanen6c6c2792008-05-12 21:21:02 +0200429 unsigned int readpos;
Steven Rostedt214023c2008-05-12 21:20:46 +0200430};
431
Steven Rostedtf9520752009-03-02 14:04:40 -0500432static inline void
433trace_seq_init(struct trace_seq *s)
434{
435 s->len = 0;
436 s->readpos = 0;
437}
438
439
Frederic Weisbeckerb04cc6b2009-02-25 03:22:28 +0100440#define TRACE_PIPE_ALL_CPU -1
441
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200442/*
443 * Trace iterator - used by printout routines who present trace
444 * results to users and which routines might sleep, etc:
445 */
446struct trace_iterator {
447 struct trace_array *tr;
448 struct tracer *trace;
Steven Rostedt107bad82008-05-12 21:21:01 +0200449 void *private;
Frederic Weisbeckerb04cc6b2009-02-25 03:22:28 +0100450 int cpu_file;
Frederic Weisbeckerd7350c3f2009-02-25 06:13:16 +0100451 struct mutex mutex;
452 struct ring_buffer_iter *buffer_iter[NR_CPUS];
Ingo Molnar4e3c3332008-05-12 21:20:45 +0200453
Steven Rostedt53d0aa72008-05-12 21:21:01 +0200454 /* The below is zeroed out in pipe_read */
455 struct trace_seq seq;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200456 struct trace_entry *ent;
Ingo Molnar4e3c3332008-05-12 21:20:45 +0200457 int cpu;
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400458 u64 ts;
Ingo Molnar4e3c3332008-05-12 21:20:45 +0200459
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200460 unsigned long iter_flags;
461 loff_t pos;
Steven Rostedt4c11d7a2008-05-12 21:20:43 +0200462 long idx;
Steven Rostedta3097202008-11-07 22:36:02 -0500463
Rusty Russell44623442009-01-01 10:12:23 +1030464 cpumask_var_t started;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200465};
466
Arnaldo Carvalho de Melob6f11df2009-02-05 18:02:00 -0200467int tracer_init(struct tracer *t, struct trace_array *tr);
Steven Rostedt90369902008-11-05 16:05:44 -0500468int tracing_is_enabled(void);
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300469void trace_wake_up(void);
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400470void tracing_reset(struct trace_array *tr, int cpu);
Pekka J Enberg213cc062008-12-19 12:08:39 +0200471void tracing_reset_online_cpus(struct trace_array *tr);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200472int tracing_open_generic(struct inode *inode, struct file *filp);
473struct dentry *tracing_init_dentry(void);
Ingo Molnard618b3e2008-05-12 21:20:49 +0200474void init_tracer_sysprof_debugfs(struct dentry *d_tracer);
475
Arnaldo Carvalho de Melo51a763d2009-02-05 16:14:13 -0200476struct ring_buffer_event;
477
478struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
479 unsigned char type,
480 unsigned long len,
481 unsigned long flags,
482 int pc);
483void trace_buffer_unlock_commit(struct trace_array *tr,
484 struct ring_buffer_event *event,
485 unsigned long flags, int pc);
486
Steven Rostedtef5580d2009-02-27 19:38:04 -0500487struct ring_buffer_event *
488trace_current_buffer_lock_reserve(unsigned char type, unsigned long len,
489 unsigned long flags, int pc);
490void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
491 unsigned long flags, int pc);
Frederic Weisbecker07edf712009-03-22 23:10:46 +0100492void trace_nowake_buffer_unlock_commit(struct ring_buffer_event *event,
493 unsigned long flags, int pc);
Steven Rostedtef5580d2009-02-27 19:38:04 -0500494
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300495struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
496 struct trace_array_cpu *data);
Frederic Weisbeckerc4a8e8b2009-02-02 20:29:21 -0200497
498struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
499 int *ent_cpu, u64 *ent_ts);
500
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300501void tracing_generic_entry_update(struct trace_entry *entry,
Steven Rostedt38697052008-10-01 13:14:09 -0400502 unsigned long flags,
503 int pc);
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300504
Frederic Weisbecker6eaaa5d2009-02-11 02:25:00 +0100505void default_wait_pipe(struct trace_iterator *iter);
506void poll_wait_pipe(struct trace_iterator *iter);
507
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200508void ftrace(struct trace_array *tr,
509 struct trace_array_cpu *data,
510 unsigned long ip,
511 unsigned long parent_ip,
Steven Rostedt38697052008-10-01 13:14:09 -0400512 unsigned long flags, int pc);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200513void tracing_sched_switch_trace(struct trace_array *tr,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200514 struct task_struct *prev,
515 struct task_struct *next,
Steven Rostedt38697052008-10-01 13:14:09 -0400516 unsigned long flags, int pc);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200517void tracing_record_cmdline(struct task_struct *tsk);
Ingo Molnar57422792008-05-12 21:20:51 +0200518
519void tracing_sched_wakeup_trace(struct trace_array *tr,
Ingo Molnar57422792008-05-12 21:20:51 +0200520 struct task_struct *wakee,
521 struct task_struct *cur,
Steven Rostedt38697052008-10-01 13:14:09 -0400522 unsigned long flags, int pc);
Ingo Molnarf0a920d2008-05-12 21:20:47 +0200523void trace_special(struct trace_array *tr,
524 struct trace_array_cpu *data,
525 unsigned long arg1,
526 unsigned long arg2,
Steven Rostedt38697052008-10-01 13:14:09 -0400527 unsigned long arg3, int pc);
Steven Rostedt6fb44b72008-05-12 21:20:49 +0200528void trace_function(struct trace_array *tr,
Steven Rostedt6fb44b72008-05-12 21:20:49 +0200529 unsigned long ip,
530 unsigned long parent_ip,
Steven Rostedt38697052008-10-01 13:14:09 -0400531 unsigned long flags, int pc);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200532
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100533void trace_graph_return(struct ftrace_graph_ret *trace);
Steven Rostedte49dc192008-12-02 23:50:05 -0500534int trace_graph_entry(struct ftrace_graph_ent *trace);
Markus Metzger1e9b51c2008-11-25 09:24:15 +0100535
Steven Rostedt41bc8142008-05-22 11:49:22 -0400536void tracing_start_cmdline_record(void);
537void tracing_stop_cmdline_record(void);
Steven Rostedte168e052008-11-07 22:36:02 -0500538void tracing_sched_switch_assign_trace(struct trace_array *tr);
539void tracing_stop_sched_switch_record(void);
540void tracing_start_sched_switch_record(void);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200541int register_tracer(struct tracer *type);
542void unregister_tracer(struct tracer *type);
543
544extern unsigned long nsecs_to_usecs(unsigned long nsecs);
545
546extern unsigned long tracing_max_latency;
547extern unsigned long tracing_thresh;
548
549void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
550void update_max_tr_single(struct trace_array *tr,
551 struct task_struct *tsk, int cpu);
552
Steven Rostedt53614992009-01-15 19:12:40 -0500553void __trace_stack(struct trace_array *tr,
Steven Rostedt53614992009-01-15 19:12:40 -0500554 unsigned long flags,
555 int skip, int pc);
556
Ingo Molnare309b412008-05-12 21:20:51 +0200557extern cycle_t ftrace_now(int cpu);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200558
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200559#ifdef CONFIG_CONTEXT_SWITCH_TRACER
560typedef void
561(*tracer_switch_func_t)(void *private,
Mathieu Desnoyers5b82a1b2008-05-12 21:21:10 +0200562 void *__rq,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200563 struct task_struct *prev,
564 struct task_struct *next);
565
566struct tracer_switch_ops {
567 tracer_switch_func_t func;
568 void *private;
569 struct tracer_switch_ops *next;
570};
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200571#endif /* CONFIG_CONTEXT_SWITCH_TRACER */
572
Steven Rostedt4ca530852009-03-16 19:20:15 -0400573extern void trace_find_cmdline(int pid, char comm[]);
Ingo Molnarf7d48cb2008-12-29 13:02:17 +0100574
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200575#ifdef CONFIG_DYNAMIC_FTRACE
576extern unsigned long ftrace_update_tot_cnt;
Steven Rostedtd05cdb22008-05-12 21:20:54 +0200577#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
578extern int DYN_FTRACE_TEST_NAME(void);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200579#endif
580
Steven Rostedt60a11772008-05-12 21:20:44 +0200581#ifdef CONFIG_FTRACE_STARTUP_TEST
Steven Rostedt60a11772008-05-12 21:20:44 +0200582extern int trace_selftest_startup_function(struct tracer *trace,
583 struct trace_array *tr);
Frederic Weisbecker7447dce2009-02-07 21:33:57 +0100584extern int trace_selftest_startup_function_graph(struct tracer *trace,
585 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200586extern int trace_selftest_startup_irqsoff(struct tracer *trace,
587 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200588extern int trace_selftest_startup_preemptoff(struct tracer *trace,
589 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200590extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
591 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200592extern int trace_selftest_startup_wakeup(struct tracer *trace,
593 struct trace_array *tr);
Steven Noonanfb1b6d82008-09-19 03:06:43 -0700594extern int trace_selftest_startup_nop(struct tracer *trace,
595 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200596extern int trace_selftest_startup_sched_switch(struct tracer *trace,
597 struct trace_array *tr);
Ingo Molnara6dd24f2008-05-12 21:20:47 +0200598extern int trace_selftest_startup_sysprof(struct tracer *trace,
599 struct trace_array *tr);
Steven Rostedt80e5ea42008-11-12 15:24:24 -0500600extern int trace_selftest_startup_branch(struct tracer *trace,
601 struct trace_array *tr);
Steven Rostedt60a11772008-05-12 21:20:44 +0200602#endif /* CONFIG_FTRACE_STARTUP_TEST */
603
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200604extern void *head_page(struct trace_array_cpu *data);
Thomas Gleixner72829bc2008-05-23 21:37:28 +0200605extern long ns2usecs(cycle_t nsec);
Frederic Weisbecker1fd8f2a2008-12-03 23:45:11 +0100606extern int
Steven Rostedt40ce74f2009-03-19 14:03:53 -0400607trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
Frederic Weisbecker48ead022009-03-12 18:24:49 +0100608extern int
Steven Rostedt40ce74f2009-03-19 14:03:53 -0400609trace_vprintk(unsigned long ip, const char *fmt, va_list args);
Ingo Molnarc7aafc52008-05-12 21:20:45 +0200610
Ingo Molnar4e655512008-05-12 21:20:52 +0200611extern unsigned long trace_flags;
612
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100613/* Standard output formatting function used for function return traces */
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100614#ifdef CONFIG_FUNCTION_GRAPH_TRACER
615extern enum print_line_t print_graph_function(struct trace_iterator *iter);
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500616
617#ifdef CONFIG_DYNAMIC_FTRACE
618/* TODO: make this variable */
619#define FTRACE_GRAPH_MAX_FUNCS 32
620extern int ftrace_graph_count;
621extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
622
623static inline int ftrace_graph_addr(unsigned long addr)
624{
625 int i;
626
627 if (!ftrace_graph_count || test_tsk_trace_graph(current))
628 return 1;
629
630 for (i = 0; i < ftrace_graph_count; i++) {
631 if (addr == ftrace_graph_funcs[i])
632 return 1;
633 }
634
635 return 0;
636}
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100637#else
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500638static inline int ftrace_trace_addr(unsigned long addr)
639{
Ingo Molnar6b253932008-12-04 09:18:28 +0100640 return 1;
641}
642static inline int ftrace_graph_addr(unsigned long addr)
643{
644 return 1;
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500645}
646#endif /* CONFIG_DYNAMIC_FTRACE */
647
648#else /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100649static inline enum print_line_t
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100650print_graph_function(struct trace_iterator *iter)
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100651{
652 return TRACE_TYPE_UNHANDLED;
653}
Steven Rostedtea4e2bc2008-12-03 15:36:57 -0500654#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100655
Steven Rostedt978f3a42008-12-04 00:26:40 -0500656extern struct pid *ftrace_pid_trace;
Steven Rostedt804a6852008-12-03 15:36:59 -0500657
658static inline int ftrace_trace_task(struct task_struct *task)
659{
Frederic Weisbecker77d683f2008-12-04 23:49:47 +0100660 if (!ftrace_pid_trace)
Steven Rostedt804a6852008-12-03 15:36:59 -0500661 return 1;
662
663 return test_tsk_trace_trace(task);
664}
665
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200666/*
667 * trace_iterator_flags is an enumeration that defines bit
668 * positions into trace_flags that controls the output.
669 *
670 * NOTE: These bits must match the trace_options array in
671 * trace.c.
672 */
Ingo Molnar4e655512008-05-12 21:20:52 +0200673enum trace_iterator_flags {
674 TRACE_ITER_PRINT_PARENT = 0x01,
675 TRACE_ITER_SYM_OFFSET = 0x02,
676 TRACE_ITER_SYM_ADDR = 0x04,
677 TRACE_ITER_VERBOSE = 0x08,
678 TRACE_ITER_RAW = 0x10,
679 TRACE_ITER_HEX = 0x20,
680 TRACE_ITER_BIN = 0x40,
681 TRACE_ITER_BLOCK = 0x80,
682 TRACE_ITER_STACKTRACE = 0x100,
Ingo Molnar4ac3ba42008-05-12 21:20:52 +0200683 TRACE_ITER_SCHED_TREE = 0x200,
Peter Zijlstraf09ce572008-09-04 10:24:14 +0200684 TRACE_ITER_PRINTK = 0x400,
Steven Rostedtb2a866f2008-11-03 23:15:57 -0500685 TRACE_ITER_PREEMPTONLY = 0x800,
Steven Rostedt9f029e82008-11-12 15:24:24 -0500686 TRACE_ITER_BRANCH = 0x1000,
Steven Rostedt12ef7d42008-11-12 17:52:38 -0500687 TRACE_ITER_ANNOTATE = 0x2000,
Török Edwinb54d3de2008-11-22 13:28:48 +0200688 TRACE_ITER_USERSTACKTRACE = 0x4000,
Frederic Weisbecker66896a82008-12-13 20:18:13 +0100689 TRACE_ITER_SYM_USEROBJ = 0x8000,
Frederic Weisbeckerc4a8e8b2009-02-02 20:29:21 -0200690 TRACE_ITER_PRINTK_MSGONLY = 0x10000,
Steven Rostedtc032ef642009-03-04 20:34:24 -0500691 TRACE_ITER_CONTEXT_INFO = 0x20000, /* Print pid/cpu/time */
692 TRACE_ITER_LATENCY_FMT = 0x40000,
Steven Rostedtaf4617b2009-03-17 18:09:55 -0400693 TRACE_ITER_GLOBAL_CLK = 0x80000,
Steven Rostedtbe6f1642009-03-24 11:06:24 -0400694 TRACE_ITER_SLEEP_TIME = 0x100000,
Ingo Molnar4e655512008-05-12 21:20:52 +0200695};
696
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100697/*
698 * TRACE_ITER_SYM_MASK masks the options in trace_flags that
699 * control the output of kernel symbols.
700 */
701#define TRACE_ITER_SYM_MASK \
702 (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
703
Frédéric Weisbecker43a15382008-09-21 20:16:30 +0200704extern struct tracer nop_trace;
705
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500706/**
707 * ftrace_preempt_disable - disable preemption scheduler safe
708 *
709 * When tracing can happen inside the scheduler, there exists
710 * cases that the tracing might happen before the need_resched
711 * flag is checked. If this happens and the tracer calls
712 * preempt_enable (after a disable), a schedule might take place
713 * causing an infinite recursion.
714 *
Wenji Huang57794a92009-02-06 17:33:27 +0800715 * To prevent this, we read the need_resched flag before
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500716 * disabling preemption. When we want to enable preemption we
717 * check the flag, if it is set, then we call preempt_enable_no_resched.
718 * Otherwise, we call preempt_enable.
719 *
Wenji Huang57794a92009-02-06 17:33:27 +0800720 * The rational for doing the above is that if need_resched is set
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500721 * and we have yet to reschedule, we are either in an atomic location
722 * (where we do not need to check for scheduling) or we are inside
723 * the scheduler and do not want to resched.
724 */
725static inline int ftrace_preempt_disable(void)
726{
727 int resched;
728
729 resched = need_resched();
730 preempt_disable_notrace();
731
732 return resched;
733}
734
735/**
736 * ftrace_preempt_enable - enable preemption scheduler safe
737 * @resched: the return value from ftrace_preempt_disable
738 *
739 * This is a scheduler safe way to enable preemption and not miss
740 * any preemption checks. The disabled saved the state of preemption.
Wenji Huang57794a92009-02-06 17:33:27 +0800741 * If resched is set, then we are either inside an atomic or
Steven Rostedt8f0a0562008-11-03 23:15:55 -0500742 * are inside the scheduler (we would have already scheduled
743 * otherwise). In this case, we do not want to call normal
744 * preempt_enable, but preempt_enable_no_resched instead.
745 */
746static inline void ftrace_preempt_enable(int resched)
747{
748 if (resched)
749 preempt_enable_no_resched_notrace();
750 else
751 preempt_enable_notrace();
752}
753
Steven Rostedt2ed84ee2008-11-12 15:24:24 -0500754#ifdef CONFIG_BRANCH_TRACER
Steven Rostedt9f029e82008-11-12 15:24:24 -0500755extern int enable_branch_tracing(struct trace_array *tr);
756extern void disable_branch_tracing(void);
757static inline int trace_branch_enable(struct trace_array *tr)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500758{
Steven Rostedt9f029e82008-11-12 15:24:24 -0500759 if (trace_flags & TRACE_ITER_BRANCH)
760 return enable_branch_tracing(tr);
Steven Rostedt52f232c2008-11-12 00:14:40 -0500761 return 0;
762}
Steven Rostedt9f029e82008-11-12 15:24:24 -0500763static inline void trace_branch_disable(void)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500764{
765 /* due to races, always disable */
Steven Rostedt9f029e82008-11-12 15:24:24 -0500766 disable_branch_tracing();
Steven Rostedt52f232c2008-11-12 00:14:40 -0500767}
768#else
Steven Rostedt9f029e82008-11-12 15:24:24 -0500769static inline int trace_branch_enable(struct trace_array *tr)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500770{
771 return 0;
772}
Steven Rostedt9f029e82008-11-12 15:24:24 -0500773static inline void trace_branch_disable(void)
Steven Rostedt52f232c2008-11-12 00:14:40 -0500774{
775}
Steven Rostedt2ed84ee2008-11-12 15:24:24 -0500776#endif /* CONFIG_BRANCH_TRACER */
Steven Rostedt52f232c2008-11-12 00:14:40 -0500777
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400778/* set ring buffers to default size if not already done so */
779int tracing_update_buffers(void);
780
Steven Rostedtfd994982009-02-28 02:41:25 -0500781/* trace event type bit fields, not numeric */
782enum {
783 TRACE_EVENT_TYPE_PRINTF = 1,
784 TRACE_EVENT_TYPE_RAW = 2,
785};
786
Tom Zanussicf027f62009-03-22 03:30:39 -0500787struct ftrace_event_field {
788 struct list_head link;
789 char *name;
790 char *type;
791 int offset;
792 int size;
793};
794
Steven Rostedtc32e8272009-02-27 19:12:30 -0500795struct ftrace_event_call {
Tom Zanussicf027f62009-03-22 03:30:39 -0500796 char *name;
797 char *system;
798 struct dentry *dir;
799 int enabled;
800 int (*regfunc)(void);
801 void (*unregfunc)(void);
802 int id;
803 int (*raw_init)(void);
804 int (*show_format)(struct trace_seq *s);
805 int (*define_fields)(void);
806 struct list_head fields;
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500807 struct filter_pred **preds;
Peter Zijlstraac199db2009-03-19 20:26:15 +0100808
809#ifdef CONFIG_EVENT_PROFILE
810 atomic_t profile_count;
811 int (*profile_enable)(struct ftrace_event_call *);
812 void (*profile_disable)(struct ftrace_event_call *);
813#endif
Steven Rostedtc32e8272009-02-27 19:12:30 -0500814};
815
Tom Zanussicfb180f2009-03-22 03:31:17 -0500816struct event_subsystem {
817 struct list_head list;
818 const char *name;
819 struct dentry *entry;
820 struct filter_pred **preds;
821};
822
823#define events_for_each(event) \
824 for (event = __start_ftrace_events; \
825 (unsigned long)event < (unsigned long)__stop_ftrace_events; \
826 event++)
827
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500828#define MAX_FILTER_PRED 8
829
830struct filter_pred;
831
832typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
833
834struct filter_pred {
835 filter_pred_fn_t fn;
836 u64 val;
837 char *str_val;
838 int str_len;
839 char *field_name;
840 int offset;
841 int not;
842 int or;
843 int compound;
844 int clear;
845};
846
Tom Zanussicf027f62009-03-22 03:30:39 -0500847int trace_define_field(struct ftrace_event_call *call, char *type,
848 char *name, int offset, int size);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500849extern void filter_free_pred(struct filter_pred *pred);
Tom Zanussi4bda2d52009-03-24 02:14:31 -0500850extern void filter_print_preds(struct filter_pred **preds,
851 struct trace_seq *s);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500852extern int filter_parse(char **pbuf, struct filter_pred *pred);
853extern int filter_add_pred(struct ftrace_event_call *call,
854 struct filter_pred *pred);
855extern void filter_free_preds(struct ftrace_event_call *call);
856extern int filter_match_preds(struct ftrace_event_call *call, void *rec);
Tom Zanussicfb180f2009-03-22 03:31:17 -0500857extern void filter_free_subsystem_preds(struct event_subsystem *system);
858extern int filter_add_subsystem_pred(struct event_subsystem *system,
859 struct filter_pred *pred);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500860
Steven Rostedtc32e8272009-02-27 19:12:30 -0500861void event_trace_printk(unsigned long ip, const char *fmt, ...);
862extern struct ftrace_event_call __start_ftrace_events[];
863extern struct ftrace_event_call __stop_ftrace_events[];
864
Peter Zijlstraac199db2009-03-19 20:26:15 +0100865#define for_each_event(event) \
866 for (event = __start_ftrace_events; \
867 (unsigned long)event < (unsigned long)__stop_ftrace_events; \
868 event++)
869
Steven Rostedte9fb2b62009-03-12 14:19:25 -0400870extern const char *__start___trace_bprintk_fmt[];
871extern const char *__stop___trace_bprintk_fmt[];
872
Steven Rostedtbdc067582009-03-13 00:12:52 -0400873/*
874 * The double __builtin_constant_p is because gcc will give us an error
875 * if we try to allocate the static variable to fmt if it is not a
876 * constant. Even with the outer if statement optimizing out.
877 */
Steven Rostedte9fb2b62009-03-12 14:19:25 -0400878#define event_trace_printk(ip, fmt, args...) \
879do { \
880 __trace_printk_check_format(fmt, ##args); \
881 tracing_record_cmdline(current); \
882 if (__builtin_constant_p(fmt)) { \
883 static const char *trace_printk_fmt \
884 __attribute__((section("__trace_printk_fmt"))) = \
885 __builtin_constant_p(fmt) ? fmt : NULL; \
886 \
887 __trace_bprintk(ip, trace_printk_fmt, ##args); \
888 } else \
889 __trace_printk(ip, fmt, ##args); \
890} while (0)
891
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200892#endif /* _LINUX_KERNEL_TRACE_H */