adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-29 12:16:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

function tracing: fix wrong position computing of stack_trace

Browse source 
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>
This commit is contained in:
Liming Wang 2008-11-21 11:00:18 +08:00 committed by Ingo Molnar
parent ed313489ba
commit 522a110b42
1 changed files with 15 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
kernel/trace/trace_stack.c
View file

@ -184,11 +184,16 @@ static struct file_operations stack_max_size_fops = {
static void * static void *
t_next(struct seq_file *m, void *v, loff_t *pos) t_next(struct seq_file *m, void *v, loff_t *pos)
{ {
long i = (long)m->private; long i;
(*pos)++; (*pos)++;
if (v == SEQ_START_TOKEN)
i = 0;
else {
i = *(long *)v;
i++; i++;
}
if (i >= max_stack_trace.nr_entries || if (i >= max_stack_trace.nr_entries ||
stack_dump_trace[i] == ULONG_MAX) stack_dump_trace[i] == ULONG_MAX)
@ -201,12 +206,15 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
static void *t_start(struct seq_file *m, loff_t *pos) static void *t_start(struct seq_file *m, loff_t *pos)
{ {
void *t = &m->private; void *t = SEQ_START_TOKEN;
loff_t l = 0; loff_t l = 0;
local_irq_disable(); local_irq_disable();
__raw_spin_lock(&max_stack_lock); __raw_spin_lock(&max_stack_lock);
if (*pos == 0)
return SEQ_START_TOKEN;
for (; t && l < *pos; t = t_next(m, t, &l)) for (; t && l < *pos; t = t_next(m, t, &l))
; ;
@ -235,10 +243,10 @@ static int trace_lookup_stack(struct seq_file *m, long i)
static int t_show(struct seq_file *m, void *v) static int t_show(struct seq_file *m, void *v)
{ {
long i = *(long *)v; long i;
int size; int size;
if (i < 0) { if (v == SEQ_START_TOKEN) {
seq_printf(m, " Depth Size Location" seq_printf(m, " Depth Size Location"
" (%d entries)\n" " (%d entries)\n"
" ----- ---- --------\n", " ----- ---- --------\n",
@ -246,6 +254,8 @@ static int t_show(struct seq_file *m, void *v)
return 0; return 0;
} }
i = *(long *)v;
if (i >= max_stack_trace.nr_entries || if (i >= max_stack_trace.nr_entries ||
stack_dump_trace[i] == ULONG_MAX) stack_dump_trace[i] == ULONG_MAX)
return 0; return 0;
@ -275,10 +285,6 @@ static int stack_trace_open(struct inode *inode, struct file *file)
int ret; int ret;
ret = seq_open(file, &stack_trace_seq_ops); ret = seq_open(file, &stack_trace_seq_ops);
if (!ret) {
struct seq_file *m = file->private_data;
m->private = (void *)-1;
}
return ret; return ret;
} }