tracing/events: Move TRACE_SYSTEM outside of include guard
[linux-2.6.git] / include / trace / events / sched.h
1 #undef TRACE_SYSTEM
2 #define TRACE_SYSTEM sched
3
4 #if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_SCHED_H
6
7 #include <linux/sched.h>
8 #include <linux/tracepoint.h>
9
10 /*
11  * Tracepoint for calling kthread_stop, performed to end a kthread:
12  */
13 TRACE_EVENT(sched_kthread_stop,
14
15         TP_PROTO(struct task_struct *t),
16
17         TP_ARGS(t),
18
19         TP_STRUCT__entry(
20                 __array(        char,   comm,   TASK_COMM_LEN   )
21                 __field(        pid_t,  pid                     )
22         ),
23
24         TP_fast_assign(
25                 memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
26                 __entry->pid    = t->pid;
27         ),
28
29         TP_printk("task %s:%d", __entry->comm, __entry->pid)
30 );
31
32 /*
33  * Tracepoint for the return value of the kthread stopping:
34  */
35 TRACE_EVENT(sched_kthread_stop_ret,
36
37         TP_PROTO(int ret),
38
39         TP_ARGS(ret),
40
41         TP_STRUCT__entry(
42                 __field(        int,    ret     )
43         ),
44
45         TP_fast_assign(
46                 __entry->ret    = ret;
47         ),
48
49         TP_printk("ret %d", __entry->ret)
50 );
51
52 /*
53  * Tracepoint for waiting on task to unschedule:
54  *
55  * (NOTE: the 'rq' argument is not used by generic trace events,
56  *        but used by the latency tracer plugin. )
57  */
58 TRACE_EVENT(sched_wait_task,
59
60         TP_PROTO(struct rq *rq, struct task_struct *p),
61
62         TP_ARGS(rq, p),
63
64         TP_STRUCT__entry(
65                 __array(        char,   comm,   TASK_COMM_LEN   )
66                 __field(        pid_t,  pid                     )
67                 __field(        int,    prio                    )
68         ),
69
70         TP_fast_assign(
71                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
72                 __entry->pid    = p->pid;
73                 __entry->prio   = p->prio;
74         ),
75
76         TP_printk("task %s:%d [%d]",
77                   __entry->comm, __entry->pid, __entry->prio)
78 );
79
80 /*
81  * Tracepoint for waking up a task:
82  *
83  * (NOTE: the 'rq' argument is not used by generic trace events,
84  *        but used by the latency tracer plugin. )
85  */
86 TRACE_EVENT(sched_wakeup,
87
88         TP_PROTO(struct rq *rq, struct task_struct *p, int success),
89
90         TP_ARGS(rq, p, success),
91
92         TP_STRUCT__entry(
93                 __array(        char,   comm,   TASK_COMM_LEN   )
94                 __field(        pid_t,  pid                     )
95                 __field(        int,    prio                    )
96                 __field(        int,    success                 )
97         ),
98
99         TP_fast_assign(
100                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
101                 __entry->pid            = p->pid;
102                 __entry->prio           = p->prio;
103                 __entry->success        = success;
104         ),
105
106         TP_printk("task %s:%d [%d] success=%d",
107                   __entry->comm, __entry->pid, __entry->prio,
108                   __entry->success)
109 );
110
111 /*
112  * Tracepoint for waking up a new task:
113  *
114  * (NOTE: the 'rq' argument is not used by generic trace events,
115  *        but used by the latency tracer plugin. )
116  */
117 TRACE_EVENT(sched_wakeup_new,
118
119         TP_PROTO(struct rq *rq, struct task_struct *p, int success),
120
121         TP_ARGS(rq, p, success),
122
123         TP_STRUCT__entry(
124                 __array(        char,   comm,   TASK_COMM_LEN   )
125                 __field(        pid_t,  pid                     )
126                 __field(        int,    prio                    )
127                 __field(        int,    success                 )
128         ),
129
130         TP_fast_assign(
131                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
132                 __entry->pid            = p->pid;
133                 __entry->prio           = p->prio;
134                 __entry->success        = success;
135         ),
136
137         TP_printk("task %s:%d [%d] success=%d",
138                   __entry->comm, __entry->pid, __entry->prio,
139                   __entry->success)
140 );
141
142 /*
143  * Tracepoint for task switches, performed by the scheduler:
144  *
145  * (NOTE: the 'rq' argument is not used by generic trace events,
146  *        but used by the latency tracer plugin. )
147  */
148 TRACE_EVENT(sched_switch,
149
150         TP_PROTO(struct rq *rq, struct task_struct *prev,
151                  struct task_struct *next),
152
153         TP_ARGS(rq, prev, next),
154
155         TP_STRUCT__entry(
156                 __array(        char,   prev_comm,      TASK_COMM_LEN   )
157                 __field(        pid_t,  prev_pid                        )
158                 __field(        int,    prev_prio                       )
159                 __field(        long,   prev_state                      )
160                 __array(        char,   next_comm,      TASK_COMM_LEN   )
161                 __field(        pid_t,  next_pid                        )
162                 __field(        int,    next_prio                       )
163         ),
164
165         TP_fast_assign(
166                 memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
167                 __entry->prev_pid       = prev->pid;
168                 __entry->prev_prio      = prev->prio;
169                 __entry->prev_state     = prev->state;
170                 memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
171                 __entry->next_pid       = next->pid;
172                 __entry->next_prio      = next->prio;
173         ),
174
175         TP_printk("task %s:%d [%d] (%s) ==> %s:%d [%d]",
176                 __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
177                 __entry->prev_state ?
178                   __print_flags(__entry->prev_state, "|",
179                                 { 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
180                                 { 16, "Z" }, { 32, "X" }, { 64, "x" },
181                                 { 128, "W" }) : "R",
182                 __entry->next_comm, __entry->next_pid, __entry->next_prio)
183 );
184
185 /*
186  * Tracepoint for a task being migrated:
187  */
188 TRACE_EVENT(sched_migrate_task,
189
190         TP_PROTO(struct task_struct *p, int dest_cpu),
191
192         TP_ARGS(p, dest_cpu),
193
194         TP_STRUCT__entry(
195                 __array(        char,   comm,   TASK_COMM_LEN   )
196                 __field(        pid_t,  pid                     )
197                 __field(        int,    prio                    )
198                 __field(        int,    orig_cpu                )
199                 __field(        int,    dest_cpu                )
200         ),
201
202         TP_fast_assign(
203                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
204                 __entry->pid            = p->pid;
205                 __entry->prio           = p->prio;
206                 __entry->orig_cpu       = task_cpu(p);
207                 __entry->dest_cpu       = dest_cpu;
208         ),
209
210         TP_printk("task %s:%d [%d] from: %d  to: %d",
211                   __entry->comm, __entry->pid, __entry->prio,
212                   __entry->orig_cpu, __entry->dest_cpu)
213 );
214
215 /*
216  * Tracepoint for freeing a task:
217  */
218 TRACE_EVENT(sched_process_free,
219
220         TP_PROTO(struct task_struct *p),
221
222         TP_ARGS(p),
223
224         TP_STRUCT__entry(
225                 __array(        char,   comm,   TASK_COMM_LEN   )
226                 __field(        pid_t,  pid                     )
227                 __field(        int,    prio                    )
228         ),
229
230         TP_fast_assign(
231                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
232                 __entry->pid            = p->pid;
233                 __entry->prio           = p->prio;
234         ),
235
236         TP_printk("task %s:%d [%d]",
237                   __entry->comm, __entry->pid, __entry->prio)
238 );
239
240 /*
241  * Tracepoint for a task exiting:
242  */
243 TRACE_EVENT(sched_process_exit,
244
245         TP_PROTO(struct task_struct *p),
246
247         TP_ARGS(p),
248
249         TP_STRUCT__entry(
250                 __array(        char,   comm,   TASK_COMM_LEN   )
251                 __field(        pid_t,  pid                     )
252                 __field(        int,    prio                    )
253         ),
254
255         TP_fast_assign(
256                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
257                 __entry->pid            = p->pid;
258                 __entry->prio           = p->prio;
259         ),
260
261         TP_printk("task %s:%d [%d]",
262                   __entry->comm, __entry->pid, __entry->prio)
263 );
264
265 /*
266  * Tracepoint for a waiting task:
267  */
268 TRACE_EVENT(sched_process_wait,
269
270         TP_PROTO(struct pid *pid),
271
272         TP_ARGS(pid),
273
274         TP_STRUCT__entry(
275                 __array(        char,   comm,   TASK_COMM_LEN   )
276                 __field(        pid_t,  pid                     )
277                 __field(        int,    prio                    )
278         ),
279
280         TP_fast_assign(
281                 memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
282                 __entry->pid            = pid_nr(pid);
283                 __entry->prio           = current->prio;
284         ),
285
286         TP_printk("task %s:%d [%d]",
287                   __entry->comm, __entry->pid, __entry->prio)
288 );
289
290 /*
291  * Tracepoint for do_fork:
292  */
293 TRACE_EVENT(sched_process_fork,
294
295         TP_PROTO(struct task_struct *parent, struct task_struct *child),
296
297         TP_ARGS(parent, child),
298
299         TP_STRUCT__entry(
300                 __array(        char,   parent_comm,    TASK_COMM_LEN   )
301                 __field(        pid_t,  parent_pid                      )
302                 __array(        char,   child_comm,     TASK_COMM_LEN   )
303                 __field(        pid_t,  child_pid                       )
304         ),
305
306         TP_fast_assign(
307                 memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
308                 __entry->parent_pid     = parent->pid;
309                 memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
310                 __entry->child_pid      = child->pid;
311         ),
312
313         TP_printk("parent %s:%d  child %s:%d",
314                 __entry->parent_comm, __entry->parent_pid,
315                 __entry->child_comm, __entry->child_pid)
316 );
317
318 /*
319  * Tracepoint for sending a signal:
320  */
321 TRACE_EVENT(sched_signal_send,
322
323         TP_PROTO(int sig, struct task_struct *p),
324
325         TP_ARGS(sig, p),
326
327         TP_STRUCT__entry(
328                 __field(        int,    sig                     )
329                 __array(        char,   comm,   TASK_COMM_LEN   )
330                 __field(        pid_t,  pid                     )
331         ),
332
333         TP_fast_assign(
334                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
335                 __entry->pid    = p->pid;
336                 __entry->sig    = sig;
337         ),
338
339         TP_printk("sig: %d  task %s:%d",
340                   __entry->sig, __entry->comm, __entry->pid)
341 );
342
343 #endif /* _TRACE_SCHED_H */
344
345 /* This part must be outside protection */
346 #include <trace/define_trace.h>