ftrace: fix comm on function trace output
[linux-2.6.git] / kernel / trace / trace_sched_switch.c
1 /*
2  * trace context switch
3  *
4  * Copyright (C) 2007 Steven Rostedt <srostedt@redhat.com>
5  *
6  */
7 #include <linux/module.h>
8 #include <linux/fs.h>
9 #include <linux/debugfs.h>
10 #include <linux/kallsyms.h>
11 #include <linux/uaccess.h>
12 #include <linux/marker.h>
13 #include <linux/ftrace.h>
14
15 #include "trace.h"
16
17 static struct trace_array       *ctx_trace;
18 static int __read_mostly        tracer_enabled;
19
20 static void
21 ctx_switch_func(void *__rq, struct task_struct *prev, struct task_struct *next)
22 {
23         struct trace_array *tr = ctx_trace;
24         struct trace_array_cpu *data;
25         unsigned long flags;
26         long disabled;
27         int cpu;
28
29         if (!tracer_enabled)
30                 return;
31
32         local_irq_save(flags);
33         cpu = raw_smp_processor_id();
34         data = tr->data[cpu];
35         disabled = atomic_inc_return(&data->disabled);
36
37         if (likely(disabled == 1))
38                 tracing_sched_switch_trace(tr, data, prev, next, flags);
39
40         atomic_dec(&data->disabled);
41         local_irq_restore(flags);
42 }
43
44 static void
45 wakeup_func(void *__rq, struct task_struct *wakee, struct task_struct *curr)
46 {
47         struct trace_array *tr = ctx_trace;
48         struct trace_array_cpu *data;
49         unsigned long flags;
50         long disabled;
51         int cpu;
52
53         if (!tracer_enabled)
54                 return;
55
56         tracing_record_cmdline(curr);
57
58         local_irq_save(flags);
59         cpu = raw_smp_processor_id();
60         data = tr->data[cpu];
61         disabled = atomic_inc_return(&data->disabled);
62
63         if (likely(disabled == 1))
64                 tracing_sched_wakeup_trace(tr, data, wakee, curr, flags);
65
66         atomic_dec(&data->disabled);
67         local_irq_restore(flags);
68 }
69
70 void
71 ftrace_ctx_switch(void *__rq, struct task_struct *prev,
72                   struct task_struct *next)
73 {
74         if (unlikely(atomic_read(&trace_record_cmdline_enabled)))
75                 tracing_record_cmdline(prev);
76
77         /*
78          * If tracer_switch_func only points to the local
79          * switch func, it still needs the ptr passed to it.
80          */
81         ctx_switch_func(__rq, prev, next);
82
83         /*
84          * Chain to the wakeup tracer (this is a NOP if disabled):
85          */
86         wakeup_sched_switch(prev, next);
87 }
88
89 void
90 ftrace_wake_up_task(void *__rq, struct task_struct *wakee,
91                     struct task_struct *curr)
92 {
93         wakeup_func(__rq, wakee, curr);
94
95         /*
96          * Chain to the wakeup tracer (this is a NOP if disabled):
97          */
98         wakeup_sched_wakeup(wakee, curr);
99 }
100
101 void
102 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
103 {
104         struct trace_array *tr = ctx_trace;
105         struct trace_array_cpu *data;
106         unsigned long flags;
107         long disabled;
108         int cpu;
109
110         if (!tracer_enabled)
111                 return;
112
113         local_irq_save(flags);
114         cpu = raw_smp_processor_id();
115         data = tr->data[cpu];
116         disabled = atomic_inc_return(&data->disabled);
117
118         if (likely(disabled == 1))
119                 __trace_special(tr, data, arg1, arg2, arg3);
120
121         atomic_dec(&data->disabled);
122         local_irq_restore(flags);
123 }
124
125 static void sched_switch_reset(struct trace_array *tr)
126 {
127         int cpu;
128
129         tr->time_start = ftrace_now(tr->cpu);
130
131         for_each_online_cpu(cpu)
132                 tracing_reset(tr->data[cpu]);
133 }
134
135 static void start_sched_trace(struct trace_array *tr)
136 {
137         sched_switch_reset(tr);
138         atomic_inc(&trace_record_cmdline_enabled);
139         tracer_enabled = 1;
140 }
141
142 static void stop_sched_trace(struct trace_array *tr)
143 {
144         atomic_dec(&trace_record_cmdline_enabled);
145         tracer_enabled = 0;
146 }
147
148 static void sched_switch_trace_init(struct trace_array *tr)
149 {
150         ctx_trace = tr;
151
152         if (tr->ctrl)
153                 start_sched_trace(tr);
154 }
155
156 static void sched_switch_trace_reset(struct trace_array *tr)
157 {
158         if (tr->ctrl)
159                 stop_sched_trace(tr);
160 }
161
162 static void sched_switch_trace_ctrl_update(struct trace_array *tr)
163 {
164         /* When starting a new trace, reset the buffers */
165         if (tr->ctrl)
166                 start_sched_trace(tr);
167         else
168                 stop_sched_trace(tr);
169 }
170
171 static struct tracer sched_switch_trace __read_mostly =
172 {
173         .name           = "sched_switch",
174         .init           = sched_switch_trace_init,
175         .reset          = sched_switch_trace_reset,
176         .ctrl_update    = sched_switch_trace_ctrl_update,
177 #ifdef CONFIG_FTRACE_SELFTEST
178         .selftest    = trace_selftest_startup_sched_switch,
179 #endif
180 };
181
182 __init static int init_sched_switch_trace(void)
183 {
184         return register_tracer(&sched_switch_trace);
185 }
186 device_initcall(init_sched_switch_trace);