projects/linux·blob cefcb602 · refs

376 lines · 7.7 KiB

1/*
2 * Copyright (C) 2008 Steven Rostedt <[email protected]>
3 *
4 */
5#include <linux/stacktrace.h>
6#include <linux/kallsyms.h>
7#include <linux/seq_file.h>
8#include <linux/spinlock.h>
9#include <linux/uaccess.h>
10#include <linux/debugfs.h>
11#include <linux/ftrace.h>
12#include <linux/module.h>
13#include <linux/sysctl.h>
14#include <linux/init.h>
15#include <linux/fs.h>
16#include "trace.h"
17
18#define STACK_TRACE_ENTRIES 500
19
20static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
21 { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
22static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
23
24static struct stack_trace max_stack_trace = {
25 .max_entries = STACK_TRACE_ENTRIES,
26 .entries = stack_dump_trace,
27};
28
29static unsigned long max_stack_size;
30static arch_spinlock_t max_stack_lock =
31 (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
32
33static int stack_trace_disabled __read_mostly;
34static DEFINE_PER_CPU(int, trace_active);
35static DEFINE_MUTEX(stack_sysctl_mutex);
36
37int stack_tracer_enabled;
38static int last_stack_tracer_enabled;
39
40static inline void check_stack(void)
41{
42 unsigned long this_size, flags;
43 unsigned long *p, *top, *start;
44 int i;
45
46 this_size = ((unsigned long)&this_size) & (THREAD_SIZE-1);
47 this_size = THREAD_SIZE - this_size;
48
49 if (this_size <= max_stack_size)
50 return;
51
52 /* we do not handle interrupt stacks yet */
53 if (!object_is_on_stack(&this_size))
54 return;
55
56 local_irq_save(flags);
57 arch_spin_lock(&max_stack_lock);
58
59 /* a race could have already updated it */
60 if (this_size <= max_stack_size)
61 goto out;
62
63 max_stack_size = this_size;
64
65 max_stack_trace.nr_entries = 0;
66 max_stack_trace.skip = 3;
67
68 save_stack_trace(&max_stack_trace);
69
70 /*
71 * Now find where in the stack these are.
72 */
73 i = 0;
74 start = &this_size;
75 top = (unsigned long *)
76 (((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
77
78 /*
79 * Loop through all the entries. One of the entries may
80 * for some reason be missed on the stack, so we may
81 * have to account for them. If they are all there, this
82 * loop will only happen once. This code only takes place
83 * on a new max, so it is far from a fast path.
84 */
85 while (i < max_stack_trace.nr_entries) {
86 int found = 0;
87
88 stack_dump_index[i] = this_size;
89 p = start;
90
91 for (; p < top && i < max_stack_trace.nr_entries; p++) {
92 if (*p == stack_dump_trace[i]) {
93 this_size = stack_dump_index[i++] =
94 (top - p) * sizeof(unsigned long);
95 found = 1;
96 /* Start the search from here */
97 start = p + 1;
98 }
99 }
100
101 if (!found)
102 i++;
103 }
104
105 out:
106 arch_spin_unlock(&max_stack_lock);
107 local_irq_restore(flags);
108}
109
110static void
111stack_trace_call(unsigned long ip, unsigned long parent_ip)
112{
113 int cpu;
114
115 if (unlikely(!ftrace_enabled || stack_trace_disabled))
116 return;
117
118 preempt_disable_notrace();
119
120 cpu = raw_smp_processor_id();
121 /* no atomic needed, we only modify this variable by this cpu */
122 if (per_cpu(trace_active, cpu)++ != 0)
123 goto out;
124
125 check_stack();
126
127 out:
128 per_cpu(trace_active, cpu)--;
129 /* prevent recursion in schedule */
130 preempt_enable_notrace();
131}
132
133static struct ftrace_ops trace_ops __read_mostly =
134{
135 .func = stack_trace_call,
136 .flags = FTRACE_OPS_FL_GLOBAL,
137};
138
139static ssize_t
140stack_max_size_read(struct file *filp, char __user *ubuf,
141 size_t count, loff_t *ppos)
142{
143 unsigned long *ptr = filp->private_data;
144 char buf[64];
145 int r;
146
147 r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
148 if (r > sizeof(buf))
149 r = sizeof(buf);
150 return simple_read_from_buffer(ubuf, count, ppos, buf, r);
151}
152
153static ssize_t
154stack_max_size_write(struct file *filp, const char __user *ubuf,
155 size_t count, loff_t *ppos)
156{
157 long *ptr = filp->private_data;
158 unsigned long val, flags;
159 char buf[64];
160 int ret;
161 int cpu;
162
163 if (count >= sizeof(buf))
164 return -EINVAL;
165
166 if (copy_from_user(&buf, ubuf, count))
167 return -EFAULT;
168
169 buf[count] = 0;
170
171 ret = strict_strtoul(buf, 10, &val);
172 if (ret < 0)
173 return ret;
174
175 local_irq_save(flags);
176
177 /*
178 * In case we trace inside arch_spin_lock() or after (NMI),
179 * we will cause circular lock, so we also need to increase
180 * the percpu trace_active here.
181 */
182 cpu = smp_processor_id();
183 per_cpu(trace_active, cpu)++;
184
185 arch_spin_lock(&max_stack_lock);
186 *ptr = val;
187 arch_spin_unlock(&max_stack_lock);
188
189 per_cpu(trace_active, cpu)--;
190 local_irq_restore(flags);
191
192 return count;
193}
194
195static const struct file_operations stack_max_size_fops = {
196 .open = tracing_open_generic,
197 .read = stack_max_size_read,
198 .write = stack_max_size_write,
199 .llseek = default_llseek,
200};
201
202static void *
203__next(struct seq_file *m, loff_t *pos)
204{
205 long n = *pos - 1;
206
207 if (n >= max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
208 return NULL;
209
210 m->private = (void *)n;
211 return &m->private;
212}
213
214static void *
215t_next(struct seq_file *m, void *v, loff_t *pos)
216{
217 (*pos)++;
218 return __next(m, pos);
219}
220
221static void *t_start(struct seq_file *m, loff_t *pos)
222{
223 int cpu;
224
225 local_irq_disable();
226
227 cpu = smp_processor_id();
228 per_cpu(trace_active, cpu)++;
229
230 arch_spin_lock(&max_stack_lock);
231
232 if (*pos == 0)
233 return SEQ_START_TOKEN;
234
235 return __next(m, pos);
236}
237
238static void t_stop(struct seq_file *m, void *p)
239{
240 int cpu;
241
242 arch_spin_unlock(&max_stack_lock);
243
244 cpu = smp_processor_id();
245 per_cpu(trace_active, cpu)--;
246
247 local_irq_enable();
248}
249
250static int trace_lookup_stack(struct seq_file *m, long i)
251{
252 unsigned long addr = stack_dump_trace[i];
253
254 return seq_printf(m, "%pS\n", (void *)addr);
255}
256
257static void print_disabled(struct seq_file *m)
258{
259 seq_puts(m, "#\n"
260 "# Stack tracer disabled\n"
261 "#\n"
262 "# To enable the stack tracer, either add 'stacktrace' to the\n"
263 "# kernel command line\n"
264 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
265 "#\n");
266}
267
268static int t_show(struct seq_file *m, void *v)
269{
270 long i;
271 int size;
272
273 if (v == SEQ_START_TOKEN) {
274 seq_printf(m, " Depth Size Location"
275 " (%d entries)\n"
276 " ----- ---- --------\n",
277 max_stack_trace.nr_entries - 1);
278
279 if (!stack_tracer_enabled && !max_stack_size)
280 print_disabled(m);
281
282 return 0;
283 }
284
285 i = *(long *)v;
286
287 if (i >= max_stack_trace.nr_entries ||
288 stack_dump_trace[i] == ULONG_MAX)
289 return 0;
290
291 if (i+1 == max_stack_trace.nr_entries ||
292 stack_dump_trace[i+1] == ULONG_MAX)
293 size = stack_dump_index[i];
294 else
295 size = stack_dump_index[i] - stack_dump_index[i+1];
296
297 seq_printf(m, "%3ld) %8d %5d ", i, stack_dump_index[i], size);
298
299 trace_lookup_stack(m, i);
300
301 return 0;
302}
303
304static const struct seq_operations stack_trace_seq_ops = {
305 .start = t_start,
306 .next = t_next,
307 .stop = t_stop,
308 .show = t_show,
309};
310
311static int stack_trace_open(struct inode *inode, struct file *file)
312{
313 return seq_open(file, &stack_trace_seq_ops);
314}
315
316static const struct file_operations stack_trace_fops = {
317 .open = stack_trace_open,
318 .read = seq_read,
319 .llseek = seq_lseek,
320 .release = seq_release,
321};
322
323int
324stack_trace_sysctl(struct ctl_table *table, int write,
325 void __user *buffer, size_t *lenp,
326 loff_t *ppos)
327{
328 int ret;
329
330 mutex_lock(&stack_sysctl_mutex);
331
332 ret = proc_dointvec(table, write, buffer, lenp, ppos);
333
334 if (ret || !write ||
335 (last_stack_tracer_enabled == !!stack_tracer_enabled))
336 goto out;
337
338 last_stack_tracer_enabled = !!stack_tracer_enabled;
339
340 if (stack_tracer_enabled)
341 register_ftrace_function(&trace_ops);
342 else
343 unregister_ftrace_function(&trace_ops);
344
345 out:
346 mutex_unlock(&stack_sysctl_mutex);
347 return ret;
348}
349
350static __init int enable_stacktrace(char *str)
351{
352 stack_tracer_enabled = 1;
353 last_stack_tracer_enabled = 1;
354 return 1;
355}
356__setup("stacktrace", enable_stacktrace);
357
358static __init int stack_trace_init(void)
359{
360 struct dentry *d_tracer;
361
362 d_tracer = tracing_init_dentry();
363
364 trace_create_file("stack_max_size", 0644, d_tracer,
365 &max_stack_size, &stack_max_size_fops);
366
367 trace_create_file("stack_trace", 0444, d_tracer,
368 NULL, &stack_trace_fops);
369
370 if (stack_tracer_enabled)
371 register_ftrace_function(&trace_ops);
372
373 return 0;
374}
375
376device_initcall(stack_trace_init);