2 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
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>
18 #define STACK_TRACE_ENTRIES 500
20 static unsigned long stack_dump_trace
[STACK_TRACE_ENTRIES
+1] =
21 { [0 ... (STACK_TRACE_ENTRIES
)] = ULONG_MAX
};
22 static unsigned stack_dump_index
[STACK_TRACE_ENTRIES
];
24 static struct stack_trace max_stack_trace
= {
25 .max_entries
= STACK_TRACE_ENTRIES
,
26 .entries
= stack_dump_trace
,
29 static unsigned long max_stack_size
;
30 static raw_spinlock_t max_stack_lock
=
31 (raw_spinlock_t
)__RAW_SPIN_LOCK_UNLOCKED
;
33 static int stack_trace_disabled __read_mostly
;
34 static DEFINE_PER_CPU(int, trace_active
);
35 static DEFINE_MUTEX(stack_sysctl_mutex
);
37 int stack_tracer_enabled
;
38 static int last_stack_tracer_enabled
;
40 static inline void check_stack(void)
42 unsigned long this_size
, flags
;
43 unsigned long *p
, *top
, *start
;
46 this_size
= ((unsigned long)&this_size
) & (THREAD_SIZE
-1);
47 this_size
= THREAD_SIZE
- this_size
;
49 if (this_size
<= max_stack_size
)
52 /* we do not handle interrupt stacks yet */
53 if (!object_is_on_stack(&this_size
))
56 local_irq_save(flags
);
57 __raw_spin_lock(&max_stack_lock
);
59 /* a race could have already updated it */
60 if (this_size
<= max_stack_size
)
63 max_stack_size
= this_size
;
65 max_stack_trace
.nr_entries
= 0;
66 max_stack_trace
.skip
= 3;
68 save_stack_trace(&max_stack_trace
);
71 * Now find where in the stack these are.
75 top
= (unsigned long *)
76 (((unsigned long)start
& ~(THREAD_SIZE
-1)) + THREAD_SIZE
);
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.
85 while (i
< max_stack_trace
.nr_entries
) {
88 stack_dump_index
[i
] = this_size
;
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);
96 /* Start the search from here */
106 __raw_spin_unlock(&max_stack_lock
);
107 local_irq_restore(flags
);
111 stack_trace_call(unsigned long ip
, unsigned long parent_ip
)
115 if (unlikely(!ftrace_enabled
|| stack_trace_disabled
))
118 resched
= ftrace_preempt_disable();
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)
128 per_cpu(trace_active
, cpu
)--;
129 /* prevent recursion in schedule */
130 ftrace_preempt_enable(resched
);
133 static struct ftrace_ops trace_ops __read_mostly
=
135 .func
= stack_trace_call
,
139 stack_max_size_read(struct file
*filp
, char __user
*ubuf
,
140 size_t count
, loff_t
*ppos
)
142 unsigned long *ptr
= filp
->private_data
;
146 r
= snprintf(buf
, sizeof(buf
), "%ld\n", *ptr
);
149 return simple_read_from_buffer(ubuf
, count
, ppos
, buf
, r
);
153 stack_max_size_write(struct file
*filp
, const char __user
*ubuf
,
154 size_t count
, loff_t
*ppos
)
156 long *ptr
= filp
->private_data
;
157 unsigned long val
, flags
;
161 if (count
>= sizeof(buf
))
164 if (copy_from_user(&buf
, ubuf
, count
))
169 ret
= strict_strtoul(buf
, 10, &val
);
173 local_irq_save(flags
);
174 __raw_spin_lock(&max_stack_lock
);
176 __raw_spin_unlock(&max_stack_lock
);
177 local_irq_restore(flags
);
182 static const struct file_operations stack_max_size_fops
= {
183 .open
= tracing_open_generic
,
184 .read
= stack_max_size_read
,
185 .write
= stack_max_size_write
,
189 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
195 if (v
== SEQ_START_TOKEN
)
202 if (i
>= max_stack_trace
.nr_entries
||
203 stack_dump_trace
[i
] == ULONG_MAX
)
206 m
->private = (void *)i
;
211 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
213 void *t
= SEQ_START_TOKEN
;
217 __raw_spin_lock(&max_stack_lock
);
220 return SEQ_START_TOKEN
;
222 for (; t
&& l
< *pos
; t
= t_next(m
, t
, &l
))
228 static void t_stop(struct seq_file
*m
, void *p
)
230 __raw_spin_unlock(&max_stack_lock
);
234 static int trace_lookup_stack(struct seq_file
*m
, long i
)
236 unsigned long addr
= stack_dump_trace
[i
];
238 return seq_printf(m
, "%pF\n", (void *)addr
);
241 static void print_disabled(struct seq_file
*m
)
244 "# Stack tracer disabled\n"
246 "# To enable the stack tracer, either add 'stacktrace' to the\n"
247 "# kernel command line\n"
248 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
252 static int t_show(struct seq_file
*m
, void *v
)
257 if (v
== SEQ_START_TOKEN
) {
258 seq_printf(m
, " Depth Size Location"
260 " ----- ---- --------\n",
261 max_stack_trace
.nr_entries
- 1);
263 if (!stack_tracer_enabled
&& !max_stack_size
)
271 if (i
>= max_stack_trace
.nr_entries
||
272 stack_dump_trace
[i
] == ULONG_MAX
)
275 if (i
+1 == max_stack_trace
.nr_entries
||
276 stack_dump_trace
[i
+1] == ULONG_MAX
)
277 size
= stack_dump_index
[i
];
279 size
= stack_dump_index
[i
] - stack_dump_index
[i
+1];
281 seq_printf(m
, "%3ld) %8d %5d ", i
, stack_dump_index
[i
], size
);
283 trace_lookup_stack(m
, i
);
288 static const struct seq_operations stack_trace_seq_ops
= {
295 static int stack_trace_open(struct inode
*inode
, struct file
*file
)
299 ret
= seq_open(file
, &stack_trace_seq_ops
);
304 static const struct file_operations stack_trace_fops
= {
305 .open
= stack_trace_open
,
311 stack_trace_sysctl(struct ctl_table
*table
, int write
,
312 struct file
*file
, void __user
*buffer
, size_t *lenp
,
317 mutex_lock(&stack_sysctl_mutex
);
319 ret
= proc_dointvec(table
, write
, file
, buffer
, lenp
, ppos
);
322 (last_stack_tracer_enabled
== !!stack_tracer_enabled
))
325 last_stack_tracer_enabled
= !!stack_tracer_enabled
;
327 if (stack_tracer_enabled
)
328 register_ftrace_function(&trace_ops
);
330 unregister_ftrace_function(&trace_ops
);
333 mutex_unlock(&stack_sysctl_mutex
);
337 static __init
int enable_stacktrace(char *str
)
339 stack_tracer_enabled
= 1;
340 last_stack_tracer_enabled
= 1;
343 __setup("stacktrace", enable_stacktrace
);
345 static __init
int stack_trace_init(void)
347 struct dentry
*d_tracer
;
349 d_tracer
= tracing_init_dentry();
351 trace_create_file("stack_max_size", 0644, d_tracer
,
352 &max_stack_size
, &stack_max_size_fops
);
354 trace_create_file("stack_trace", 0444, d_tracer
,
355 NULL
, &stack_trace_fops
);
357 if (stack_tracer_enabled
)
358 register_ftrace_function(&trace_ops
);
363 device_initcall(stack_trace_init
);