2008-08-27 21:31:01 -06:00
|
|
|
/*
|
|
|
|
* 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>
|
2008-12-16 21:06:40 -07:00
|
|
|
#include <linux/sysctl.h>
|
2008-08-27 21:31:01 -06:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include "trace.h"
|
|
|
|
|
|
|
|
#define STACK_TRACE_ENTRIES 500
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
|
|
|
|
{ [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
|
|
|
|
static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
|
|
|
|
|
2008-08-27 21:31:01 -06:00
|
|
|
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);
|
2008-12-16 21:06:40 -07:00
|
|
|
static DEFINE_MUTEX(stack_sysctl_mutex);
|
|
|
|
|
|
|
|
int stack_tracer_enabled;
|
|
|
|
static int last_stack_tracer_enabled;
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
static inline void check_stack(void)
|
|
|
|
{
|
2008-08-29 14:51:43 -06:00
|
|
|
unsigned long this_size, flags;
|
|
|
|
unsigned long *p, *top, *start;
|
|
|
|
int i;
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
this_size = ((unsigned long)&this_size) & (THREAD_SIZE-1);
|
|
|
|
this_size = THREAD_SIZE - this_size;
|
|
|
|
|
|
|
|
if (this_size <= max_stack_size)
|
|
|
|
return;
|
|
|
|
|
2008-10-06 19:24:18 -06:00
|
|
|
/* we do not handle interrupt stacks yet */
|
|
|
|
if (!object_is_on_stack(&this_size))
|
|
|
|
return;
|
|
|
|
|
2008-12-02 13:34:05 -07:00
|
|
|
local_irq_save(flags);
|
2008-08-27 21:31:01 -06:00
|
|
|
__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;
|
2008-08-29 14:51:43 -06:00
|
|
|
max_stack_trace.skip = 3;
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
save_stack_trace(&max_stack_trace);
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
/*
|
|
|
|
* 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) {
|
2008-12-03 09:04:50 -07:00
|
|
|
int found = 0;
|
2008-08-29 14:51:43 -06:00
|
|
|
|
|
|
|
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);
|
2008-12-03 09:04:50 -07:00
|
|
|
found = 1;
|
2008-08-29 14:51:43 -06:00
|
|
|
/* Start the search from here */
|
|
|
|
start = p + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-03 09:04:50 -07:00
|
|
|
if (!found)
|
|
|
|
i++;
|
2008-08-29 14:51:43 -06:00
|
|
|
}
|
|
|
|
|
2008-08-27 21:31:01 -06:00
|
|
|
out:
|
|
|
|
__raw_spin_unlock(&max_stack_lock);
|
2008-12-02 13:34:05 -07:00
|
|
|
local_irq_restore(flags);
|
2008-08-27 21:31:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
stack_trace_call(unsigned long ip, unsigned long parent_ip)
|
|
|
|
{
|
|
|
|
int cpu, resched;
|
|
|
|
|
|
|
|
if (unlikely(!ftrace_enabled || stack_trace_disabled))
|
|
|
|
return;
|
|
|
|
|
2008-11-03 21:15:56 -07:00
|
|
|
resched = ftrace_preempt_disable();
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
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 */
|
2008-11-03 21:15:56 -07:00
|
|
|
ftrace_preempt_enable(resched);
|
2008-08-27 21:31:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2008-12-02 13:34:05 -07:00
|
|
|
local_irq_save(flags);
|
2008-08-27 21:31:01 -06:00
|
|
|
__raw_spin_lock(&max_stack_lock);
|
|
|
|
*ptr = val;
|
|
|
|
__raw_spin_unlock(&max_stack_lock);
|
2008-12-02 13:34:05 -07:00
|
|
|
local_irq_restore(flags);
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-12-16 21:06:40 -07:00
|
|
|
static const struct file_operations stack_max_size_fops = {
|
2008-08-27 21:31:01 -06:00
|
|
|
.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)
|
|
|
|
{
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
long i;
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
(*pos)++;
|
|
|
|
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
if (v == SEQ_START_TOKEN)
|
|
|
|
i = 0;
|
|
|
|
else {
|
|
|
|
i = *(long *)v;
|
|
|
|
i++;
|
|
|
|
}
|
2008-08-29 14:51:43 -06:00
|
|
|
|
|
|
|
if (i >= max_stack_trace.nr_entries ||
|
|
|
|
stack_dump_trace[i] == ULONG_MAX)
|
2008-08-27 21:31:01 -06:00
|
|
|
return NULL;
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
m->private = (void *)i;
|
2008-08-27 21:31:01 -06:00
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
return &m->private;
|
2008-08-27 21:31:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *t_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
void *t = SEQ_START_TOKEN;
|
2008-08-27 21:31:01 -06:00
|
|
|
loff_t l = 0;
|
|
|
|
|
|
|
|
local_irq_disable();
|
|
|
|
__raw_spin_lock(&max_stack_lock);
|
|
|
|
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
if (*pos == 0)
|
|
|
|
return SEQ_START_TOKEN;
|
|
|
|
|
2008-08-27 21:31:01 -06:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
static int trace_lookup_stack(struct seq_file *m, long i)
|
2008-08-27 21:31:01 -06:00
|
|
|
{
|
2008-08-29 14:51:43 -06:00
|
|
|
unsigned long addr = stack_dump_trace[i];
|
2008-08-27 21:31:01 -06:00
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
char str[KSYM_SYMBOL_LEN];
|
|
|
|
|
|
|
|
sprint_symbol(str, addr);
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
return seq_printf(m, "%s\n", str);
|
2008-08-27 21:31:01 -06:00
|
|
|
#else
|
|
|
|
return seq_printf(m, "%p\n", (void*)addr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-03-12 17:42:29 -06:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2008-08-27 21:31:01 -06:00
|
|
|
static int t_show(struct seq_file *m, void *v)
|
|
|
|
{
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
long i;
|
2008-08-29 14:51:43 -06:00
|
|
|
int size;
|
|
|
|
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
if (v == SEQ_START_TOKEN) {
|
2009-03-12 22:00:58 -06:00
|
|
|
seq_printf(m, " Depth Size Location"
|
2008-08-29 14:51:43 -06:00
|
|
|
" (%d entries)\n"
|
2009-03-12 22:00:58 -06:00
|
|
|
" ----- ---- --------\n",
|
2009-06-03 02:01:28 -06:00
|
|
|
max_stack_trace.nr_entries - 1);
|
2009-03-12 17:42:29 -06:00
|
|
|
|
|
|
|
if (!stack_tracer_enabled && !max_stack_size)
|
|
|
|
print_disabled(m);
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2008-08-27 21:31:01 -06:00
|
|
|
|
function tracing: fix wrong position computing of stack_trace
Impact: make output of stack_trace complete if buffer overruns
When read buffer overruns, the output of stack_trace isn't complete.
When printing records with seq_printf in t_show, if the read buffer
has overruned by the current record, then this record won't be
printed to user space through read buffer, it will just be dropped in
this printing.
When next printing, t_start should return the "*pos"th record, which
is the one dropped by previous printing, but it just returns
(m->private + *pos)th record.
Here we use a more sane method to implement seq_operations which can
be found in kernel code. Thus we needn't initialize m->private.
About testing, it's not easy to overrun read buffer, but we can use
seq_printf to print more padding bytes in t_show, then it's easy to
check whether or not records are lost.
This commit has been tested on both condition of overrun and non
overrun.
Signed-off-by: Liming Wang <liming.wang@windriver.com>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-20 20:00:18 -07:00
|
|
|
i = *(long *)v;
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
if (i >= max_stack_trace.nr_entries ||
|
|
|
|
stack_dump_trace[i] == ULONG_MAX)
|
2008-08-27 21:31:01 -06:00
|
|
|
return 0;
|
|
|
|
|
2008-08-29 14:51:43 -06:00
|
|
|
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);
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-16 21:06:40 -07:00
|
|
|
static const struct seq_operations stack_trace_seq_ops = {
|
2008-08-27 21:31:01 -06:00
|
|
|
.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;
|
|
|
|
}
|
|
|
|
|
2008-12-16 21:06:40 -07:00
|
|
|
static const struct file_operations stack_trace_fops = {
|
2008-08-27 21:31:01 -06:00
|
|
|
.open = stack_trace_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
};
|
|
|
|
|
2008-12-16 21:06:40 -07:00
|
|
|
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);
|
|
|
|
|
2008-12-17 07:43:00 -07:00
|
|
|
ret = proc_dointvec(table, write, file, buffer, lenp, ppos);
|
2008-12-16 21:06:40 -07:00
|
|
|
|
|
|
|
if (ret || !write ||
|
2009-06-26 02:55:51 -06:00
|
|
|
(last_stack_tracer_enabled == !!stack_tracer_enabled))
|
2008-12-16 21:06:40 -07:00
|
|
|
goto out;
|
|
|
|
|
2009-06-26 02:55:51 -06:00
|
|
|
last_stack_tracer_enabled = !!stack_tracer_enabled;
|
2008-12-16 21:06:40 -07:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2008-12-17 07:43:00 -07:00
|
|
|
stack_tracer_enabled = 1;
|
|
|
|
last_stack_tracer_enabled = 1;
|
2008-12-16 21:06:40 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("stacktrace", enable_stacktrace);
|
|
|
|
|
2008-08-27 21:31:01 -06:00
|
|
|
static __init int stack_trace_init(void)
|
|
|
|
{
|
|
|
|
struct dentry *d_tracer;
|
|
|
|
|
|
|
|
d_tracer = tracing_init_dentry();
|
|
|
|
|
2009-03-26 17:25:38 -06:00
|
|
|
trace_create_file("stack_max_size", 0644, d_tracer,
|
|
|
|
&max_stack_size, &stack_max_size_fops);
|
2008-08-27 21:31:01 -06:00
|
|
|
|
2009-03-26 17:25:38 -06:00
|
|
|
trace_create_file("stack_trace", 0444, d_tracer,
|
|
|
|
NULL, &stack_trace_fops);
|
2008-08-27 21:31:01 -06:00
|
|
|
|
2008-12-17 07:43:00 -07:00
|
|
|
if (stack_tracer_enabled)
|
2008-12-16 21:06:40 -07:00
|
|
|
register_ftrace_function(&trace_ops);
|
2008-08-27 21:31:01 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(stack_trace_init);
|