trace_stack.c 7.33 KB
Newer Older
Steven Rostedt's avatar
Steven Rostedt committed
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>
Steven Rostedt's avatar
Steven Rostedt committed
14 15 16 17 18 19
#include <linux/init.h>
#include <linux/fs.h>
#include "trace.h"

#define STACK_TRACE_ENTRIES 500

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];

Steven Rostedt's avatar
Steven Rostedt committed
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;
Steven Rostedt's avatar
Steven Rostedt committed
39 40 41

static inline void check_stack(void)
{
42 43 44
	unsigned long this_size, flags;
	unsigned long *p, *top, *start;
	int i;
Steven Rostedt's avatar
Steven Rostedt committed
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);
Steven Rostedt's avatar
Steven Rostedt committed
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;
66
	max_stack_trace.skip		= 3;
Steven Rostedt's avatar
Steven Rostedt committed
67 68 69

	save_stack_trace(&max_stack_trace);

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) {
86
		int found = 0;
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);
95
				found = 1;
96 97 98 99 100
				/* Start the search from here */
				start = p + 1;
			}
		}

101 102
		if (!found)
			i++;
103 104
	}

Steven Rostedt's avatar
Steven Rostedt committed
105 106
 out:
	__raw_spin_unlock(&max_stack_lock);
107
	local_irq_restore(flags);
Steven Rostedt's avatar
Steven Rostedt committed
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();
Steven Rostedt's avatar
Steven Rostedt committed
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);
Steven Rostedt's avatar
Steven Rostedt committed
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);
Steven Rostedt's avatar
Steven Rostedt committed
174 175 176
	__raw_spin_lock(&max_stack_lock);
	*ptr = val;
	__raw_spin_unlock(&max_stack_lock);
177
	local_irq_restore(flags);
Steven Rostedt's avatar
Steven Rostedt committed
178 179 180 181

	return count;
}

182
static const struct file_operations stack_max_size_fops = {
Steven Rostedt's avatar
Steven Rostedt committed
183 184 185 186 187 188
	.open		= tracing_open_generic,
	.read		= stack_max_size_read,
	.write		= stack_max_size_write,
};

static void *
Li Zefan's avatar
Li Zefan committed
189
__next(struct seq_file *m, loff_t *pos)
Steven Rostedt's avatar
Steven Rostedt committed
190
{
Li Zefan's avatar
Li Zefan committed
191
	long n = *pos - 1;
Steven Rostedt's avatar
Steven Rostedt committed
192

Li Zefan's avatar
Li Zefan committed
193
	if (n >= max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
Steven Rostedt's avatar
Steven Rostedt committed
194 195
		return NULL;

Li Zefan's avatar
Li Zefan committed
196
	m->private = (void *)n;
197
	return &m->private;
Steven Rostedt's avatar
Steven Rostedt committed
198 199
}

Li Zefan's avatar
Li Zefan committed
200 201
static void *
t_next(struct seq_file *m, void *v, loff_t *pos)
Steven Rostedt's avatar
Steven Rostedt committed
202
{
Li Zefan's avatar
Li Zefan committed
203 204 205
	(*pos)++;
	return __next(m, pos);
}
Steven Rostedt's avatar
Steven Rostedt committed
206

Li Zefan's avatar
Li Zefan committed
207 208
static void *t_start(struct seq_file *m, loff_t *pos)
{
Steven Rostedt's avatar
Steven Rostedt committed
209 210 211
	local_irq_disable();
	__raw_spin_lock(&max_stack_lock);

212 213 214
	if (*pos == 0)
		return SEQ_START_TOKEN;

Li Zefan's avatar
Li Zefan committed
215
	return __next(m, pos);
Steven Rostedt's avatar
Steven Rostedt committed
216 217 218 219 220 221 222 223
}

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

224
static int trace_lookup_stack(struct seq_file *m, long i)
Steven Rostedt's avatar
Steven Rostedt committed
225
{
226
	unsigned long addr = stack_dump_trace[i];
Steven Rostedt's avatar
Steven Rostedt committed
227

228
	return seq_printf(m, "%pF\n", (void *)addr);
Steven Rostedt's avatar
Steven Rostedt committed
229 230
}

231 232 233 234 235 236 237 238 239 240 241
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");
}

Steven Rostedt's avatar
Steven Rostedt committed
242 243
static int t_show(struct seq_file *m, void *v)
{
244
	long i;
245 246
	int size;

247
	if (v == SEQ_START_TOKEN) {
248
		seq_printf(m, "        Depth    Size   Location"
249
			   "    (%d entries)\n"
250
			   "        -----    ----   --------\n",
251
			   max_stack_trace.nr_entries - 1);
252 253 254 255

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

256 257
		return 0;
	}
Steven Rostedt's avatar
Steven Rostedt committed
258

259 260
	i = *(long *)v;

261 262
	if (i >= max_stack_trace.nr_entries ||
	    stack_dump_trace[i] == ULONG_MAX)
Steven Rostedt's avatar
Steven Rostedt committed
263 264
		return 0;

265 266 267 268 269 270 271 272 273
	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);
Steven Rostedt's avatar
Steven Rostedt committed
274 275 276 277

	return 0;
}

278
static const struct seq_operations stack_trace_seq_ops = {
Steven Rostedt's avatar
Steven Rostedt committed
279 280 281 282 283 284 285 286
	.start		= t_start,
	.next		= t_next,
	.stop		= t_stop,
	.show		= t_show,
};

static int stack_trace_open(struct inode *inode, struct file *file)
{
287
	return seq_open(file, &stack_trace_seq_ops);
Steven Rostedt's avatar
Steven Rostedt committed
288 289
}

290
static const struct file_operations stack_trace_fops = {
Steven Rostedt's avatar
Steven Rostedt committed
291 292 293
	.open		= stack_trace_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
294
	.release	= seq_release,
Steven Rostedt's avatar
Steven Rostedt committed
295 296
};

297 298 299 300 301 302 303 304 305
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);

306
	ret = proc_dointvec(table, write, file, buffer, lenp, ppos);
307 308

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

312
	last_stack_tracer_enabled = !!stack_tracer_enabled;
313 314 315 316 317 318 319 320 321 322 323 324 325

	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)
{
326 327
	stack_tracer_enabled = 1;
	last_stack_tracer_enabled = 1;
328 329 330 331
	return 1;
}
__setup("stacktrace", enable_stacktrace);

Steven Rostedt's avatar
Steven Rostedt committed
332 333 334 335 336 337
static __init int stack_trace_init(void)
{
	struct dentry *d_tracer;

	d_tracer = tracing_init_dentry();

338 339
	trace_create_file("stack_max_size", 0644, d_tracer,
			&max_stack_size, &stack_max_size_fops);
Steven Rostedt's avatar
Steven Rostedt committed
340

341 342
	trace_create_file("stack_trace", 0444, d_tracer,
			NULL, &stack_trace_fops);
Steven Rostedt's avatar
Steven Rostedt committed
343

344
	if (stack_tracer_enabled)
345
		register_ftrace_function(&trace_ops);
Steven Rostedt's avatar
Steven Rostedt committed
346 347 348 349 350

	return 0;
}

device_initcall(stack_trace_init);