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/ftrace.h>
11 #include <linux/module.h>
12 #include <linux/sysctl.h>
13 #include <linux/init.h>
15 #include <asm/setup.h>
19 static unsigned long stack_dump_trace
[STACK_TRACE_ENTRIES
+1] =
20 { [0 ... (STACK_TRACE_ENTRIES
)] = ULONG_MAX
};
21 unsigned stack_trace_index
[STACK_TRACE_ENTRIES
];
24 * Reserve one entry for the passed in ip. This will allow
25 * us to remove most or all of the stack size overhead
26 * added by the stack tracer itself.
28 struct stack_trace stack_trace_max
= {
29 .max_entries
= STACK_TRACE_ENTRIES
- 1,
30 .entries
= &stack_dump_trace
[0],
33 unsigned long stack_trace_max_size
;
34 arch_spinlock_t stack_trace_max_lock
=
35 (arch_spinlock_t
)__ARCH_SPIN_LOCK_UNLOCKED
;
37 static DEFINE_PER_CPU(int, trace_active
);
38 static DEFINE_MUTEX(stack_sysctl_mutex
);
40 int stack_tracer_enabled
;
41 static int last_stack_tracer_enabled
;
43 void stack_trace_print(void)
48 pr_emerg(" Depth Size Location (%d entries)\n"
49 " ----- ---- --------\n",
50 stack_trace_max
.nr_entries
);
52 for (i
= 0; i
< stack_trace_max
.nr_entries
; i
++) {
53 if (stack_dump_trace
[i
] == ULONG_MAX
)
55 if (i
+1 == stack_trace_max
.nr_entries
||
56 stack_dump_trace
[i
+1] == ULONG_MAX
)
57 size
= stack_trace_index
[i
];
59 size
= stack_trace_index
[i
] - stack_trace_index
[i
+1];
61 pr_emerg("%3ld) %8d %5d %pS\n", i
, stack_trace_index
[i
],
62 size
, (void *)stack_dump_trace
[i
]);
67 * When arch-specific code overides this function, the following
68 * data should be filled up, assuming stack_trace_max_lock is held to
69 * prevent concurrent updates.
72 * stack_trace_max_size
75 check_stack(unsigned long ip
, unsigned long *stack
)
77 unsigned long this_size
, flags
; unsigned long *p
, *top
, *start
;
78 static int tracer_frame
;
79 int frame_size
= ACCESS_ONCE(tracer_frame
);
82 this_size
= ((unsigned long)stack
) & (THREAD_SIZE
-1);
83 this_size
= THREAD_SIZE
- this_size
;
84 /* Remove the frame of the tracer */
85 this_size
-= frame_size
;
87 if (this_size
<= stack_trace_max_size
)
90 /* we do not handle interrupt stacks yet */
91 if (!object_is_on_stack(stack
))
94 /* Can't do this from NMI context (can cause deadlocks) */
98 local_irq_save(flags
);
99 arch_spin_lock(&stack_trace_max_lock
);
102 * RCU may not be watching, make it see us.
103 * The stack trace code uses rcu_sched.
107 /* In case another CPU set the tracer_frame on us */
108 if (unlikely(!frame_size
))
109 this_size
-= tracer_frame
;
111 /* a race could have already updated it */
112 if (this_size
<= stack_trace_max_size
)
115 stack_trace_max_size
= this_size
;
117 stack_trace_max
.nr_entries
= 0;
118 stack_trace_max
.skip
= 3;
120 save_stack_trace(&stack_trace_max
);
122 /* Skip over the overhead of the stack tracer itself */
123 for (i
= 0; i
< stack_trace_max
.nr_entries
; i
++) {
124 if (stack_dump_trace
[i
] == ip
)
129 * Some archs may not have the passed in ip in the dump.
130 * If that happens, we need to show everything.
132 if (i
== stack_trace_max
.nr_entries
)
136 * Now find where in the stack these are.
140 top
= (unsigned long *)
141 (((unsigned long)start
& ~(THREAD_SIZE
-1)) + THREAD_SIZE
);
144 * Loop through all the entries. One of the entries may
145 * for some reason be missed on the stack, so we may
146 * have to account for them. If they are all there, this
147 * loop will only happen once. This code only takes place
148 * on a new max, so it is far from a fast path.
150 while (i
< stack_trace_max
.nr_entries
) {
153 stack_trace_index
[x
] = this_size
;
156 for (; p
< top
&& i
< stack_trace_max
.nr_entries
; p
++) {
157 if (stack_dump_trace
[i
] == ULONG_MAX
)
159 if (*p
== stack_dump_trace
[i
]) {
160 stack_dump_trace
[x
] = stack_dump_trace
[i
++];
161 this_size
= stack_trace_index
[x
++] =
162 (top
- p
) * sizeof(unsigned long);
164 /* Start the search from here */
167 * We do not want to show the overhead
168 * of the stack tracer stack in the
169 * max stack. If we haven't figured
170 * out what that is, then figure it out
173 if (unlikely(!tracer_frame
)) {
174 tracer_frame
= (p
- stack
) *
175 sizeof(unsigned long);
176 stack_trace_max_size
-= tracer_frame
;
185 stack_trace_max
.nr_entries
= x
;
187 stack_dump_trace
[x
] = ULONG_MAX
;
189 if (task_stack_end_corrupted(current
)) {
196 arch_spin_unlock(&stack_trace_max_lock
);
197 local_irq_restore(flags
);
201 stack_trace_call(unsigned long ip
, unsigned long parent_ip
,
202 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
207 preempt_disable_notrace();
209 cpu
= raw_smp_processor_id();
210 /* no atomic needed, we only modify this variable by this cpu */
211 if (per_cpu(trace_active
, cpu
)++ != 0)
214 ip
+= MCOUNT_INSN_SIZE
;
216 check_stack(ip
, &stack
);
219 per_cpu(trace_active
, cpu
)--;
220 /* prevent recursion in schedule */
221 preempt_enable_notrace();
224 static struct ftrace_ops trace_ops __read_mostly
=
226 .func
= stack_trace_call
,
227 .flags
= FTRACE_OPS_FL_RECURSION_SAFE
,
231 stack_max_size_read(struct file
*filp
, char __user
*ubuf
,
232 size_t count
, loff_t
*ppos
)
234 unsigned long *ptr
= filp
->private_data
;
238 r
= snprintf(buf
, sizeof(buf
), "%ld\n", *ptr
);
241 return simple_read_from_buffer(ubuf
, count
, ppos
, buf
, r
);
245 stack_max_size_write(struct file
*filp
, const char __user
*ubuf
,
246 size_t count
, loff_t
*ppos
)
248 long *ptr
= filp
->private_data
;
249 unsigned long val
, flags
;
253 ret
= kstrtoul_from_user(ubuf
, count
, 10, &val
);
257 local_irq_save(flags
);
260 * In case we trace inside arch_spin_lock() or after (NMI),
261 * we will cause circular lock, so we also need to increase
262 * the percpu trace_active here.
264 cpu
= smp_processor_id();
265 per_cpu(trace_active
, cpu
)++;
267 arch_spin_lock(&stack_trace_max_lock
);
269 arch_spin_unlock(&stack_trace_max_lock
);
271 per_cpu(trace_active
, cpu
)--;
272 local_irq_restore(flags
);
277 static const struct file_operations stack_max_size_fops
= {
278 .open
= tracing_open_generic
,
279 .read
= stack_max_size_read
,
280 .write
= stack_max_size_write
,
281 .llseek
= default_llseek
,
285 __next(struct seq_file
*m
, loff_t
*pos
)
289 if (n
> stack_trace_max
.nr_entries
|| stack_dump_trace
[n
] == ULONG_MAX
)
292 m
->private = (void *)n
;
297 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
300 return __next(m
, pos
);
303 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
309 cpu
= smp_processor_id();
310 per_cpu(trace_active
, cpu
)++;
312 arch_spin_lock(&stack_trace_max_lock
);
315 return SEQ_START_TOKEN
;
317 return __next(m
, pos
);
320 static void t_stop(struct seq_file
*m
, void *p
)
324 arch_spin_unlock(&stack_trace_max_lock
);
326 cpu
= smp_processor_id();
327 per_cpu(trace_active
, cpu
)--;
332 static void trace_lookup_stack(struct seq_file
*m
, long i
)
334 unsigned long addr
= stack_dump_trace
[i
];
336 seq_printf(m
, "%pS\n", (void *)addr
);
339 static void print_disabled(struct seq_file
*m
)
342 "# Stack tracer disabled\n"
344 "# To enable the stack tracer, either add 'stacktrace' to the\n"
345 "# kernel command line\n"
346 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
350 static int t_show(struct seq_file
*m
, void *v
)
355 if (v
== SEQ_START_TOKEN
) {
356 seq_printf(m
, " Depth Size Location"
358 " ----- ---- --------\n",
359 stack_trace_max
.nr_entries
);
361 if (!stack_tracer_enabled
&& !stack_trace_max_size
)
369 if (i
>= stack_trace_max
.nr_entries
||
370 stack_dump_trace
[i
] == ULONG_MAX
)
373 if (i
+1 == stack_trace_max
.nr_entries
||
374 stack_dump_trace
[i
+1] == ULONG_MAX
)
375 size
= stack_trace_index
[i
];
377 size
= stack_trace_index
[i
] - stack_trace_index
[i
+1];
379 seq_printf(m
, "%3ld) %8d %5d ", i
, stack_trace_index
[i
], size
);
381 trace_lookup_stack(m
, i
);
386 static const struct seq_operations stack_trace_seq_ops
= {
393 static int stack_trace_open(struct inode
*inode
, struct file
*file
)
395 return seq_open(file
, &stack_trace_seq_ops
);
398 static const struct file_operations stack_trace_fops
= {
399 .open
= stack_trace_open
,
402 .release
= seq_release
,
406 stack_trace_filter_open(struct inode
*inode
, struct file
*file
)
408 return ftrace_regex_open(&trace_ops
, FTRACE_ITER_FILTER
,
412 static const struct file_operations stack_trace_filter_fops
= {
413 .open
= stack_trace_filter_open
,
415 .write
= ftrace_filter_write
,
416 .llseek
= tracing_lseek
,
417 .release
= ftrace_regex_release
,
421 stack_trace_sysctl(struct ctl_table
*table
, int write
,
422 void __user
*buffer
, size_t *lenp
,
427 mutex_lock(&stack_sysctl_mutex
);
429 ret
= proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
432 (last_stack_tracer_enabled
== !!stack_tracer_enabled
))
435 last_stack_tracer_enabled
= !!stack_tracer_enabled
;
437 if (stack_tracer_enabled
)
438 register_ftrace_function(&trace_ops
);
440 unregister_ftrace_function(&trace_ops
);
443 mutex_unlock(&stack_sysctl_mutex
);
447 static char stack_trace_filter_buf
[COMMAND_LINE_SIZE
+1] __initdata
;
449 static __init
int enable_stacktrace(char *str
)
451 if (strncmp(str
, "_filter=", 8) == 0)
452 strncpy(stack_trace_filter_buf
, str
+8, COMMAND_LINE_SIZE
);
454 stack_tracer_enabled
= 1;
455 last_stack_tracer_enabled
= 1;
458 __setup("stacktrace", enable_stacktrace
);
460 static __init
int stack_trace_init(void)
462 struct dentry
*d_tracer
;
464 d_tracer
= tracing_init_dentry();
465 if (IS_ERR(d_tracer
))
468 trace_create_file("stack_max_size", 0644, d_tracer
,
469 &stack_trace_max_size
, &stack_max_size_fops
);
471 trace_create_file("stack_trace", 0444, d_tracer
,
472 NULL
, &stack_trace_fops
);
474 trace_create_file("stack_trace_filter", 0444, d_tracer
,
475 NULL
, &stack_trace_filter_fops
);
477 if (stack_trace_filter_buf
[0])
478 ftrace_set_early_filter(&trace_ops
, stack_trace_filter_buf
, 1);
480 if (stack_tracer_enabled
)
481 register_ftrace_function(&trace_ops
);
486 device_initcall(stack_trace_init
);