xref: /openbmc/linux/kernel/trace/trace_stack.c (revision a2cce7a9)
1 /*
2  * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
3  *
4  */
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>
14 
15 #include <asm/setup.h>
16 
17 #include "trace.h"
18 
19 #define STACK_TRACE_ENTRIES 500
20 
21 static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
22 	 { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
23 static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
24 
25 /*
26  * Reserve one entry for the passed in ip. This will allow
27  * us to remove most or all of the stack size overhead
28  * added by the stack tracer itself.
29  */
30 static struct stack_trace max_stack_trace = {
31 	.max_entries		= STACK_TRACE_ENTRIES - 1,
32 	.entries		= &stack_dump_trace[0],
33 };
34 
35 static unsigned long max_stack_size;
36 static arch_spinlock_t max_stack_lock =
37 	(arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
38 
39 static DEFINE_PER_CPU(int, trace_active);
40 static DEFINE_MUTEX(stack_sysctl_mutex);
41 
42 int stack_tracer_enabled;
43 static int last_stack_tracer_enabled;
44 
45 static inline void print_max_stack(void)
46 {
47 	long i;
48 	int size;
49 
50 	pr_emerg("        Depth    Size   Location    (%d entries)\n"
51 			   "        -----    ----   --------\n",
52 			   max_stack_trace.nr_entries);
53 
54 	for (i = 0; i < max_stack_trace.nr_entries; i++) {
55 		if (stack_dump_trace[i] == ULONG_MAX)
56 			break;
57 		if (i+1 == max_stack_trace.nr_entries ||
58 				stack_dump_trace[i+1] == ULONG_MAX)
59 			size = stack_dump_index[i];
60 		else
61 			size = stack_dump_index[i] - stack_dump_index[i+1];
62 
63 		pr_emerg("%3ld) %8d   %5d   %pS\n", i, stack_dump_index[i],
64 				size, (void *)stack_dump_trace[i]);
65 	}
66 }
67 
68 static inline void
69 check_stack(unsigned long ip, unsigned long *stack)
70 {
71 	unsigned long this_size, flags; unsigned long *p, *top, *start;
72 	static int tracer_frame;
73 	int frame_size = ACCESS_ONCE(tracer_frame);
74 	int i, x;
75 
76 	this_size = ((unsigned long)stack) & (THREAD_SIZE-1);
77 	this_size = THREAD_SIZE - this_size;
78 	/* Remove the frame of the tracer */
79 	this_size -= frame_size;
80 
81 	if (this_size <= max_stack_size)
82 		return;
83 
84 	/* we do not handle interrupt stacks yet */
85 	if (!object_is_on_stack(stack))
86 		return;
87 
88 	local_irq_save(flags);
89 	arch_spin_lock(&max_stack_lock);
90 
91 	/* In case another CPU set the tracer_frame on us */
92 	if (unlikely(!frame_size))
93 		this_size -= tracer_frame;
94 
95 	/* a race could have already updated it */
96 	if (this_size <= max_stack_size)
97 		goto out;
98 
99 	max_stack_size = this_size;
100 
101 	max_stack_trace.nr_entries = 0;
102 	max_stack_trace.skip = 3;
103 
104 	save_stack_trace(&max_stack_trace);
105 
106 	/* Skip over the overhead of the stack tracer itself */
107 	for (i = 0; i < max_stack_trace.nr_entries; i++) {
108 		if (stack_dump_trace[i] == ip)
109 			break;
110 	}
111 
112 	/*
113 	 * Now find where in the stack these are.
114 	 */
115 	x = 0;
116 	start = stack;
117 	top = (unsigned long *)
118 		(((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
119 
120 	/*
121 	 * Loop through all the entries. One of the entries may
122 	 * for some reason be missed on the stack, so we may
123 	 * have to account for them. If they are all there, this
124 	 * loop will only happen once. This code only takes place
125 	 * on a new max, so it is far from a fast path.
126 	 */
127 	while (i < max_stack_trace.nr_entries) {
128 		int found = 0;
129 
130 		stack_dump_index[x] = this_size;
131 		p = start;
132 
133 		for (; p < top && i < max_stack_trace.nr_entries; p++) {
134 			if (stack_dump_trace[i] == ULONG_MAX)
135 				break;
136 			if (*p == stack_dump_trace[i]) {
137 				stack_dump_trace[x] = stack_dump_trace[i++];
138 				this_size = stack_dump_index[x++] =
139 					(top - p) * sizeof(unsigned long);
140 				found = 1;
141 				/* Start the search from here */
142 				start = p + 1;
143 				/*
144 				 * We do not want to show the overhead
145 				 * of the stack tracer stack in the
146 				 * max stack. If we haven't figured
147 				 * out what that is, then figure it out
148 				 * now.
149 				 */
150 				if (unlikely(!tracer_frame)) {
151 					tracer_frame = (p - stack) *
152 						sizeof(unsigned long);
153 					max_stack_size -= tracer_frame;
154 				}
155 			}
156 		}
157 
158 		if (!found)
159 			i++;
160 	}
161 
162 	max_stack_trace.nr_entries = x;
163 	for (; x < i; x++)
164 		stack_dump_trace[x] = ULONG_MAX;
165 
166 	if (task_stack_end_corrupted(current)) {
167 		print_max_stack();
168 		BUG();
169 	}
170 
171  out:
172 	arch_spin_unlock(&max_stack_lock);
173 	local_irq_restore(flags);
174 }
175 
176 static void
177 stack_trace_call(unsigned long ip, unsigned long parent_ip,
178 		 struct ftrace_ops *op, struct pt_regs *pt_regs)
179 {
180 	unsigned long stack;
181 	int cpu;
182 
183 	preempt_disable_notrace();
184 
185 	cpu = raw_smp_processor_id();
186 	/* no atomic needed, we only modify this variable by this cpu */
187 	if (per_cpu(trace_active, cpu)++ != 0)
188 		goto out;
189 
190 	ip += MCOUNT_INSN_SIZE;
191 
192 	check_stack(ip, &stack);
193 
194  out:
195 	per_cpu(trace_active, cpu)--;
196 	/* prevent recursion in schedule */
197 	preempt_enable_notrace();
198 }
199 
200 static struct ftrace_ops trace_ops __read_mostly =
201 {
202 	.func = stack_trace_call,
203 	.flags = FTRACE_OPS_FL_RECURSION_SAFE,
204 };
205 
206 static ssize_t
207 stack_max_size_read(struct file *filp, char __user *ubuf,
208 		    size_t count, loff_t *ppos)
209 {
210 	unsigned long *ptr = filp->private_data;
211 	char buf[64];
212 	int r;
213 
214 	r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
215 	if (r > sizeof(buf))
216 		r = sizeof(buf);
217 	return simple_read_from_buffer(ubuf, count, ppos, buf, r);
218 }
219 
220 static ssize_t
221 stack_max_size_write(struct file *filp, const char __user *ubuf,
222 		     size_t count, loff_t *ppos)
223 {
224 	long *ptr = filp->private_data;
225 	unsigned long val, flags;
226 	int ret;
227 	int cpu;
228 
229 	ret = kstrtoul_from_user(ubuf, count, 10, &val);
230 	if (ret)
231 		return ret;
232 
233 	local_irq_save(flags);
234 
235 	/*
236 	 * In case we trace inside arch_spin_lock() or after (NMI),
237 	 * we will cause circular lock, so we also need to increase
238 	 * the percpu trace_active here.
239 	 */
240 	cpu = smp_processor_id();
241 	per_cpu(trace_active, cpu)++;
242 
243 	arch_spin_lock(&max_stack_lock);
244 	*ptr = val;
245 	arch_spin_unlock(&max_stack_lock);
246 
247 	per_cpu(trace_active, cpu)--;
248 	local_irq_restore(flags);
249 
250 	return count;
251 }
252 
253 static const struct file_operations stack_max_size_fops = {
254 	.open		= tracing_open_generic,
255 	.read		= stack_max_size_read,
256 	.write		= stack_max_size_write,
257 	.llseek		= default_llseek,
258 };
259 
260 static void *
261 __next(struct seq_file *m, loff_t *pos)
262 {
263 	long n = *pos - 1;
264 
265 	if (n > max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
266 		return NULL;
267 
268 	m->private = (void *)n;
269 	return &m->private;
270 }
271 
272 static void *
273 t_next(struct seq_file *m, void *v, loff_t *pos)
274 {
275 	(*pos)++;
276 	return __next(m, pos);
277 }
278 
279 static void *t_start(struct seq_file *m, loff_t *pos)
280 {
281 	int cpu;
282 
283 	local_irq_disable();
284 
285 	cpu = smp_processor_id();
286 	per_cpu(trace_active, cpu)++;
287 
288 	arch_spin_lock(&max_stack_lock);
289 
290 	if (*pos == 0)
291 		return SEQ_START_TOKEN;
292 
293 	return __next(m, pos);
294 }
295 
296 static void t_stop(struct seq_file *m, void *p)
297 {
298 	int cpu;
299 
300 	arch_spin_unlock(&max_stack_lock);
301 
302 	cpu = smp_processor_id();
303 	per_cpu(trace_active, cpu)--;
304 
305 	local_irq_enable();
306 }
307 
308 static void trace_lookup_stack(struct seq_file *m, long i)
309 {
310 	unsigned long addr = stack_dump_trace[i];
311 
312 	seq_printf(m, "%pS\n", (void *)addr);
313 }
314 
315 static void print_disabled(struct seq_file *m)
316 {
317 	seq_puts(m, "#\n"
318 		 "#  Stack tracer disabled\n"
319 		 "#\n"
320 		 "# To enable the stack tracer, either add 'stacktrace' to the\n"
321 		 "# kernel command line\n"
322 		 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
323 		 "#\n");
324 }
325 
326 static int t_show(struct seq_file *m, void *v)
327 {
328 	long i;
329 	int size;
330 
331 	if (v == SEQ_START_TOKEN) {
332 		seq_printf(m, "        Depth    Size   Location"
333 			   "    (%d entries)\n"
334 			   "        -----    ----   --------\n",
335 			   max_stack_trace.nr_entries);
336 
337 		if (!stack_tracer_enabled && !max_stack_size)
338 			print_disabled(m);
339 
340 		return 0;
341 	}
342 
343 	i = *(long *)v;
344 
345 	if (i >= max_stack_trace.nr_entries ||
346 	    stack_dump_trace[i] == ULONG_MAX)
347 		return 0;
348 
349 	if (i+1 == max_stack_trace.nr_entries ||
350 	    stack_dump_trace[i+1] == ULONG_MAX)
351 		size = stack_dump_index[i];
352 	else
353 		size = stack_dump_index[i] - stack_dump_index[i+1];
354 
355 	seq_printf(m, "%3ld) %8d   %5d   ", i, stack_dump_index[i], size);
356 
357 	trace_lookup_stack(m, i);
358 
359 	return 0;
360 }
361 
362 static const struct seq_operations stack_trace_seq_ops = {
363 	.start		= t_start,
364 	.next		= t_next,
365 	.stop		= t_stop,
366 	.show		= t_show,
367 };
368 
369 static int stack_trace_open(struct inode *inode, struct file *file)
370 {
371 	return seq_open(file, &stack_trace_seq_ops);
372 }
373 
374 static const struct file_operations stack_trace_fops = {
375 	.open		= stack_trace_open,
376 	.read		= seq_read,
377 	.llseek		= seq_lseek,
378 	.release	= seq_release,
379 };
380 
381 static int
382 stack_trace_filter_open(struct inode *inode, struct file *file)
383 {
384 	return ftrace_regex_open(&trace_ops, FTRACE_ITER_FILTER,
385 				 inode, file);
386 }
387 
388 static const struct file_operations stack_trace_filter_fops = {
389 	.open = stack_trace_filter_open,
390 	.read = seq_read,
391 	.write = ftrace_filter_write,
392 	.llseek = tracing_lseek,
393 	.release = ftrace_regex_release,
394 };
395 
396 int
397 stack_trace_sysctl(struct ctl_table *table, int write,
398 		   void __user *buffer, size_t *lenp,
399 		   loff_t *ppos)
400 {
401 	int ret;
402 
403 	mutex_lock(&stack_sysctl_mutex);
404 
405 	ret = proc_dointvec(table, write, buffer, lenp, ppos);
406 
407 	if (ret || !write ||
408 	    (last_stack_tracer_enabled == !!stack_tracer_enabled))
409 		goto out;
410 
411 	last_stack_tracer_enabled = !!stack_tracer_enabled;
412 
413 	if (stack_tracer_enabled)
414 		register_ftrace_function(&trace_ops);
415 	else
416 		unregister_ftrace_function(&trace_ops);
417 
418  out:
419 	mutex_unlock(&stack_sysctl_mutex);
420 	return ret;
421 }
422 
423 static char stack_trace_filter_buf[COMMAND_LINE_SIZE+1] __initdata;
424 
425 static __init int enable_stacktrace(char *str)
426 {
427 	if (strncmp(str, "_filter=", 8) == 0)
428 		strncpy(stack_trace_filter_buf, str+8, COMMAND_LINE_SIZE);
429 
430 	stack_tracer_enabled = 1;
431 	last_stack_tracer_enabled = 1;
432 	return 1;
433 }
434 __setup("stacktrace", enable_stacktrace);
435 
436 static __init int stack_trace_init(void)
437 {
438 	struct dentry *d_tracer;
439 
440 	d_tracer = tracing_init_dentry();
441 	if (IS_ERR(d_tracer))
442 		return 0;
443 
444 	trace_create_file("stack_max_size", 0644, d_tracer,
445 			&max_stack_size, &stack_max_size_fops);
446 
447 	trace_create_file("stack_trace", 0444, d_tracer,
448 			NULL, &stack_trace_fops);
449 
450 	trace_create_file("stack_trace_filter", 0444, d_tracer,
451 			NULL, &stack_trace_filter_fops);
452 
453 	if (stack_trace_filter_buf[0])
454 		ftrace_set_early_filter(&trace_ops, stack_trace_filter_buf, 1);
455 
456 	if (stack_tracer_enabled)
457 		register_ftrace_function(&trace_ops);
458 
459 	return 0;
460 }
461 
462 device_initcall(stack_trace_init);
463