tracing: Let tracepoints have data passed to tracepoint callbacks
[linux-2.6.git] / kernel / trace / ftrace.c
index 2074e5b..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;
                        }
@@ -225,9 +236,13 @@ static void ftrace_update_pid_func(void)
        if (ftrace_trace_function == ftrace_stub)
                return;
 
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
        func = ftrace_trace_function;
+#else
+       func = __ftrace_trace_function;
+#endif
 
-       if (ftrace_pid_trace) {
+       if (!list_empty(&ftrace_pids)) {
                set_ftrace_pid_function(func);
                func = ftrace_pid_func;
        } else {
@@ -249,6 +264,7 @@ struct ftrace_profile {
        unsigned long                   counter;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
        unsigned long long              time;
+       unsigned long long              time_squared;
 #endif
 };
 
@@ -291,7 +307,9 @@ function_stat_next(void *v, int idx)
        pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
 
  again:
-       rec++;
+       if (idx != 0)
+               rec++;
+
        if ((void *)rec >= (void *)&pg->records[pg->index]) {
                pg = pg->next;
                if (!pg)
@@ -349,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");
@@ -367,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);
@@ -377,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
@@ -599,7 +632,7 @@ function_profile_call(unsigned long ip, unsigned long parent_ip)
        local_irq_save(flags);
 
        stat = &__get_cpu_var(ftrace_profile_stats);
-       if (!stat->hash)
+       if (!stat->hash || !ftrace_profile_enabled)
                goto out;
 
        rec = ftrace_find_profiled_func(stat, ip);
@@ -630,7 +663,11 @@ static void profile_graph_return(struct ftrace_graph_ret *trace)
 
        local_irq_save(flags);
        stat = &__get_cpu_var(ftrace_profile_stats);
-       if (!stat->hash)
+       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;
@@ -651,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);
@@ -724,13 +763,17 @@ ftrace_profile_write(struct file *filp, const char __user *ubuf,
                        ftrace_profile_enabled = 1;
                } else {
                        ftrace_profile_enabled = 0;
+                       /*
+                        * unregister_ftrace_profiler calls stop_machine
+                        * so this acts like an synchronize_sched.
+                        */
                        unregister_ftrace_profiler();
                }
        }
  out:
        mutex_unlock(&ftrace_profile_lock);
 
-       filp->f_pos += cnt;
+       *ppos += cnt;
 
        return cnt;
 }
@@ -762,7 +805,7 @@ static struct tracer_stat function_stats __initdata = {
        .stat_show      = function_stat_show
 };
 
-static void ftrace_profile_debugfs(struct dentry *d_tracer)
+static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
 {
        struct ftrace_profile_stat *stat;
        struct dentry *entry;
@@ -780,7 +823,6 @@ static void ftrace_profile_debugfs(struct dentry *d_tracer)
                         * The files created are permanent, if something happens
                         * we still do not free memory.
                         */
-                       kfree(stat);
                        WARN(1,
                             "Could not allocate stat file for cpu %d\n",
                             cpu);
@@ -807,13 +849,11 @@ static void ftrace_profile_debugfs(struct dentry *d_tracer)
 }
 
 #else /* CONFIG_FUNCTION_PROFILER */
-static void ftrace_profile_debugfs(struct dentry *d_tracer)
+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
@@ -880,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;
@@ -1007,75 +1017,54 @@ 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)
 {
        unsigned long ftrace_addr;
-       unsigned long ip, fl;
+       unsigned long flag = 0UL;
 
        ftrace_addr = (unsigned long)FTRACE_ADDR;
 
-       ip = rec->ip;
-
        /*
-        * If this record is not to be traced and
-        * it is not enabled then do nothing.
+        * If this record is not to be traced or we want to disable it,
+        * then disable it.
         *
-        * If this record is not to be traced and
-        * it is enabled then disable it.
+        * If we want to enable it and filtering is off, then enable it.
         *
+        * If we want to enable it and filtering is on, enable it only if
+        * it's filtered
         */
-       if (rec->flags & FTRACE_FL_NOTRACE) {
-               if (rec->flags & FTRACE_FL_ENABLED)
-                       rec->flags &= ~FTRACE_FL_ENABLED;
-               else
-                       return 0;
-
-       } else if (ftrace_filtered && enable) {
-               /*
-                * Filtering is on:
-                */
-
-               fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
-
-               /* Record is filtered and enabled, do nothing */
-               if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
-                       return 0;
-
-               /* Record is not filtered or enabled, do nothing */
-               if (!fl)
-                       return 0;
-
-               /* Record is not filtered but enabled, disable it */
-               if (fl == FTRACE_FL_ENABLED)
-                       rec->flags &= ~FTRACE_FL_ENABLED;
-               else
-               /* Otherwise record is filtered but not enabled, enable it */
-                       rec->flags |= FTRACE_FL_ENABLED;
-       } else {
-               /* Disable or not filtered */
-
-               if (enable) {
-                       /* if record is enabled, do nothing */
-                       if (rec->flags & FTRACE_FL_ENABLED)
-                               return 0;
-
-                       rec->flags |= FTRACE_FL_ENABLED;
-
-               } else {
+       if (enable && !(rec->flags & FTRACE_FL_NOTRACE)) {
+               if (!ftrace_filtered || (rec->flags & FTRACE_FL_FILTER))
+                       flag = FTRACE_FL_ENABLED;
+       }
 
-                       /* if record is not enabled, do nothing */
-                       if (!(rec->flags & FTRACE_FL_ENABLED))
-                               return 0;
+       /* If the state of this record hasn't changed, then do nothing */
+       if ((rec->flags & FTRACE_FL_ENABLED) == flag)
+               return 0;
 
-                       rec->flags &= ~FTRACE_FL_ENABLED;
-               }
+       if (flag) {
+               rec->flags |= FTRACE_FL_ENABLED;
+               return ftrace_make_call(rec, ftrace_addr);
        }
 
-       if (rec->flags & FTRACE_FL_ENABLED)
-               return ftrace_make_call(rec, ftrace_addr);
-       else
-               return ftrace_make_nop(NULL, rec, ftrace_addr);
+       rec->flags &= ~FTRACE_FL_ENABLED;
+       return ftrace_make_nop(NULL, rec, ftrace_addr);
 }
 
 static void ftrace_replace_code(int enable)
@@ -1094,25 +1083,12 @@ 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;
-                       if ((system_state == SYSTEM_BOOTING) ||
-                           !core_kernel_text(rec->ip)) {
-                               ftrace_free_rec(rec);
-                               } else {
-                               ftrace_bug(failed, rec->ip);
-                                       /* Stop processing */
-                                       return;
-                               }
+                       ftrace_bug(failed, rec->ip);
+                       /* Stop processing */
+                       return;
                }
        } while_for_each_ftrace_rec();
 }
@@ -1220,6 +1196,13 @@ static void ftrace_shutdown(int command)
                return;
 
        ftrace_start_up--;
+       /*
+        * Just warn in case of unbalance, no need to kill ftrace, it's not
+        * critical but the ftrace_call callers may be never nopped again after
+        * further ftrace uses.
+        */
+       WARN_ON_ONCE(ftrace_start_up < 0);
+
        if (!ftrace_start_up)
                command |= FTRACE_DISABLE_CALLS;
 
@@ -1286,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());
@@ -1347,11 +1352,10 @@ static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
 
 enum {
        FTRACE_ITER_FILTER      = (1 << 0),
-       FTRACE_ITER_CONT        = (1 << 1),
-       FTRACE_ITER_NOTRACE     = (1 << 2),
-       FTRACE_ITER_FAILURES    = (1 << 3),
-       FTRACE_ITER_PRINTALL    = (1 << 4),
-       FTRACE_ITER_HASH        = (1 << 5),
+       FTRACE_ITER_NOTRACE     = (1 << 1),
+       FTRACE_ITER_FAILURES    = (1 << 2),
+       FTRACE_ITER_PRINTALL    = (1 << 3),
+       FTRACE_ITER_HASH        = (1 << 4),
 };
 
 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
@@ -1361,9 +1365,7 @@ struct ftrace_iterator {
        int                     hidx;
        int                     idx;
        unsigned                flags;
-       unsigned char           buffer[FTRACE_BUFF_MAX+1];
-       unsigned                buffer_idx;
-       unsigned                filtered;
+       struct trace_parser     parser;
 };
 
 static void *
@@ -1406,28 +1408,33 @@ static void *t_hash_start(struct seq_file *m, loff_t *pos)
 {
        struct ftrace_iterator *iter = m->private;
        void *p = NULL;
+       loff_t l;
+
+       if (!(iter->flags & FTRACE_ITER_HASH))
+               *pos = 0;
 
        iter->flags |= FTRACE_ITER_HASH;
 
-       return t_hash_next(m, p, pos);
+       iter->hidx = 0;
+       for (l = 0; l <= *pos; ) {
+               p = t_hash_next(m, p, &l);
+               if (!p)
+                       break;
+       }
+       return p;
 }
 
 static int t_hash_show(struct seq_file *m, void *v)
 {
        struct ftrace_func_probe *rec;
        struct hlist_node *hnd = v;
-       char str[KSYM_SYMBOL_LEN];
 
        rec = hlist_entry(hnd, struct ftrace_func_probe, node);
 
        if (rec->ops->print)
                return rec->ops->print(m, rec->ip, rec->ops, rec->data);
 
-       kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-       seq_printf(m, "%s:", str);
-
-       kallsyms_lookup((unsigned long)rec->ops->func, NULL, NULL, NULL, str);
-       seq_printf(m, "%s", str);
+       seq_printf(m, "%ps:%ps", (void *)rec->ip, (void *)rec->ops->func);
 
        if (rec->data)
                seq_printf(m, ":%p", rec->data);
@@ -1456,8 +1463,6 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                        iter->pg = iter->pg->next;
                        iter->idx = 0;
                        goto retry;
-               } else {
-                       iter->idx = -1;
                }
        } else {
                rec = &iter->pg->records[iter->idx++];
@@ -1486,6 +1491,7 @@ static void *t_start(struct seq_file *m, loff_t *pos)
 {
        struct ftrace_iterator *iter = m->private;
        void *p = NULL;
+       loff_t l;
 
        mutex_lock(&ftrace_lock);
        /*
@@ -1497,23 +1503,21 @@ static void *t_start(struct seq_file *m, loff_t *pos)
                if (*pos > 0)
                        return t_hash_start(m, pos);
                iter->flags |= FTRACE_ITER_PRINTALL;
-               (*pos)++;
                return iter;
        }
 
        if (iter->flags & FTRACE_ITER_HASH)
                return t_hash_start(m, pos);
 
-       if (*pos > 0) {
-               if (iter->idx < 0)
-                       return p;
-               (*pos)--;
-               iter->idx--;
+       iter->pg = ftrace_pages_start;
+       iter->idx = 0;
+       for (l = 0; l <= *pos; ) {
+               p = t_next(m, p, &l);
+               if (!p)
+                       break;
        }
 
-       p = t_next(m, p, pos);
-
-       if (!p)
+       if (!p && iter->flags & FTRACE_ITER_FILTER)
                return t_hash_start(m, pos);
 
        return p;
@@ -1528,7 +1532,6 @@ static int t_show(struct seq_file *m, void *v)
 {
        struct ftrace_iterator *iter = m->private;
        struct dyn_ftrace *rec = v;
-       char str[KSYM_SYMBOL_LEN];
 
        if (iter->flags & FTRACE_ITER_HASH)
                return t_hash_show(m, v);
@@ -1541,14 +1544,12 @@ static int t_show(struct seq_file *m, void *v)
        if (!rec)
                return 0;
 
-       kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-
-       seq_printf(m, "%s\n", str);
+       seq_printf(m, "%ps\n", (void *)rec->ip);
 
        return 0;
 }
 
-static struct seq_operations show_ftrace_seq_ops = {
+static const struct seq_operations show_ftrace_seq_ops = {
        .start = t_start,
        .next = t_next,
        .stop = t_stop,
@@ -1582,17 +1583,6 @@ ftrace_avail_open(struct inode *inode, struct file *file)
        return ret;
 }
 
-int ftrace_avail_release(struct inode *inode, struct file *file)
-{
-       struct seq_file *m = (struct seq_file *)file->private_data;
-       struct ftrace_iterator *iter = m->private;
-
-       seq_release(inode, file);
-       kfree(iter);
-
-       return 0;
-}
-
 static int
 ftrace_failures_open(struct inode *inode, struct file *file)
 {
@@ -1641,9 +1631,14 @@ ftrace_regex_open(struct inode *inode, struct file *file, int enable)
        if (!iter)
                return -ENOMEM;
 
+       if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) {
+               kfree(iter);
+               return -ENOMEM;
+       }
+
        mutex_lock(&ftrace_regex_lock);
        if ((file->f_mode & FMODE_WRITE) &&
-           !(file->f_flags & O_APPEND))
+           (file->f_flags & O_TRUNC))
                ftrace_filter_reset(enable);
 
        if (file->f_mode & FMODE_READ) {
@@ -1655,8 +1650,10 @@ ftrace_regex_open(struct inode *inode, struct file *file, int enable)
                if (!ret) {
                        struct seq_file *m = file->private_data;
                        m->private = iter;
-               } else
+               } else {
+                       trace_parser_put(&iter->parser);
                        kfree(iter);
+               }
        } else
                file->private_data = iter;
        mutex_unlock(&ftrace_regex_lock);
@@ -1689,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:
@@ -1762,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;
        }
@@ -1780,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;
@@ -1789,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);
 
@@ -1806,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
@@ -1815,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
@@ -1836,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;
@@ -1845,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;
 
@@ -1859,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);
        }
 
@@ -1875,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;
 }
 
 /*
@@ -1909,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 = {
@@ -2024,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 */
@@ -2096,12 +2048,12 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
        int i, len = 0;
        char *search;
 
-       if (glob && (strcmp(glob, "*") || !strlen(glob)))
+       if (glob && (strcmp(glob, "*") == 0 || !strlen(glob)))
                glob = NULL;
-       else {
+       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 */
@@ -2207,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 */
@@ -2233,11 +2186,10 @@ ftrace_regex_write(struct file *file, const char __user *ubuf,
                   size_t cnt, loff_t *ppos, int enable)
 {
        struct ftrace_iterator *iter;
-       char ch;
-       size_t read = 0;
-       ssize_t ret;
+       struct trace_parser *parser;
+       ssize_t ret, read;
 
-       if (!cnt || cnt < 0)
+       if (!cnt)
                return 0;
 
        mutex_lock(&ftrace_regex_lock);
@@ -2248,66 +2200,20 @@ ftrace_regex_write(struct file *file, const char __user *ubuf,
        } else
                iter = file->private_data;
 
-       if (!*ppos) {
-               iter->flags &= ~FTRACE_ITER_CONT;
-               iter->buffer_idx = 0;
-       }
+       parser = &iter->parser;
+       read = trace_get_user(parser, ubuf, cnt, ppos);
 
-       ret = get_user(ch, ubuf++);
-       if (ret)
-               goto out;
-       read++;
-       cnt--;
-
-       if (!(iter->flags & ~FTRACE_ITER_CONT)) {
-               /* skip white space */
-               while (cnt && isspace(ch)) {
-                       ret = get_user(ch, ubuf++);
-                       if (ret)
-                               goto out;
-                       read++;
-                       cnt--;
-               }
-
-               if (isspace(ch)) {
-                       file->f_pos += read;
-                       ret = read;
-                       goto out;
-               }
-
-               iter->buffer_idx = 0;
-       }
-
-       while (cnt && !isspace(ch)) {
-               if (iter->buffer_idx < FTRACE_BUFF_MAX)
-                       iter->buffer[iter->buffer_idx++] = ch;
-               else {
-                       ret = -EINVAL;
-                       goto out;
-               }
-               ret = get_user(ch, ubuf++);
+       if (read >= 0 && trace_parser_loaded(parser) &&
+           !trace_parser_cont(parser)) {
+               ret = ftrace_process_regex(parser->buffer,
+                                          parser->idx, enable);
+               trace_parser_clear(parser);
                if (ret)
-                       goto out;
-               read++;
-               cnt--;
+                       goto out_unlock;
        }
 
-       if (isspace(ch)) {
-               iter->filtered++;
-               iter->buffer[iter->buffer_idx] = 0;
-               ret = ftrace_process_regex(iter->buffer,
-                                          iter->buffer_idx, enable);
-               if (ret)
-                       goto out;
-               iter->buffer_idx = 0;
-       } else
-               iter->flags |= FTRACE_ITER_CONT;
-
-
-       file->f_pos += read;
-
        ret = read;
- out:
+out_unlock:
        mutex_unlock(&ftrace_regex_lock);
 
        return ret;
@@ -2391,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;
@@ -2407,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
@@ -2414,6 +2352,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
 {
        struct seq_file *m = (struct seq_file *)file->private_data;
        struct ftrace_iterator *iter;
+       struct trace_parser *parser;
 
        mutex_lock(&ftrace_regex_lock);
        if (file->f_mode & FMODE_READ) {
@@ -2423,10 +2362,10 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
        } else
                iter = file->private_data;
 
-       if (iter->buffer_idx) {
-               iter->filtered++;
-               iter->buffer[iter->buffer_idx] = 0;
-               ftrace_match_records(iter->buffer, iter->buffer_idx, enable);
+       parser = &iter->parser;
+       if (trace_parser_loaded(parser)) {
+               parser->buffer[parser->idx] = 0;
+               ftrace_match_records(parser->buffer, parser->idx, enable);
        }
 
        mutex_lock(&ftrace_lock);
@@ -2434,7 +2373,9 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
                ftrace_run_update_code(FTRACE_ENABLE_CALLS);
        mutex_unlock(&ftrace_lock);
 
+       trace_parser_put(parser);
        kfree(iter);
+
        mutex_unlock(&ftrace_regex_lock);
        return 0;
 }
@@ -2455,14 +2396,14 @@ static const struct file_operations ftrace_avail_fops = {
        .open = ftrace_avail_open,
        .read = seq_read,
        .llseek = seq_lseek,
-       .release = ftrace_avail_release,
+       .release = seq_release_private,
 };
 
 static const struct file_operations ftrace_failures_fops = {
        .open = ftrace_failures_open,
        .read = seq_read,
        .llseek = seq_lseek,
-       .release = ftrace_avail_release,
+       .release = seq_release_private,
 };
 
 static const struct file_operations ftrace_filter_fops = {
@@ -2486,35 +2427,33 @@ 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 *
-g_next(struct seq_file *m, void *v, loff_t *pos)
+__g_next(struct seq_file *m, loff_t *pos)
 {
-       unsigned long *array = m->private;
-       int index = *pos;
-
-       (*pos)++;
-
-       if (index >= ftrace_graph_count)
+       if (*pos >= ftrace_graph_count)
                return NULL;
+       return &ftrace_graph_funcs[*pos];
+}
 
-       return &array[index];
+static void *
+g_next(struct seq_file *m, void *v, loff_t *pos)
+{
+       (*pos)++;
+       return __g_next(m, pos);
 }
 
 static void *g_start(struct seq_file *m, loff_t *pos)
 {
-       void *p = NULL;
-
        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;
 
-       p = g_next(m, p, pos);
-
-       return p;
+       return __g_next(m, pos);
 }
 
 static void g_stop(struct seq_file *m, void *p)
@@ -2525,7 +2464,6 @@ static void g_stop(struct seq_file *m, void *p)
 static int g_show(struct seq_file *m, void *v)
 {
        unsigned long *ptr = v;
-       char str[KSYM_SYMBOL_LEN];
 
        if (!ptr)
                return 0;
@@ -2535,14 +2473,12 @@ static int g_show(struct seq_file *m, void *v)
                return 0;
        }
 
-       kallsyms_lookup(*ptr, NULL, NULL, NULL, str);
-
-       seq_printf(m, "%s\n", str);
+       seq_printf(m, "%ps\n", (void *)*ptr);
 
        return 0;
 }
 
-static struct seq_operations ftrace_graph_seq_ops = {
+static const struct seq_operations ftrace_graph_seq_ops = {
        .start = g_start,
        .next = g_next,
        .stop = g_stop,
@@ -2559,31 +2495,34 @@ ftrace_graph_open(struct inode *inode, struct file *file)
 
        mutex_lock(&graph_lock);
        if ((file->f_mode & FMODE_WRITE) &&
-           !(file->f_flags & O_APPEND)) {
+           (file->f_flags & O_TRUNC)) {
+               ftrace_graph_filter_enabled = 0;
                ftrace_graph_count = 0;
                memset(ftrace_graph_funcs, 0, sizeof(ftrace_graph_funcs));
        }
+       mutex_unlock(&graph_lock);
 
-       if (file->f_mode & FMODE_READ) {
+       if (file->f_mode & FMODE_READ)
                ret = seq_open(file, &ftrace_graph_seq_ops);
-               if (!ret) {
-                       struct seq_file *m = file->private_data;
-                       m->private = ftrace_graph_funcs;
-               }
-       } else
-               file->private_data = ftrace_graph_funcs;
-       mutex_unlock(&graph_lock);
 
        return ret;
 }
 
 static int
+ftrace_graph_release(struct inode *inode, struct file *file)
+{
+       if (file->f_mode & FMODE_READ)
+               seq_release(inode, file);
+       return 0;
+}
+
+static int
 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;
@@ -2593,122 +2532,98 @@ 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
 ftrace_graph_write(struct file *file, const char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
-       unsigned char buffer[FTRACE_BUFF_MAX+1];
-       unsigned long *array;
-       size_t read = 0;
-       ssize_t ret;
-       int index = 0;
-       char ch;
+       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;
+       if (trace_parser_get_init(&parser, FTRACE_BUFF_MAX)) {
+               ret = -ENOMEM;
+               goto out_unlock;
        }
 
-       if (file->f_mode & FMODE_READ) {
-               struct seq_file *m = file->private_data;
-               array = m->private;
-       } else
-               array = file->private_data;
+       read = trace_get_user(&parser, ubuf, cnt, ppos);
 
-       ret = get_user(ch, ubuf++);
-       if (ret)
-               goto out;
-       read++;
-       cnt--;
+       if (read >= 0 && trace_parser_loaded((&parser))) {
+               parser.buffer[parser.idx] = 0;
 
-       /* skip white space */
-       while (cnt && isspace(ch)) {
-               ret = get_user(ch, ubuf++);
+               /* we allow only one expression at a time */
+               ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
+                                       parser.buffer);
                if (ret)
-                       goto out;
-               read++;
-               cnt--;
-       }
-
-       if (isspace(ch)) {
-               *ppos += read;
-               ret = read;
-               goto out;
-       }
-
-       while (cnt && !isspace(ch)) {
-               if (index < FTRACE_BUFF_MAX)
-                       buffer[index++] = ch;
-               else {
-                       ret = -EINVAL;
-                       goto out;
-               }
-               ret = get_user(ch, ubuf++);
-               if (ret)
-                       goto out;
-               read++;
-               cnt--;
+                       goto out_free;
        }
-       buffer[index] = 0;
-
-       /* we allow only one expression at a time */
-       ret = ftrace_set_func(array, &ftrace_graph_count, buffer);
-       if (ret)
-               goto out;
-
-       file->f_pos += read;
 
        ret = read;
- out:
+
+out_free:
+       trace_parser_put(&parser);
+out_unlock:
        mutex_unlock(&graph_lock);
 
        return ret;
 }
 
 static const struct file_operations ftrace_graph_fops = {
-       .open = ftrace_graph_open,
-       .read = seq_read,
-       .write = ftrace_graph_write,
+       .open           = ftrace_graph_open,
+       .read           = seq_read,
+       .write          = ftrace_graph_write,
+       .release        = ftrace_graph_release,
 };
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 
@@ -2736,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)
 {
@@ -2769,19 +2684,17 @@ static int ftrace_convert_nops(struct module *mod,
 }
 
 #ifdef CONFIG_MODULES
-void ftrace_release(void *start, void *end)
+void ftrace_release_mod(struct module *mod)
 {
        struct dyn_ftrace *rec;
        struct ftrace_page *pg;
-       unsigned long s = (unsigned long)start;
-       unsigned long e = (unsigned long)end;
 
-       if (ftrace_disabled || !start || start == end)
+       if (ftrace_disabled)
                return;
 
        mutex_lock(&ftrace_lock);
        do_for_each_ftrace_rec(pg, rec) {
-               if ((rec->ip >= s) && (rec->ip < e)) {
+               if (within_module_core(rec->ip, mod)) {
                        /*
                         * rec->ip is changed in ftrace_free_rec()
                         * It should not between s and e if record was freed.
@@ -2798,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,
@@ -2813,9 +2726,7 @@ static int ftrace_module_notify(struct notifier_block *self,
                                   mod->num_ftrace_callsites);
                break;
        case MODULE_STATE_GOING:
-               ftrace_release(mod->ftrace_callsites,
-                              mod->ftrace_callsites +
-                              mod->num_ftrace_callsites);
+               ftrace_release_mod(mod);
                break;
        }
 
@@ -2861,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);
 
@@ -2894,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;
@@ -2961,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)
@@ -2979,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);
 
-               ftrace_pid_trace = pid;
+out:
+       mutex_unlock(&ftrace_lock);
+       return ret;
+}
+
+static void ftrace_pid_reset(void)
+{
+       struct ftrace_pid *fpid, *safe;
 
-               set_ftrace_pid_task(ftrace_pid_trace);
+       mutex_lock(&ftrace_lock);
+       list_for_each_entry_safe(fpid, safe, &ftrace_pids, list) {
+               struct pid *pid = fpid->pid;
+
+               clear_ftrace_pid_task(pid);
+
+               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)
@@ -3129,7 +3131,7 @@ int unregister_ftrace_function(struct ftrace_ops *ops)
 
 int
 ftrace_enable_sysctl(struct ctl_table *table, int write,
-                    struct file *file, void __user *buffer, size_t *lenp,
+                    void __user *buffer, size_t *lenp,
                     loff_t *ppos)
 {
        int ret;
@@ -3139,12 +3141,12 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
 
        mutex_lock(&ftrace_lock);
 
-       ret  = proc_dointvec(table, write, file, buffer, lenp, ppos);
+       ret  = proc_dointvec(table, write, buffer, lenp, ppos);
 
-       if (ret || !write || (last_ftrace_enabled == ftrace_enabled))
+       if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled))
                goto out;
 
-       last_ftrace_enabled = ftrace_enabled;
+       last_ftrace_enabled = !!ftrace_enabled;
 
        if (ftrace_enabled) {
 
@@ -3214,12 +3216,12 @@ static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list)
                }
 
                if (t->ret_stack == NULL) {
-                       t->curr_ret_stack = -1;
-                       /* Make sure IRQs see the -1 first: */
-                       barrier();
-                       t->ret_stack = ret_stack_list[start++];
                        atomic_set(&t->tracing_graph_pause, 0);
                        atomic_set(&t->trace_overrun, 0);
+                       t->curr_ret_stack = -1;
+                       /* Make sure the tasks see the -1 first: */
+                       smp_wmb();
+                       t->ret_stack = ret_stack_list[start++];
                }
        } while_each_thread(g, t);
 
@@ -3232,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;
@@ -3277,15 +3279,17 @@ static int start_graph_tracing(void)
                return -ENOMEM;
 
        /* The cpu_boot init_task->ret_stack will never be freed */
-       for_each_online_cpu(cpu)
-               ftrace_graph_init_task(idle_task(cpu));
+       for_each_online_cpu(cpu) {
+               if (!idle_task(cpu)->ret_stack)
+                       ftrace_graph_init_task(idle_task(cpu));
+       }
 
        do {
                ret = alloc_retstack_tasklist(ret_stack_list);
        } 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");
@@ -3357,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);
@@ -3370,18 +3374,25 @@ void unregister_ftrace_graph(void)
 /* Allocate a return stack for newly created task */
 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) {
-               t->ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
+               struct ftrace_ret_stack *ret_stack;
+
+               ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
                                * sizeof(struct ftrace_ret_stack),
                                GFP_KERNEL);
-               if (!t->ret_stack)
+               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;
-       } else
-               t->ret_stack = NULL;
+               /* make curr_ret_stack visable before we add the ret_stack */
+               smp_wmb();
+               t->ret_stack = ret_stack;
+       }
 }
 
 void ftrace_graph_exit_task(struct task_struct *t)
@@ -3400,4 +3411,3 @@ void ftrace_graph_stop(void)
        ftrace_stop();
 }
 #endif
-