blob: 42ca822fc7019670d8bea7291caea4110477749b [file] [log] [blame]
Steven Rostedte5a81b62008-08-27 23:31:01 -04001/*
2 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
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>
Steven Rostedtf38f1d22008-12-16 23:06:40 -050013#include <linux/sysctl.h>
Steven Rostedte5a81b62008-08-27 23:31:01 -040014#include <linux/init.h>
15#include <linux/fs.h>
Steven Rostedt762e1202011-12-19 22:01:00 -050016
17#include <asm/setup.h>
18
Steven Rostedte5a81b62008-08-27 23:31:01 -040019#include "trace.h"
20
21#define STACK_TRACE_ENTRIES 500
22
Steven Rostedt1b6cced2008-08-29 16:51:43 -040023static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
24 { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
25static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
26
Steven Rostedte5a81b62008-08-27 23:31:01 -040027static struct stack_trace max_stack_trace = {
28 .max_entries = STACK_TRACE_ENTRIES,
29 .entries = stack_dump_trace,
30};
31
32static unsigned long max_stack_size;
Thomas Gleixner445c8952009-12-02 19:49:50 +010033static arch_spinlock_t max_stack_lock =
Thomas Gleixneredc35bd2009-12-03 12:38:57 +010034 (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
Steven Rostedte5a81b62008-08-27 23:31:01 -040035
Steven Rostedte5a81b62008-08-27 23:31:01 -040036static DEFINE_PER_CPU(int, trace_active);
Steven Rostedtf38f1d22008-12-16 23:06:40 -050037static DEFINE_MUTEX(stack_sysctl_mutex);
38
39int stack_tracer_enabled;
40static int last_stack_tracer_enabled;
Steven Rostedte5a81b62008-08-27 23:31:01 -040041
42static inline void check_stack(void)
43{
Steven Rostedt1b6cced2008-08-29 16:51:43 -040044 unsigned long this_size, flags;
45 unsigned long *p, *top, *start;
46 int i;
Steven Rostedte5a81b62008-08-27 23:31:01 -040047
48 this_size = ((unsigned long)&this_size) & (THREAD_SIZE-1);
49 this_size = THREAD_SIZE - this_size;
50
51 if (this_size <= max_stack_size)
52 return;
53
Steven Rostedt81520a12008-10-06 21:24:18 -040054 /* we do not handle interrupt stacks yet */
55 if (!object_is_on_stack(&this_size))
56 return;
57
Steven Rostedta5e25882008-12-02 15:34:05 -050058 local_irq_save(flags);
Thomas Gleixner0199c4e2009-12-02 20:01:25 +010059 arch_spin_lock(&max_stack_lock);
Steven Rostedte5a81b62008-08-27 23:31:01 -040060
61 /* a race could have already updated it */
62 if (this_size <= max_stack_size)
63 goto out;
64
65 max_stack_size = this_size;
66
67 max_stack_trace.nr_entries = 0;
Steven Rostedt1b6cced2008-08-29 16:51:43 -040068 max_stack_trace.skip = 3;
Steven Rostedte5a81b62008-08-27 23:31:01 -040069
70 save_stack_trace(&max_stack_trace);
71
Steven Rostedt1b6cced2008-08-29 16:51:43 -040072 /*
73 * Now find where in the stack these are.
74 */
75 i = 0;
76 start = &this_size;
77 top = (unsigned long *)
78 (((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
79
80 /*
81 * Loop through all the entries. One of the entries may
82 * for some reason be missed on the stack, so we may
83 * have to account for them. If they are all there, this
84 * loop will only happen once. This code only takes place
85 * on a new max, so it is far from a fast path.
86 */
87 while (i < max_stack_trace.nr_entries) {
Steven Rostedt0a371192008-12-03 11:04:50 -050088 int found = 0;
Steven Rostedt1b6cced2008-08-29 16:51:43 -040089
90 stack_dump_index[i] = this_size;
91 p = start;
92
93 for (; p < top && i < max_stack_trace.nr_entries; p++) {
94 if (*p == stack_dump_trace[i]) {
95 this_size = stack_dump_index[i++] =
96 (top - p) * sizeof(unsigned long);
Steven Rostedt0a371192008-12-03 11:04:50 -050097 found = 1;
Steven Rostedt1b6cced2008-08-29 16:51:43 -040098 /* Start the search from here */
99 start = p + 1;
100 }
101 }
102
Steven Rostedt0a371192008-12-03 11:04:50 -0500103 if (!found)
104 i++;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400105 }
106
Steven Rostedte5a81b62008-08-27 23:31:01 -0400107 out:
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100108 arch_spin_unlock(&max_stack_lock);
Steven Rostedta5e25882008-12-02 15:34:05 -0500109 local_irq_restore(flags);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400110}
111
112static void
Steven Rostedta1e2e312011-08-09 12:50:46 -0400113stack_trace_call(unsigned long ip, unsigned long parent_ip,
114 struct ftrace_ops *op, struct pt_regs *pt_regs)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400115{
Steven Rostedt5168ae52010-06-03 09:36:50 -0400116 int cpu;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400117
Steven Rostedt5168ae52010-06-03 09:36:50 -0400118 preempt_disable_notrace();
Steven Rostedte5a81b62008-08-27 23:31:01 -0400119
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 */
Steven Rostedt5168ae52010-06-03 09:36:50 -0400130 preempt_enable_notrace();
Steven Rostedte5a81b62008-08-27 23:31:01 -0400131}
132
133static struct ftrace_ops trace_ops __read_mostly =
134{
135 .func = stack_trace_call,
Steven Rostedt47409742012-07-20 11:04:44 -0400136 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
Steven Rostedte5a81b62008-08-27 23:31:01 -0400137};
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;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400159 int ret;
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800160 int cpu;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400161
Peter Huewe22fe9b52011-06-07 21:58:27 +0200162 ret = kstrtoul_from_user(ubuf, count, 10, &val);
163 if (ret)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400164 return ret;
165
Steven Rostedta5e25882008-12-02 15:34:05 -0500166 local_irq_save(flags);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800167
168 /*
169 * In case we trace inside arch_spin_lock() or after (NMI),
170 * we will cause circular lock, so we also need to increase
171 * the percpu trace_active here.
172 */
173 cpu = smp_processor_id();
174 per_cpu(trace_active, cpu)++;
175
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100176 arch_spin_lock(&max_stack_lock);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400177 *ptr = val;
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100178 arch_spin_unlock(&max_stack_lock);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800179
180 per_cpu(trace_active, cpu)--;
Steven Rostedta5e25882008-12-02 15:34:05 -0500181 local_irq_restore(flags);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400182
183 return count;
184}
185
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500186static const struct file_operations stack_max_size_fops = {
Steven Rostedte5a81b62008-08-27 23:31:01 -0400187 .open = tracing_open_generic,
188 .read = stack_max_size_read,
189 .write = stack_max_size_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200190 .llseek = default_llseek,
Steven Rostedte5a81b62008-08-27 23:31:01 -0400191};
192
193static void *
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800194__next(struct seq_file *m, loff_t *pos)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400195{
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800196 long n = *pos - 1;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400197
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800198 if (n >= max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400199 return NULL;
200
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800201 m->private = (void *)n;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400202 return &m->private;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400203}
204
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800205static void *
206t_next(struct seq_file *m, void *v, loff_t *pos)
207{
208 (*pos)++;
209 return __next(m, pos);
210}
211
Steven Rostedte5a81b62008-08-27 23:31:01 -0400212static void *t_start(struct seq_file *m, loff_t *pos)
213{
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800214 int cpu;
215
Steven Rostedte5a81b62008-08-27 23:31:01 -0400216 local_irq_disable();
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800217
218 cpu = smp_processor_id();
219 per_cpu(trace_active, cpu)++;
220
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100221 arch_spin_lock(&max_stack_lock);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400222
Liming Wang522a1102008-11-21 11:00:18 +0800223 if (*pos == 0)
224 return SEQ_START_TOKEN;
225
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800226 return __next(m, pos);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400227}
228
229static void t_stop(struct seq_file *m, void *p)
230{
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800231 int cpu;
232
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100233 arch_spin_unlock(&max_stack_lock);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800234
235 cpu = smp_processor_id();
236 per_cpu(trace_active, cpu)--;
237
Steven Rostedte5a81b62008-08-27 23:31:01 -0400238 local_irq_enable();
239}
240
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400241static int trace_lookup_stack(struct seq_file *m, long i)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400242{
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400243 unsigned long addr = stack_dump_trace[i];
Steven Rostedte5a81b62008-08-27 23:31:01 -0400244
Anton Blanchard151772d2010-08-25 11:32:38 +1000245 return seq_printf(m, "%pS\n", (void *)addr);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400246}
247
Steven Rostedte447e1d2009-03-12 19:42:29 -0400248static void print_disabled(struct seq_file *m)
249{
250 seq_puts(m, "#\n"
251 "# Stack tracer disabled\n"
252 "#\n"
253 "# To enable the stack tracer, either add 'stacktrace' to the\n"
254 "# kernel command line\n"
255 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
256 "#\n");
257}
258
Steven Rostedte5a81b62008-08-27 23:31:01 -0400259static int t_show(struct seq_file *m, void *v)
260{
Liming Wang522a1102008-11-21 11:00:18 +0800261 long i;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400262 int size;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400263
Liming Wang522a1102008-11-21 11:00:18 +0800264 if (v == SEQ_START_TOKEN) {
Steven Rostedteb1871f2009-03-13 00:00:58 -0400265 seq_printf(m, " Depth Size Location"
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400266 " (%d entries)\n"
Steven Rostedteb1871f2009-03-13 00:00:58 -0400267 " ----- ---- --------\n",
walimis083a63b2009-06-03 16:01:28 +0800268 max_stack_trace.nr_entries - 1);
Steven Rostedte447e1d2009-03-12 19:42:29 -0400269
270 if (!stack_tracer_enabled && !max_stack_size)
271 print_disabled(m);
272
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400273 return 0;
274 }
275
Liming Wang522a1102008-11-21 11:00:18 +0800276 i = *(long *)v;
277
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400278 if (i >= max_stack_trace.nr_entries ||
279 stack_dump_trace[i] == ULONG_MAX)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400280 return 0;
281
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400282 if (i+1 == max_stack_trace.nr_entries ||
283 stack_dump_trace[i+1] == ULONG_MAX)
284 size = stack_dump_index[i];
285 else
286 size = stack_dump_index[i] - stack_dump_index[i+1];
287
288 seq_printf(m, "%3ld) %8d %5d ", i, stack_dump_index[i], size);
289
290 trace_lookup_stack(m, i);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400291
292 return 0;
293}
294
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500295static const struct seq_operations stack_trace_seq_ops = {
Steven Rostedte5a81b62008-08-27 23:31:01 -0400296 .start = t_start,
297 .next = t_next,
298 .stop = t_stop,
299 .show = t_show,
300};
301
302static int stack_trace_open(struct inode *inode, struct file *file)
303{
Li Zefand8cc1ab2009-07-23 11:28:40 +0800304 return seq_open(file, &stack_trace_seq_ops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400305}
306
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500307static const struct file_operations stack_trace_fops = {
Steven Rostedte5a81b62008-08-27 23:31:01 -0400308 .open = stack_trace_open,
309 .read = seq_read,
310 .llseek = seq_lseek,
Li Zefand8cc1ab2009-07-23 11:28:40 +0800311 .release = seq_release,
Steven Rostedte5a81b62008-08-27 23:31:01 -0400312};
313
Steven Rostedtd2d45c72011-12-19 14:44:09 -0500314static int
315stack_trace_filter_open(struct inode *inode, struct file *file)
316{
317 return ftrace_regex_open(&trace_ops, FTRACE_ITER_FILTER,
318 inode, file);
319}
320
321static const struct file_operations stack_trace_filter_fops = {
322 .open = stack_trace_filter_open,
323 .read = seq_read,
324 .write = ftrace_filter_write,
325 .llseek = ftrace_regex_lseek,
326 .release = ftrace_regex_release,
327};
328
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500329int
330stack_trace_sysctl(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700331 void __user *buffer, size_t *lenp,
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500332 loff_t *ppos)
333{
334 int ret;
335
336 mutex_lock(&stack_sysctl_mutex);
337
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700338 ret = proc_dointvec(table, write, buffer, lenp, ppos);
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500339
340 if (ret || !write ||
Li Zefana32c7762009-06-26 16:55:51 +0800341 (last_stack_tracer_enabled == !!stack_tracer_enabled))
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500342 goto out;
343
Li Zefana32c7762009-06-26 16:55:51 +0800344 last_stack_tracer_enabled = !!stack_tracer_enabled;
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500345
346 if (stack_tracer_enabled)
347 register_ftrace_function(&trace_ops);
348 else
349 unregister_ftrace_function(&trace_ops);
350
351 out:
352 mutex_unlock(&stack_sysctl_mutex);
353 return ret;
354}
355
Steven Rostedt762e1202011-12-19 22:01:00 -0500356static char stack_trace_filter_buf[COMMAND_LINE_SIZE+1] __initdata;
357
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500358static __init int enable_stacktrace(char *str)
359{
Steven Rostedt762e1202011-12-19 22:01:00 -0500360 if (strncmp(str, "_filter=", 8) == 0)
361 strncpy(stack_trace_filter_buf, str+8, COMMAND_LINE_SIZE);
362
Steven Rostedte05a43b2008-12-17 09:43:00 -0500363 stack_tracer_enabled = 1;
364 last_stack_tracer_enabled = 1;
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500365 return 1;
366}
367__setup("stacktrace", enable_stacktrace);
368
Steven Rostedte5a81b62008-08-27 23:31:01 -0400369static __init int stack_trace_init(void)
370{
371 struct dentry *d_tracer;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400372
373 d_tracer = tracing_init_dentry();
374
Frederic Weisbecker5452af62009-03-27 00:25:38 +0100375 trace_create_file("stack_max_size", 0644, d_tracer,
376 &max_stack_size, &stack_max_size_fops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400377
Frederic Weisbecker5452af62009-03-27 00:25:38 +0100378 trace_create_file("stack_trace", 0444, d_tracer,
379 NULL, &stack_trace_fops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400380
Steven Rostedtd2d45c72011-12-19 14:44:09 -0500381 trace_create_file("stack_trace_filter", 0444, d_tracer,
382 NULL, &stack_trace_filter_fops);
383
Steven Rostedt762e1202011-12-19 22:01:00 -0500384 if (stack_trace_filter_buf[0])
385 ftrace_set_early_filter(&trace_ops, stack_trace_filter_buf, 1);
386
Steven Rostedte05a43b2008-12-17 09:43:00 -0500387 if (stack_tracer_enabled)
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500388 register_ftrace_function(&trace_ops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400389
390 return 0;
391}
392
393device_initcall(stack_trace_init);