ftrace: mmiotrace, updates
[linux-2.6.git] / kernel / trace / trace.h
1 #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>
8 #include <linux/mmiotrace.h>
9
10 enum trace_type {
11         __TRACE_FIRST_TYPE = 0,
12
13         TRACE_FN,
14         TRACE_CTX,
15         TRACE_WAKE,
16         TRACE_STACK,
17         TRACE_SPECIAL,
18         TRACE_MMIO_RW,
19         TRACE_MMIO_MAP,
20
21         __TRACE_LAST_TYPE
22 };
23
24 /*
25  * Function trace entry - function address and parent function addres:
26  */
27 struct ftrace_entry {
28         unsigned long           ip;
29         unsigned long           parent_ip;
30 };
31
32 /*
33  * Context switch trace entry - which task (and prio) we switched from/to:
34  */
35 struct ctx_switch_entry {
36         unsigned int            prev_pid;
37         unsigned char           prev_prio;
38         unsigned char           prev_state;
39         unsigned int            next_pid;
40         unsigned char           next_prio;
41         unsigned char           next_state;
42 };
43
44 /*
45  * Special (free-form) trace entry:
46  */
47 struct special_entry {
48         unsigned long           arg1;
49         unsigned long           arg2;
50         unsigned long           arg3;
51 };
52
53 /*
54  * Stack-trace entry:
55  */
56
57 #define FTRACE_STACK_ENTRIES    8
58
59 struct stack_entry {
60         unsigned long           caller[FTRACE_STACK_ENTRIES];
61 };
62
63 /*
64  * The trace entry - the most basic unit of tracing. This is what
65  * is printed in the end as a single line in the trace output, such as:
66  *
67  *     bash-15816 [01]   235.197585: idle_cpu <- irq_enter
68  */
69 struct trace_entry {
70         char                    type;
71         char                    cpu;
72         char                    flags;
73         char                    preempt_count;
74         int                     pid;
75         cycle_t                 t;
76         union {
77                 struct ftrace_entry             fn;
78                 struct ctx_switch_entry         ctx;
79                 struct special_entry            special;
80                 struct stack_entry              stack;
81                 struct mmiotrace_rw             mmiorw;
82                 struct mmiotrace_map            mmiomap;
83         };
84 };
85
86 #define TRACE_ENTRY_SIZE        sizeof(struct trace_entry)
87
88 /*
89  * The CPU trace array - it consists of thousands of trace entries
90  * plus some other descriptor data: (for example which task started
91  * the trace, etc.)
92  */
93 struct trace_array_cpu {
94         struct list_head        trace_pages;
95         atomic_t                disabled;
96         raw_spinlock_t          lock;
97         struct lock_class_key   lock_key;
98
99         /* these fields get copied into max-trace: */
100         unsigned                trace_head_idx;
101         unsigned                trace_tail_idx;
102         void                    *trace_head; /* producer */
103         void                    *trace_tail; /* consumer */
104         unsigned long           trace_idx;
105         unsigned long           overrun;
106         unsigned long           saved_latency;
107         unsigned long           critical_start;
108         unsigned long           critical_end;
109         unsigned long           critical_sequence;
110         unsigned long           nice;
111         unsigned long           policy;
112         unsigned long           rt_priority;
113         cycle_t                 preempt_timestamp;
114         pid_t                   pid;
115         uid_t                   uid;
116         char                    comm[TASK_COMM_LEN];
117 };
118
119 struct trace_iterator;
120
121 /*
122  * The trace array - an array of per-CPU trace arrays. This is the
123  * highest level data structure that individual tracers deal with.
124  * They have on/off state as well:
125  */
126 struct trace_array {
127         unsigned long           entries;
128         long                    ctrl;
129         int                     cpu;
130         cycle_t                 time_start;
131         struct task_struct      *waiter;
132         struct trace_array_cpu  *data[NR_CPUS];
133 };
134
135 /*
136  * A specific tracer, represented by methods that operate on a trace array:
137  */
138 struct tracer {
139         const char              *name;
140         void                    (*init)(struct trace_array *tr);
141         void                    (*reset)(struct trace_array *tr);
142         void                    (*open)(struct trace_iterator *iter);
143         void                    (*pipe_open)(struct trace_iterator *iter);
144         void                    (*close)(struct trace_iterator *iter);
145         void                    (*start)(struct trace_iterator *iter);
146         void                    (*stop)(struct trace_iterator *iter);
147         ssize_t                 (*read)(struct trace_iterator *iter,
148                                         struct file *filp, char __user *ubuf,
149                                         size_t cnt, loff_t *ppos);
150         void                    (*ctrl_update)(struct trace_array *tr);
151 #ifdef CONFIG_FTRACE_STARTUP_TEST
152         int                     (*selftest)(struct tracer *trace,
153                                             struct trace_array *tr);
154 #endif
155         int                     (*print_line)(struct trace_iterator *iter);
156         struct tracer           *next;
157         int                     print_max;
158 };
159
160 struct trace_seq {
161         unsigned char           buffer[PAGE_SIZE];
162         unsigned int            len;
163         unsigned int            readpos;
164 };
165
166 /*
167  * Trace iterator - used by printout routines who present trace
168  * results to users and which routines might sleep, etc:
169  */
170 struct trace_iterator {
171         struct trace_array      *tr;
172         struct tracer           *trace;
173         void                    *private;
174         long                    last_overrun[NR_CPUS];
175         long                    overrun[NR_CPUS];
176
177         /* The below is zeroed out in pipe_read */
178         struct trace_seq        seq;
179         struct trace_entry      *ent;
180         int                     cpu;
181
182         struct trace_entry      *prev_ent;
183         int                     prev_cpu;
184
185         unsigned long           iter_flags;
186         loff_t                  pos;
187         unsigned long           next_idx[NR_CPUS];
188         struct list_head        *next_page[NR_CPUS];
189         unsigned                next_page_idx[NR_CPUS];
190         long                    idx;
191 };
192
193 void tracing_reset(struct trace_array_cpu *data);
194 int tracing_open_generic(struct inode *inode, struct file *filp);
195 struct dentry *tracing_init_dentry(void);
196 void ftrace(struct trace_array *tr,
197                             struct trace_array_cpu *data,
198                             unsigned long ip,
199                             unsigned long parent_ip,
200                             unsigned long flags);
201 void tracing_sched_switch_trace(struct trace_array *tr,
202                                 struct trace_array_cpu *data,
203                                 struct task_struct *prev,
204                                 struct task_struct *next,
205                                 unsigned long flags);
206 void tracing_record_cmdline(struct task_struct *tsk);
207
208 void tracing_sched_wakeup_trace(struct trace_array *tr,
209                                 struct trace_array_cpu *data,
210                                 struct task_struct *wakee,
211                                 struct task_struct *cur,
212                                 unsigned long flags);
213 void trace_special(struct trace_array *tr,
214                    struct trace_array_cpu *data,
215                    unsigned long arg1,
216                    unsigned long arg2,
217                    unsigned long arg3);
218 void trace_function(struct trace_array *tr,
219                     struct trace_array_cpu *data,
220                     unsigned long ip,
221                     unsigned long parent_ip,
222                     unsigned long flags);
223
224 void tracing_start_function_trace(void);
225 void tracing_stop_function_trace(void);
226 int register_tracer(struct tracer *type);
227 void unregister_tracer(struct tracer *type);
228
229 extern unsigned long nsecs_to_usecs(unsigned long nsecs);
230
231 extern unsigned long tracing_max_latency;
232 extern unsigned long tracing_thresh;
233
234 extern atomic_t trace_record_cmdline_enabled;
235
236 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
237 void update_max_tr_single(struct trace_array *tr,
238                           struct task_struct *tsk, int cpu);
239
240 extern cycle_t ftrace_now(int cpu);
241
242 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
243 typedef void
244 (*tracer_switch_func_t)(void *private,
245                         void *__rq,
246                         struct task_struct *prev,
247                         struct task_struct *next);
248
249 struct tracer_switch_ops {
250         tracer_switch_func_t            func;
251         void                            *private;
252         struct tracer_switch_ops        *next;
253 };
254
255 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
256
257 #ifdef CONFIG_DYNAMIC_FTRACE
258 extern unsigned long ftrace_update_tot_cnt;
259 #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
260 extern int DYN_FTRACE_TEST_NAME(void);
261 #endif
262
263 #ifdef CONFIG_MMIOTRACE
264 extern void __trace_mmiotrace_rw(struct trace_array *tr,
265                                 struct trace_array_cpu *data,
266                                 struct mmiotrace_rw *rw);
267 extern void __trace_mmiotrace_map(struct trace_array *tr,
268                                 struct trace_array_cpu *data,
269                                 struct mmiotrace_map *map);
270 #endif
271
272 #ifdef CONFIG_FTRACE_STARTUP_TEST
273 #ifdef CONFIG_FTRACE
274 extern int trace_selftest_startup_function(struct tracer *trace,
275                                            struct trace_array *tr);
276 #endif
277 #ifdef CONFIG_IRQSOFF_TRACER
278 extern int trace_selftest_startup_irqsoff(struct tracer *trace,
279                                           struct trace_array *tr);
280 #endif
281 #ifdef CONFIG_PREEMPT_TRACER
282 extern int trace_selftest_startup_preemptoff(struct tracer *trace,
283                                              struct trace_array *tr);
284 #endif
285 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
286 extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
287                                                  struct trace_array *tr);
288 #endif
289 #ifdef CONFIG_SCHED_TRACER
290 extern int trace_selftest_startup_wakeup(struct tracer *trace,
291                                          struct trace_array *tr);
292 #endif
293 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
294 extern int trace_selftest_startup_sched_switch(struct tracer *trace,
295                                                struct trace_array *tr);
296 #endif
297 #endif /* CONFIG_FTRACE_STARTUP_TEST */
298
299 extern void *head_page(struct trace_array_cpu *data);
300 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
301 extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
302                                  size_t cnt);
303 extern long ns2usecs(cycle_t nsec);
304
305 extern unsigned long trace_flags;
306
307 /*
308  * trace_iterator_flags is an enumeration that defines bit
309  * positions into trace_flags that controls the output.
310  *
311  * NOTE: These bits must match the trace_options array in
312  *       trace.c.
313  */
314 enum trace_iterator_flags {
315         TRACE_ITER_PRINT_PARENT         = 0x01,
316         TRACE_ITER_SYM_OFFSET           = 0x02,
317         TRACE_ITER_SYM_ADDR             = 0x04,
318         TRACE_ITER_VERBOSE              = 0x08,
319         TRACE_ITER_RAW                  = 0x10,
320         TRACE_ITER_HEX                  = 0x20,
321         TRACE_ITER_BIN                  = 0x40,
322         TRACE_ITER_BLOCK                = 0x80,
323         TRACE_ITER_STACKTRACE           = 0x100,
324         TRACE_ITER_SCHED_TREE           = 0x200,
325 };
326
327 #endif /* _LINUX_KERNEL_TRACE_H */