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
= __RAW_SPIN_LOCK_UNLOCKED
;
32 static int stack_trace_disabled __read_mostly
;
33 static DEFINE_PER_CPU(int, trace_active
);
34 static DEFINE_MUTEX(stack_sysctl_mutex
);
36 int stack_tracer_enabled
;
37 static int last_stack_tracer_enabled
;
39 static inline void check_stack(void)
41 unsigned long this_size
, flags
;
42 unsigned long *p
, *top
, *start
;
45 this_size
= ((unsigned long)&this_size
) & (THREAD_SIZE
-1);
46 this_size
= THREAD_SIZE
- this_size
;
48 if (this_size
<= max_stack_size
)
51 /* we do not handle interrupt stacks yet */
52 if (!object_is_on_stack(&this_size
))
55 local_irq_save(flags
);
56 __raw_spin_lock(&max_stack_lock
);
58 /* a race could have already updated it */
59 if (this_size
<= max_stack_size
)
62 max_stack_size
= this_size
;
64 max_stack_trace
.nr_entries
= 0;
65 max_stack_trace
.skip
= 3;
67 save_stack_trace(&max_stack_trace
);
70 * Now find where in the stack these are.
74 top
= (unsigned long *)
75 (((unsigned long)start
& ~(THREAD_SIZE
-1)) + THREAD_SIZE
);
78 * Loop through all the entries. One of the entries may
79 * for some reason be missed on the stack, so we may
80 * have to account for them. If they are all there, this
81 * loop will only happen once. This code only takes place
82 * on a new max, so it is far from a fast path.
84 while (i
< max_stack_trace
.nr_entries
) {
87 stack_dump_index
[i
] = this_size
;
90 for (; p
< top
&& i
< max_stack_trace
.nr_entries
; p
++) {
91 if (*p
== stack_dump_trace
[i
]) {
92 this_size
= stack_dump_index
[i
++] =
93 (top
- p
) * sizeof(unsigned long);
95 /* Start the search from here */
105 __raw_spin_unlock(&max_stack_lock
);
106 local_irq_restore(flags
);
110 stack_trace_call(unsigned long ip
, unsigned long parent_ip
)
114 if (unlikely(!ftrace_enabled
|| stack_trace_disabled
))
117 resched
= ftrace_preempt_disable();
119 cpu
= raw_smp_processor_id();
120 /* no atomic needed, we only modify this variable by this cpu */
121 if (per_cpu(trace_active
, cpu
)++ != 0)
127 per_cpu(trace_active
, cpu
)--;
128 /* prevent recursion in schedule */
129 ftrace_preempt_enable(resched
);
132 static struct ftrace_ops trace_ops __read_mostly
=
134 .func
= stack_trace_call
,
138 stack_max_size_read(struct file
*filp
, char __user
*ubuf
,
139 size_t count
, loff_t
*ppos
)
141 unsigned long *ptr
= filp
->private_data
;
145 r
= snprintf(buf
, sizeof(buf
), "%ld\n", *ptr
);
148 return simple_read_from_buffer(ubuf
, count
, ppos
, buf
, r
);
152 stack_max_size_write(struct file
*filp
, const char __user
*ubuf
,
153 size_t count
, loff_t
*ppos
)
155 long *ptr
= filp
->private_data
;
156 unsigned long val
, flags
;
160 if (count
>= sizeof(buf
))
163 if (copy_from_user(&buf
, ubuf
, count
))
168 ret
= strict_strtoul(buf
, 10, &val
);
172 local_irq_save(flags
);
173 __raw_spin_lock(&max_stack_lock
);
175 __raw_spin_unlock(&max_stack_lock
);
176 local_irq_restore(flags
);
181 static const struct file_operations stack_max_size_fops
= {
182 .open
= tracing_open_generic
,
183 .read
= stack_max_size_read
,
184 .write
= stack_max_size_write
,
188 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
194 if (v
== SEQ_START_TOKEN
)
201 if (i
>= max_stack_trace
.nr_entries
||
202 stack_dump_trace
[i
] == ULONG_MAX
)
205 m
->private = (void *)i
;
210 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
212 void *t
= SEQ_START_TOKEN
;
216 __raw_spin_lock(&max_stack_lock
);
219 return SEQ_START_TOKEN
;
221 for (; t
&& l
< *pos
; t
= t_next(m
, t
, &l
))
227 static void t_stop(struct seq_file
*m
, void *p
)
229 __raw_spin_unlock(&max_stack_lock
);
233 static int trace_lookup_stack(struct seq_file
*m
, long i
)
235 unsigned long addr
= stack_dump_trace
[i
];
236 #ifdef CONFIG_KALLSYMS
237 char str
[KSYM_SYMBOL_LEN
];
239 sprint_symbol(str
, addr
);
241 return seq_printf(m
, "%s\n", str
);
243 return seq_printf(m
, "%p\n", (void*)addr
);
247 static void print_disabled(struct seq_file
*m
)
250 "# Stack tracer disabled\n"
252 "# To enable the stack tracer, either add 'stacktrace' to the\n"
253 "# kernel command line\n"
254 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
258 static int t_show(struct seq_file
*m
, void *v
)
263 if (v
== SEQ_START_TOKEN
) {
264 seq_printf(m
, " Depth Size Location"
266 " ----- ---- --------\n",
267 max_stack_trace
.nr_entries
);
269 if (!stack_tracer_enabled
&& !max_stack_size
)
277 if (i
>= max_stack_trace
.nr_entries
||
278 stack_dump_trace
[i
] == ULONG_MAX
)
281 if (i
+1 == max_stack_trace
.nr_entries
||
282 stack_dump_trace
[i
+1] == ULONG_MAX
)
283 size
= stack_dump_index
[i
];
285 size
= stack_dump_index
[i
] - stack_dump_index
[i
+1];
287 seq_printf(m
, "%3ld) %8d %5d ", i
, stack_dump_index
[i
], size
);
289 trace_lookup_stack(m
, i
);
294 static const struct seq_operations stack_trace_seq_ops
= {
301 static int stack_trace_open(struct inode
*inode
, struct file
*file
)
305 ret
= seq_open(file
, &stack_trace_seq_ops
);
310 static const struct file_operations stack_trace_fops
= {
311 .open
= stack_trace_open
,
317 stack_trace_sysctl(struct ctl_table
*table
, int write
,
318 struct file
*file
, void __user
*buffer
, size_t *lenp
,
323 mutex_lock(&stack_sysctl_mutex
);
325 ret
= proc_dointvec(table
, write
, file
, buffer
, lenp
, ppos
);
328 (last_stack_tracer_enabled
== stack_tracer_enabled
))
331 last_stack_tracer_enabled
= stack_tracer_enabled
;
333 if (stack_tracer_enabled
)
334 register_ftrace_function(&trace_ops
);
336 unregister_ftrace_function(&trace_ops
);
339 mutex_unlock(&stack_sysctl_mutex
);
343 static __init
int enable_stacktrace(char *str
)
345 stack_tracer_enabled
= 1;
346 last_stack_tracer_enabled
= 1;
349 __setup("stacktrace", enable_stacktrace
);
351 static __init
int stack_trace_init(void)
353 struct dentry
*d_tracer
;
354 struct dentry
*entry
;
356 d_tracer
= tracing_init_dentry();
358 entry
= debugfs_create_file("stack_max_size", 0644, d_tracer
,
359 &max_stack_size
, &stack_max_size_fops
);
361 pr_warning("Could not create debugfs 'stack_max_size' entry\n");
363 entry
= debugfs_create_file("stack_trace", 0444, d_tracer
,
364 NULL
, &stack_trace_fops
);
366 pr_warning("Could not create debugfs 'stack_trace' entry\n");
368 if (stack_tracer_enabled
)
369 register_ftrace_function(&trace_ops
);
374 device_initcall(stack_trace_init
);