2 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
5 #include <linux/sched/task_stack.h>
6 #include <linux/stacktrace.h>
7 #include <linux/kallsyms.h>
8 #include <linux/seq_file.h>
9 #include <linux/spinlock.h>
10 #include <linux/uaccess.h>
11 #include <linux/ftrace.h>
12 #include <linux/module.h>
13 #include <linux/sysctl.h>
14 #include <linux/init.h>
16 #include <asm/setup.h>
20 static unsigned long stack_dump_trace
[STACK_TRACE_ENTRIES
+1] =
21 { [0 ... (STACK_TRACE_ENTRIES
)] = ULONG_MAX
};
22 unsigned stack_trace_index
[STACK_TRACE_ENTRIES
];
25 * Reserve one entry for the passed in ip. This will allow
26 * us to remove most or all of the stack size overhead
27 * added by the stack tracer itself.
29 struct stack_trace stack_trace_max
= {
30 .max_entries
= STACK_TRACE_ENTRIES
- 1,
31 .entries
= &stack_dump_trace
[0],
34 unsigned long stack_trace_max_size
;
35 arch_spinlock_t stack_trace_max_lock
=
36 (arch_spinlock_t
)__ARCH_SPIN_LOCK_UNLOCKED
;
38 DEFINE_PER_CPU(int, disable_stack_tracer
);
39 static DEFINE_MUTEX(stack_sysctl_mutex
);
41 int stack_tracer_enabled
;
42 static int last_stack_tracer_enabled
;
44 void stack_trace_print(void)
49 pr_emerg(" Depth Size Location (%d entries)\n"
50 " ----- ---- --------\n",
51 stack_trace_max
.nr_entries
);
53 for (i
= 0; i
< stack_trace_max
.nr_entries
; i
++) {
54 if (stack_dump_trace
[i
] == ULONG_MAX
)
56 if (i
+1 == stack_trace_max
.nr_entries
||
57 stack_dump_trace
[i
+1] == ULONG_MAX
)
58 size
= stack_trace_index
[i
];
60 size
= stack_trace_index
[i
] - stack_trace_index
[i
+1];
62 pr_emerg("%3ld) %8d %5d %pS\n", i
, stack_trace_index
[i
],
63 size
, (void *)stack_dump_trace
[i
]);
68 * When arch-specific code overrides this function, the following
69 * data should be filled up, assuming stack_trace_max_lock is held to
70 * prevent concurrent updates.
73 * stack_trace_max_size
76 check_stack(unsigned long ip
, unsigned long *stack
)
78 unsigned long this_size
, flags
; unsigned long *p
, *top
, *start
;
79 static int tracer_frame
;
80 int frame_size
= ACCESS_ONCE(tracer_frame
);
83 this_size
= ((unsigned long)stack
) & (THREAD_SIZE
-1);
84 this_size
= THREAD_SIZE
- this_size
;
85 /* Remove the frame of the tracer */
86 this_size
-= frame_size
;
88 if (this_size
<= stack_trace_max_size
)
91 /* we do not handle interrupt stacks yet */
92 if (!object_is_on_stack(stack
))
95 /* Can't do this from NMI context (can cause deadlocks) */
100 * There's a slight chance that we are tracing inside the
101 * RCU infrastructure, and rcu_irq_enter() will not work
104 if (unlikely(rcu_irq_enter_disabled()))
107 local_irq_save(flags
);
108 arch_spin_lock(&stack_trace_max_lock
);
111 * RCU may not be watching, make it see us.
112 * The stack trace code uses rcu_sched.
116 /* In case another CPU set the tracer_frame on us */
117 if (unlikely(!frame_size
))
118 this_size
-= tracer_frame
;
120 /* a race could have already updated it */
121 if (this_size
<= stack_trace_max_size
)
124 stack_trace_max_size
= this_size
;
126 stack_trace_max
.nr_entries
= 0;
127 stack_trace_max
.skip
= 3;
129 save_stack_trace(&stack_trace_max
);
131 /* Skip over the overhead of the stack tracer itself */
132 for (i
= 0; i
< stack_trace_max
.nr_entries
; i
++) {
133 if (stack_dump_trace
[i
] == ip
)
138 * Some archs may not have the passed in ip in the dump.
139 * If that happens, we need to show everything.
141 if (i
== stack_trace_max
.nr_entries
)
145 * Now find where in the stack these are.
149 top
= (unsigned long *)
150 (((unsigned long)start
& ~(THREAD_SIZE
-1)) + THREAD_SIZE
);
153 * Loop through all the entries. One of the entries may
154 * for some reason be missed on the stack, so we may
155 * have to account for them. If they are all there, this
156 * loop will only happen once. This code only takes place
157 * on a new max, so it is far from a fast path.
159 while (i
< stack_trace_max
.nr_entries
) {
162 stack_trace_index
[x
] = this_size
;
165 for (; p
< top
&& i
< stack_trace_max
.nr_entries
; p
++) {
166 if (stack_dump_trace
[i
] == ULONG_MAX
)
169 * The READ_ONCE_NOCHECK is used to let KASAN know that
170 * this is not a stack-out-of-bounds error.
172 if ((READ_ONCE_NOCHECK(*p
)) == stack_dump_trace
[i
]) {
173 stack_dump_trace
[x
] = stack_dump_trace
[i
++];
174 this_size
= stack_trace_index
[x
++] =
175 (top
- p
) * sizeof(unsigned long);
177 /* Start the search from here */
180 * We do not want to show the overhead
181 * of the stack tracer stack in the
182 * max stack. If we haven't figured
183 * out what that is, then figure it out
186 if (unlikely(!tracer_frame
)) {
187 tracer_frame
= (p
- stack
) *
188 sizeof(unsigned long);
189 stack_trace_max_size
-= tracer_frame
;
198 stack_trace_max
.nr_entries
= x
;
200 stack_dump_trace
[x
] = ULONG_MAX
;
202 if (task_stack_end_corrupted(current
)) {
209 arch_spin_unlock(&stack_trace_max_lock
);
210 local_irq_restore(flags
);
214 stack_trace_call(unsigned long ip
, unsigned long parent_ip
,
215 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
219 preempt_disable_notrace();
221 /* no atomic needed, we only modify this variable by this cpu */
222 __this_cpu_inc(disable_stack_tracer
);
223 if (__this_cpu_read(disable_stack_tracer
) != 1)
226 ip
+= MCOUNT_INSN_SIZE
;
228 check_stack(ip
, &stack
);
231 __this_cpu_dec(disable_stack_tracer
);
232 /* prevent recursion in schedule */
233 preempt_enable_notrace();
236 static struct ftrace_ops trace_ops __read_mostly
=
238 .func
= stack_trace_call
,
239 .flags
= FTRACE_OPS_FL_RECURSION_SAFE
,
243 stack_max_size_read(struct file
*filp
, char __user
*ubuf
,
244 size_t count
, loff_t
*ppos
)
246 unsigned long *ptr
= filp
->private_data
;
250 r
= snprintf(buf
, sizeof(buf
), "%ld\n", *ptr
);
253 return simple_read_from_buffer(ubuf
, count
, ppos
, buf
, r
);
257 stack_max_size_write(struct file
*filp
, const char __user
*ubuf
,
258 size_t count
, loff_t
*ppos
)
260 long *ptr
= filp
->private_data
;
261 unsigned long val
, flags
;
264 ret
= kstrtoul_from_user(ubuf
, count
, 10, &val
);
268 local_irq_save(flags
);
271 * In case we trace inside arch_spin_lock() or after (NMI),
272 * we will cause circular lock, so we also need to increase
273 * the percpu disable_stack_tracer here.
275 __this_cpu_inc(disable_stack_tracer
);
277 arch_spin_lock(&stack_trace_max_lock
);
279 arch_spin_unlock(&stack_trace_max_lock
);
281 __this_cpu_dec(disable_stack_tracer
);
282 local_irq_restore(flags
);
287 static const struct file_operations stack_max_size_fops
= {
288 .open
= tracing_open_generic
,
289 .read
= stack_max_size_read
,
290 .write
= stack_max_size_write
,
291 .llseek
= default_llseek
,
295 __next(struct seq_file
*m
, loff_t
*pos
)
299 if (n
> stack_trace_max
.nr_entries
|| stack_dump_trace
[n
] == ULONG_MAX
)
302 m
->private = (void *)n
;
307 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
310 return __next(m
, pos
);
313 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
317 __this_cpu_inc(disable_stack_tracer
);
319 arch_spin_lock(&stack_trace_max_lock
);
322 return SEQ_START_TOKEN
;
324 return __next(m
, pos
);
327 static void t_stop(struct seq_file
*m
, void *p
)
329 arch_spin_unlock(&stack_trace_max_lock
);
331 __this_cpu_dec(disable_stack_tracer
);
336 static void trace_lookup_stack(struct seq_file
*m
, long i
)
338 unsigned long addr
= stack_dump_trace
[i
];
340 seq_printf(m
, "%pS\n", (void *)addr
);
343 static void print_disabled(struct seq_file
*m
)
346 "# Stack tracer disabled\n"
348 "# To enable the stack tracer, either add 'stacktrace' to the\n"
349 "# kernel command line\n"
350 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
354 static int t_show(struct seq_file
*m
, void *v
)
359 if (v
== SEQ_START_TOKEN
) {
360 seq_printf(m
, " Depth Size Location"
362 " ----- ---- --------\n",
363 stack_trace_max
.nr_entries
);
365 if (!stack_tracer_enabled
&& !stack_trace_max_size
)
373 if (i
>= stack_trace_max
.nr_entries
||
374 stack_dump_trace
[i
] == ULONG_MAX
)
377 if (i
+1 == stack_trace_max
.nr_entries
||
378 stack_dump_trace
[i
+1] == ULONG_MAX
)
379 size
= stack_trace_index
[i
];
381 size
= stack_trace_index
[i
] - stack_trace_index
[i
+1];
383 seq_printf(m
, "%3ld) %8d %5d ", i
, stack_trace_index
[i
], size
);
385 trace_lookup_stack(m
, i
);
390 static const struct seq_operations stack_trace_seq_ops
= {
397 static int stack_trace_open(struct inode
*inode
, struct file
*file
)
399 return seq_open(file
, &stack_trace_seq_ops
);
402 static const struct file_operations stack_trace_fops
= {
403 .open
= stack_trace_open
,
406 .release
= seq_release
,
410 stack_trace_filter_open(struct inode
*inode
, struct file
*file
)
412 return ftrace_regex_open(&trace_ops
, FTRACE_ITER_FILTER
,
416 static const struct file_operations stack_trace_filter_fops
= {
417 .open
= stack_trace_filter_open
,
419 .write
= ftrace_filter_write
,
420 .llseek
= tracing_lseek
,
421 .release
= ftrace_regex_release
,
425 stack_trace_sysctl(struct ctl_table
*table
, int write
,
426 void __user
*buffer
, size_t *lenp
,
431 mutex_lock(&stack_sysctl_mutex
);
433 ret
= proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
436 (last_stack_tracer_enabled
== !!stack_tracer_enabled
))
439 last_stack_tracer_enabled
= !!stack_tracer_enabled
;
441 if (stack_tracer_enabled
)
442 register_ftrace_function(&trace_ops
);
444 unregister_ftrace_function(&trace_ops
);
447 mutex_unlock(&stack_sysctl_mutex
);
451 static char stack_trace_filter_buf
[COMMAND_LINE_SIZE
+1] __initdata
;
453 static __init
int enable_stacktrace(char *str
)
455 if (strncmp(str
, "_filter=", 8) == 0)
456 strncpy(stack_trace_filter_buf
, str
+8, COMMAND_LINE_SIZE
);
458 stack_tracer_enabled
= 1;
459 last_stack_tracer_enabled
= 1;
462 __setup("stacktrace", enable_stacktrace
);
464 static __init
int stack_trace_init(void)
466 struct dentry
*d_tracer
;
468 d_tracer
= tracing_init_dentry();
469 if (IS_ERR(d_tracer
))
472 trace_create_file("stack_max_size", 0644, d_tracer
,
473 &stack_trace_max_size
, &stack_max_size_fops
);
475 trace_create_file("stack_trace", 0444, d_tracer
,
476 NULL
, &stack_trace_fops
);
478 trace_create_file("stack_trace_filter", 0444, d_tracer
,
479 NULL
, &stack_trace_filter_fops
);
481 if (stack_trace_filter_buf
[0])
482 ftrace_set_early_filter(&trace_ops
, stack_trace_filter_buf
, 1);
484 if (stack_tracer_enabled
)
485 register_ftrace_function(&trace_ops
);
490 device_initcall(stack_trace_init
);