blob: 5a48dba912eaeb8bf8f9061b6120fdb566816e59 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Steven Rostedte5a81b62008-08-27 23:31:01 -04002/*
3 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
4 *
5 */
Ingo Molnar68db0cf2017-02-08 18:51:37 +01006#include <linux/sched/task_stack.h>
Steven Rostedte5a81b62008-08-27 23:31:01 -04007#include <linux/stacktrace.h>
Steven Rostedt (VMware)17911ff2019-10-11 17:22:50 -04008#include <linux/security.h>
Steven Rostedte5a81b62008-08-27 23:31:01 -04009#include <linux/kallsyms.h>
10#include <linux/seq_file.h>
11#include <linux/spinlock.h>
12#include <linux/uaccess.h>
Steven Rostedte5a81b62008-08-27 23:31:01 -040013#include <linux/ftrace.h>
14#include <linux/module.h>
Steven Rostedtf38f1d22008-12-16 23:06:40 -050015#include <linux/sysctl.h>
Steven Rostedte5a81b62008-08-27 23:31:01 -040016#include <linux/init.h>
Steven Rostedt762e1202011-12-19 22:01:00 -050017
18#include <asm/setup.h>
19
Steven Rostedte5a81b62008-08-27 23:31:01 -040020#include "trace.h"
21
Thomas Gleixner3d9a8072019-04-25 11:44:54 +020022#define STACK_TRACE_ENTRIES 500
Steven Rostedt1b6cced2008-08-29 16:51:43 -040023
Thomas Gleixner3d9a8072019-04-25 11:44:54 +020024static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES];
25static unsigned stack_trace_index[STACK_TRACE_ENTRIES];
26
Thomas Gleixner9f50c912019-04-25 11:45:17 +020027static unsigned int stack_trace_nr_entries;
Thomas Gleixner3d9a8072019-04-25 11:44:54 +020028static unsigned long stack_trace_max_size;
29static arch_spinlock_t stack_trace_max_lock =
Thomas Gleixneredc35bd2009-12-03 12:38:57 +010030 (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
Steven Rostedte5a81b62008-08-27 23:31:01 -040031
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -040032DEFINE_PER_CPU(int, disable_stack_tracer);
Steven Rostedtf38f1d22008-12-16 23:06:40 -050033static DEFINE_MUTEX(stack_sysctl_mutex);
34
35int stack_tracer_enabled;
Steven Rostedte5a81b62008-08-27 23:31:01 -040036
Thomas Gleixner3d9a8072019-04-25 11:44:54 +020037static void print_max_stack(void)
Minchan Kime3172182014-06-02 13:33:12 +090038{
39 long i;
40 int size;
41
42 pr_emerg(" Depth Size Location (%d entries)\n"
43 " ----- ---- --------\n",
Thomas Gleixner9f50c912019-04-25 11:45:17 +020044 stack_trace_nr_entries);
Minchan Kime3172182014-06-02 13:33:12 +090045
Thomas Gleixner9f50c912019-04-25 11:45:17 +020046 for (i = 0; i < stack_trace_nr_entries; i++) {
47 if (i + 1 == stack_trace_nr_entries)
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +090048 size = stack_trace_index[i];
Minchan Kime3172182014-06-02 13:33:12 +090049 else
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +090050 size = stack_trace_index[i] - stack_trace_index[i+1];
Minchan Kime3172182014-06-02 13:33:12 +090051
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +090052 pr_emerg("%3ld) %8d %5d %pS\n", i, stack_trace_index[i],
Minchan Kime3172182014-06-02 13:33:12 +090053 size, (void *)stack_dump_trace[i]);
54 }
55}
56
Steven Rostedt (VMware)58fe7a82019-08-07 12:27:30 -040057/*
58 * The stack tracer looks for a maximum stack at each call from a function. It
59 * registers a callback from ftrace, and in that callback it examines the stack
60 * size. It determines the stack size from the variable passed in, which is the
61 * address of a local variable in the stack_trace_call() callback function.
62 * The stack size is calculated by the address of the local variable to the top
63 * of the current stack. If that size is smaller than the currently saved max
64 * stack size, nothing more is done.
65 *
66 * If the size of the stack is greater than the maximum recorded size, then the
67 * following algorithm takes place.
68 *
69 * For architectures (like x86) that store the function's return address before
70 * saving the function's local variables, the stack will look something like
71 * this:
72 *
73 * [ top of stack ]
74 * 0: sys call entry frame
75 * 10: return addr to entry code
76 * 11: start of sys_foo frame
77 * 20: return addr to sys_foo
78 * 21: start of kernel_func_bar frame
79 * 30: return addr to kernel_func_bar
80 * 31: [ do trace stack here ]
81 *
82 * The save_stack_trace() is called returning all the functions it finds in the
83 * current stack. Which would be (from the bottom of the stack to the top):
84 *
85 * return addr to kernel_func_bar
86 * return addr to sys_foo
87 * return addr to entry code
88 *
89 * Now to figure out how much each of these functions' local variable size is,
90 * a search of the stack is made to find these values. When a match is made, it
91 * is added to the stack_dump_trace[] array. The offset into the stack is saved
92 * in the stack_trace_index[] array. The above example would show:
93 *
94 * stack_dump_trace[] | stack_trace_index[]
95 * ------------------ + -------------------
96 * return addr to kernel_func_bar | 30
97 * return addr to sys_foo | 20
98 * return addr to entry | 10
99 *
100 * The print_max_stack() function above, uses these values to print the size of
101 * each function's portion of the stack.
102 *
103 * for (i = 0; i < nr_entries; i++) {
104 * size = i == nr_entries - 1 ? stack_trace_index[i] :
105 * stack_trace_index[i] - stack_trace_index[i+1]
106 * print "%d %d %d %s\n", i, stack_trace_index[i], size, stack_dump_trace[i]);
107 * }
108 *
109 * The above shows
110 *
111 * depth size location
112 * ----- ---- --------
113 * 0 30 10 kernel_func_bar
114 * 1 20 10 sys_foo
115 * 2 10 10 entry code
116 *
117 * Now for architectures that might save the return address after the functions
118 * local variables (saving the link register before calling nested functions),
119 * this will cause the stack to look a little different:
120 *
121 * [ top of stack ]
122 * 0: sys call entry frame
123 * 10: start of sys_foo_frame
124 * 19: return addr to entry code << lr saved before calling kernel_func_bar
125 * 20: start of kernel_func_bar frame
126 * 29: return addr to sys_foo_frame << lr saved before calling next function
127 * 30: [ do trace stack here ]
128 *
129 * Although the functions returned by save_stack_trace() may be the same, the
130 * placement in the stack will be different. Using the same algorithm as above
131 * would yield:
132 *
133 * stack_dump_trace[] | stack_trace_index[]
134 * ------------------ + -------------------
135 * return addr to kernel_func_bar | 30
136 * return addr to sys_foo | 29
137 * return addr to entry | 19
138 *
139 * Where the mapping is off by one:
140 *
141 * kernel_func_bar stack frame size is 29 - 19 not 30 - 29!
142 *
143 * To fix this, if the architecture sets ARCH_RET_ADDR_AFTER_LOCAL_VARS the
144 * values in stack_trace_index[] are shifted by one to and the number of
145 * stack trace entries is decremented by one.
146 *
147 * stack_dump_trace[] | stack_trace_index[]
148 * ------------------ + -------------------
149 * return addr to kernel_func_bar | 29
150 * return addr to sys_foo | 19
151 *
152 * Although the entry function is not displayed, the first function (sys_foo)
153 * will still include the stack size of it.
154 */
Thomas Gleixner3d9a8072019-04-25 11:44:54 +0200155static void check_stack(unsigned long ip, unsigned long *stack)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400156{
Minchan Kime3172182014-06-02 13:33:12 +0900157 unsigned long this_size, flags; unsigned long *p, *top, *start;
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400158 static int tracer_frame;
Mark Rutland6aa7de02017-10-23 14:07:29 -0700159 int frame_size = READ_ONCE(tracer_frame);
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400160 int i, x;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400161
Steven Rostedt (Red Hat)878895012013-03-13 20:43:57 -0400162 this_size = ((unsigned long)stack) & (THREAD_SIZE-1);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400163 this_size = THREAD_SIZE - this_size;
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400164 /* Remove the frame of the tracer */
165 this_size -= frame_size;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400166
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900167 if (this_size <= stack_trace_max_size)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400168 return;
169
Steven Rostedt81520a12008-10-06 21:24:18 -0400170 /* we do not handle interrupt stacks yet */
Steven Rostedt (Red Hat)878895012013-03-13 20:43:57 -0400171 if (!object_is_on_stack(stack))
Steven Rostedt81520a12008-10-06 21:24:18 -0400172 return;
173
Steven Rostedt (Red Hat)1904be12015-10-20 21:48:02 -0400174 /* Can't do this from NMI context (can cause deadlocks) */
175 if (in_nmi())
176 return;
177
Steven Rostedta5e25882008-12-02 15:34:05 -0500178 local_irq_save(flags);
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500179 arch_spin_lock(&stack_trace_max_lock);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400180
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400181 /* In case another CPU set the tracer_frame on us */
182 if (unlikely(!frame_size))
183 this_size -= tracer_frame;
184
Steven Rostedte5a81b62008-08-27 23:31:01 -0400185 /* a race could have already updated it */
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900186 if (this_size <= stack_trace_max_size)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400187 goto out;
188
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900189 stack_trace_max_size = this_size;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400190
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200191 stack_trace_nr_entries = stack_trace_save(stack_dump_trace,
192 ARRAY_SIZE(stack_dump_trace) - 1,
193 0);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400194
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400195 /* Skip over the overhead of the stack tracer itself */
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200196 for (i = 0; i < stack_trace_nr_entries; i++) {
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400197 if (stack_dump_trace[i] == ip)
198 break;
199 }
Steven Rostedt (Red Hat)d4ecbfc2013-03-13 21:25:35 -0400200
201 /*
Steven Rostedt6ccd8372016-01-29 10:22:41 -0500202 * Some archs may not have the passed in ip in the dump.
203 * If that happens, we need to show everything.
204 */
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200205 if (i == stack_trace_nr_entries)
Steven Rostedt6ccd8372016-01-29 10:22:41 -0500206 i = 0;
207
208 /*
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400209 * Now find where in the stack these are.
210 */
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400211 x = 0;
Steven Rostedt (Red Hat)878895012013-03-13 20:43:57 -0400212 start = stack;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400213 top = (unsigned long *)
214 (((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
215
216 /*
217 * Loop through all the entries. One of the entries may
218 * for some reason be missed on the stack, so we may
219 * have to account for them. If they are all there, this
220 * loop will only happen once. This code only takes place
221 * on a new max, so it is far from a fast path.
222 */
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200223 while (i < stack_trace_nr_entries) {
Steven Rostedt0a371192008-12-03 11:04:50 -0500224 int found = 0;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400225
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900226 stack_trace_index[x] = this_size;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400227 p = start;
228
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200229 for (; p < top && i < stack_trace_nr_entries; p++) {
Yang Shi6e22c832016-02-12 12:46:00 -0800230 /*
231 * The READ_ONCE_NOCHECK is used to let KASAN know that
232 * this is not a stack-out-of-bounds error.
233 */
234 if ((READ_ONCE_NOCHECK(*p)) == stack_dump_trace[i]) {
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400235 stack_dump_trace[x] = stack_dump_trace[i++];
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900236 this_size = stack_trace_index[x++] =
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400237 (top - p) * sizeof(unsigned long);
Steven Rostedt0a371192008-12-03 11:04:50 -0500238 found = 1;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400239 /* Start the search from here */
240 start = p + 1;
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400241 /*
242 * We do not want to show the overhead
243 * of the stack tracer stack in the
244 * max stack. If we haven't figured
245 * out what that is, then figure it out
246 * now.
247 */
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400248 if (unlikely(!tracer_frame)) {
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400249 tracer_frame = (p - stack) *
250 sizeof(unsigned long);
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900251 stack_trace_max_size -= tracer_frame;
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400252 }
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400253 }
254 }
255
Steven Rostedt0a371192008-12-03 11:04:50 -0500256 if (!found)
257 i++;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400258 }
259
Steven Rostedt (VMware)f7edb452019-08-07 11:28:59 -0400260#ifdef ARCH_FTRACE_SHIFT_STACK_TRACER
261 /*
262 * Some archs will store the link register before calling
263 * nested functions. This means the saved return address
264 * comes after the local storage, and we need to shift
265 * for that.
266 */
267 if (x > 1) {
268 memmove(&stack_trace_index[0], &stack_trace_index[1],
269 sizeof(stack_trace_index[0]) * (x - 1));
270 x--;
271 }
272#endif
273
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200274 stack_trace_nr_entries = x;
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400275
Aaron Tomlina70857e2014-09-12 14:16:18 +0100276 if (task_stack_end_corrupted(current)) {
Thomas Gleixner3d9a8072019-04-25 11:44:54 +0200277 print_max_stack();
Minchan Kime3172182014-06-02 13:33:12 +0900278 BUG();
279 }
280
Steven Rostedte5a81b62008-08-27 23:31:01 -0400281 out:
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500282 arch_spin_unlock(&stack_trace_max_lock);
Steven Rostedta5e25882008-12-02 15:34:05 -0500283 local_irq_restore(flags);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400284}
285
Steven Rostedt (VMware)b8299d32020-01-02 22:02:41 -0500286/* Some archs may not define MCOUNT_INSN_SIZE */
287#ifndef MCOUNT_INSN_SIZE
288# define MCOUNT_INSN_SIZE 0
289#endif
290
Steven Rostedte5a81b62008-08-27 23:31:01 -0400291static void
Steven Rostedta1e2e312011-08-09 12:50:46 -0400292stack_trace_call(unsigned long ip, unsigned long parent_ip,
Steven Rostedt (VMware)d19ad072020-10-28 17:42:17 -0400293 struct ftrace_ops *op, struct ftrace_regs *fregs)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400294{
Steven Rostedt (Red Hat)878895012013-03-13 20:43:57 -0400295 unsigned long stack;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400296
Steven Rostedt5168ae52010-06-03 09:36:50 -0400297 preempt_disable_notrace();
Steven Rostedte5a81b62008-08-27 23:31:01 -0400298
Steven Rostedte5a81b62008-08-27 23:31:01 -0400299 /* no atomic needed, we only modify this variable by this cpu */
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400300 __this_cpu_inc(disable_stack_tracer);
301 if (__this_cpu_read(disable_stack_tracer) != 1)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400302 goto out;
303
Steven Rostedt (VMware)b00d6072017-12-05 04:41:51 -0500304 /* If rcu is not watching, then save stack trace can fail */
305 if (!rcu_is_watching())
306 goto out;
307
Steven Rostedt (Red Hat)72ac4262015-07-16 13:24:54 -0400308 ip += MCOUNT_INSN_SIZE;
Steven Rostedt (Red Hat)4df29712013-03-13 23:34:22 -0400309
310 check_stack(ip, &stack);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400311
312 out:
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400313 __this_cpu_dec(disable_stack_tracer);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400314 /* prevent recursion in schedule */
Steven Rostedt5168ae52010-06-03 09:36:50 -0400315 preempt_enable_notrace();
Steven Rostedte5a81b62008-08-27 23:31:01 -0400316}
317
318static struct ftrace_ops trace_ops __read_mostly =
319{
320 .func = stack_trace_call,
321};
322
323static ssize_t
324stack_max_size_read(struct file *filp, char __user *ubuf,
325 size_t count, loff_t *ppos)
326{
327 unsigned long *ptr = filp->private_data;
328 char buf[64];
329 int r;
330
331 r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
332 if (r > sizeof(buf))
333 r = sizeof(buf);
334 return simple_read_from_buffer(ubuf, count, ppos, buf, r);
335}
336
337static ssize_t
338stack_max_size_write(struct file *filp, const char __user *ubuf,
339 size_t count, loff_t *ppos)
340{
341 long *ptr = filp->private_data;
342 unsigned long val, flags;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400343 int ret;
344
Peter Huewe22fe9b52011-06-07 21:58:27 +0200345 ret = kstrtoul_from_user(ubuf, count, 10, &val);
346 if (ret)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400347 return ret;
348
Steven Rostedta5e25882008-12-02 15:34:05 -0500349 local_irq_save(flags);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800350
351 /*
352 * In case we trace inside arch_spin_lock() or after (NMI),
353 * we will cause circular lock, so we also need to increase
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400354 * the percpu disable_stack_tracer here.
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800355 */
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400356 __this_cpu_inc(disable_stack_tracer);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800357
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500358 arch_spin_lock(&stack_trace_max_lock);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400359 *ptr = val;
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500360 arch_spin_unlock(&stack_trace_max_lock);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800361
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400362 __this_cpu_dec(disable_stack_tracer);
Steven Rostedta5e25882008-12-02 15:34:05 -0500363 local_irq_restore(flags);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400364
365 return count;
366}
367
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500368static const struct file_operations stack_max_size_fops = {
Steven Rostedte5a81b62008-08-27 23:31:01 -0400369 .open = tracing_open_generic,
370 .read = stack_max_size_read,
371 .write = stack_max_size_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200372 .llseek = default_llseek,
Steven Rostedte5a81b62008-08-27 23:31:01 -0400373};
374
375static void *
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800376__next(struct seq_file *m, loff_t *pos)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400377{
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800378 long n = *pos - 1;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400379
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200380 if (n >= stack_trace_nr_entries)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400381 return NULL;
382
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800383 m->private = (void *)n;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400384 return &m->private;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400385}
386
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800387static void *
388t_next(struct seq_file *m, void *v, loff_t *pos)
389{
390 (*pos)++;
391 return __next(m, pos);
392}
393
Steven Rostedte5a81b62008-08-27 23:31:01 -0400394static void *t_start(struct seq_file *m, loff_t *pos)
395{
Steven Rostedte5a81b62008-08-27 23:31:01 -0400396 local_irq_disable();
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800397
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400398 __this_cpu_inc(disable_stack_tracer);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800399
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500400 arch_spin_lock(&stack_trace_max_lock);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400401
Liming Wang522a1102008-11-21 11:00:18 +0800402 if (*pos == 0)
403 return SEQ_START_TOKEN;
404
Li Zefan2fc5f0c2009-08-17 16:53:37 +0800405 return __next(m, pos);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400406}
407
408static void t_stop(struct seq_file *m, void *p)
409{
Steven Rostedt (Red Hat)d3327362015-11-03 14:50:15 -0500410 arch_spin_unlock(&stack_trace_max_lock);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800411
Steven Rostedt (VMware)8aaf1ee2017-04-06 15:47:32 -0400412 __this_cpu_dec(disable_stack_tracer);
Lai Jiangshan4f48f8b2010-02-02 15:32:09 +0800413
Steven Rostedte5a81b62008-08-27 23:31:01 -0400414 local_irq_enable();
415}
416
Joe Perches962e3702015-04-15 16:18:22 -0700417static void trace_lookup_stack(struct seq_file *m, long i)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400418{
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400419 unsigned long addr = stack_dump_trace[i];
Steven Rostedte5a81b62008-08-27 23:31:01 -0400420
Joe Perches962e3702015-04-15 16:18:22 -0700421 seq_printf(m, "%pS\n", (void *)addr);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400422}
423
Steven Rostedte447e1df2009-03-12 19:42:29 -0400424static void print_disabled(struct seq_file *m)
425{
426 seq_puts(m, "#\n"
427 "# Stack tracer disabled\n"
428 "#\n"
429 "# To enable the stack tracer, either add 'stacktrace' to the\n"
430 "# kernel command line\n"
431 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
432 "#\n");
433}
434
Steven Rostedte5a81b62008-08-27 23:31:01 -0400435static int t_show(struct seq_file *m, void *v)
436{
Liming Wang522a1102008-11-21 11:00:18 +0800437 long i;
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400438 int size;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400439
Liming Wang522a1102008-11-21 11:00:18 +0800440 if (v == SEQ_START_TOKEN) {
Steven Rostedteb1871f2009-03-13 00:00:58 -0400441 seq_printf(m, " Depth Size Location"
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400442 " (%d entries)\n"
Steven Rostedteb1871f2009-03-13 00:00:58 -0400443 " ----- ---- --------\n",
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200444 stack_trace_nr_entries);
Steven Rostedte447e1df2009-03-12 19:42:29 -0400445
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900446 if (!stack_tracer_enabled && !stack_trace_max_size)
Steven Rostedte447e1df2009-03-12 19:42:29 -0400447 print_disabled(m);
448
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400449 return 0;
450 }
451
Liming Wang522a1102008-11-21 11:00:18 +0800452 i = *(long *)v;
453
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200454 if (i >= stack_trace_nr_entries)
Steven Rostedte5a81b62008-08-27 23:31:01 -0400455 return 0;
456
Thomas Gleixner9f50c912019-04-25 11:45:17 +0200457 if (i + 1 == stack_trace_nr_entries)
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900458 size = stack_trace_index[i];
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400459 else
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900460 size = stack_trace_index[i] - stack_trace_index[i+1];
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400461
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900462 seq_printf(m, "%3ld) %8d %5d ", i, stack_trace_index[i], size);
Steven Rostedt1b6cced2008-08-29 16:51:43 -0400463
464 trace_lookup_stack(m, i);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400465
466 return 0;
467}
468
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500469static const struct seq_operations stack_trace_seq_ops = {
Steven Rostedte5a81b62008-08-27 23:31:01 -0400470 .start = t_start,
471 .next = t_next,
472 .stop = t_stop,
473 .show = t_show,
474};
475
476static int stack_trace_open(struct inode *inode, struct file *file)
477{
Steven Rostedt (VMware)17911ff2019-10-11 17:22:50 -0400478 int ret;
479
480 ret = security_locked_down(LOCKDOWN_TRACEFS);
481 if (ret)
482 return ret;
483
Li Zefand8cc1ab2009-07-23 11:28:40 +0800484 return seq_open(file, &stack_trace_seq_ops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400485}
486
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500487static const struct file_operations stack_trace_fops = {
Steven Rostedte5a81b62008-08-27 23:31:01 -0400488 .open = stack_trace_open,
489 .read = seq_read,
490 .llseek = seq_lseek,
Li Zefand8cc1ab2009-07-23 11:28:40 +0800491 .release = seq_release,
Steven Rostedte5a81b62008-08-27 23:31:01 -0400492};
493
Steven Rostedt (VMware)bbd1d272017-07-11 19:21:04 -0400494#ifdef CONFIG_DYNAMIC_FTRACE
495
Steven Rostedtd2d45c72011-12-19 14:44:09 -0500496static int
497stack_trace_filter_open(struct inode *inode, struct file *file)
498{
Steven Rostedt (VMware)0f179762017-06-29 10:05:45 -0400499 struct ftrace_ops *ops = inode->i_private;
500
Steven Rostedt (VMware)17911ff2019-10-11 17:22:50 -0400501 /* Checks for tracefs lockdown */
Steven Rostedt (VMware)0f179762017-06-29 10:05:45 -0400502 return ftrace_regex_open(ops, FTRACE_ITER_FILTER,
Steven Rostedtd2d45c72011-12-19 14:44:09 -0500503 inode, file);
504}
505
506static const struct file_operations stack_trace_filter_fops = {
507 .open = stack_trace_filter_open,
508 .read = seq_read,
509 .write = ftrace_filter_write,
Steven Rostedt (Red Hat)098c879e2013-12-21 17:39:40 -0500510 .llseek = tracing_lseek,
Steven Rostedtd2d45c72011-12-19 14:44:09 -0500511 .release = ftrace_regex_release,
512};
513
Steven Rostedt (VMware)bbd1d272017-07-11 19:21:04 -0400514#endif /* CONFIG_DYNAMIC_FTRACE */
515
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500516int
Christoph Hellwig7ff0d442020-06-03 07:52:37 +0200517stack_trace_sysctl(struct ctl_table *table, int write, void *buffer,
518 size_t *lenp, loff_t *ppos)
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500519{
Thomas Gleixner3d9a8072019-04-25 11:44:54 +0200520 int was_enabled;
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500521 int ret;
522
523 mutex_lock(&stack_sysctl_mutex);
Thomas Gleixner3d9a8072019-04-25 11:44:54 +0200524 was_enabled = !!stack_tracer_enabled;
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500525
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700526 ret = proc_dointvec(table, write, buffer, lenp, ppos);
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500527
Thomas Gleixner3d9a8072019-04-25 11:44:54 +0200528 if (ret || !write || (was_enabled == !!stack_tracer_enabled))
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500529 goto out;
530
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500531 if (stack_tracer_enabled)
532 register_ftrace_function(&trace_ops);
533 else
534 unregister_ftrace_function(&trace_ops);
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500535 out:
536 mutex_unlock(&stack_sysctl_mutex);
537 return ret;
538}
539
Steven Rostedt762e1202011-12-19 22:01:00 -0500540static char stack_trace_filter_buf[COMMAND_LINE_SIZE+1] __initdata;
541
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500542static __init int enable_stacktrace(char *str)
543{
Steven Rostedt (VMware)3d739c12018-12-21 23:10:26 -0500544 int len;
545
546 if ((len = str_has_prefix(str, "_filter=")))
547 strncpy(stack_trace_filter_buf, str + len, COMMAND_LINE_SIZE);
Steven Rostedt762e1202011-12-19 22:01:00 -0500548
Steven Rostedte05a43b2008-12-17 09:43:00 -0500549 stack_tracer_enabled = 1;
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500550 return 1;
551}
552__setup("stacktrace", enable_stacktrace);
553
Steven Rostedte5a81b62008-08-27 23:31:01 -0400554static __init int stack_trace_init(void)
555{
Wei Yang22c36b12020-07-12 09:10:36 +0800556 int ret;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400557
Wei Yang22c36b12020-07-12 09:10:36 +0800558 ret = tracing_init_dentry();
559 if (ret)
Namhyung Kimed6f1c92013-04-10 09:18:12 +0900560 return 0;
Steven Rostedte5a81b62008-08-27 23:31:01 -0400561
Steven Rostedt (VMware)21ccc9c2021-08-18 11:24:51 -0400562 trace_create_file("stack_max_size", TRACE_MODE_WRITE, NULL,
AKASHI Takahirobb99d8c2015-10-30 14:25:39 +0900563 &stack_trace_max_size, &stack_max_size_fops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400564
Steven Rostedt (VMware)21ccc9c2021-08-18 11:24:51 -0400565 trace_create_file("stack_trace", TRACE_MODE_READ, NULL,
Frederic Weisbecker5452af62009-03-27 00:25:38 +0100566 NULL, &stack_trace_fops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400567
Steven Rostedt (VMware)bbd1d272017-07-11 19:21:04 -0400568#ifdef CONFIG_DYNAMIC_FTRACE
Steven Rostedt (VMware)21ccc9c2021-08-18 11:24:51 -0400569 trace_create_file("stack_trace_filter", TRACE_MODE_WRITE, NULL,
Steven Rostedt (VMware)0f179762017-06-29 10:05:45 -0400570 &trace_ops, &stack_trace_filter_fops);
Steven Rostedt (VMware)bbd1d272017-07-11 19:21:04 -0400571#endif
Steven Rostedtd2d45c72011-12-19 14:44:09 -0500572
Steven Rostedt762e1202011-12-19 22:01:00 -0500573 if (stack_trace_filter_buf[0])
574 ftrace_set_early_filter(&trace_ops, stack_trace_filter_buf, 1);
575
Steven Rostedte05a43b2008-12-17 09:43:00 -0500576 if (stack_tracer_enabled)
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500577 register_ftrace_function(&trace_ops);
Steven Rostedte5a81b62008-08-27 23:31:01 -0400578
579 return 0;
580}
581
582device_initcall(stack_trace_init);