oprofile: fixing whitespaces in drivers/oprofile/*
[linux-2.6.git] / drivers / oprofile / cpu_buffer.c
1 /**
2  * @file cpu_buffer.c
3  *
4  * @remark Copyright 2002 OProfile authors
5  * @remark Read the file COPYING
6  *
7  * @author John Levon <levon@movementarian.org>
8  * @author Barry Kasindorf <barry.kasindorf@amd.com>
9  *
10  * Each CPU has a local buffer that stores PC value/event
11  * pairs. We also log context switches when we notice them.
12  * Eventually each CPU's buffer is processed into the global
13  * event buffer by sync_buffer().
14  *
15  * We use a local buffer for two reasons: an NMI or similar
16  * interrupt cannot synchronise, and high sampling rates
17  * would lead to catastrophic global synchronisation if
18  * a global buffer was used.
19  */
20
21 #include <linux/sched.h>
22 #include <linux/oprofile.h>
23 #include <linux/vmalloc.h>
24 #include <linux/errno.h>
25
26 #include "event_buffer.h"
27 #include "cpu_buffer.h"
28 #include "buffer_sync.h"
29 #include "oprof.h"
30
31 DEFINE_PER_CPU(struct oprofile_cpu_buffer, cpu_buffer);
32
33 static void wq_sync_buffer(struct work_struct *work);
34
35 #define DEFAULT_TIMER_EXPIRE (HZ / 10)
36 static int work_enabled;
37
38 void free_cpu_buffers(void)
39 {
40         int i;
41
42         for_each_online_cpu(i) {
43                 vfree(per_cpu(cpu_buffer, i).buffer);
44                 per_cpu(cpu_buffer, i).buffer = NULL;
45         }
46 }
47
48 int alloc_cpu_buffers(void)
49 {
50         int i;
51
52         unsigned long buffer_size = fs_cpu_buffer_size;
53
54         for_each_online_cpu(i) {
55                 struct oprofile_cpu_buffer *b = &per_cpu(cpu_buffer, i);
56
57                 b->buffer = vmalloc_node(sizeof(struct op_sample) * buffer_size,
58                         cpu_to_node(i));
59                 if (!b->buffer)
60                         goto fail;
61
62                 b->last_task = NULL;
63                 b->last_is_kernel = -1;
64                 b->tracing = 0;
65                 b->buffer_size = buffer_size;
66                 b->tail_pos = 0;
67                 b->head_pos = 0;
68                 b->sample_received = 0;
69                 b->sample_lost_overflow = 0;
70                 b->backtrace_aborted = 0;
71                 b->sample_invalid_eip = 0;
72                 b->cpu = i;
73                 INIT_DELAYED_WORK(&b->work, wq_sync_buffer);
74         }
75         return 0;
76
77 fail:
78         free_cpu_buffers();
79         return -ENOMEM;
80 }
81
82 void start_cpu_work(void)
83 {
84         int i;
85
86         work_enabled = 1;
87
88         for_each_online_cpu(i) {
89                 struct oprofile_cpu_buffer *b = &per_cpu(cpu_buffer, i);
90
91                 /*
92                  * Spread the work by 1 jiffy per cpu so they dont all
93                  * fire at once.
94                  */
95                 schedule_delayed_work_on(i, &b->work, DEFAULT_TIMER_EXPIRE + i);
96         }
97 }
98
99 void end_cpu_work(void)
100 {
101         int i;
102
103         work_enabled = 0;
104
105         for_each_online_cpu(i) {
106                 struct oprofile_cpu_buffer *b = &per_cpu(cpu_buffer, i);
107
108                 cancel_delayed_work(&b->work);
109         }
110
111         flush_scheduled_work();
112 }
113
114 /* Resets the cpu buffer to a sane state. */
115 void cpu_buffer_reset(struct oprofile_cpu_buffer *cpu_buf)
116 {
117         /* reset these to invalid values; the next sample
118          * collected will populate the buffer with proper
119          * values to initialize the buffer
120          */
121         cpu_buf->last_is_kernel = -1;
122         cpu_buf->last_task = NULL;
123 }
124
125 /* compute number of available slots in cpu_buffer queue */
126 static unsigned long nr_available_slots(struct oprofile_cpu_buffer const *b)
127 {
128         unsigned long head = b->head_pos;
129         unsigned long tail = b->tail_pos;
130
131         if (tail > head)
132                 return (tail - head) - 1;
133
134         return tail + (b->buffer_size - head) - 1;
135 }
136
137 static void increment_head(struct oprofile_cpu_buffer *b)
138 {
139         unsigned long new_head = b->head_pos + 1;
140
141         /* Ensure anything written to the slot before we
142          * increment is visible */
143         wmb();
144
145         if (new_head < b->buffer_size)
146                 b->head_pos = new_head;
147         else
148                 b->head_pos = 0;
149 }
150
151 static inline void
152 add_sample(struct oprofile_cpu_buffer *cpu_buf,
153            unsigned long pc, unsigned long event)
154 {
155         struct op_sample *entry = &cpu_buf->buffer[cpu_buf->head_pos];
156         entry->eip = pc;
157         entry->event = event;
158         increment_head(cpu_buf);
159 }
160
161 static inline void
162 add_code(struct oprofile_cpu_buffer *buffer, unsigned long value)
163 {
164         add_sample(buffer, ESCAPE_CODE, value);
165 }
166
167 /* This must be safe from any context. It's safe writing here
168  * because of the head/tail separation of the writer and reader
169  * of the CPU buffer.
170  *
171  * is_kernel is needed because on some architectures you cannot
172  * tell if you are in kernel or user space simply by looking at
173  * pc. We tag this in the buffer by generating kernel enter/exit
174  * events whenever is_kernel changes
175  */
176 static int log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
177                       int is_kernel, unsigned long event)
178 {
179         struct task_struct *task;
180
181         cpu_buf->sample_received++;
182
183         if (pc == ESCAPE_CODE) {
184                 cpu_buf->sample_invalid_eip++;
185                 return 0;
186         }
187
188         if (nr_available_slots(cpu_buf) < 3) {
189                 cpu_buf->sample_lost_overflow++;
190                 return 0;
191         }
192
193         is_kernel = !!is_kernel;
194
195         task = current;
196
197         /* notice a switch from user->kernel or vice versa */
198         if (cpu_buf->last_is_kernel != is_kernel) {
199                 cpu_buf->last_is_kernel = is_kernel;
200                 add_code(cpu_buf, is_kernel);
201         }
202
203         /* notice a task switch */
204         if (cpu_buf->last_task != task) {
205                 cpu_buf->last_task = task;
206                 add_code(cpu_buf, (unsigned long)task);
207         }
208
209         add_sample(cpu_buf, pc, event);
210         return 1;
211 }
212
213 static int oprofile_begin_trace(struct oprofile_cpu_buffer *cpu_buf)
214 {
215         if (nr_available_slots(cpu_buf) < 4) {
216                 cpu_buf->sample_lost_overflow++;
217                 return 0;
218         }
219
220         add_code(cpu_buf, CPU_TRACE_BEGIN);
221         cpu_buf->tracing = 1;
222         return 1;
223 }
224
225 static void oprofile_end_trace(struct oprofile_cpu_buffer *cpu_buf)
226 {
227         cpu_buf->tracing = 0;
228 }
229
230 void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
231                                 unsigned long event, int is_kernel)
232 {
233         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
234
235         if (!backtrace_depth) {
236                 log_sample(cpu_buf, pc, is_kernel, event);
237                 return;
238         }
239
240         if (!oprofile_begin_trace(cpu_buf))
241                 return;
242
243         /* if log_sample() fail we can't backtrace since we lost the source
244          * of this event */
245         if (log_sample(cpu_buf, pc, is_kernel, event))
246                 oprofile_ops.backtrace(regs, backtrace_depth);
247         oprofile_end_trace(cpu_buf);
248 }
249
250 void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
251 {
252         int is_kernel = !user_mode(regs);
253         unsigned long pc = profile_pc(regs);
254
255         oprofile_add_ext_sample(pc, regs, event, is_kernel);
256 }
257
258 #ifdef CONFIG_OPROFILE_IBS
259
260 #define MAX_IBS_SAMPLE_SIZE 14
261
262 void oprofile_add_ibs_sample(struct pt_regs *const regs,
263                              unsigned int *const ibs_sample, int ibs_code)
264 {
265         int is_kernel = !user_mode(regs);
266         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
267         struct task_struct *task;
268
269         cpu_buf->sample_received++;
270
271         if (nr_available_slots(cpu_buf) < MAX_IBS_SAMPLE_SIZE) {
272                 /* we can't backtrace since we lost the source of this event */
273                 cpu_buf->sample_lost_overflow++;
274                 return;
275         }
276
277         /* notice a switch from user->kernel or vice versa */
278         if (cpu_buf->last_is_kernel != is_kernel) {
279                 cpu_buf->last_is_kernel = is_kernel;
280                 add_code(cpu_buf, is_kernel);
281         }
282
283         /* notice a task switch */
284         if (!is_kernel) {
285                 task = current;
286                 if (cpu_buf->last_task != task) {
287                         cpu_buf->last_task = task;
288                         add_code(cpu_buf, (unsigned long)task);
289                 }
290         }
291
292         add_code(cpu_buf, ibs_code);
293         add_sample(cpu_buf, ibs_sample[0], ibs_sample[1]);
294         add_sample(cpu_buf, ibs_sample[2], ibs_sample[3]);
295         add_sample(cpu_buf, ibs_sample[4], ibs_sample[5]);
296
297         if (ibs_code == IBS_OP_BEGIN) {
298                 add_sample(cpu_buf, ibs_sample[6], ibs_sample[7]);
299                 add_sample(cpu_buf, ibs_sample[8], ibs_sample[9]);
300                 add_sample(cpu_buf, ibs_sample[10], ibs_sample[11]);
301         }
302
303         if (backtrace_depth)
304                 oprofile_ops.backtrace(regs, backtrace_depth);
305 }
306
307 #endif
308
309 void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
310 {
311         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
312         log_sample(cpu_buf, pc, is_kernel, event);
313 }
314
315 void oprofile_add_trace(unsigned long pc)
316 {
317         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
318
319         if (!cpu_buf->tracing)
320                 return;
321
322         if (nr_available_slots(cpu_buf) < 1) {
323                 cpu_buf->tracing = 0;
324                 cpu_buf->sample_lost_overflow++;
325                 return;
326         }
327
328         /* broken frame can give an eip with the same value as an escape code,
329          * abort the trace if we get it */
330         if (pc == ESCAPE_CODE) {
331                 cpu_buf->tracing = 0;
332                 cpu_buf->backtrace_aborted++;
333                 return;
334         }
335
336         add_sample(cpu_buf, pc, 0);
337 }
338
339 /*
340  * This serves to avoid cpu buffer overflow, and makes sure
341  * the task mortuary progresses
342  *
343  * By using schedule_delayed_work_on and then schedule_delayed_work
344  * we guarantee this will stay on the correct cpu
345  */
346 static void wq_sync_buffer(struct work_struct *work)
347 {
348         struct oprofile_cpu_buffer *b =
349                 container_of(work, struct oprofile_cpu_buffer, work.work);
350         if (b->cpu != smp_processor_id()) {
351                 printk(KERN_DEBUG "WQ on CPU%d, prefer CPU%d\n",
352                        smp_processor_id(), b->cpu);
353         }
354         sync_buffer(b->cpu);
355
356         /* don't re-add the work if we're shutting down */
357         if (work_enabled)
358                 schedule_delayed_work(&b->work, DEFAULT_TIMER_EXPIRE);
359 }