ftrace: Allow enabling of filters via index of available_filter_functions

Enabling of large number of functions by echoing in a large subset of the
functions in available_filter_functions can take a very long time. The
process requires testing all functions registered by the function tracer
(which is in the 10s of thousands), and doing a kallsyms lookup to convert
the ip address into a name, then comparing that name with the string passed
in.

When a function causes the function tracer to crash the system, a binary
bisect of the available_filter_functions can be done to find the culprit.
But this requires passing in half of the functions in
available_filter_functions over and over again, which makes it basically a
O(n^2) operation. With 40,000 functions, that ends up bing 1,600,000,000
opertions! And enabling this can take over 20 minutes.

As a quick speed up, if a number is passed into one of the filter files,
instead of doing a search, it just enables the function at the corresponding
line of the available_filter_functions file. That is:

 # echo 50 > set_ftrace_filter
 # cat set_ftrace_filter
 x86_pmu_commit_txn

 # head -50 available_filter_functions | tail -1
 x86_pmu_commit_txn

This allows setting of half the available_filter_functions to take place in
less than a second!

 # time seq 20000 > set_ftrace_filter
 real    0m0.042s
 user    0m0.005s
 sys     0m0.015s

 # wc -l set_ftrace_filter
 20000 set_ftrace_filter

Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>

1 files changed, 30 insertions, 0 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index aac7847c0214..fa79323331b2 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -3702,6 +3702,31 @@ enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int clear_filter)
 }
 
 static int
+add_rec_by_index(struct ftrace_hash *hash, struct ftrace_glob *func_g,
+                 int clear_filter)
+{
+        long index = simple_strtoul(func_g->search, NULL, 0);
+        struct ftrace_page *pg;
+        struct dyn_ftrace *rec;
+
+        /* The index starts at 1 */
+        if (--index < 0)
+                return 0;
+
+        do_for_each_ftrace_rec(pg, rec) {
+                if (pg->index <= index) {
+                        index -= pg->index;
+                        /* this is a double loop, break goes to the next page */
+                        break;
+                }
+                rec = &pg->records[index];
+                enter_record(hash, rec, clear_filter);
+                return 1;
+        } while_for_each_ftrace_rec();
+        return 0;
+}
+
+static int
 ftrace_match_record(struct dyn_ftrace *rec, struct ftrace_glob *func_g,
                 struct ftrace_glob *mod_g, int exclude_mod)
 {
@@ -3769,6 +3794,11 @@ match_records(struct ftrace_hash *hash, char *func, int len, char *mod)
         if (unlikely(ftrace_disabled))
                 goto out_unlock;
 
+        if (func_g.type == MATCH_INDEX) {
+                found = add_rec_by_index(hash, &func_g, clear_filter);
+                goto out_unlock;
+        }
+
         do_for_each_ftrace_rec(pg, rec) {
 
                 if (rec->flags & FTRACE_FL_DISABLED)