Root/kernel/trace/trace_stack.c

1/*
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>
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);
377

Archive Download this file



interactive