tracing: real fix for set_ftrace_filter
Steven Rostedt
maintainerIngo,
This includes the real fix for the bug that was found for set_ftrace_filter. Since I noticed that Linus's tree has the quick fix that Christ Wright and I made, I just based off of mainline.
-- Steve
Please pull the latest tip/perf/core tree, which can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git
tip/perf/core
Steven Rostedt (4):
tracing: Do not reset *pos in set_ftrace_filter
tracing: Replace typecasted void pointer in set_ftrace_filter code
tracing: Keep track of set_ftrace_filter position and allow lseek again
tracing: Fix reading of set_ftrace_filter across lists
----
kernel/trace/ftrace.c | 105 +++++++++++++++++++++++++++++++++++------------- 1 files changed, 76 insertions(+), 29 deletions(-)
Steven Rostedt
maintainerPATCH 1/4 tracing: Do not reset *pos in set_ftrace_filter
From: Steven Rostedt <[email protected]>
After the filtered functions are read, the probed functions are read from the hash in set_ftrace_filter. When the hashed probed functions are read, the *pos passed in is reset. Instead of modifying the pos given to the read function, just record the pos where the filtered functions ended and subtract from that.
--- kernel/trace/ftrace.c | 8 ++++++-- 1 files changed, 6 insertions(+), 2 deletions(-)
kernel/trace/ftrace.c +6 -2
@@ -1368,6 +1368,7 @@ enum {#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4)/* room for wildcards */ struct ftrace_iterator { +loff_t func_pos;struct ftrace_page *pg;int hidx;int idx;
@@ -1418,12 +1419,15 @@ static void *t_hash_start(struct seq_file *m, loff_t *pos)loff_t l;if (!(iter->flags &FTRACE_ITER_HASH )) - *pos =0 ; + iter->func_pos = *pos; + +if (iter->func_pos > *pos) +return NULL ; iter->flags |=FTRACE_ITER_HASH ; iter->hidx =0 ; -for (l =0 ; l <= *pos; ) { +for (l =0 ; l <= (*pos - iter->func_pos); ) { p =t_hash_next (m, p, &l);if (!p)break ;
Signature · 1 line
1.7.1
Steven Rostedt
maintainerPATCH 3/4 tracing: Keep track of set_ftrace_filter position and allow lseek again
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
This patch keeps track of the index within the elements of set_ftrace_filter and if the position goes backwards, it nicely resets and starts from the beginning again.
This allows for lseek and pread to work properly now.
--- kernel/trace/ftrace.c | 34 ++++++++++++++++++++++++++-------- 1 files changed, 26 insertions(+), 8 deletions(-)
kernel/trace/ftrace.c +26 -8
@@ -1368,6 +1368,7 @@ enum {#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4)/* room for wildcards */ struct ftrace_iterator { +loff_t pos;loff_t func_pos;struct ftrace_page *pg;struct dyn_ftrace *func;
@@ -1385,9 +1386,8 @@ t_hash_next(struct seq_file *m, loff_t *pos)struct hlist_node *hnd =NULL ;struct hlist_head *hhd; -WARN_ON (!(iter->flags &FTRACE_ITER_HASH )); - (*pos)++; + iter->pos = *pos;if (iter->probe) hnd = &iter->probe->node;
@@ -1427,14 +1427,9 @@ static void *t_hash_start(struct seq_file *m, loff_t *pos)void *p =NULL ;loff_t l; -if (!(iter->flags &FTRACE_ITER_HASH )) - iter->func_pos = *pos; -if (iter->func_pos > *pos)return NULL ; - iter->flags |=FTRACE_ITER_HASH ; - iter->hidx =0 ;for (l =0 ; l <= (*pos - iter->func_pos); ) { p =t_hash_next (m, &l);
@@ -1444,6 +1439,9 @@ static void *t_hash_start(struct seq_file *m, loff_t *pos)if (!p)return NULL ; +/* Only set this if we have an item */ + iter->flags |=FTRACE_ITER_HASH ; +return iter; }
@@ -1478,6 +1476,8 @@ t_next(struct seq_file *m, void *v, loff_t *pos)return t_hash_next (m, pos); (*pos)++; + iter->pos = *pos; + iter->func_pos = *pos;if (iter->flags &FTRACE_ITER_PRINTALL )return NULL ;
@@ -1517,6 +1517,13 @@ t_next(struct seq_file *m, void *v, loff_t *pos)return iter; } +static void reset_iter_read (struct ftrace_iterator *iter) +{ + iter->pos =0 ; + iter->func_pos =0 ; + iter->flags &= ~(FTRACE_ITER_PRINTALL &FTRACE_ITER_HASH ); +} +static void *t_start (struct seq_file *m,loff_t *pos) {struct ftrace_iterator *iter = m->private;
@@ -1525,6 +1532,12 @@ static void *t_start(struct seq_file *m, loff_t *pos)mutex_lock (&ftrace_lock);/* +* If an lseek was done, then reset and start from beginning. +*/ +if (*pos < iter->pos) +reset_iter_read (iter); + +/* * For set_ftrace_filter reading, if we have the filter * off, we can short cut and just print out that all * functions are enabled.
@@ -1541,6 +1554,11 @@ static void *t_start(struct seq_file *m, loff_t *pos)if (iter->flags &FTRACE_ITER_HASH )return t_hash_start (m, pos); +/* +* Unfortunately, we need to restart at ftrace_pages_start +* every time we let go of the ftrace_mutex. This is because +* those pointers can change without the lock. +*/ iter->pg = ftrace_pages_start; iter->idx =0 ;for (l =0 ; l <= *pos; ) {
@@ -2447,7 +2465,7 @@ static const struct file_operations ftrace_filter_fops = { .open = ftrace_filter_open, .read = seq_read, .write = ftrace_filter_write, - .llseek = no_llseek, + .llseek = ftrace_regex_lseek, .release = ftrace_filter_release, };
Signature · 1 line
1.7.1
Steven Rostedt
maintainerPATCH 2/4 tracing: Replace typecasted void pointer in set_ftrace_filter code
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
The set_ftrace_filter uses seq_file and reads from two lists. The pointer returned by t_next() can either be of type struct dyn_ftrace or struct ftrace_func_probe. If there is a bug (there was one) the wrong pointer may be used and the reference can cause an oops.
This patch makes t_next() and friends only return the iterator structure which now has a pointer of type struct dyn_ftrace and struct ftrace_func_probe. The t_show() can now test if the pointer is NULL or not and if the pointer exists, it is guaranteed to be of the correct type.
Now if there's a bug, only wrong data will be shown but not an oops.
--- kernel/trace/ftrace.c | 67 +++++++++++++++++++++++++++++++++--------------- 1 files changed, 46 insertions(+), 21 deletions(-)
kernel/trace/ftrace.c +46 -21
@@ -1368,25 +1368,29 @@ enum {#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4)/* room for wildcards */ struct ftrace_iterator { -loff_t func_pos; -struct ftrace_page *pg; -int hidx; -int idx; -unsigned flags; -struct trace_parser parser; +loff_t func_pos; +struct ftrace_page *pg; +struct dyn_ftrace *func; +struct ftrace_func_probe *probe; +struct trace_parser parser; +int hidx; +int idx; +unsigned flags; };static void * -t_hash_next (struct seq_file *m,void *v,loff_t *pos) +t_hash_next (struct seq_file *m,loff_t *pos) {struct ftrace_iterator *iter = m->private; -struct hlist_node *hnd = v; +struct hlist_node *hnd =NULL ;struct hlist_head *hhd;WARN_ON (!(iter->flags &FTRACE_ITER_HASH )); (*pos)++; +if (iter->probe) + hnd = &iter->probe->node; retry:if (iter->hidx >=FTRACE_FUNC_HASHSIZE )return NULL ;
@@ -1409,7 +1413,12 @@ t_hash_next(struct seq_file *m, void *v, loff_t *pos) } } -return hnd; +if (WARN_ON_ONCE (!hnd)) +return NULL ; + + iter->probe = hlist_entry(hnd, struct ftrace_func_probe, node); + +return iter; }static void *t_hash_start (struct seq_file *m,loff_t *pos)
@@ -1428,19 +1437,24 @@ static void *t_hash_start(struct seq_file *m, loff_t *pos) iter->hidx =0 ;for (l =0 ; l <= (*pos - iter->func_pos); ) { - p =t_hash_next (m, p, &l); + p =t_hash_next (m, &l);if (!p)break ; } -return p; +if (!p) +return NULL ; + +return iter; } -static int t_hash_show (struct seq_file *m,void *v) +static int +t_hash_show (struct seq_file *m,struct ftrace_iterator *iter) {struct ftrace_func_probe *rec; -struct hlist_node *hnd = v; - rec = hlist_entry(hnd, struct ftrace_func_probe, node); + rec = iter->probe; +if (WARN_ON_ONCE (!rec)) +return -EIO ;if (rec->ops->print)return rec->ops->
@@ -1461,7 +1475,7 @@ t_next(struct seq_file *m, void *v, loff_t *pos)struct dyn_ftrace *rec =NULL ;if (iter->flags &FTRACE_ITER_HASH ) -return t_hash_next (m, v, pos); +return t_hash_next (m, pos); (*pos)++;
@@ -1495,7 +1509,12 @@ t_next(struct seq_file *m, void *v, loff_t *pos) } } -return rec; +if (!rec) +return NULL ; + + iter->func = rec; + +return iter; }static void *t_start (struct seq_file *m,loff_t *pos)
@@ -1530,10 +1549,14 @@ static void *t_start(struct seq_file *m, loff_t *pos)break ; } -if (!p && iter->flags &FTRACE_ITER_FILTER ) -return t_hash_start (m, pos); +if (!p) { +if (iter->flags &FTRACE_ITER_FILTER ) +return t_hash_start (m, pos); -return p; +return NULL ; + } + +return iter; }static void t_stop (struct seq_file *m,void *p)
@@ -1544,16 +1567,18 @@ static void t_stop(struct seq_file *m, void *p)static int t_show (struct seq_file *m,void *v) {struct ftrace_iterator *iter = m->private; -struct dyn_ftrace *rec = v; +struct dyn_ftrace *rec;if (iter->flags &FTRACE_ITER_HASH ) -return t_hash_show (m, v); +return t_hash_show (m, iter);if (iter->flags &FTRACE_ITER_PRINTALL ) {seq_printf (m,"#### all functions enabled ####\n" );return 0 ; } + rec = iter->func; +if (!rec)return 0 ;
Signature · 1 line
1.7.1
Steven Rostedt
maintainerPATCH 4/4 tracing: Fix reading of set_ftrace_filter across lists
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
If we do:
# cd /sys/kernel/debug
# echo 'do_IRQ:traceon schedule:traceon sys_write:traceon' > \
set_ftrace_filter
# cat set_ftrace_filterWe get the following output:
#### all functions enabled ####
sys_write:traceon:unlimited
schedule:traceon:unlimited
do_IRQ:traceon:unlimited
This outputs two lists. One is the fact that all functions are currently enabled for function tracing, the other has three probed functions, which happen to have 'traceon' as their commands.
Currently, when reading the first list (functions enabled) the seq_file code will receive a "NULL" from the t_next() function causing it to exit early. This makes "read()" from userspace stop reading the code at this boarder. Although read is allowed to do this, some (broken) applications might consider this an end of file and stop early.
This patch adds the start of the second list to t_next() when it finishes the first list. It is a simple change and gives the set_ftrace_filter file nicer reading ability.
--- kernel/trace/ftrace.c | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-)
kernel/trace/ftrace.c +3 -3
@@ -1477,10 +1477,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos) (*pos)++; iter->pos = *pos; - iter->func_pos = *pos;if (iter->flags &FTRACE_ITER_PRINTALL ) -return NULL ; +return t_hash_start (m, pos); retry:if (iter->idx >= iter->pg->index) {
@@ -1510,8 +1509,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos) }if (!rec) -return NULL ; +return t_hash_start (m, pos); + iter->func_pos = *pos; iter->func = rec;return iter;
Signature · 1 line
1.7.1
Quoted 21 lines · Steven Rostedt
Ingo,
This includes the real fix for the bug that was found for
set_ftrace_filter. Since I noticed that Linus's tree has the quick fix that Christ Wright and I made, I just based off of mainline.-- Steve
Please pull the latest tip/perf/core tree, which can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git
tip/perf/coreSteven Rostedt (4):
tracing: Do not reset *pos inset_ftrace_filter
tracing: Replace typecasted void pointer inset_ftrace_filtercode
tracing: Keep track ofset_ftrace_filterposition and allow lseek again
tracing: Fix reading ofset_ftrace_filteracross lists
Quoted 3 lines
----
kernel/trace/ftrace.c | 105 +++++++++++++++++++++++++++++++++++------------- 1 files changed, 76 insertions(+), 29 deletions(-)
Pulled, thanks a lot Steve! I wanted to merge -rc4 into perf/core anyway ;-)
Ingo