ftrace: fix boot trace sched startup
[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/ftrace.h>
13 #include <trace/sched.h>
14
15 #include "trace.h"
16
17 static struct trace_array       *ctx_trace;
18 static int __read_mostly        tracer_enabled;
19 static int                      sched_ref;
20 static DEFINE_MUTEX(sched_register_mutex);
21
22 static void
23 probe_sched_switch(struct rq *__rq, struct task_struct *prev,
24                         struct task_struct *next)
25 {
26         struct trace_array_cpu *data;
27         unsigned long flags;
28         int cpu;
29         int pc;
30
31         if (!sched_ref)
32                 return;
33
34         tracing_record_cmdline(prev);
35         tracing_record_cmdline(next);
36
37         if (!tracer_enabled)
38                 return;
39
40         pc = preempt_count();
41         local_irq_save(flags);
42         cpu = raw_smp_processor_id();
43         data = ctx_trace->data[cpu];
44
45         if (likely(!atomic_read(&data->disabled)))
46                 tracing_sched_switch_trace(ctx_trace, data, prev, next, flags, pc);
47
48         local_irq_restore(flags);
49 }
50
51 static void
52 probe_sched_wakeup(struct rq *__rq, struct task_struct *wakee)
53 {
54         struct trace_array_cpu *data;
55         unsigned long flags;
56         int cpu, pc;
57
58         if (!likely(tracer_enabled))
59                 return;
60
61         pc = preempt_count();
62         tracing_record_cmdline(current);
63
64         local_irq_save(flags);
65         cpu = raw_smp_processor_id();
66         data = ctx_trace->data[cpu];
67
68         if (likely(!atomic_read(&data->disabled)))
69                 tracing_sched_wakeup_trace(ctx_trace, data, wakee, current,
70                                            flags, pc);
71
72         local_irq_restore(flags);
73 }
74
75 static void sched_switch_reset(struct trace_array *tr)
76 {
77         int cpu;
78
79         tr->time_start = ftrace_now(tr->cpu);
80
81         for_each_online_cpu(cpu)
82                 tracing_reset(tr, cpu);
83 }
84
85 static int tracing_sched_register(void)
86 {
87         int ret;
88
89         ret = register_trace_sched_wakeup(probe_sched_wakeup);
90         if (ret) {
91                 pr_info("wakeup trace: Couldn't activate tracepoint"
92                         " probe to kernel_sched_wakeup\n");
93                 return ret;
94         }
95
96         ret = register_trace_sched_wakeup_new(probe_sched_wakeup);
97         if (ret) {
98                 pr_info("wakeup trace: Couldn't activate tracepoint"
99                         " probe to kernel_sched_wakeup_new\n");
100                 goto fail_deprobe;
101         }
102
103         ret = register_trace_sched_switch(probe_sched_switch);
104         if (ret) {
105                 pr_info("sched trace: Couldn't activate tracepoint"
106                         " probe to kernel_sched_schedule\n");
107                 goto fail_deprobe_wake_new;
108         }
109
110         return ret;
111 fail_deprobe_wake_new:
112         unregister_trace_sched_wakeup_new(probe_sched_wakeup);
113 fail_deprobe:
114         unregister_trace_sched_wakeup(probe_sched_wakeup);
115         return ret;
116 }
117
118 static void tracing_sched_unregister(void)
119 {
120         unregister_trace_sched_switch(probe_sched_switch);
121         unregister_trace_sched_wakeup_new(probe_sched_wakeup);
122         unregister_trace_sched_wakeup(probe_sched_wakeup);
123 }
124
125 static void tracing_start_sched_switch(void)
126 {
127         mutex_lock(&sched_register_mutex);
128         if (!(sched_ref++)) {
129                 tracer_enabled = 1;
130                 tracing_sched_register();
131         }
132         mutex_unlock(&sched_register_mutex);
133 }
134
135 static void tracing_stop_sched_switch(void)
136 {
137         mutex_lock(&sched_register_mutex);
138         if (!(--sched_ref)) {
139                 tracing_sched_unregister();
140                 tracer_enabled = 0;
141         }
142         mutex_unlock(&sched_register_mutex);
143 }
144
145 void tracing_start_cmdline_record(void)
146 {
147         tracing_start_sched_switch();
148 }
149
150 void tracing_stop_cmdline_record(void)
151 {
152         tracing_stop_sched_switch();
153 }
154
155 /**
156  * tracing_cmdline_assign_trace - assign a trace array for ctx switch
157  * @tr: trace array pointer to assign
158  *
159  * Some tracers might want to record the context switches in their
160  * trace. This function lets those tracers assign the trace array
161  * to use.
162  */
163 void tracing_cmdline_assign_trace(struct trace_array *tr)
164 {
165         ctx_trace = tr;
166 }
167
168 static void start_sched_trace(struct trace_array *tr)
169 {
170         sched_switch_reset(tr);
171         tracing_start_cmdline_record();
172 }
173
174 static void stop_sched_trace(struct trace_array *tr)
175 {
176         tracing_stop_cmdline_record();
177 }
178
179 static void sched_switch_trace_init(struct trace_array *tr)
180 {
181         ctx_trace = tr;
182
183         if (tr->ctrl)
184                 start_sched_trace(tr);
185 }
186
187 static void sched_switch_trace_reset(struct trace_array *tr)
188 {
189         if (tr->ctrl && sched_ref)
190                 stop_sched_trace(tr);
191 }
192
193 static void sched_switch_trace_ctrl_update(struct trace_array *tr)
194 {
195         /* When starting a new trace, reset the buffers */
196         if (tr->ctrl)
197                 start_sched_trace(tr);
198         else
199                 stop_sched_trace(tr);
200 }
201
202 static void sched_switch_trace_start(struct trace_array *tr)
203 {
204         sched_switch_reset(tr);
205         tracing_start_sched_switch();
206 }
207
208 static void sched_switch_trace_stop(struct trace_array *tr)
209 {
210         tracing_stop_sched_switch();
211 }
212
213 static struct tracer sched_switch_trace __read_mostly =
214 {
215         .name           = "sched_switch",
216         .init           = sched_switch_trace_init,
217         .reset          = sched_switch_trace_reset,
218         .start          = sched_switch_trace_start,
219         .stop           = sched_switch_trace_stop,
220         .ctrl_update    = sched_switch_trace_ctrl_update,
221 #ifdef CONFIG_FTRACE_SELFTEST
222         .selftest    = trace_selftest_startup_sched_switch,
223 #endif
224 };
225
226 __init static int init_sched_switch_trace(void)
227 {
228         return register_tracer(&sched_switch_trace);
229 }
230 device_initcall(init_sched_switch_trace);