tracing: Let tracepoints have data passed to tracepoint callbacks
[linux-2.6.git] / kernel / trace / ftrace.c
index 37ba67e..6d2cb14 100644 (file)
 #include <linux/hardirq.h>
 #include <linux/kthread.h>
 #include <linux/uaccess.h>
-#include <linux/kprobes.h>
 #include <linux/ftrace.h>
 #include <linux/sysctl.h>
+#include <linux/slab.h>
 #include <linux/ctype.h>
 #include <linux/list.h>
 #include <linux/hash.h>
+#include <linux/rcupdate.h>
 
 #include <trace/events/sched.h>
 
@@ -60,6 +61,13 @@ static int last_ftrace_enabled;
 /* Quick disabling of function tracer. */
 int function_trace_stop;
 
+/* List for set_ftrace_pid's pids. */
+LIST_HEAD(ftrace_pids);
+struct ftrace_pid {
+       struct list_head list;
+       struct pid *pid;
+};
+
 /*
  * ftrace_disabled is set when an anomaly is discovered.
  * ftrace_disabled is much stronger than ftrace_enabled.
@@ -78,18 +86,22 @@ ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
 ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 
+/*
+ * Traverse the ftrace_list, invoking all entries.  The reason that we
+ * can use rcu_dereference_raw() is that elements removed from this list
+ * are simply leaked, so there is no need to interact with a grace-period
+ * mechanism.  The rcu_dereference_raw() calls are needed to handle
+ * concurrent insertions into the ftrace_list.
+ *
+ * Silly Alpha and silly pointer-speculation compiler optimizations!
+ */
 static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 {
-       struct ftrace_ops *op = ftrace_list;
-
-       /* in case someone actually ports this to alpha! */
-       read_barrier_depends();
+       struct ftrace_ops *op = rcu_dereference_raw(ftrace_list); /*see above*/
 
        while (op != &ftrace_list_end) {
-               /* silly alpha */
-               read_barrier_depends();
                op->func(ip, parent_ip);
-               op = op->next;
+               op = rcu_dereference_raw(op->next); /*see above*/
        };
 }
 
@@ -144,8 +156,7 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         * the ops->next pointer is valid before another CPU sees
         * the ops pointer included into the ftrace_list.
         */
-       smp_wmb();
-       ftrace_list = ops;
+       rcu_assign_pointer(ftrace_list, ops);
 
        if (ftrace_enabled) {
                ftrace_func_t func;
@@ -155,7 +166,7 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
                else
                        func = ftrace_list_func;
 
-               if (ftrace_pid_trace) {
+               if (!list_empty(&ftrace_pids)) {
                        set_ftrace_pid_function(func);
                        func = ftrace_pid_func;
                }
@@ -203,7 +214,7 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
                if (ftrace_list->next == &ftrace_list_end) {
                        ftrace_func_t func = ftrace_list->func;
 
-                       if (ftrace_pid_trace) {
+                       if (!list_empty(&ftrace_pids)) {
                                set_ftrace_pid_function(func);
                                func = ftrace_pid_func;
                        }
@@ -231,7 +242,7 @@ static void ftrace_update_pid_func(void)
        func = __ftrace_trace_function;
 #endif
 
-       if (ftrace_pid_trace) {
+       if (!list_empty(&ftrace_pids)) {
                set_ftrace_pid_function(func);
                func = ftrace_pid_func;
        } else {
@@ -253,6 +264,7 @@ struct ftrace_profile {
        unsigned long                   counter;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
        unsigned long long              time;
+       unsigned long long              time_squared;
 #endif
 };
 
@@ -355,9 +367,9 @@ static int function_stat_headers(struct seq_file *m)
 {
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
        seq_printf(m, "  Function                               "
-                  "Hit    Time            Avg\n"
+                  "Hit    Time            Avg             s^2\n"
                      "  --------                               "
-                  "---    ----            ---\n");
+                  "---    ----            ---             ---\n");
 #else
        seq_printf(m, "  Function                               Hit\n"
                      "  --------                               ---\n");
@@ -373,6 +385,7 @@ static int function_stat_show(struct seq_file *m, void *v)
        static DEFINE_MUTEX(mutex);
        static struct trace_seq s;
        unsigned long long avg;
+       unsigned long long stddev;
 #endif
 
        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
@@ -383,11 +396,25 @@ static int function_stat_show(struct seq_file *m, void *v)
        avg = rec->time;
        do_div(avg, rec->counter);
 
+       /* Sample standard deviation (s^2) */
+       if (rec->counter <= 1)
+               stddev = 0;
+       else {
+               stddev = rec->time_squared - rec->counter * avg * avg;
+               /*
+                * Divide only 1000 for ns^2 -> us^2 conversion.
+                * trace_print_graph_duration will divide 1000 again.
+                */
+               do_div(stddev, (rec->counter - 1) * 1000);
+       }
+
        mutex_lock(&mutex);
        trace_seq_init(&s);
        trace_print_graph_duration(rec->time, &s);
        trace_seq_puts(&s, "    ");
        trace_print_graph_duration(avg, &s);
+       trace_seq_puts(&s, "    ");
+       trace_print_graph_duration(stddev, &s);
        trace_print_seq(m, &s);
        mutex_unlock(&mutex);
 #endif
@@ -639,6 +666,10 @@ static void profile_graph_return(struct ftrace_graph_ret *trace)
        if (!stat->hash || !ftrace_profile_enabled)
                goto out;
 
+       /* If the calltime was zero'd ignore it */
+       if (!trace->calltime)
+               goto out;
+
        calltime = trace->rettime - trace->calltime;
 
        if (!(trace_flags & TRACE_ITER_GRAPH_TIME)) {
@@ -657,8 +688,10 @@ static void profile_graph_return(struct ftrace_graph_ret *trace)
        }
 
        rec = ftrace_find_profiled_func(stat, trace->func);
-       if (rec)
+       if (rec) {
                rec->time += calltime;
+               rec->time_squared += calltime * calltime;
+       }
 
  out:
        local_irq_restore(flags);
@@ -740,7 +773,7 @@ ftrace_profile_write(struct file *filp, const char __user *ubuf,
  out:
        mutex_unlock(&ftrace_profile_lock);
 
-       filp->f_pos += cnt;
+       *ppos += cnt;
 
        return cnt;
 }
@@ -821,8 +854,6 @@ static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
 }
 #endif /* CONFIG_FUNCTION_PROFILER */
 
-/* set when tracing only a pid */
-struct pid *ftrace_pid_trace;
 static struct pid * const ftrace_swapper_pid = &init_struct_pid;
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -889,36 +920,6 @@ static struct dyn_ftrace *ftrace_free_records;
                }                               \
        }
 
-#ifdef CONFIG_KPROBES
-
-static int frozen_record_count;
-
-static inline void freeze_record(struct dyn_ftrace *rec)
-{
-       if (!(rec->flags & FTRACE_FL_FROZEN)) {
-               rec->flags |= FTRACE_FL_FROZEN;
-               frozen_record_count++;
-       }
-}
-
-static inline void unfreeze_record(struct dyn_ftrace *rec)
-{
-       if (rec->flags & FTRACE_FL_FROZEN) {
-               rec->flags &= ~FTRACE_FL_FROZEN;
-               frozen_record_count--;
-       }
-}
-
-static inline int record_frozen(struct dyn_ftrace *rec)
-{
-       return rec->flags & FTRACE_FL_FROZEN;
-}
-#else
-# define freeze_record(rec)                    ({ 0; })
-# define unfreeze_record(rec)                  ({ 0; })
-# define record_frozen(rec)                    ({ 0; })
-#endif /* CONFIG_KPROBES */
-
 static void ftrace_free_rec(struct dyn_ftrace *rec)
 {
        rec->freelist = ftrace_free_records;
@@ -1016,6 +1017,21 @@ static void ftrace_bug(int failed, unsigned long ip)
 }
 
 
+/* Return 1 if the address range is reserved for ftrace */
+int ftrace_text_reserved(void *start, void *end)
+{
+       struct dyn_ftrace *rec;
+       struct ftrace_page *pg;
+
+       do_for_each_ftrace_rec(pg, rec) {
+               if (rec->ip <= (unsigned long)end &&
+                   rec->ip + MCOUNT_INSN_SIZE > (unsigned long)start)
+                       return 1;
+       } while_for_each_ftrace_rec();
+       return 0;
+}
+
+
 static int
 __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 {
@@ -1067,14 +1083,6 @@ static void ftrace_replace_code(int enable)
                    !(rec->flags & FTRACE_FL_CONVERTED))
                        continue;
 
-               /* ignore updates to this record's mcount site */
-               if (get_kprobe((void *)rec->ip)) {
-                       freeze_record(rec);
-                       continue;
-               } else {
-                       unfreeze_record(rec);
-               }
-
                failed = __ftrace_replace_code(rec, enable);
                if (failed) {
                        rec->flags |= FTRACE_FL_FAILED;
@@ -1261,12 +1269,34 @@ static int ftrace_update_code(struct module *mod)
                ftrace_new_addrs = p->newlist;
                p->flags = 0L;
 
-               /* convert record (i.e, patch mcount-call with NOP) */
-               if (ftrace_code_disable(mod, p)) {
-                       p->flags |= FTRACE_FL_CONVERTED;
-                       ftrace_update_cnt++;
-               } else
+               /*
+                * Do the initial record convertion from mcount jump
+                * to the NOP instructions.
+                */
+               if (!ftrace_code_disable(mod, p)) {
                        ftrace_free_rec(p);
+                       continue;
+               }
+
+               p->flags |= FTRACE_FL_CONVERTED;
+               ftrace_update_cnt++;
+
+               /*
+                * If the tracing is enabled, go ahead and enable the record.
+                *
+                * The reason not to enable the record immediatelly is the
+                * inherent check of ftrace_make_nop/ftrace_make_call for
+                * correct previous instructions.  Making first the NOP
+                * conversion puts the module to the correct state, thus
+                * passing the ftrace_make_call check.
+                */
+               if (ftrace_start_up) {
+                       int failed = __ftrace_replace_code(p, 1);
+                       if (failed) {
+                               ftrace_bug(failed, p->ip);
+                               ftrace_free_rec(p);
+                       }
+               }
        }
 
        stop = ftrace_now(raw_smp_processor_id());
@@ -1656,64 +1686,10 @@ ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
        return ret;
 }
 
-enum {
-       MATCH_FULL,
-       MATCH_FRONT_ONLY,
-       MATCH_MIDDLE_ONLY,
-       MATCH_END_ONLY,
-};
-
-/*
- * (static function - no need for kernel doc)
- *
- * Pass in a buffer containing a glob and this function will
- * set search to point to the search part of the buffer and
- * return the type of search it is (see enum above).
- * This does modify buff.
- *
- * Returns enum type.
- *  search returns the pointer to use for comparison.
- *  not returns 1 if buff started with a '!'
- *     0 otherwise.
- */
-static int
-ftrace_setup_glob(char *buff, int len, char **search, int *not)
-{
-       int type = MATCH_FULL;
-       int i;
-
-       if (buff[0] == '!') {
-               *not = 1;
-               buff++;
-               len--;
-       } else
-               *not = 0;
-
-       *search = buff;
-
-       for (i = 0; i < len; i++) {
-               if (buff[i] == '*') {
-                       if (!i) {
-                               *search = buff + 1;
-                               type = MATCH_END_ONLY;
-                       } else {
-                               if (type == MATCH_END_ONLY)
-                                       type = MATCH_MIDDLE_ONLY;
-                               else
-                                       type = MATCH_FRONT_ONLY;
-                               buff[i] = 0;
-                               break;
-                       }
-               }
-       }
-
-       return type;
-}
-
 static int ftrace_match(char *str, char *regex, int len, int type)
 {
        int matched = 0;
-       char *ptr;
+       int slen;
 
        switch (type) {
        case MATCH_FULL:
@@ -1729,8 +1705,8 @@ static int ftrace_match(char *str, char *regex, int len, int type)
                        matched = 1;
                break;
        case MATCH_END_ONLY:
-               ptr = strstr(str, regex);
-               if (ptr && (ptr[len] == 0))
+               slen = strlen(str);
+               if (slen >= len && memcmp(str + slen - len, regex, len) == 0)
                        matched = 1;
                break;
        }
@@ -1747,7 +1723,7 @@ ftrace_match_record(struct dyn_ftrace *rec, char *regex, int len, int type)
        return ftrace_match(str, regex, len, type);
 }
 
-static void ftrace_match_records(char *buff, int len, int enable)
+static int ftrace_match_records(char *buff, int len, int enable)
 {
        unsigned int search_len;
        struct ftrace_page *pg;
@@ -1756,9 +1732,10 @@ static void ftrace_match_records(char *buff, int len, int enable)
        char *search;
        int type;
        int not;
+       int found = 0;
 
        flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
-       type = ftrace_setup_glob(buff, len, &search, &not);
+       type = filter_parse_regex(buff, len, &search, &not);
 
        search_len = strlen(search);
 
@@ -1773,6 +1750,7 @@ static void ftrace_match_records(char *buff, int len, int enable)
                                rec->flags &= ~flag;
                        else
                                rec->flags |= flag;
+                       found = 1;
                }
                /*
                 * Only enable filtering if we have a function that
@@ -1782,6 +1760,8 @@ static void ftrace_match_records(char *buff, int len, int enable)
                        ftrace_filtered = 1;
        } while_for_each_ftrace_rec();
        mutex_unlock(&ftrace_lock);
+
+       return found;
 }
 
 static int
@@ -1803,7 +1783,7 @@ ftrace_match_module_record(struct dyn_ftrace *rec, char *mod,
                return 1;
 }
 
-static void ftrace_match_module_records(char *buff, char *mod, int enable)
+static int ftrace_match_module_records(char *buff, char *mod, int enable)
 {
        unsigned search_len = 0;
        struct ftrace_page *pg;
@@ -1812,6 +1792,7 @@ static void ftrace_match_module_records(char *buff, char *mod, int enable)
        char *search = buff;
        unsigned long flag;
        int not = 0;
+       int found = 0;
 
        flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
 
@@ -1826,7 +1807,7 @@ static void ftrace_match_module_records(char *buff, char *mod, int enable)
        }
 
        if (strlen(buff)) {
-               type = ftrace_setup_glob(buff, strlen(buff), &search, &not);
+               type = filter_parse_regex(buff, strlen(buff), &search, &not);
                search_len = strlen(search);
        }
 
@@ -1842,12 +1823,15 @@ static void ftrace_match_module_records(char *buff, char *mod, int enable)
                                rec->flags &= ~flag;
                        else
                                rec->flags |= flag;
+                       found = 1;
                }
                if (enable && (rec->flags & FTRACE_FL_FILTER))
                        ftrace_filtered = 1;
 
        } while_for_each_ftrace_rec();
        mutex_unlock(&ftrace_lock);
+
+       return found;
 }
 
 /*
@@ -1876,8 +1860,9 @@ ftrace_mod_callback(char *func, char *cmd, char *param, int enable)
        if (!strlen(mod))
                return -EINVAL;
 
-       ftrace_match_module_records(func, mod, enable);
-       return 0;
+       if (ftrace_match_module_records(func, mod, enable))
+               return 0;
+       return -EINVAL;
 }
 
 static struct ftrace_func_command ftrace_mod_cmd = {
@@ -1991,7 +1976,7 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
        int count = 0;
        char *search;
 
-       type = ftrace_setup_glob(glob, strlen(glob), &search, &not);
+       type = filter_parse_regex(glob, strlen(glob), &search, &not);
        len = strlen(search);
 
        /* we do not support '!' for function probes */
@@ -2068,7 +2053,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
        else if (glob) {
                int not;
 
-               type = ftrace_setup_glob(glob, strlen(glob), &search, &not);
+               type = filter_parse_regex(glob, strlen(glob), &search, &not);
                len = strlen(search);
 
                /* we do not support '!' for function probes */
@@ -2174,8 +2159,9 @@ static int ftrace_process_regex(char *buff, int len, int enable)
        func = strsep(&next, ":");
 
        if (!next) {
-               ftrace_match_records(func, len, enable);
-               return 0;
+               if (ftrace_match_records(func, len, enable))
+                       return 0;
+               return ret;
        }
 
        /* command found */
@@ -2221,16 +2207,15 @@ ftrace_regex_write(struct file *file, const char __user *ubuf,
            !trace_parser_cont(parser)) {
                ret = ftrace_process_regex(parser->buffer,
                                           parser->idx, enable);
-               if (ret)
-                       goto out;
-
                trace_parser_clear(parser);
+               if (ret)
+                       goto out_unlock;
        }
 
        ret = read;
-
+out_unlock:
        mutex_unlock(&ftrace_regex_lock);
-out:
+
        return ret;
 }
 
@@ -2312,6 +2297,34 @@ static int __init set_ftrace_filter(char *str)
 }
 __setup("ftrace_filter=", set_ftrace_filter);
 
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
+static int ftrace_set_func(unsigned long *array, int *idx, char *buffer);
+
+static int __init set_graph_function(char *str)
+{
+       strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
+       return 1;
+}
+__setup("ftrace_graph_filter=", set_graph_function);
+
+static void __init set_ftrace_early_graph(char *buf)
+{
+       int ret;
+       char *func;
+
+       while (buf) {
+               func = strsep(&buf, ",");
+               /* we allow only one expression at a time */
+               ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
+                                     func);
+               if (ret)
+                       printk(KERN_DEBUG "ftrace: function %s not "
+                                         "traceable\n", func);
+       }
+}
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+
 static void __init set_ftrace_early_filter(char *buf, int enable)
 {
        char *func;
@@ -2328,6 +2341,10 @@ static void __init set_ftrace_early_filters(void)
                set_ftrace_early_filter(ftrace_filter_buf, 1);
        if (ftrace_notrace_buf[0])
                set_ftrace_early_filter(ftrace_notrace_buf, 0);
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+       if (ftrace_graph_buf[0])
+               set_ftrace_early_graph(ftrace_graph_buf);
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 }
 
 static int
@@ -2410,6 +2427,7 @@ static const struct file_operations ftrace_notrace_fops = {
 static DEFINE_MUTEX(graph_lock);
 
 int ftrace_graph_count;
+int ftrace_graph_filter_enabled;
 unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS] __read_mostly;
 
 static void *
@@ -2432,7 +2450,7 @@ static void *g_start(struct seq_file *m, loff_t *pos)
        mutex_lock(&graph_lock);
 
        /* Nothing, tell g_show to print all functions are enabled */
-       if (!ftrace_graph_count && !*pos)
+       if (!ftrace_graph_filter_enabled && !*pos)
                return (void *)1;
 
        return __g_next(m, pos);
@@ -2478,6 +2496,7 @@ ftrace_graph_open(struct inode *inode, struct file *file)
        mutex_lock(&graph_lock);
        if ((file->f_mode & FMODE_WRITE) &&
            (file->f_flags & O_TRUNC)) {
+               ftrace_graph_filter_enabled = 0;
                ftrace_graph_count = 0;
                memset(ftrace_graph_funcs, 0, sizeof(ftrace_graph_funcs));
        }
@@ -2503,7 +2522,7 @@ ftrace_set_func(unsigned long *array, int *idx, char *buffer)
        struct dyn_ftrace *rec;
        struct ftrace_page *pg;
        int search_len;
-       int found = 0;
+       int fail = 1;
        int type, not;
        char *search;
        bool exists;
@@ -2513,39 +2532,52 @@ ftrace_set_func(unsigned long *array, int *idx, char *buffer)
                return -ENODEV;
 
        /* decode regex */
-       type = ftrace_setup_glob(buffer, strlen(buffer), &search, &not);
-       if (not)
-               return -EINVAL;
+       type = filter_parse_regex(buffer, strlen(buffer), &search, &not);
+       if (!not && *idx >= FTRACE_GRAPH_MAX_FUNCS)
+               return -EBUSY;
 
        search_len = strlen(search);
 
        mutex_lock(&ftrace_lock);
        do_for_each_ftrace_rec(pg, rec) {
 
-               if (*idx >= FTRACE_GRAPH_MAX_FUNCS)
-                       break;
-
                if (rec->flags & (FTRACE_FL_FAILED | FTRACE_FL_FREE))
                        continue;
 
                if (ftrace_match_record(rec, search, search_len, type)) {
-                       /* ensure it is not already in the array */
+                       /* if it is in the array */
                        exists = false;
-                       for (i = 0; i < *idx; i++)
+                       for (i = 0; i < *idx; i++) {
                                if (array[i] == rec->ip) {
                                        exists = true;
                                        break;
                                }
-                       if (!exists) {
-                               array[(*idx)++] = rec->ip;
-                               found = 1;
+                       }
+
+                       if (!not) {
+                               fail = 0;
+                               if (!exists) {
+                                       array[(*idx)++] = rec->ip;
+                                       if (*idx >= FTRACE_GRAPH_MAX_FUNCS)
+                                               goto out;
+                               }
+                       } else {
+                               if (exists) {
+                                       array[i] = array[--(*idx)];
+                                       array[*idx] = 0;
+                                       fail = 0;
+                               }
                        }
                }
        } while_for_each_ftrace_rec();
-
+out:
        mutex_unlock(&ftrace_lock);
 
-       return found ? 0 : -EINVAL;
+       if (fail)
+               return -EINVAL;
+
+       ftrace_graph_filter_enabled = 1;
+       return 0;
 }
 
 static ssize_t
@@ -2555,16 +2587,11 @@ ftrace_graph_write(struct file *file, const char __user *ubuf,
        struct trace_parser parser;
        ssize_t read, ret;
 
-       if (!cnt || cnt < 0)
+       if (!cnt)
                return 0;
 
        mutex_lock(&graph_lock);
 
-       if (ftrace_graph_count >= FTRACE_GRAPH_MAX_FUNCS) {
-               ret = -EBUSY;
-               goto out_unlock;
-       }
-
        if (trace_parser_get_init(&parser, FTRACE_BUFF_MAX)) {
                ret = -ENOMEM;
                goto out_unlock;
@@ -2624,7 +2651,7 @@ static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
        return 0;
 }
 
-static int ftrace_convert_nops(struct module *mod,
+static int ftrace_process_locs(struct module *mod,
                               unsigned long *start,
                               unsigned long *end)
 {
@@ -2684,7 +2711,7 @@ static void ftrace_init_module(struct module *mod,
 {
        if (ftrace_disabled || start == end)
                return;
-       ftrace_convert_nops(mod, start, end);
+       ftrace_process_locs(mod, start, end);
 }
 
 static int ftrace_module_notify(struct notifier_block *self,
@@ -2745,7 +2772,7 @@ void __init ftrace_init(void)
 
        last_ftrace_enabled = ftrace_enabled = 1;
 
-       ret = ftrace_convert_nops(NULL,
+       ret = ftrace_process_locs(NULL,
                                  __start_mcount_loc,
                                  __stop_mcount_loc);
 
@@ -2778,23 +2805,6 @@ static inline void ftrace_startup_enable(int command) { }
 # define ftrace_shutdown_sysctl()      do { } while (0)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
-static ssize_t
-ftrace_pid_read(struct file *file, char __user *ubuf,
-                      size_t cnt, loff_t *ppos)
-{
-       char buf[64];
-       int r;
-
-       if (ftrace_pid_trace == ftrace_swapper_pid)
-               r = sprintf(buf, "swapper tasks\n");
-       else if (ftrace_pid_trace)
-               r = sprintf(buf, "%u\n", pid_vnr(ftrace_pid_trace));
-       else
-               r = sprintf(buf, "no pid\n");
-
-       return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-}
-
 static void clear_ftrace_swapper(void)
 {
        struct task_struct *p;
@@ -2845,14 +2855,12 @@ static void set_ftrace_pid(struct pid *pid)
        rcu_read_unlock();
 }
 
-static void clear_ftrace_pid_task(struct pid **pid)
+static void clear_ftrace_pid_task(struct pid *pid)
 {
-       if (*pid == ftrace_swapper_pid)
+       if (pid == ftrace_swapper_pid)
                clear_ftrace_swapper();
        else
-               clear_ftrace_pid(*pid);
-
-       *pid = NULL;
+               clear_ftrace_pid(pid);
 }
 
 static void set_ftrace_pid_task(struct pid *pid)
@@ -2863,74 +2871,184 @@ static void set_ftrace_pid_task(struct pid *pid)
                set_ftrace_pid(pid);
 }
 
-static ssize_t
-ftrace_pid_write(struct file *filp, const char __user *ubuf,
-                  size_t cnt, loff_t *ppos)
+static int ftrace_pid_add(int p)
 {
        struct pid *pid;
-       char buf[64];
-       long val;
-       int ret;
+       struct ftrace_pid *fpid;
+       int ret = -EINVAL;
 
-       if (cnt >= sizeof(buf))
-               return -EINVAL;
+       mutex_lock(&ftrace_lock);
 
-       if (copy_from_user(&buf, ubuf, cnt))
-               return -EFAULT;
+       if (!p)
+               pid = ftrace_swapper_pid;
+       else
+               pid = find_get_pid(p);
 
-       buf[cnt] = 0;
+       if (!pid)
+               goto out;
 
-       ret = strict_strtol(buf, 10, &val);
-       if (ret < 0)
-               return ret;
+       ret = 0;
 
-       mutex_lock(&ftrace_lock);
-       if (val < 0) {
-               /* disable pid tracing */
-               if (!ftrace_pid_trace)
-                       goto out;
+       list_for_each_entry(fpid, &ftrace_pids, list)
+               if (fpid->pid == pid)
+                       goto out_put;
 
-               clear_ftrace_pid_task(&ftrace_pid_trace);
+       ret = -ENOMEM;
 
-       } else {
-               /* swapper task is special */
-               if (!val) {
-                       pid = ftrace_swapper_pid;
-                       if (pid == ftrace_pid_trace)
-                               goto out;
-               } else {
-                       pid = find_get_pid(val);
+       fpid = kmalloc(sizeof(*fpid), GFP_KERNEL);
+       if (!fpid)
+               goto out_put;
 
-                       if (pid == ftrace_pid_trace) {
-                               put_pid(pid);
-                               goto out;
-                       }
-               }
+       list_add(&fpid->list, &ftrace_pids);
+       fpid->pid = pid;
 
-               if (ftrace_pid_trace)
-                       clear_ftrace_pid_task(&ftrace_pid_trace);
+       set_ftrace_pid_task(pid);
 
-               if (!pid)
-                       goto out;
+       ftrace_update_pid_func();
+       ftrace_startup_enable(0);
+
+       mutex_unlock(&ftrace_lock);
+       return 0;
+
+out_put:
+       if (pid != ftrace_swapper_pid)
+               put_pid(pid);
+
+out:
+       mutex_unlock(&ftrace_lock);
+       return ret;
+}
+
+static void ftrace_pid_reset(void)
+{
+       struct ftrace_pid *fpid, *safe;
 
-               ftrace_pid_trace = pid;
+       mutex_lock(&ftrace_lock);
+       list_for_each_entry_safe(fpid, safe, &ftrace_pids, list) {
+               struct pid *pid = fpid->pid;
+
+               clear_ftrace_pid_task(pid);
 
-               set_ftrace_pid_task(ftrace_pid_trace);
+               list_del(&fpid->list);
+               kfree(fpid);
        }
 
-       /* update the function call */
        ftrace_update_pid_func();
        ftrace_startup_enable(0);
 
- out:
        mutex_unlock(&ftrace_lock);
+}
 
-       return cnt;
+static void *fpid_start(struct seq_file *m, loff_t *pos)
+{
+       mutex_lock(&ftrace_lock);
+
+       if (list_empty(&ftrace_pids) && (!*pos))
+               return (void *) 1;
+
+       return seq_list_start(&ftrace_pids, *pos);
+}
+
+static void *fpid_next(struct seq_file *m, void *v, loff_t *pos)
+{
+       if (v == (void *)1)
+               return NULL;
+
+       return seq_list_next(v, &ftrace_pids, pos);
+}
+
+static void fpid_stop(struct seq_file *m, void *p)
+{
+       mutex_unlock(&ftrace_lock);
+}
+
+static int fpid_show(struct seq_file *m, void *v)
+{
+       const struct ftrace_pid *fpid = list_entry(v, struct ftrace_pid, list);
+
+       if (v == (void *)1) {
+               seq_printf(m, "no pid\n");
+               return 0;
+       }
+
+       if (fpid->pid == ftrace_swapper_pid)
+               seq_printf(m, "swapper tasks\n");
+       else
+               seq_printf(m, "%u\n", pid_vnr(fpid->pid));
+
+       return 0;
+}
+
+static const struct seq_operations ftrace_pid_sops = {
+       .start = fpid_start,
+       .next = fpid_next,
+       .stop = fpid_stop,
+       .show = fpid_show,
+};
+
+static int
+ftrace_pid_open(struct inode *inode, struct file *file)
+{
+       int ret = 0;
+
+       if ((file->f_mode & FMODE_WRITE) &&
+           (file->f_flags & O_TRUNC))
+               ftrace_pid_reset();
+
+       if (file->f_mode & FMODE_READ)
+               ret = seq_open(file, &ftrace_pid_sops);
+
+       return ret;
+}
+
+static ssize_t
+ftrace_pid_write(struct file *filp, const char __user *ubuf,
+                  size_t cnt, loff_t *ppos)
+{
+       char buf[64], *tmp;
+       long val;
+       int ret;
+
+       if (cnt >= sizeof(buf))
+               return -EINVAL;
+
+       if (copy_from_user(&buf, ubuf, cnt))
+               return -EFAULT;
+
+       buf[cnt] = 0;
+
+       /*
+        * Allow "echo > set_ftrace_pid" or "echo -n '' > set_ftrace_pid"
+        * to clean the filter quietly.
+        */
+       tmp = strstrip(buf);
+       if (strlen(tmp) == 0)
+               return 1;
+
+       ret = strict_strtol(tmp, 10, &val);
+       if (ret < 0)
+               return ret;
+
+       ret = ftrace_pid_add(val);
+
+       return ret ? ret : cnt;
+}
+
+static int
+ftrace_pid_release(struct inode *inode, struct file *file)
+{
+       if (file->f_mode & FMODE_READ)
+               seq_release(inode, file);
+
+       return 0;
 }
 
 static const struct file_operations ftrace_pid_fops = {
-       .read = ftrace_pid_read,
-       .write = ftrace_pid_write,
+       .open           = ftrace_pid_open,
+       .write          = ftrace_pid_write,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = ftrace_pid_release,
 };
 
 static __init int ftrace_init_debugfs(void)
@@ -3116,8 +3234,8 @@ free:
 }
 
 static void
-ftrace_graph_probe_sched_switch(struct rq *__rq, struct task_struct *prev,
-                               struct task_struct *next)
+ftrace_graph_probe_sched_switch(void *ignore,
+                       struct task_struct *prev, struct task_struct *next)
 {
        unsigned long long timestamp;
        int index;
@@ -3171,7 +3289,7 @@ static int start_graph_tracing(void)
        } while (ret == -EAGAIN);
 
        if (!ret) {
-               ret = register_trace_sched_switch(ftrace_graph_probe_sched_switch);
+               ret = register_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
                if (ret)
                        pr_info("ftrace_graph: Couldn't activate tracepoint"
                                " probe to kernel_sched_switch\n");
@@ -3243,11 +3361,11 @@ void unregister_ftrace_graph(void)
                goto out;
 
        ftrace_graph_active--;
-       unregister_trace_sched_switch(ftrace_graph_probe_sched_switch);
        ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
        ftrace_graph_entry = ftrace_graph_entry_stub;
        ftrace_shutdown(FTRACE_STOP_FUNC_RET);
        unregister_pm_notifier(&ftrace_suspend_notifier);
+       unregister_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
 
  out:
        mutex_unlock(&ftrace_lock);
@@ -3258,6 +3376,7 @@ void ftrace_graph_init_task(struct task_struct *t)
 {
        /* Make sure we do not use the parent ret_stack */
        t->ret_stack = NULL;
+       t->curr_ret_stack = -1;
 
        if (ftrace_graph_active) {
                struct ftrace_ret_stack *ret_stack;
@@ -3267,7 +3386,6 @@ void ftrace_graph_init_task(struct task_struct *t)
                                GFP_KERNEL);
                if (!ret_stack)
                        return;
-               t->curr_ret_stack = -1;
                atomic_set(&t->tracing_graph_pause, 0);
                atomic_set(&t->trace_overrun, 0);
                t->ftrace_timestamp = 0;
@@ -3293,4 +3411,3 @@ void ftrace_graph_stop(void)
        ftrace_stop();
 }
 #endif
-