trace_stack.c 6.45 KB
Newer Older
Steven Rostedt's avatar
Steven Rostedt committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * 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>
#include <linux/init.h>
#include <linux/fs.h>
#include "trace.h"

#define STACK_TRACE_ENTRIES 500

19 20 21 22
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
23 24 25 26 27 28 29 30 31 32 33 34 35 36
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);

static inline void check_stack(void)
{
37 38 39
	unsigned long this_size, flags;
	unsigned long *p, *top, *start;
	int i;
Steven Rostedt's avatar
Steven Rostedt committed
40 41 42 43 44 45 46

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

	if (this_size <= max_stack_size)
		return;

47 48 49 50
	/* we do not handle interrupt stacks yet */
	if (!object_is_on_stack(&this_size))
		return;

Steven Rostedt's avatar
Steven Rostedt committed
51 52 53 54 55 56 57 58 59 60
	raw_local_irq_save(flags);
	__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;
61
	max_stack_trace.skip		= 3;
Steven Rostedt's avatar
Steven Rostedt committed
62 63 64

	save_stack_trace(&max_stack_trace);

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
	/*
	 * 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) {

		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);
				/* Start the search from here */
				start = p + 1;
			}
		}

		i++;
	}

Steven Rostedt's avatar
Steven Rostedt committed
97 98 99 100 101 102 103 104 105 106 107 108 109
 out:
	__raw_spin_unlock(&max_stack_lock);
	raw_local_irq_restore(flags);
}

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

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

110
	resched = ftrace_preempt_disable();
Steven Rostedt's avatar
Steven Rostedt committed
111 112 113 114 115 116 117 118 119 120 121

	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 */
122
	ftrace_preempt_enable(resched);
Steven Rostedt's avatar
Steven Rostedt committed
123 124 125 126 127 128 129 130 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 173 174 175 176 177 178 179 180 181 182
}

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;

	raw_local_irq_save(flags);
	__raw_spin_lock(&max_stack_lock);
	*ptr = val;
	__raw_spin_unlock(&max_stack_lock);
	raw_local_irq_restore(flags);

	return count;
}

static struct file_operations stack_max_size_fops = {
	.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)
{
183
	long i;
Steven Rostedt's avatar
Steven Rostedt committed
184 185 186

	(*pos)++;

187 188 189 190 191 192
	if (v == SEQ_START_TOKEN)
		i = 0;
	else {
		i = *(long *)v;
		i++;
	}
193 194 195

	if (i >= max_stack_trace.nr_entries ||
	    stack_dump_trace[i] == ULONG_MAX)
Steven Rostedt's avatar
Steven Rostedt committed
196 197
		return NULL;

198
	m->private = (void *)i;
Steven Rostedt's avatar
Steven Rostedt committed
199

200
	return &m->private;
Steven Rostedt's avatar
Steven Rostedt committed
201 202 203 204
}

static void *t_start(struct seq_file *m, loff_t *pos)
{
205
	void *t = SEQ_START_TOKEN;
Steven Rostedt's avatar
Steven Rostedt committed
206 207 208 209 210
	loff_t l = 0;

	local_irq_disable();
	__raw_spin_lock(&max_stack_lock);

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

Steven Rostedt's avatar
Steven Rostedt committed
214 215 216 217 218 219 220 221 222 223 224 225
	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();
}

226
static int trace_lookup_stack(struct seq_file *m, long i)
Steven Rostedt's avatar
Steven Rostedt committed
227
{
228
	unsigned long addr = stack_dump_trace[i];
Steven Rostedt's avatar
Steven Rostedt committed
229 230 231 232 233
#ifdef CONFIG_KALLSYMS
	char str[KSYM_SYMBOL_LEN];

	sprint_symbol(str, addr);

234
	return seq_printf(m, "%s\n", str);
Steven Rostedt's avatar
Steven Rostedt committed
235 236 237 238 239 240 241
#else
	return seq_printf(m, "%p\n", (void*)addr);
#endif
}

static int t_show(struct seq_file *m, void *v)
{
242
	long i;
243 244
	int size;

245
	if (v == SEQ_START_TOKEN) {
246 247 248 249 250 251
		seq_printf(m, "        Depth   Size      Location"
			   "    (%d entries)\n"
			   "        -----   ----      --------\n",
			   max_stack_trace.nr_entries);
		return 0;
	}
Steven Rostedt's avatar
Steven Rostedt committed
252

253 254
	i = *(long *)v;

255 256
	if (i >= max_stack_trace.nr_entries ||
	    stack_dump_trace[i] == ULONG_MAX)
Steven Rostedt's avatar
Steven Rostedt committed
257 258
		return 0;

259 260 261 262 263 264 265 266 267
	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
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316

	return 0;
}

static struct seq_operations stack_trace_seq_ops = {
	.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;
}

static struct file_operations stack_trace_fops = {
	.open		= stack_trace_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
};

static __init int stack_trace_init(void)
{
	struct dentry *d_tracer;
	struct dentry *entry;

	d_tracer = tracing_init_dentry();

	entry = debugfs_create_file("stack_max_size", 0644, d_tracer,
				    &max_stack_size, &stack_max_size_fops);
	if (!entry)
		pr_warning("Could not create debugfs 'stack_max_size' entry\n");

	entry = debugfs_create_file("stack_trace", 0444, d_tracer,
				    NULL, &stack_trace_fops);
	if (!entry)
		pr_warning("Could not create debugfs 'stack_trace' entry\n");

	register_ftrace_function(&trace_ops);

	return 0;
}

device_initcall(stack_trace_init);