trace_stack.c 7.5 KB
Newer Older
S
Steven Rostedt 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
 *
 */
#include <linux/stacktrace.h>
#include <linux/kallsyms.h>
#include <linux/seq_file.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <linux/ftrace.h>
#include <linux/module.h>
13
#include <linux/sysctl.h>
S
Steven Rostedt 已提交
14 15 16 17 18 19
#include <linux/init.h>
#include <linux/fs.h>
#include "trace.h"

#define STACK_TRACE_ENTRIES 500

S
Steven Rostedt 已提交
20 21 22 23
static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
	 { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
static unsigned stack_dump_index[STACK_TRACE_ENTRIES];

S
Steven Rostedt 已提交
24 25 26 27 28 29 30 31 32 33 34
static struct stack_trace max_stack_trace = {
	.max_entries		= STACK_TRACE_ENTRIES,
	.entries		= stack_dump_trace,
};

static unsigned long max_stack_size;
static raw_spinlock_t max_stack_lock =
	(raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;

static int stack_trace_disabled __read_mostly;
static DEFINE_PER_CPU(int, trace_active);
35 36 37 38
static DEFINE_MUTEX(stack_sysctl_mutex);

int stack_tracer_enabled;
static int last_stack_tracer_enabled;
S
Steven Rostedt 已提交
39 40 41

static inline void check_stack(void)
{
S
Steven Rostedt 已提交
42 43 44
	unsigned long this_size, flags;
	unsigned long *p, *top, *start;
	int i;
S
Steven Rostedt 已提交
45 46 47 48 49 50 51

	this_size = ((unsigned long)&this_size) & (THREAD_SIZE-1);
	this_size = THREAD_SIZE - this_size;

	if (this_size <= max_stack_size)
		return;

52 53 54 55
	/* we do not handle interrupt stacks yet */
	if (!object_is_on_stack(&this_size))
		return;

56
	local_irq_save(flags);
S
Steven Rostedt 已提交
57 58 59 60 61 62 63 64 65
	__raw_spin_lock(&max_stack_lock);

	/* a race could have already updated it */
	if (this_size <= max_stack_size)
		goto out;

	max_stack_size = this_size;

	max_stack_trace.nr_entries	= 0;
S
Steven Rostedt 已提交
66
	max_stack_trace.skip		= 3;
S
Steven Rostedt 已提交
67 68 69

	save_stack_trace(&max_stack_trace);

S
Steven Rostedt 已提交
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
	/*
	 * Now find where in the stack these are.
	 */
	i = 0;
	start = &this_size;
	top = (unsigned long *)
		(((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);

	/*
	 * Loop through all the entries. One of the entries may
	 * for some reason be missed on the stack, so we may
	 * have to account for them. If they are all there, this
	 * loop will only happen once. This code only takes place
	 * on a new max, so it is far from a fast path.
	 */
	while (i < max_stack_trace.nr_entries) {
S
Steven Rostedt 已提交
86
		int found = 0;
S
Steven Rostedt 已提交
87 88 89 90 91 92 93 94

		stack_dump_index[i] = this_size;
		p = start;

		for (; p < top && i < max_stack_trace.nr_entries; p++) {
			if (*p == stack_dump_trace[i]) {
				this_size = stack_dump_index[i++] =
					(top - p) * sizeof(unsigned long);
S
Steven Rostedt 已提交
95
				found = 1;
S
Steven Rostedt 已提交
96 97 98 99 100
				/* Start the search from here */
				start = p + 1;
			}
		}

S
Steven Rostedt 已提交
101 102
		if (!found)
			i++;
S
Steven Rostedt 已提交
103 104
	}

S
Steven Rostedt 已提交
105 106
 out:
	__raw_spin_unlock(&max_stack_lock);
107
	local_irq_restore(flags);
S
Steven Rostedt 已提交
108 109 110 111 112 113 114 115 116 117
}

static void
stack_trace_call(unsigned long ip, unsigned long parent_ip)
{
	int cpu, resched;

	if (unlikely(!ftrace_enabled || stack_trace_disabled))
		return;

118
	resched = ftrace_preempt_disable();
S
Steven Rostedt 已提交
119 120 121 122 123 124 125 126 127 128 129

	cpu = raw_smp_processor_id();
	/* no atomic needed, we only modify this variable by this cpu */
	if (per_cpu(trace_active, cpu)++ != 0)
		goto out;

	check_stack();

 out:
	per_cpu(trace_active, cpu)--;
	/* prevent recursion in schedule */
130
	ftrace_preempt_enable(resched);
S
Steven Rostedt 已提交
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
}

static struct ftrace_ops trace_ops __read_mostly =
{
	.func = stack_trace_call,
};

static ssize_t
stack_max_size_read(struct file *filp, char __user *ubuf,
		    size_t count, loff_t *ppos)
{
	unsigned long *ptr = filp->private_data;
	char buf[64];
	int r;

	r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
	if (r > sizeof(buf))
		r = sizeof(buf);
	return simple_read_from_buffer(ubuf, count, ppos, buf, r);
}

static ssize_t
stack_max_size_write(struct file *filp, const char __user *ubuf,
		     size_t count, loff_t *ppos)
{
	long *ptr = filp->private_data;
	unsigned long val, flags;
	char buf[64];
	int ret;

	if (count >= sizeof(buf))
		return -EINVAL;

	if (copy_from_user(&buf, ubuf, count))
		return -EFAULT;

	buf[count] = 0;

	ret = strict_strtoul(buf, 10, &val);
	if (ret < 0)
		return ret;

173
	local_irq_save(flags);
S
Steven Rostedt 已提交
174 175 176
	__raw_spin_lock(&max_stack_lock);
	*ptr = val;
	__raw_spin_unlock(&max_stack_lock);
177
	local_irq_restore(flags);
S
Steven Rostedt 已提交
178 179 180 181

	return count;
}

182
static const struct file_operations stack_max_size_fops = {
S
Steven Rostedt 已提交
183 184 185 186 187 188 189 190
	.open		= tracing_open_generic,
	.read		= stack_max_size_read,
	.write		= stack_max_size_write,
};

static void *
t_next(struct seq_file *m, void *v, loff_t *pos)
{
191
	long i;
S
Steven Rostedt 已提交
192 193 194

	(*pos)++;

195 196 197 198 199 200
	if (v == SEQ_START_TOKEN)
		i = 0;
	else {
		i = *(long *)v;
		i++;
	}
S
Steven Rostedt 已提交
201 202 203

	if (i >= max_stack_trace.nr_entries ||
	    stack_dump_trace[i] == ULONG_MAX)
S
Steven Rostedt 已提交
204 205
		return NULL;

S
Steven Rostedt 已提交
206
	m->private = (void *)i;
S
Steven Rostedt 已提交
207

S
Steven Rostedt 已提交
208
	return &m->private;
S
Steven Rostedt 已提交
209 210 211 212
}

static void *t_start(struct seq_file *m, loff_t *pos)
{
213
	void *t = SEQ_START_TOKEN;
S
Steven Rostedt 已提交
214 215 216 217 218
	loff_t l = 0;

	local_irq_disable();
	__raw_spin_lock(&max_stack_lock);

219 220 221
	if (*pos == 0)
		return SEQ_START_TOKEN;

S
Steven Rostedt 已提交
222 223 224 225 226 227 228 229 230 231 232 233
	for (; t && l < *pos; t = t_next(m, t, &l))
		;

	return t;
}

static void t_stop(struct seq_file *m, void *p)
{
	__raw_spin_unlock(&max_stack_lock);
	local_irq_enable();
}

S
Steven Rostedt 已提交
234
static int trace_lookup_stack(struct seq_file *m, long i)
S
Steven Rostedt 已提交
235
{
S
Steven Rostedt 已提交
236
	unsigned long addr = stack_dump_trace[i];
S
Steven Rostedt 已提交
237 238 239 240 241
#ifdef CONFIG_KALLSYMS
	char str[KSYM_SYMBOL_LEN];

	sprint_symbol(str, addr);

S
Steven Rostedt 已提交
242
	return seq_printf(m, "%s\n", str);
S
Steven Rostedt 已提交
243 244 245 246 247
#else
	return seq_printf(m, "%p\n", (void*)addr);
#endif
}

248 249 250 251 252 253 254 255 256 257 258
static void print_disabled(struct seq_file *m)
{
	seq_puts(m, "#\n"
		 "#  Stack tracer disabled\n"
		 "#\n"
		 "# To enable the stack tracer, either add 'stacktrace' to the\n"
		 "# kernel command line\n"
		 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
		 "#\n");
}

S
Steven Rostedt 已提交
259 260
static int t_show(struct seq_file *m, void *v)
{
261
	long i;
S
Steven Rostedt 已提交
262 263
	int size;

264
	if (v == SEQ_START_TOKEN) {
265
		seq_printf(m, "        Depth    Size   Location"
S
Steven Rostedt 已提交
266
			   "    (%d entries)\n"
267
			   "        -----    ----   --------\n",
268
			   max_stack_trace.nr_entries - 1);
269 270 271 272

		if (!stack_tracer_enabled && !max_stack_size)
			print_disabled(m);

S
Steven Rostedt 已提交
273 274
		return 0;
	}
S
Steven Rostedt 已提交
275

276 277
	i = *(long *)v;

S
Steven Rostedt 已提交
278 279
	if (i >= max_stack_trace.nr_entries ||
	    stack_dump_trace[i] == ULONG_MAX)
S
Steven Rostedt 已提交
280 281
		return 0;

S
Steven Rostedt 已提交
282 283 284 285 286 287 288 289 290
	if (i+1 == max_stack_trace.nr_entries ||
	    stack_dump_trace[i+1] == ULONG_MAX)
		size = stack_dump_index[i];
	else
		size = stack_dump_index[i] - stack_dump_index[i+1];

	seq_printf(m, "%3ld) %8d   %5d   ", i, stack_dump_index[i], size);

	trace_lookup_stack(m, i);
S
Steven Rostedt 已提交
291 292 293 294

	return 0;
}

295
static const struct seq_operations stack_trace_seq_ops = {
S
Steven Rostedt 已提交
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
	.start		= t_start,
	.next		= t_next,
	.stop		= t_stop,
	.show		= t_show,
};

static int stack_trace_open(struct inode *inode, struct file *file)
{
	int ret;

	ret = seq_open(file, &stack_trace_seq_ops);

	return ret;
}

311
static const struct file_operations stack_trace_fops = {
S
Steven Rostedt 已提交
312 313 314 315 316
	.open		= stack_trace_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
};

317 318 319 320 321 322 323 324 325
int
stack_trace_sysctl(struct ctl_table *table, int write,
		   struct file *file, void __user *buffer, size_t *lenp,
		   loff_t *ppos)
{
	int ret;

	mutex_lock(&stack_sysctl_mutex);

326
	ret = proc_dointvec(table, write, file, buffer, lenp, ppos);
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345

	if (ret || !write ||
	    (last_stack_tracer_enabled == stack_tracer_enabled))
		goto out;

	last_stack_tracer_enabled = stack_tracer_enabled;

	if (stack_tracer_enabled)
		register_ftrace_function(&trace_ops);
	else
		unregister_ftrace_function(&trace_ops);

 out:
	mutex_unlock(&stack_sysctl_mutex);
	return ret;
}

static __init int enable_stacktrace(char *str)
{
346 347
	stack_tracer_enabled = 1;
	last_stack_tracer_enabled = 1;
348 349 350 351
	return 1;
}
__setup("stacktrace", enable_stacktrace);

S
Steven Rostedt 已提交
352 353 354 355 356 357
static __init int stack_trace_init(void)
{
	struct dentry *d_tracer;

	d_tracer = tracing_init_dentry();

358 359
	trace_create_file("stack_max_size", 0644, d_tracer,
			&max_stack_size, &stack_max_size_fops);
S
Steven Rostedt 已提交
360

361 362
	trace_create_file("stack_trace", 0444, d_tracer,
			NULL, &stack_trace_fops);
S
Steven Rostedt 已提交
363

364
	if (stack_tracer_enabled)
365
		register_ftrace_function(&trace_ops);
S
Steven Rostedt 已提交
366 367 368 369 370

	return 0;
}

device_initcall(stack_trace_init);