27 files changed, 1727 insertions, 1565 deletions

diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index 67d6369ddf83..979ccde26720 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -55,7 +55,7 @@ obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o
 obj-$(CONFIG_EVENT_TRACING) += trace_events_trigger.o
 obj-$(CONFIG_KPROBE_EVENT) += trace_kprobe.o
 obj-$(CONFIG_TRACEPOINTS) += power-traces.o
-ifeq ($(CONFIG_PM_RUNTIME),y)
+ifeq ($(CONFIG_PM),y)
 obj-$(CONFIG_TRACEPOINTS) += rpm-traces.o
 endif
 ifeq ($(CONFIG_TRACING),y)
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index c1bd4ada2a04..483cecfa5c17 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1142,9 +1142,9 @@ static void get_pdu_remap(const struct trace_entry *ent,
         r->sector_from = be64_to_cpu(sector_from);
 }
 
-typedef int (blk_log_action_t) (struct trace_iterator *iter, const char *act);
+typedef void (blk_log_action_t) (struct trace_iterator *iter, const char *act);
 
-static int blk_log_action_classic(struct trace_iterator *iter, const char *act)
+static void blk_log_action_classic(struct trace_iterator *iter, const char *act)
 {
         char rwbs[RWBS_LEN];
         unsigned long long ts  = iter->ts;
@@ -1154,33 +1154,33 @@ static int blk_log_action_classic(struct trace_iterator *iter, const char *act)
 
         fill_rwbs(rwbs, t);
 
-        return trace_seq_printf(&iter->seq,
-                                "%3d,%-3d %2d %5d.%09lu %5u %2s %3s ",
-                                MAJOR(t->device), MINOR(t->device), iter->cpu,
-                                secs, nsec_rem, iter->ent->pid, act, rwbs);
+        trace_seq_printf(&iter->seq,
+                         "%3d,%-3d %2d %5d.%09lu %5u %2s %3s ",
+                         MAJOR(t->device), MINOR(t->device), iter->cpu,
+                         secs, nsec_rem, iter->ent->pid, act, rwbs);
 }
 
-static int blk_log_action(struct trace_iterator *iter, const char *act)
+static void blk_log_action(struct trace_iterator *iter, const char *act)
 {
         char rwbs[RWBS_LEN];
         const struct blk_io_trace *t = te_blk_io_trace(iter->ent);
 
         fill_rwbs(rwbs, t);
-        return trace_seq_printf(&iter->seq, "%3d,%-3d %2s %3s ",
-                                MAJOR(t->device), MINOR(t->device), act, rwbs);
+        trace_seq_printf(&iter->seq, "%3d,%-3d %2s %3s ",
+                         MAJOR(t->device), MINOR(t->device), act, rwbs);
 }
 
-static int blk_log_dump_pdu(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_dump_pdu(struct trace_seq *s, const struct trace_entry *ent)
 {
         const unsigned char *pdu_buf;
         int pdu_len;
-        int i, end, ret;
+        int i, end;
 
         pdu_buf = pdu_start(ent);
         pdu_len = te_blk_io_trace(ent)->pdu_len;
 
         if (!pdu_len)
-                return 1;
+                return;
 
         /* find the last zero that needs to be printed */
         for (end = pdu_len - 1; end >= 0; end--)
@@ -1188,119 +1188,107 @@ static int blk_log_dump_pdu(struct trace_seq *s, const struct trace_entry *ent)
                         break;
         end++;
 
-        if (!trace_seq_putc(s, '('))
-                return 0;
+        trace_seq_putc(s, '(');
 
         for (i = 0; i < pdu_len; i++) {
 
-                ret = trace_seq_printf(s, "%s%02x",
-                                       i == 0 ? "" : " ", pdu_buf[i]);
-                if (!ret)
-                        return ret;
+                trace_seq_printf(s, "%s%02x",
+                                 i == 0 ? "" : " ", pdu_buf[i]);
 
                 /*
                  * stop when the rest is just zeroes and indicate so
                  * with a ".." appended
                  */
-                if (i == end && end != pdu_len - 1)
-                        return trace_seq_puts(s, " ..) ");
+                if (i == end && end != pdu_len - 1) {
+                        trace_seq_puts(s, " ..) ");
+                        return;
+                }
         }
 
-        return trace_seq_puts(s, ") ");
+        trace_seq_puts(s, ") ");
 }
 
-static int blk_log_generic(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_generic(struct trace_seq *s, const struct trace_entry *ent)
 {
         char cmd[TASK_COMM_LEN];
 
         trace_find_cmdline(ent->pid, cmd);
 
         if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) {
-                int ret;
-
-                ret = trace_seq_printf(s, "%u ", t_bytes(ent));
-                if (!ret)
-                        return 0;
-                ret = blk_log_dump_pdu(s, ent);
-                if (!ret)
-                        return 0;
-                return trace_seq_printf(s, "[%s]\n", cmd);
+                trace_seq_printf(s, "%u ", t_bytes(ent));
+                blk_log_dump_pdu(s, ent);
+                trace_seq_printf(s, "[%s]\n", cmd);
         } else {
                 if (t_sec(ent))
-                        return trace_seq_printf(s, "%llu + %u [%s]\n",
+                        trace_seq_printf(s, "%llu + %u [%s]\n",
                                                 t_sector(ent), t_sec(ent), cmd);
-                return trace_seq_printf(s, "[%s]\n", cmd);
+                else
+                        trace_seq_printf(s, "[%s]\n", cmd);
         }
 }
 
-static int blk_log_with_error(struct trace_seq *s,
+static void blk_log_with_error(struct trace_seq *s,
                               const struct trace_entry *ent)
 {
         if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) {
-                int ret;
-
-                ret = blk_log_dump_pdu(s, ent);
-                if (ret)
-                        return trace_seq_printf(s, "[%d]\n", t_error(ent));
-                return 0;
+                blk_log_dump_pdu(s, ent);
+                trace_seq_printf(s, "[%d]\n", t_error(ent));
         } else {
                 if (t_sec(ent))
-                        return trace_seq_printf(s, "%llu + %u [%d]\n",
-                                                t_sector(ent),
-                                                t_sec(ent), t_error(ent));
-                return trace_seq_printf(s, "%llu [%d]\n",
-                                        t_sector(ent), t_error(ent));
+                        trace_seq_printf(s, "%llu + %u [%d]\n",
+                                         t_sector(ent),
+                                         t_sec(ent), t_error(ent));
+                else
+                        trace_seq_printf(s, "%llu [%d]\n",
+                                         t_sector(ent), t_error(ent));
         }
 }
 
-static int blk_log_remap(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_remap(struct trace_seq *s, const struct trace_entry *ent)
 {
         struct blk_io_trace_remap r = { .device_from = 0, };
 
         get_pdu_remap(ent, &r);
-        return trace_seq_printf(s, "%llu + %u <- (%d,%d) %llu\n",
-                                t_sector(ent), t_sec(ent),
-                                MAJOR(r.device_from), MINOR(r.device_from),
-                                (unsigned long long)r.sector_from);
+        trace_seq_printf(s, "%llu + %u <- (%d,%d) %llu\n",
+                         t_sector(ent), t_sec(ent),
+                         MAJOR(r.device_from), MINOR(r.device_from),
+                         (unsigned long long)r.sector_from);
 }
 
-static int blk_log_plug(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_plug(struct trace_seq *s, const struct trace_entry *ent)
 {
         char cmd[TASK_COMM_LEN];
 
         trace_find_cmdline(ent->pid, cmd);
 
-        return trace_seq_printf(s, "[%s]\n", cmd);
+        trace_seq_printf(s, "[%s]\n", cmd);
 }
 
-static int blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent)
 {
         char cmd[TASK_COMM_LEN];
 
         trace_find_cmdline(ent->pid, cmd);
 
-        return trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int(ent));
+        trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int(ent));
 }
 
-static int blk_log_split(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_split(struct trace_seq *s, const struct trace_entry *ent)
 {
         char cmd[TASK_COMM_LEN];
 
         trace_find_cmdline(ent->pid, cmd);
 
-        return trace_seq_printf(s, "%llu / %llu [%s]\n", t_sector(ent),
-                                get_pdu_int(ent), cmd);
+        trace_seq_printf(s, "%llu / %llu [%s]\n", t_sector(ent),
+                         get_pdu_int(ent), cmd);
 }
 
-static int blk_log_msg(struct trace_seq *s, const struct trace_entry *ent)
+static void blk_log_msg(struct trace_seq *s, const struct trace_entry *ent)
 {
-        int ret;
         const struct blk_io_trace *t = te_blk_io_trace(ent);
 
-        ret = trace_seq_putmem(s, t + 1, t->pdu_len);
-        if (ret)
-                return trace_seq_putc(s, '\n');
-        return ret;
+        trace_seq_putmem(s, t + 1, t->pdu_len);
+        trace_seq_putc(s, '\n');
 }
 
 /*
@@ -1339,7 +1327,7 @@ static void blk_tracer_reset(struct trace_array *tr)
 
 static const struct {
         const char *act[2];
-        int        (*print)(struct trace_seq *s, const struct trace_entry *ent);
+        void       (*print)(struct trace_seq *s, const struct trace_entry *ent);
 } what2act[] = {
         [__BLK_TA_QUEUE]        = {{  "Q", "queue" },      blk_log_generic },
         [__BLK_TA_BACKMERGE]    = {{  "M", "backmerge" },  blk_log_generic },
@@ -1364,7 +1352,6 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
         struct trace_seq *s = &iter->seq;
         const struct blk_io_trace *t;
         u16 what;
-        int ret;
         bool long_act;
         blk_log_action_t *log_action;
 
@@ -1374,21 +1361,18 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
         log_action = classic ? &blk_log_action_classic : &blk_log_action;
 
         if (t->action == BLK_TN_MESSAGE) {
-                ret = log_action(iter, long_act ? "message" : "m");
-                if (ret)
-                        ret = blk_log_msg(s, iter->ent);
-                goto out;
+                log_action(iter, long_act ? "message" : "m");
+                blk_log_msg(s, iter->ent);
         }
 
         if (unlikely(what == 0 || what >= ARRAY_SIZE(what2act)))
-                ret = trace_seq_printf(s, "Unknown action %x\n", what);
+                trace_seq_printf(s, "Unknown action %x\n", what);
         else {
-                ret = log_action(iter, what2act[what].act[long_act]);
-                if (ret)
-                        ret = what2act[what].print(s, iter->ent);
+                log_action(iter, what2act[what].act[long_act]);
+                what2act[what].print(s, iter->ent);
         }
-out:
-        return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+
+        return trace_handle_return(s);
 }
 
 static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
@@ -1397,7 +1381,7 @@ static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
         return print_one_line(iter, false);
 }
 
-static int blk_trace_synthesize_old_trace(struct trace_iterator *iter)
+static void blk_trace_synthesize_old_trace(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         struct blk_io_trace *t = (struct blk_io_trace *)iter->ent;
@@ -1407,18 +1391,18 @@ static int blk_trace_synthesize_old_trace(struct trace_iterator *iter)
                 .time     = iter->ts,
         };
 
-        if (!trace_seq_putmem(s, &old, offset))
-                return 0;
-        return trace_seq_putmem(s, &t->sector,
-                                sizeof(old) - offset + t->pdu_len);
+        trace_seq_putmem(s, &old, offset);
+        trace_seq_putmem(s, &t->sector,
+                         sizeof(old) - offset + t->pdu_len);
 }
 
 static enum print_line_t
 blk_trace_event_print_binary(struct trace_iterator *iter, int flags,
                              struct trace_event *event)
 {
-        return blk_trace_synthesize_old_trace(iter) ?
-                        TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+        blk_trace_synthesize_old_trace(iter);
+
+        return trace_handle_return(&iter->seq);
 }
 
 static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)
@@ -1493,9 +1477,6 @@ static int blk_trace_remove_queue(struct request_queue *q)
         if (atomic_dec_and_test(&blk_probes_ref))
                 blk_unregister_tracepoints();
 
-        spin_lock_irq(&running_trace_lock);
-        list_del(&bt->running_list);
-        spin_unlock_irq(&running_trace_lock);
         blk_trace_free(bt);
         return 0;
 }
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 5916a8e59e87..929a733d302e 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -113,6 +113,9 @@ ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 static struct ftrace_ops global_ops;
 static struct ftrace_ops control_ops;
 
+static void ftrace_ops_recurs_func(unsigned long ip, unsigned long parent_ip,
+                                   struct ftrace_ops *op, struct pt_regs *regs);
+
 #if ARCH_SUPPORTS_FTRACE_OPS
 static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
                                  struct ftrace_ops *op, struct pt_regs *regs);
@@ -251,18 +254,24 @@ static void update_ftrace_function(void)
         ftrace_func_t func;
 
         /*
+         * Prepare the ftrace_ops that the arch callback will use.
+         * If there's only one ftrace_ops registered, the ftrace_ops_list
+         * will point to the ops we want.
+         */
+        set_function_trace_op = ftrace_ops_list;
+
+        /* If there's no ftrace_ops registered, just call the stub function */
+        if (ftrace_ops_list == &ftrace_list_end) {
+                func = ftrace_stub;
+
+        /*
          * If we are at the end of the list and this ops is
          * recursion safe and not dynamic and the arch supports passing ops,
          * then have the mcount trampoline call the function directly.
          */
-        if (ftrace_ops_list == &ftrace_list_end ||
-            (ftrace_ops_list->next == &ftrace_list_end &&
-             !(ftrace_ops_list->flags & FTRACE_OPS_FL_DYNAMIC) &&
-             (ftrace_ops_list->flags & FTRACE_OPS_FL_RECURSION_SAFE) &&
-             !FTRACE_FORCE_LIST_FUNC)) {
-                /* Set the ftrace_ops that the arch callback uses */
-                set_function_trace_op = ftrace_ops_list;
-                func = ftrace_ops_list->func;
+        } else if (ftrace_ops_list->next == &ftrace_list_end) {
+                func = ftrace_ops_get_func(ftrace_ops_list);
+
         } else {
                 /* Just use the default ftrace_ops */
                 set_function_trace_op = &ftrace_list_end;
@@ -378,6 +387,8 @@ static int remove_ftrace_list_ops(struct ftrace_ops **list,
         return ret;
 }
 
+static void ftrace_update_trampoline(struct ftrace_ops *ops);
+
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
         if (ops->flags & FTRACE_OPS_FL_DELETED)
@@ -407,9 +418,13 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
                 if (control_ops_alloc(ops))
                         return -ENOMEM;
                 add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops);
+                /* The control_ops needs the trampoline update */
+                ops = &control_ops;
         } else
                 add_ftrace_ops(&ftrace_ops_list, ops);
 
+        ftrace_update_trampoline(ops);
+
         if (ftrace_enabled)
                 update_ftrace_function();
 
@@ -556,13 +571,13 @@ static int function_stat_cmp(void *p1, void *p2)
 static int function_stat_headers(struct seq_file *m)
 {
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
-        seq_printf(m, "  Function                               "
-                   "Hit    Time            Avg             s^2\n"
-                      "  --------                               "
-                   "---    ----            ---             ---\n");
+        seq_puts(m, "  Function                               "
+                 "Hit    Time            Avg             s^2\n"
+                    "  --------                               "
+                 "---    ----            ---             ---\n");
 #else
-        seq_printf(m, "  Function                               Hit\n"
-                      "  --------                               ---\n");
+        seq_puts(m, "  Function                               Hit\n"
+                    "  --------                               ---\n");
 #endif
         return 0;
 }
@@ -589,7 +604,7 @@ static int function_stat_show(struct seq_file *m, void *v)
         seq_printf(m, "  %-30.30s  %10lu", str, rec->counter);
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
-        seq_printf(m, "    ");
+        seq_puts(m, "    ");
         avg = rec->time;
         do_div(avg, rec->counter);
 
@@ -1048,6 +1063,12 @@ static struct pid * const ftrace_swapper_pid = &init_struct_pid;
 
 static struct ftrace_ops *removed_ops;
 
+/*
+ * Set when doing a global update, like enabling all recs or disabling them.
+ * It is not set when just updating a single ftrace_ops.
+ */
+static bool update_all_ops;
+
 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
 # error Dynamic ftrace depends on MCOUNT_RECORD
 #endif
@@ -1096,6 +1117,43 @@ static struct ftrace_ops global_ops = {
                                           FTRACE_OPS_FL_INITIALIZED,
 };
 
+/*
+ * This is used by __kernel_text_address() to return true if the
+ * address is on a dynamically allocated trampoline that would
+ * not return true for either core_kernel_text() or
+ * is_module_text_address().
+ */
+bool is_ftrace_trampoline(unsigned long addr)
+{
+        struct ftrace_ops *op;
+        bool ret = false;
+
+        /*
+         * Some of the ops may be dynamically allocated,
+         * they are freed after a synchronize_sched().
+         */
+        preempt_disable_notrace();
+
+        do_for_each_ftrace_op(op, ftrace_ops_list) {
+                /*
+                 * This is to check for dynamically allocated trampolines.
+                 * Trampolines that are in kernel text will have
+                 * core_kernel_text() return true.
+                 */
+                if (op->trampoline && op->trampoline_size)
+                        if (addr >= op->trampoline &&
+                            addr < op->trampoline + op->trampoline_size) {
+                                ret = true;
+                                goto out;
+                        }
+        } while_for_each_ftrace_op(op);
+
+ out:
+        preempt_enable_notrace();
+
+        return ret;
+}
+
 struct ftrace_page {
         struct ftrace_page      *next;
         struct dyn_ftrace       *records;
@@ -1300,6 +1358,9 @@ ftrace_hash_rec_disable_modify(struct ftrace_ops *ops, int filter_hash);
 static void
 ftrace_hash_rec_enable_modify(struct ftrace_ops *ops, int filter_hash);
 
+static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
+                                       struct ftrace_hash *new_hash);
+
 static int
 ftrace_hash_move(struct ftrace_ops *ops, int enable,
                  struct ftrace_hash **dst, struct ftrace_hash *src)
@@ -1307,12 +1368,16 @@ ftrace_hash_move(struct ftrace_ops *ops, int enable,
         struct ftrace_func_entry *entry;
         struct hlist_node *tn;
         struct hlist_head *hhd;
-        struct ftrace_hash *old_hash;
         struct ftrace_hash *new_hash;
         int size = src->count;
         int bits = 0;
+        int ret;
         int i;
 
+        /* Reject setting notrace hash on IPMODIFY ftrace_ops */
+        if (ops->flags & FTRACE_OPS_FL_IPMODIFY && !enable)
+                return -EINVAL;
+
         /*
          * If the new source is empty, just free dst and assign it
          * the empty_hash.
@@ -1346,21 +1411,44 @@ ftrace_hash_move(struct ftrace_ops *ops, int enable,
         }
 
 update:
+        /* Make sure this can be applied if it is IPMODIFY ftrace_ops */
+        if (enable) {
+                /* IPMODIFY should be updated only when filter_hash updating */
+                ret = ftrace_hash_ipmodify_update(ops, new_hash);
+                if (ret < 0) {
+                        free_ftrace_hash(new_hash);
+                        return ret;
+                }
+        }
+
         /*
          * Remove the current set, update the hash and add
          * them back.
          */
         ftrace_hash_rec_disable_modify(ops, enable);
 
-        old_hash = *dst;
         rcu_assign_pointer(*dst, new_hash);
-        free_ftrace_hash_rcu(old_hash);
 
         ftrace_hash_rec_enable_modify(ops, enable);
 
         return 0;
 }
 
+static bool hash_contains_ip(unsigned long ip,
+                             struct ftrace_ops_hash *hash)
+{
+        /*
+         * The function record is a match if it exists in the filter
+         * hash and not in the notrace hash. Note, an emty hash is
+         * considered a match for the filter hash, but an empty
+         * notrace hash is considered not in the notrace hash.
+         */
+        return (ftrace_hash_empty(hash->filter_hash) ||
+                ftrace_lookup_ip(hash->filter_hash, ip)) &&
+                (ftrace_hash_empty(hash->notrace_hash) ||
+                 !ftrace_lookup_ip(hash->notrace_hash, ip));
+}
+
 /*
  * Test the hashes for this ops to see if we want to call
  * the ops->func or not.
@@ -1376,8 +1464,7 @@ update:
 static int
 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
 {
-        struct ftrace_hash *filter_hash;
-        struct ftrace_hash *notrace_hash;
+        struct ftrace_ops_hash hash;
         int ret;
 
 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
@@ -1390,13 +1477,10 @@ ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
                 return 0;
 #endif
 
-        filter_hash = rcu_dereference_raw_notrace(ops->func_hash->filter_hash);
-        notrace_hash = rcu_dereference_raw_notrace(ops->func_hash->notrace_hash);
+        hash.filter_hash = rcu_dereference_raw_notrace(ops->func_hash->filter_hash);
+        hash.notrace_hash = rcu_dereference_raw_notrace(ops->func_hash->notrace_hash);
 
-        if ((ftrace_hash_empty(filter_hash) ||
-             ftrace_lookup_ip(filter_hash, ip)) &&
-            (ftrace_hash_empty(notrace_hash) ||
-             !ftrace_lookup_ip(notrace_hash, ip)))
+        if (hash_contains_ip(ip, &hash))
                 ret = 1;
         else
                 ret = 0;
@@ -1508,46 +1592,6 @@ static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec)
         return  keep_regs;
 }
 
-static void ftrace_remove_tramp(struct ftrace_ops *ops,
-                                struct dyn_ftrace *rec)
-{
-        /* If TRAMP is not set, no ops should have a trampoline for this */
-        if (!(rec->flags & FTRACE_FL_TRAMP))
-                return;
-
-        rec->flags &= ~FTRACE_FL_TRAMP;
-
-        if ((!ftrace_hash_empty(ops->func_hash->filter_hash) &&
-             !ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip)) ||
-            ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip))
-                return;
-        /*
-         * The tramp_hash entry will be removed at time
-         * of update.
-         */
-        ops->nr_trampolines--;
-}
-
-static void ftrace_clear_tramps(struct dyn_ftrace *rec, struct ftrace_ops *ops)
-{
-        struct ftrace_ops *op;
-
-        /* If TRAMP is not set, no ops should have a trampoline for this */
-        if (!(rec->flags & FTRACE_FL_TRAMP))
-                return;
-
-        do_for_each_ftrace_op(op, ftrace_ops_list) {
-                /*
-                 * This function is called to clear other tramps
-                 * not the one that is being updated.
-                 */
-                if (op == ops)
-                        continue;
-                if (op->nr_trampolines)
-                        ftrace_remove_tramp(op, rec);
-        } while_for_each_ftrace_op(op);
-}
-
 static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
                                      int filter_hash,
                                      bool inc)
@@ -1636,18 +1680,16 @@ static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
                          * function, and the ops has a trampoline registered
                          * for it, then we can call it directly.
                          */
-                        if (ftrace_rec_count(rec) == 1 && ops->trampoline) {
+                        if (ftrace_rec_count(rec) == 1 && ops->trampoline)
                                 rec->flags |= FTRACE_FL_TRAMP;
-                                ops->nr_trampolines++;
-                        } else {
+                        else
                                 /*
                                  * If we are adding another function callback
                                  * to this function, and the previous had a
                                  * custom trampoline in use, then we need to go
                                  * back to the default trampoline.
                                  */
-                                ftrace_clear_tramps(rec, ops);
-                        }
+                                rec->flags &= ~FTRACE_FL_TRAMP;
 
                         /*
                          * If any ops wants regs saved for this function
@@ -1660,9 +1702,6 @@ static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
                                 return;
                         rec->flags--;
 
-                        if (ops->trampoline && !ftrace_rec_count(rec))
-                                ftrace_remove_tramp(ops, rec);
-
                         /*
                          * If the rec had REGS enabled and the ops that is
                          * being removed had REGS set, then see if there is
@@ -1677,6 +1716,17 @@ static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
                         }
 
                         /*
+                         * If the rec had TRAMP enabled, then it needs to
+                         * be cleared. As TRAMP can only be enabled iff
+                         * there is only a single ops attached to it.
+                         * In otherwords, always disable it on decrementing.
+                         * In the future, we may set it if rec count is
+                         * decremented to one, and the ops that is left
+                         * has a trampoline.
+                         */
+                        rec->flags &= ~FTRACE_FL_TRAMP;
+
+                        /*
                          * flags will be cleared in ftrace_check_record()
                          * if rec count is zero.
                          */
@@ -1735,6 +1785,114 @@ static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops,
         ftrace_hash_rec_update_modify(ops, filter_hash, 1);
 }
 
+/*
+ * Try to update IPMODIFY flag on each ftrace_rec. Return 0 if it is OK
+ * or no-needed to update, -EBUSY if it detects a conflict of the flag
+ * on a ftrace_rec, and -EINVAL if the new_hash tries to trace all recs.
+ * Note that old_hash and new_hash has below meanings
+ *  - If the hash is NULL, it hits all recs (if IPMODIFY is set, this is rejected)
+ *  - If the hash is EMPTY_HASH, it hits nothing
+ *  - Anything else hits the recs which match the hash entries.
+ */
+static int __ftrace_hash_update_ipmodify(struct ftrace_ops *ops,
+                                         struct ftrace_hash *old_hash,
+                                         struct ftrace_hash *new_hash)
+{
+        struct ftrace_page *pg;
+        struct dyn_ftrace *rec, *end = NULL;
+        int in_old, in_new;
+
+        /* Only update if the ops has been registered */
+        if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
+                return 0;
+
+        if (!(ops->flags & FTRACE_OPS_FL_IPMODIFY))
+                return 0;
+
+        /*
+         * Since the IPMODIFY is a very address sensitive action, we do not
+         * allow ftrace_ops to set all functions to new hash.
+         */
+        if (!new_hash || !old_hash)
+                return -EINVAL;
+
+        /* Update rec->flags */
+        do_for_each_ftrace_rec(pg, rec) {
+                /* We need to update only differences of filter_hash */
+                in_old = !!ftrace_lookup_ip(old_hash, rec->ip);
+                in_new = !!ftrace_lookup_ip(new_hash, rec->ip);
+                if (in_old == in_new)
+                        continue;
+
+                if (in_new) {
+                        /* New entries must ensure no others are using it */
+                        if (rec->flags & FTRACE_FL_IPMODIFY)
+                                goto rollback;
+                        rec->flags |= FTRACE_FL_IPMODIFY;
+                } else /* Removed entry */
+                        rec->flags &= ~FTRACE_FL_IPMODIFY;
+        } while_for_each_ftrace_rec();
+
+        return 0;
+
+rollback:
+        end = rec;
+
+        /* Roll back what we did above */
+        do_for_each_ftrace_rec(pg, rec) {
+                if (rec == end)
+                        goto err_out;
+
+                in_old = !!ftrace_lookup_ip(old_hash, rec->ip);
+                in_new = !!ftrace_lookup_ip(new_hash, rec->ip);
+                if (in_old == in_new)
+                        continue;
+
+                if (in_new)
+                        rec->flags &= ~FTRACE_FL_IPMODIFY;
+                else
+                        rec->flags |= FTRACE_FL_IPMODIFY;
+        } while_for_each_ftrace_rec();
+
+err_out:
+        return -EBUSY;
+}
+
+static int ftrace_hash_ipmodify_enable(struct ftrace_ops *ops)
+{
+        struct ftrace_hash *hash = ops->func_hash->filter_hash;
+
+        if (ftrace_hash_empty(hash))
+                hash = NULL;
+
+        return __ftrace_hash_update_ipmodify(ops, EMPTY_HASH, hash);
+}
+
+/* Disabling always succeeds */
+static void ftrace_hash_ipmodify_disable(struct ftrace_ops *ops)
+{
+        struct ftrace_hash *hash = ops->func_hash->filter_hash;
+
+        if (ftrace_hash_empty(hash))
+                hash = NULL;
+
+        __ftrace_hash_update_ipmodify(ops, hash, EMPTY_HASH);
+}
+
+static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
+                                       struct ftrace_hash *new_hash)
+{
+        struct ftrace_hash *old_hash = ops->func_hash->filter_hash;
+
+        if (ftrace_hash_empty(old_hash))
+                old_hash = NULL;
+
+        if (ftrace_hash_empty(new_hash))
+                new_hash = NULL;
+
+        return __ftrace_hash_update_ipmodify(ops, old_hash, new_hash);
+}
+
 static void print_ip_ins(const char *fmt, unsigned char *p)
 {
         int i;
@@ -1745,10 +1903,13 @@ static void print_ip_ins(const char *fmt, unsigned char *p)
                 printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
 }
 
+static struct ftrace_ops *
+ftrace_find_tramp_ops_any(struct dyn_ftrace *rec);
+
 /**
  * ftrace_bug - report and shutdown function tracer
  * @failed: The failed type (EFAULT, EINVAL, EPERM)
- * @ip: The address that failed
+ * @rec: The record that failed
  *
  * The arch code that enables or disables the function tracing
  * can call ftrace_bug() when it has detected a problem in
@@ -1757,8 +1918,10 @@ static void print_ip_ins(const char *fmt, unsigned char *p)
  * EINVAL - if what is read at @ip is not what was expected
  * EPERM - if the problem happens on writting to the @ip address
  */
-void ftrace_bug(int failed, unsigned long ip)
+void ftrace_bug(int failed, struct dyn_ftrace *rec)
 {
+        unsigned long ip = rec ? rec->ip : 0;
+
         switch (failed) {
         case -EFAULT:
                 FTRACE_WARN_ON_ONCE(1);
@@ -1770,7 +1933,7 @@ void ftrace_bug(int failed, unsigned long ip)
                 pr_info("ftrace failed to modify ");
                 print_ip_sym(ip);
                 print_ip_ins(" actual: ", (unsigned char *)ip);
-                printk(KERN_CONT "\n");
+                pr_cont("\n");
                 break;
         case -EPERM:
                 FTRACE_WARN_ON_ONCE(1);
@@ -1782,6 +1945,24 @@ void ftrace_bug(int failed, unsigned long ip)
                 pr_info("ftrace faulted on unknown error ");
                 print_ip_sym(ip);
         }
+        if (rec) {
+                struct ftrace_ops *ops = NULL;
+
+                pr_info("ftrace record flags: %lx\n", rec->flags);
+                pr_cont(" (%ld)%s", ftrace_rec_count(rec),
+                        rec->flags & FTRACE_FL_REGS ? " R" : "  ");
+                if (rec->flags & FTRACE_FL_TRAMP_EN) {
+                        ops = ftrace_find_tramp_ops_any(rec);
+                        if (ops)
+                                pr_cont("\ttramp: %pS",
+                                        (void *)ops->trampoline);
+                        else
+                                pr_cont("\ttramp: ERROR!");
+
+                }
+                ip = ftrace_get_addr_curr(rec);
+                pr_cont(" expected tramp: %lx\n", ip);
+        }
 }
 
 static int ftrace_check_record(struct dyn_ftrace *rec, int enable, int update)
@@ -1895,21 +2076,86 @@ int ftrace_test_record(struct dyn_ftrace *rec, int enable)
 }
 
 static struct ftrace_ops *
+ftrace_find_tramp_ops_any(struct dyn_ftrace *rec)
+{
+        struct ftrace_ops *op;
+        unsigned long ip = rec->ip;
+
+        do_for_each_ftrace_op(op, ftrace_ops_list) {
+
+                if (!op->trampoline)
+                        continue;
+
+                if (hash_contains_ip(ip, op->func_hash))
+                        return op;
+        } while_for_each_ftrace_op(op);
+
+        return NULL;
+}
+
+static struct ftrace_ops *
 ftrace_find_tramp_ops_curr(struct dyn_ftrace *rec)
 {
         struct ftrace_ops *op;
+        unsigned long ip = rec->ip;
 
-        /* Removed ops need to be tested first */
-        if (removed_ops && removed_ops->tramp_hash) {
-                if (ftrace_lookup_ip(removed_ops->tramp_hash, rec->ip))
+        /*
+         * Need to check removed ops first.
+         * If they are being removed, and this rec has a tramp,
+         * and this rec is in the ops list, then it would be the
+         * one with the tramp.
+         */
+        if (removed_ops) {
+                if (hash_contains_ip(ip, &removed_ops->old_hash))
                         return removed_ops;
         }
 
+        /*
+         * Need to find the current trampoline for a rec.
+         * Now, a trampoline is only attached to a rec if there
+         * was a single 'ops' attached to it. But this can be called
+         * when we are adding another op to the rec or removing the
+         * current one. Thus, if the op is being added, we can
+         * ignore it because it hasn't attached itself to the rec
+         * yet.
+         *
+         * If an ops is being modified (hooking to different functions)
+         * then we don't care about the new functions that are being
+         * added, just the old ones (that are probably being removed).
+         *
+         * If we are adding an ops to a function that already is using
+         * a trampoline, it needs to be removed (trampolines are only
+         * for single ops connected), then an ops that is not being
+         * modified also needs to be checked.
+         */
         do_for_each_ftrace_op(op, ftrace_ops_list) {
-                if (!op->tramp_hash)
+
+                if (!op->trampoline)
                         continue;
 
-                if (ftrace_lookup_ip(op->tramp_hash, rec->ip))
+                /*
+                 * If the ops is being added, it hasn't gotten to
+                 * the point to be removed from this tree yet.
+                 */
+                if (op->flags & FTRACE_OPS_FL_ADDING)
+                        continue;
+
+
+                /*
+                 * If the ops is being modified and is in the old
+                 * hash, then it is probably being removed from this
+                 * function.
+                 */
+                if ((op->flags & FTRACE_OPS_FL_MODIFYING) &&
+                    hash_contains_ip(ip, &op->old_hash))
+                        return op;
+                /*
+                 * If the ops is not being added or modified, and it's
+                 * in its normal filter hash, then this must be the one
+                 * we want!
+                 */
+                if (!(op->flags & FTRACE_OPS_FL_MODIFYING) &&
+                    hash_contains_ip(ip, op->func_hash))
                         return op;
 
         } while_for_each_ftrace_op(op);
@@ -1921,10 +2167,11 @@ static struct ftrace_ops *
 ftrace_find_tramp_ops_new(struct dyn_ftrace *rec)
 {
         struct ftrace_ops *op;
+        unsigned long ip = rec->ip;
 
         do_for_each_ftrace_op(op, ftrace_ops_list) {
                 /* pass rec in as regs to have non-NULL val */
-                if (ftrace_ops_test(op, rec->ip, rec))
+                if (hash_contains_ip(ip, op->func_hash))
                         return op;
         } while_for_each_ftrace_op(op);
 
@@ -2038,7 +2285,7 @@ void __weak ftrace_replace_code(int enable)
         do_for_each_ftrace_rec(pg, rec) {
                 failed = __ftrace_replace_code(rec, enable);
                 if (failed) {
-                        ftrace_bug(failed, rec->ip);
+                        ftrace_bug(failed, rec);
                         /* Stop processing */
                         return;
                 }
@@ -2120,17 +2367,14 @@ struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)
 static int
 ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
 {
-        unsigned long ip;
         int ret;
 
-        ip = rec->ip;
-
         if (unlikely(ftrace_disabled))
                 return 0;
 
         ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
         if (ret) {
-                ftrace_bug(ret, ip);
+                ftrace_bug(ret, rec);
                 return 0;
         }
         return 1;
@@ -2231,92 +2475,6 @@ void __weak arch_ftrace_update_code(int command)
         ftrace_run_stop_machine(command);
 }
 
-static int ftrace_save_ops_tramp_hash(struct ftrace_ops *ops)
-{
-        struct ftrace_page *pg;
-        struct dyn_ftrace *rec;
-        int size, bits;
-        int ret;
-
-        size = ops->nr_trampolines;
-        bits = 0;
-        /*
-         * Make the hash size about 1/2 the # found
-         */
-        for (size /= 2; size; size >>= 1)
-                bits++;
-
-        ops->tramp_hash = alloc_ftrace_hash(bits);
-        /*
-         * TODO: a failed allocation is going to screw up
-         * the accounting of what needs to be modified
-         * and not. For now, we kill ftrace if we fail
-         * to allocate here. But there are ways around this,
-         * but that will take a little more work.
-         */
-        if (!ops->tramp_hash)
-                return -ENOMEM;
-
-        do_for_each_ftrace_rec(pg, rec) {
-                if (ftrace_rec_count(rec) == 1 &&
-                    ftrace_ops_test(ops, rec->ip, rec)) {
-
-                        /*
-                         * If another ops adds to a rec, the rec will
-                         * lose its trampoline and never get it back
-                         * until all ops are off of it.
-                         */
-                        if (!(rec->flags & FTRACE_FL_TRAMP))
-                                continue;
-
-                        /* This record had better have a trampoline */
-                        if (FTRACE_WARN_ON(!(rec->flags & FTRACE_FL_TRAMP_EN)))
-                                return -1;
-
-                        ret = add_hash_entry(ops->tramp_hash, rec->ip);
-                        if (ret < 0)
-                                return ret;
-                }
-        } while_for_each_ftrace_rec();
-
-        /* The number of recs in the hash must match nr_trampolines */
-        if (FTRACE_WARN_ON(ops->tramp_hash->count != ops->nr_trampolines))
-                pr_warn("count=%ld trampolines=%d\n",
-                        ops->tramp_hash->count,
-                        ops->nr_trampolines);
-
-        return 0;
-}
-
-static int ftrace_save_tramp_hashes(void)
-{
-        struct ftrace_ops *op;
-        int ret;
-
-        /*
-         * Now that any trampoline is being used, we need to save the
-         * hashes for the ops that have them. This allows the mapping
-         * back from the record to the ops that has the trampoline to
-         * know what code is being replaced. Modifying code must always
-         * verify what it is changing.
-         */
-        do_for_each_ftrace_op(op, ftrace_ops_list) {
-
-                /* The tramp_hash is recreated each time. */
-                free_ftrace_hash(op->tramp_hash);
-                op->tramp_hash = NULL;
-
-                if (op->nr_trampolines) {
-                        ret = ftrace_save_ops_tramp_hash(op);
-                        if (ret)
-                                return ret;
-                }
-
-        } while_for_each_ftrace_op(op);
-
-        return 0;
-}
-
 static void ftrace_run_update_code(int command)
 {
         int ret;
@@ -2336,14 +2494,25 @@ static void ftrace_run_update_code(int command)
 
         ret = ftrace_arch_code_modify_post_process();
         FTRACE_WARN_ON(ret);
+}
 
-        ret = ftrace_save_tramp_hashes();
-        FTRACE_WARN_ON(ret);
+static void ftrace_run_modify_code(struct ftrace_ops *ops, int command,
+                                   struct ftrace_hash *old_hash)
+{
+        ops->flags |= FTRACE_OPS_FL_MODIFYING;
+        ops->old_hash.filter_hash = old_hash;
+        ftrace_run_update_code(command);
+        ops->old_hash.filter_hash = NULL;
+        ops->flags &= ~FTRACE_OPS_FL_MODIFYING;
 }
 
 static ftrace_func_t saved_ftrace_func;
 static int ftrace_start_up;
 
+void __weak arch_ftrace_trampoline_free(struct ftrace_ops *ops)
+{
+}
+
 static void control_ops_free(struct ftrace_ops *ops)
 {
         free_percpu(ops->disabled);
@@ -2362,6 +2531,13 @@ static void ftrace_startup_enable(int command)
         ftrace_run_update_code(command);
 }
 
+static void ftrace_startup_all(int command)
+{
+        update_all_ops = true;
+        ftrace_startup_enable(command);
+        update_all_ops = false;
+}
+
 static int ftrace_startup(struct ftrace_ops *ops, int command)
 {
         int ret;
@@ -2376,12 +2552,31 @@ static int ftrace_startup(struct ftrace_ops *ops, int command)
         ftrace_start_up++;
         command |= FTRACE_UPDATE_CALLS;
 
-        ops->flags |= FTRACE_OPS_FL_ENABLED;
+        /*
+         * Note that ftrace probes uses this to start up
+         * and modify functions it will probe. But we still
+         * set the ADDING flag for modification, as probes
+         * do not have trampolines. If they add them in the
+         * future, then the probes will need to distinguish
+         * between adding and updating probes.
+         */
+        ops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_ADDING;
+
+        ret = ftrace_hash_ipmodify_enable(ops);
+        if (ret < 0) {
+                /* Rollback registration process */
+                __unregister_ftrace_function(ops);
+                ftrace_start_up--;
+                ops->flags &= ~FTRACE_OPS_FL_ENABLED;
+                return ret;
+        }
 
         ftrace_hash_rec_enable(ops, 1);
 
         ftrace_startup_enable(command);
 
+        ops->flags &= ~FTRACE_OPS_FL_ADDING;
+
         return 0;
 }
 
@@ -2404,6 +2599,8 @@ static int ftrace_shutdown(struct ftrace_ops *ops, int command)
          */
         WARN_ON_ONCE(ftrace_start_up < 0);
 
+        /* Disabling ipmodify never fails */
+        ftrace_hash_ipmodify_disable(ops);
         ftrace_hash_rec_disable(ops, 1);
 
         ops->flags &= ~FTRACE_OPS_FL_ENABLED;
@@ -2431,11 +2628,35 @@ static int ftrace_shutdown(struct ftrace_ops *ops, int command)
          * If the ops uses a trampoline, then it needs to be
          * tested first on update.
          */
+        ops->flags |= FTRACE_OPS_FL_REMOVING;
         removed_ops = ops;
 
+        /* The trampoline logic checks the old hashes */
+        ops->old_hash.filter_hash = ops->func_hash->filter_hash;
+        ops->old_hash.notrace_hash = ops->func_hash->notrace_hash;
+
         ftrace_run_update_code(command);
 
+        /*
+         * If there's no more ops registered with ftrace, run a
+         * sanity check to make sure all rec flags are cleared.
+         */
+        if (ftrace_ops_list == &ftrace_list_end) {
+                struct ftrace_page *pg;
+                struct dyn_ftrace *rec;
+
+                do_for_each_ftrace_rec(pg, rec) {
+                        if (FTRACE_WARN_ON_ONCE(rec->flags))
+                                pr_warn("  %pS flags:%lx\n",
+                                        (void *)rec->ip, rec->flags);
+                } while_for_each_ftrace_rec();
+        }
+
+        ops->old_hash.filter_hash = NULL;
+        ops->old_hash.notrace_hash = NULL;
+
         removed_ops = NULL;
+        ops->flags &= ~FTRACE_OPS_FL_REMOVING;
 
         /*
          * Dynamic ops may be freed, we must make sure that all
@@ -2454,6 +2675,8 @@ static int ftrace_shutdown(struct ftrace_ops *ops, int command)
         if (ops->flags & (FTRACE_OPS_FL_DYNAMIC | FTRACE_OPS_FL_CONTROL)) {
                 schedule_on_each_cpu(ftrace_sync);
 
+                arch_ftrace_trampoline_free(ops);
+
                 if (ops->flags & FTRACE_OPS_FL_CONTROL)
                         control_ops_free(ops);
         }
@@ -2606,7 +2829,7 @@ static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs)
                         if (ftrace_start_up && cnt) {
                                 int failed = __ftrace_replace_code(p, 1);
                                 if (failed)
-                                        ftrace_bug(failed, p->ip);
+                                        ftrace_bug(failed, p);
                         }
                 }
         }
@@ -2931,6 +3154,22 @@ static void t_stop(struct seq_file *m, void *p)
         mutex_unlock(&ftrace_lock);
 }
 
+void * __weak
+arch_ftrace_trampoline_func(struct ftrace_ops *ops, struct dyn_ftrace *rec)
+{
+        return NULL;
+}
+
+static void add_trampoline_func(struct seq_file *m, struct ftrace_ops *ops,
+                                struct dyn_ftrace *rec)
+{
+        void *ptr;
+
+        ptr = arch_ftrace_trampoline_func(ops, rec);
+        if (ptr)
+                seq_printf(m, " ->%pS", ptr);
+}
+
 static int t_show(struct seq_file *m, void *v)
 {
         struct ftrace_iterator *iter = m->private;
@@ -2941,9 +3180,9 @@ static int t_show(struct seq_file *m, void *v)
 
         if (iter->flags & FTRACE_ITER_PRINTALL) {
                 if (iter->flags & FTRACE_ITER_NOTRACE)
-                        seq_printf(m, "#### no functions disabled ####\n");
+                        seq_puts(m, "#### no functions disabled ####\n");
                 else
-                        seq_printf(m, "#### all functions enabled ####\n");
+                        seq_puts(m, "#### all functions enabled ####\n");
                 return 0;
         }
 
@@ -2954,22 +3193,25 @@ static int t_show(struct seq_file *m, void *v)
 
         seq_printf(m, "%ps", (void *)rec->ip);
         if (iter->flags & FTRACE_ITER_ENABLED) {
-                seq_printf(m, " (%ld)%s",
+                struct ftrace_ops *ops = NULL;
+
+                seq_printf(m, " (%ld)%s%s",
                            ftrace_rec_count(rec),
-                           rec->flags & FTRACE_FL_REGS ? " R" : "  ");
+                           rec->flags & FTRACE_FL_REGS ? " R" : "  ",
+                           rec->flags & FTRACE_FL_IPMODIFY ? " I" : "  ");
                 if (rec->flags & FTRACE_FL_TRAMP_EN) {
-                        struct ftrace_ops *ops;
-
-                        ops = ftrace_find_tramp_ops_curr(rec);
-                        if (ops && ops->trampoline)
+                        ops = ftrace_find_tramp_ops_any(rec);
+                        if (ops)
                                 seq_printf(m, "\ttramp: %pS",
                                            (void *)ops->trampoline);
                         else
-                                seq_printf(m, "\ttramp: ERROR!");
+                                seq_puts(m, "\ttramp: ERROR!");
+
                 }
+                add_trampoline_func(m, ops, rec);
         }       
 
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         return 0;
 }
@@ -3003,9 +3245,6 @@ ftrace_enabled_open(struct inode *inode, struct file *file)
 {
         struct ftrace_iterator *iter;
 
-        if (unlikely(ftrace_disabled))
-                return -ENODEV;
-
         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
         if (iter) {
                 iter->pg = ftrace_pages_start;
@@ -3340,7 +3579,7 @@ static struct ftrace_ops trace_probe_ops __read_mostly =
 
 static int ftrace_probe_registered;
 
-static void __enable_ftrace_function_probe(void)
+static void __enable_ftrace_function_probe(struct ftrace_hash *old_hash)
 {
         int ret;
         int i;
@@ -3348,7 +3587,8 @@ static void __enable_ftrace_function_probe(void)
         if (ftrace_probe_registered) {
                 /* still need to update the function call sites */
                 if (ftrace_enabled)
-                        ftrace_run_update_code(FTRACE_UPDATE_CALLS);
+                        ftrace_run_modify_code(&trace_probe_ops, FTRACE_UPDATE_CALLS,
+                                               old_hash);
                 return;
         }
 
@@ -3399,6 +3639,7 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
 {
         struct ftrace_func_probe *entry;
         struct ftrace_hash **orig_hash = &trace_probe_ops.func_hash->filter_hash;
+        struct ftrace_hash *old_hash = *orig_hash;
         struct ftrace_hash *hash;
         struct ftrace_page *pg;
         struct dyn_ftrace *rec;
@@ -3417,7 +3658,7 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
 
         mutex_lock(&trace_probe_ops.func_hash->regex_lock);
 
-        hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
+        hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash);
         if (!hash) {
                 count = -ENOMEM;
                 goto out;
@@ -3476,10 +3717,13 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
         } while_for_each_ftrace_rec();
 
         ret = ftrace_hash_move(&trace_probe_ops, 1, orig_hash, hash);
-        if (ret < 0)
-                count = ret;
 
-        __enable_ftrace_function_probe();
+        __enable_ftrace_function_probe(old_hash);
+
+        if (!ret)
+                free_ftrace_hash_rcu(old_hash);
+        else
+                count = ret;
 
  out_unlock:
         mutex_unlock(&ftrace_lock);
@@ -3503,6 +3747,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
         struct ftrace_func_probe *entry;
         struct ftrace_func_probe *p;
         struct ftrace_hash **orig_hash = &trace_probe_ops.func_hash->filter_hash;
+        struct ftrace_hash *old_hash = *orig_hash;
         struct list_head free_list;
         struct ftrace_hash *hash;
         struct hlist_node *tmp;
@@ -3510,6 +3755,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
         int type = MATCH_FULL;
         int i, len = 0;
         char *search;
+        int ret;
 
         if (glob && (strcmp(glob, "*") == 0 || !strlen(glob)))
                 glob = NULL;
@@ -3568,8 +3814,11 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
          * Remove after the disable is called. Otherwise, if the last
          * probe is removed, a null hash means *all enabled*.
          */
-        ftrace_hash_move(&trace_probe_ops, 1, orig_hash, hash);
+        ret = ftrace_hash_move(&trace_probe_ops, 1, orig_hash, hash);
         synchronize_sched();
+        if (!ret)
+                free_ftrace_hash_rcu(old_hash);
+
         list_for_each_entry_safe(entry, p, &free_list, free_list) {
                 list_del(&entry->free_list);
                 ftrace_free_entry(entry);
@@ -3756,10 +4005,11 @@ ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove)
         return add_hash_entry(hash, ip);
 }
 
-static void ftrace_ops_update_code(struct ftrace_ops *ops)
+static void ftrace_ops_update_code(struct ftrace_ops *ops,
+                                   struct ftrace_hash *old_hash)
 {
         if (ops->flags & FTRACE_OPS_FL_ENABLED && ftrace_enabled)
-                ftrace_run_update_code(FTRACE_UPDATE_CALLS);
+                ftrace_run_modify_code(ops, FTRACE_UPDATE_CALLS, old_hash);
 }
 
 static int
@@ -3767,6 +4017,7 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
                 unsigned long ip, int remove, int reset, int enable)
 {
         struct ftrace_hash **orig_hash;
+        struct ftrace_hash *old_hash;
         struct ftrace_hash *hash;
         int ret;
 
@@ -3801,10 +4052,12 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
         }
 
         mutex_lock(&ftrace_lock);
+        old_hash = *orig_hash;
         ret = ftrace_hash_move(ops, enable, orig_hash, hash);
-        if (!ret)
-                ftrace_ops_update_code(ops);
-
+        if (!ret) {
+                ftrace_ops_update_code(ops, old_hash);
+                free_ftrace_hash_rcu(old_hash);
+        }
         mutex_unlock(&ftrace_lock);
 
  out_regex_unlock:
@@ -3944,6 +4197,9 @@ static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
 static char ftrace_graph_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
 static int ftrace_set_func(unsigned long *array, int *idx, int size, char *buffer);
 
+static unsigned long save_global_trampoline;
+static unsigned long save_global_flags;
+
 static int __init set_graph_function(char *str)
 {
         strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
@@ -4013,6 +4269,7 @@ int ftrace_regex_release(struct inode *inode, struct file *file)
         struct seq_file *m = (struct seq_file *)file->private_data;
         struct ftrace_iterator *iter;
         struct ftrace_hash **orig_hash;
+        struct ftrace_hash *old_hash;
         struct trace_parser *parser;
         int filter_hash;
         int ret;
@@ -4042,11 +4299,13 @@ int ftrace_regex_release(struct inode *inode, struct file *file)
                         orig_hash = &iter->ops->func_hash->notrace_hash;
 
                 mutex_lock(&ftrace_lock);
+                old_hash = *orig_hash;
                 ret = ftrace_hash_move(iter->ops, filter_hash,
                                        orig_hash, iter->hash);
-                if (!ret)
-                        ftrace_ops_update_code(iter->ops);
-
+                if (!ret) {
+                        ftrace_ops_update_code(iter->ops, old_hash);
+                        free_ftrace_hash_rcu(old_hash);
+                }
                 mutex_unlock(&ftrace_lock);
         }
 
@@ -4149,9 +4408,9 @@ static int g_show(struct seq_file *m, void *v)
                 struct ftrace_graph_data *fgd = m->private;
 
                 if (fgd->table == ftrace_graph_funcs)
-                        seq_printf(m, "#### all functions enabled ####\n");
+                        seq_puts(m, "#### all functions enabled ####\n");
                 else
-                        seq_printf(m, "#### no functions disabled ####\n");
+                        seq_puts(m, "#### no functions disabled ####\n");
                 return 0;
         }
 
@@ -4662,6 +4921,32 @@ void __init ftrace_init(void)
         ftrace_disabled = 1;
 }
 
+/* Do nothing if arch does not support this */
+void __weak arch_ftrace_update_trampoline(struct ftrace_ops *ops)
+{
+}
+
+static void ftrace_update_trampoline(struct ftrace_ops *ops)
+{
+
+/*
+ * Currently there's no safe way to free a trampoline when the kernel
+ * is configured with PREEMPT. That is because a task could be preempted
+ * when it jumped to the trampoline, it may be preempted for a long time
+ * depending on the system load, and currently there's no way to know
+ * when it will be off the trampoline. If the trampoline is freed
+ * too early, when the task runs again, it will be executing on freed
+ * memory and crash.
+ */
+#ifdef CONFIG_PREEMPT
+        /* Currently, only non dynamic ops can have a trampoline */
+        if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
+                return;
+#endif
+
+        arch_ftrace_update_trampoline(ops);
+}
+
 #else
 
 static struct ftrace_ops global_ops = {
@@ -4678,6 +4963,7 @@ core_initcall(ftrace_nodyn_init);
 
 static inline int ftrace_init_dyn_debugfs(struct dentry *d_tracer) { return 0; }
 static inline void ftrace_startup_enable(int command) { }
+static inline void ftrace_startup_all(int command) { }
 /* Keep as macros so we do not need to define the commands */
 # define ftrace_startup(ops, command)                                   \
         ({                                                              \
@@ -4703,6 +4989,10 @@ ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
         return 1;
 }
 
+static void ftrace_update_trampoline(struct ftrace_ops *ops)
+{
+}
+
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 __init void ftrace_init_global_array_ops(struct trace_array *tr)
@@ -4827,6 +5117,56 @@ static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
 }
 #endif
 
+/*
+ * If there's only one function registered but it does not support
+ * recursion, this function will be called by the mcount trampoline.
+ * This function will handle recursion protection.
+ */
+static void ftrace_ops_recurs_func(unsigned long ip, unsigned long parent_ip,
+                                   struct ftrace_ops *op, struct pt_regs *regs)
+{
+        int bit;
+
+        bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
+        if (bit < 0)
+                return;
+
+        op->func(ip, parent_ip, op, regs);
+
+        trace_clear_recursion(bit);
+}
+
+/**
+ * ftrace_ops_get_func - get the function a trampoline should call
+ * @ops: the ops to get the function for
+ *
+ * Normally the mcount trampoline will call the ops->func, but there
+ * are times that it should not. For example, if the ops does not
+ * have its own recursion protection, then it should call the
+ * ftrace_ops_recurs_func() instead.
+ *
+ * Returns the function that the trampoline should call for @ops.
+ */
+ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops)
+{
+        /*
+         * If this is a dynamic ops or we force list func,
+         * then it needs to call the list anyway.
+         */
+        if (ops->flags & FTRACE_OPS_FL_DYNAMIC || FTRACE_FORCE_LIST_FUNC)
+                return ftrace_ops_list_func;
+
+        /*
+         * If the func handles its own recursion, call it directly.
+         * Otherwise call the recursion protected function that
+         * will call the ftrace ops function.
+         */
+        if (!(ops->flags & FTRACE_OPS_FL_RECURSION_SAFE))
+                return ftrace_ops_recurs_func;
+
+        return ops->func;
+}
+
 static void clear_ftrace_swapper(void)
 {
         struct task_struct *p;
@@ -4927,7 +5267,8 @@ static int ftrace_pid_add(int p)
         set_ftrace_pid_task(pid);
 
         ftrace_update_pid_func();
-        ftrace_startup_enable(0);
+
+        ftrace_startup_all(0);
 
         mutex_unlock(&ftrace_lock);
         return 0;
@@ -4956,7 +5297,7 @@ static void ftrace_pid_reset(void)
         }
 
         ftrace_update_pid_func();
-        ftrace_startup_enable(0);
+        ftrace_startup_all(0);
 
         mutex_unlock(&ftrace_lock);
 }
@@ -4989,12 +5330,12 @@ 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");
+                seq_puts(m, "no pid\n");
                 return 0;
         }
 
         if (fpid->pid == ftrace_swapper_pid)
-                seq_printf(m, "swapper tasks\n");
+                seq_puts(m, "swapper tasks\n");
         else
                 seq_printf(m, "%u\n", pid_vnr(fpid->pid));
 
@@ -5207,6 +5548,7 @@ static struct ftrace_ops graph_ops = {
                                    FTRACE_OPS_FL_STUB,
 #ifdef FTRACE_GRAPH_TRAMP_ADDR
         .trampoline             = FTRACE_GRAPH_TRAMP_ADDR,
+        /* trampoline_size is only needed for dynamically allocated tramps */
 #endif
         ASSIGN_OPS_HASH(graph_ops, &global_ops.local_hash)
 };
@@ -5436,7 +5778,6 @@ int register_ftrace_graph(trace_func_graph_ret_t retfunc,
         update_function_graph_func();
 
         ret = ftrace_startup(&graph_ops, FTRACE_START_FUNC_RET);
-
 out:
         mutex_unlock(&ftrace_lock);
         return ret;
@@ -5457,6 +5798,17 @@ void unregister_ftrace_graph(void)
         unregister_pm_notifier(&ftrace_suspend_notifier);
         unregister_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
 
+#ifdef CONFIG_DYNAMIC_FTRACE
+        /*
+         * Function graph does not allocate the trampoline, but
+         * other global_ops do. We need to reset the ALLOC_TRAMP flag
+         * if one was used.
+         */
+        global_ops.trampoline = save_global_trampoline;
+        if (save_global_flags & FTRACE_OPS_FL_ALLOC_TRAMP)
+                global_ops.flags |= FTRACE_OPS_FL_ALLOC_TRAMP;
+#endif
+
  out:
         mutex_unlock(&ftrace_lock);
 }
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 2d75c94ae87d..7a4104cb95cb 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -34,21 +34,19 @@ static void update_pages_handler(struct work_struct *work);
  */
 int ring_buffer_print_entry_header(struct trace_seq *s)
 {
-        int ret;
-
-        ret = trace_seq_puts(s, "# compressed entry header\n");
-        ret = trace_seq_puts(s, "\ttype_len    :    5 bits\n");
-        ret = trace_seq_puts(s, "\ttime_delta  :   27 bits\n");
-        ret = trace_seq_puts(s, "\tarray       :   32 bits\n");
-        ret = trace_seq_putc(s, '\n');
-        ret = trace_seq_printf(s, "\tpadding     : type == %d\n",
-                               RINGBUF_TYPE_PADDING);
-        ret = trace_seq_printf(s, "\ttime_extend : type == %d\n",
-                               RINGBUF_TYPE_TIME_EXTEND);
-        ret = trace_seq_printf(s, "\tdata max type_len  == %d\n",
-                               RINGBUF_TYPE_DATA_TYPE_LEN_MAX);
+        trace_seq_puts(s, "# compressed entry header\n");
+        trace_seq_puts(s, "\ttype_len    :    5 bits\n");
+        trace_seq_puts(s, "\ttime_delta  :   27 bits\n");
+        trace_seq_puts(s, "\tarray       :   32 bits\n");
+        trace_seq_putc(s, '\n');
+        trace_seq_printf(s, "\tpadding     : type == %d\n",
+                         RINGBUF_TYPE_PADDING);
+        trace_seq_printf(s, "\ttime_extend : type == %d\n",
+                         RINGBUF_TYPE_TIME_EXTEND);
+        trace_seq_printf(s, "\tdata max type_len  == %d\n",
+                         RINGBUF_TYPE_DATA_TYPE_LEN_MAX);
 
-        return ret;
+        return !trace_seq_has_overflowed(s);
 }
 
 /*
@@ -419,32 +417,31 @@ static inline int test_time_stamp(u64 delta)
 int ring_buffer_print_page_header(struct trace_seq *s)
 {
         struct buffer_data_page field;
-        int ret;
 
-        ret = trace_seq_printf(s, "\tfield: u64 timestamp;\t"
-                               "offset:0;\tsize:%u;\tsigned:%u;\n",
-                               (unsigned int)sizeof(field.time_stamp),
-                               (unsigned int)is_signed_type(u64));
-
-        ret = trace_seq_printf(s, "\tfield: local_t commit;\t"
-                               "offset:%u;\tsize:%u;\tsigned:%u;\n",
-                               (unsigned int)offsetof(typeof(field), commit),
-                               (unsigned int)sizeof(field.commit),
-                               (unsigned int)is_signed_type(long));
-
-        ret = trace_seq_printf(s, "\tfield: int overwrite;\t"
-                               "offset:%u;\tsize:%u;\tsigned:%u;\n",
-                               (unsigned int)offsetof(typeof(field), commit),
-                               1,
-                               (unsigned int)is_signed_type(long));
-
-        ret = trace_seq_printf(s, "\tfield: char data;\t"
-                               "offset:%u;\tsize:%u;\tsigned:%u;\n",
-                               (unsigned int)offsetof(typeof(field), data),
-                               (unsigned int)BUF_PAGE_SIZE,
-                               (unsigned int)is_signed_type(char));
+        trace_seq_printf(s, "\tfield: u64 timestamp;\t"
+                         "offset:0;\tsize:%u;\tsigned:%u;\n",
+                         (unsigned int)sizeof(field.time_stamp),
+                         (unsigned int)is_signed_type(u64));
 
-        return ret;
+        trace_seq_printf(s, "\tfield: local_t commit;\t"
+                         "offset:%u;\tsize:%u;\tsigned:%u;\n",
+                         (unsigned int)offsetof(typeof(field), commit),
+                         (unsigned int)sizeof(field.commit),
+                         (unsigned int)is_signed_type(long));
+
+        trace_seq_printf(s, "\tfield: int overwrite;\t"
+                         "offset:%u;\tsize:%u;\tsigned:%u;\n",
+                         (unsigned int)offsetof(typeof(field), commit),
+                         1,
+                         (unsigned int)is_signed_type(long));
+
+        trace_seq_printf(s, "\tfield: char data;\t"
+                         "offset:%u;\tsize:%u;\tsigned:%u;\n",
+                         (unsigned int)offsetof(typeof(field), data),
+                         (unsigned int)BUF_PAGE_SIZE,
+                         (unsigned int)is_signed_type(char));
+
+        return !trace_seq_has_overflowed(s);
 }
 
 struct rb_irq_work {
@@ -538,16 +535,18 @@ static void rb_wake_up_waiters(struct irq_work *work)
  * ring_buffer_wait - wait for input to the ring buffer
  * @buffer: buffer to wait on
  * @cpu: the cpu buffer to wait on
+ * @full: wait until a full page is available, if @cpu != RING_BUFFER_ALL_CPUS
  *
  * If @cpu == RING_BUFFER_ALL_CPUS then the task will wake up as soon
  * as data is added to any of the @buffer's cpu buffers. Otherwise
  * it will wait for data to be added to a specific cpu buffer.
  */
-int ring_buffer_wait(struct ring_buffer *buffer, int cpu)
+int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full)
 {
-        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_per_cpu *uninitialized_var(cpu_buffer);
         DEFINE_WAIT(wait);
         struct rb_irq_work *work;
+        int ret = 0;
 
         /*
          * Depending on what the caller is waiting for, either any
@@ -564,36 +563,61 @@ int ring_buffer_wait(struct ring_buffer *buffer, int cpu)
         }
 
 
-        prepare_to_wait(&work->waiters, &wait, TASK_INTERRUPTIBLE);
+        while (true) {
+                prepare_to_wait(&work->waiters, &wait, TASK_INTERRUPTIBLE);
 
-        /*
-         * The events can happen in critical sections where
-         * checking a work queue can cause deadlocks.
-         * After adding a task to the queue, this flag is set
-         * only to notify events to try to wake up the queue
-         * using irq_work.
-         *
-         * We don't clear it even if the buffer is no longer
-         * empty. The flag only causes the next event to run
-         * irq_work to do the work queue wake up. The worse
-         * that can happen if we race with !trace_empty() is that
-         * an event will cause an irq_work to try to wake up
-         * an empty queue.
-         *
-         * There's no reason to protect this flag either, as
-         * the work queue and irq_work logic will do the necessary
-         * synchronization for the wake ups. The only thing
-         * that is necessary is that the wake up happens after
-         * a task has been queued. It's OK for spurious wake ups.
-         */
-        work->waiters_pending = true;
+                /*
+                 * The events can happen in critical sections where
+                 * checking a work queue can cause deadlocks.
+                 * After adding a task to the queue, this flag is set
+                 * only to notify events to try to wake up the queue
+                 * using irq_work.
+                 *
+                 * We don't clear it even if the buffer is no longer
+                 * empty. The flag only causes the next event to run
+                 * irq_work to do the work queue wake up. The worse
+                 * that can happen if we race with !trace_empty() is that
+                 * an event will cause an irq_work to try to wake up
+                 * an empty queue.
+                 *
+                 * There's no reason to protect this flag either, as
+                 * the work queue and irq_work logic will do the necessary
+                 * synchronization for the wake ups. The only thing
+                 * that is necessary is that the wake up happens after
+                 * a task has been queued. It's OK for spurious wake ups.
+                 */
+                work->waiters_pending = true;
+
+                if (signal_pending(current)) {
+                        ret = -EINTR;
+                        break;
+                }
+
+                if (cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer))
+                        break;
+
+                if (cpu != RING_BUFFER_ALL_CPUS &&
+                    !ring_buffer_empty_cpu(buffer, cpu)) {
+                        unsigned long flags;
+                        bool pagebusy;
+
+                        if (!full)
+                                break;
+
+                        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+                        pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page;
+                        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+                        if (!pagebusy)
+                                break;
+                }
 
-        if ((cpu == RING_BUFFER_ALL_CPUS && ring_buffer_empty(buffer)) ||
-            (cpu != RING_BUFFER_ALL_CPUS && ring_buffer_empty_cpu(buffer, cpu)))
                 schedule();
+        }
 
         finish_wait(&work->waiters, &wait);
-        return 0;
+
+        return ret;
 }
 
 /**
diff --git a/kernel/trace/ring_buffer_benchmark.c b/kernel/trace/ring_buffer_benchmark.c
index 0434ff1b808e..3f9e328c30b5 100644
--- a/kernel/trace/ring_buffer_benchmark.c
+++ b/kernel/trace/ring_buffer_benchmark.c
@@ -205,7 +205,6 @@ static void ring_buffer_consumer(void)
                         break;
 
                 schedule();
-                __set_current_state(TASK_RUNNING);
         }
         reader_finish = 0;
         complete(&read_done);
@@ -379,7 +378,6 @@ static int ring_buffer_consumer_thread(void *arg)
                         break;
 
                 schedule();
-                __set_current_state(TASK_RUNNING);
         }
         __set_current_state(TASK_RUNNING);
 
@@ -407,7 +405,6 @@ static int ring_buffer_producer_thread(void *arg)
                 trace_printk("Sleeping for 10 secs\n");
                 set_current_state(TASK_INTERRUPTIBLE);
                 schedule_timeout(HZ * SLEEP_TIME);
-                __set_current_state(TASK_RUNNING);
         }
 
         if (kill_test)
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 8a528392b1f4..2e767972e99c 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -63,6 +63,10 @@ static bool __read_mostly tracing_selftest_running;
  */
 bool __read_mostly tracing_selftest_disabled;
 
+/* Pipe tracepoints to printk */
+struct trace_iterator *tracepoint_print_iter;
+int tracepoint_printk;
+
 /* For tracers that don't implement custom flags */
 static struct tracer_opt dummy_tracer_opt[] = {
         { }
@@ -155,10 +159,11 @@ __setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
 
 static int __init stop_trace_on_warning(char *str)
 {
-        __disable_trace_on_warning = 1;
+        if ((strcmp(str, "=0") != 0 && strcmp(str, "=off") != 0))
+                __disable_trace_on_warning = 1;
         return 1;
 }
-__setup("traceoff_on_warning=", stop_trace_on_warning);
+__setup("traceoff_on_warning", stop_trace_on_warning);
 
 static int __init boot_alloc_snapshot(char *str)
 {
@@ -192,6 +197,13 @@ static int __init set_trace_boot_clock(char *str)
 }
 __setup("trace_clock=", set_trace_boot_clock);
 
+static int __init set_tracepoint_printk(char *str)
+{
+        if ((strcmp(str, "=0") != 0 && strcmp(str, "=off") != 0))
+                tracepoint_printk = 1;
+        return 1;
+}
+__setup("tp_printk", set_tracepoint_printk);
 
 unsigned long long ns2usecs(cycle_t nsec)
 {
@@ -938,19 +950,20 @@ out:
         return ret;
 }
 
+/* TODO add a seq_buf_to_buffer() */
 static ssize_t trace_seq_to_buffer(struct trace_seq *s, void *buf, size_t cnt)
 {
         int len;
 
-        if (s->len <= s->readpos)
+        if (trace_seq_used(s) <= s->seq.readpos)
                 return -EBUSY;
 
-        len = s->len - s->readpos;
+        len = trace_seq_used(s) - s->seq.readpos;
         if (cnt > len)
                 cnt = len;
-        memcpy(buf, s->buffer + s->readpos, cnt);
+        memcpy(buf, s->buffer + s->seq.readpos, cnt);
 
-        s->readpos += cnt;
+        s->seq.readpos += cnt;
         return cnt;
 }
 
@@ -1076,13 +1089,14 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
 }
 #endif /* CONFIG_TRACER_MAX_TRACE */
 
-static int wait_on_pipe(struct trace_iterator *iter)
+static int wait_on_pipe(struct trace_iterator *iter, bool full)
 {
         /* Iterators are static, they should be filled or empty */
         if (trace_buffer_iter(iter, iter->cpu_file))
                 return 0;
 
-        return ring_buffer_wait(iter->trace_buffer->buffer, iter->cpu_file);
+        return ring_buffer_wait(iter->trace_buffer->buffer, iter->cpu_file,
+                                full);
 }
 
 #ifdef CONFIG_FTRACE_STARTUP_TEST
@@ -2028,7 +2042,7 @@ void trace_printk_init_buffers(void)
         pr_warning("** trace_printk() being used. Allocating extra memory.  **\n");
         pr_warning("**                                                      **\n");
         pr_warning("** This means that this is a DEBUG kernel and it is     **\n");
-        pr_warning("** unsafe for produciton use.                           **\n");
+        pr_warning("** unsafe for production use.                           **\n");
         pr_warning("**                                                      **\n");
         pr_warning("** If you see this message and you are not debugging    **\n");
         pr_warning("** the kernel, report this immediately to your vendor!  **\n");
@@ -2157,9 +2171,7 @@ __trace_array_vprintk(struct ring_buffer *buffer,
                 goto out;
         }
 
-        len = vsnprintf(tbuffer, TRACE_BUF_SIZE, fmt, args);
-        if (len > TRACE_BUF_SIZE)
-                goto out;
+        len = vscnprintf(tbuffer, TRACE_BUF_SIZE, fmt, args);
 
         local_save_flags(flags);
         size = sizeof(*entry) + len + 1;
@@ -2170,8 +2182,7 @@ __trace_array_vprintk(struct ring_buffer *buffer,
         entry = ring_buffer_event_data(event);
         entry->ip = ip;
 
-        memcpy(&entry->buf, tbuffer, len);
-        entry->buf[len] = '\0';
+        memcpy(&entry->buf, tbuffer, len + 1);
         if (!call_filter_check_discard(call, entry, buffer, event)) {
                 __buffer_unlock_commit(buffer, event);
                 ftrace_trace_stack(buffer, flags, 6, pc);
@@ -2508,14 +2519,14 @@ get_total_entries(struct trace_buffer *buf,
 
 static void print_lat_help_header(struct seq_file *m)
 {
-        seq_puts(m, "#                  _------=> CPU#            \n");
-        seq_puts(m, "#                 / _-----=> irqs-off        \n");
-        seq_puts(m, "#                | / _----=> need-resched    \n");
-        seq_puts(m, "#                || / _---=> hardirq/softirq \n");
-        seq_puts(m, "#                ||| / _--=> preempt-depth   \n");
-        seq_puts(m, "#                |||| /     delay             \n");
-        seq_puts(m, "#  cmd     pid   ||||| time  |   caller      \n");
-        seq_puts(m, "#     \\   /      |||||  \\    |   /           \n");
+        seq_puts(m, "#                  _------=> CPU#            \n"
+                    "#                 / _-----=> irqs-off        \n"
+                    "#                | / _----=> need-resched    \n"
+                    "#                || / _---=> hardirq/softirq \n"
+                    "#                ||| / _--=> preempt-depth   \n"
+                    "#                |||| /     delay            \n"
+                    "#  cmd     pid   ||||| time  |   caller      \n"
+                    "#     \\   /      |||||  \\    |   /         \n");
 }
 
 static void print_event_info(struct trace_buffer *buf, struct seq_file *m)
@@ -2532,20 +2543,20 @@ static void print_event_info(struct trace_buffer *buf, struct seq_file *m)
 static void print_func_help_header(struct trace_buffer *buf, struct seq_file *m)
 {
         print_event_info(buf, m);
-        seq_puts(m, "#           TASK-PID   CPU#      TIMESTAMP  FUNCTION\n");
-        seq_puts(m, "#              | |       |          |         |\n");
+        seq_puts(m, "#           TASK-PID   CPU#      TIMESTAMP  FUNCTION\n"
+                    "#              | |       |          |         |\n");
 }
 
 static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file *m)
 {
         print_event_info(buf, m);
-        seq_puts(m, "#                              _-----=> irqs-off\n");
-        seq_puts(m, "#                             / _----=> need-resched\n");
-        seq_puts(m, "#                            | / _---=> hardirq/softirq\n");
-        seq_puts(m, "#                            || / _--=> preempt-depth\n");
-        seq_puts(m, "#                            ||| /     delay\n");
-        seq_puts(m, "#           TASK-PID   CPU#  ||||    TIMESTAMP  FUNCTION\n");
-        seq_puts(m, "#              | |       |   ||||       |         |\n");
+        seq_puts(m, "#                              _-----=> irqs-off\n"
+                    "#                             / _----=> need-resched\n"
+                    "#                            | / _---=> hardirq/softirq\n"
+                    "#                            || / _--=> preempt-depth\n"
+                    "#                            ||| /     delay\n"
+                    "#           TASK-PID   CPU#  ||||    TIMESTAMP  FUNCTION\n"
+                    "#              | |       |   ||||       |         |\n");
 }
 
 void
@@ -2648,24 +2659,21 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
         event = ftrace_find_event(entry->type);
 
         if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
-                if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
-                        if (!trace_print_lat_context(iter))
-                                goto partial;
-                } else {
-                        if (!trace_print_context(iter))
-                                goto partial;
-                }
+                if (iter->iter_flags & TRACE_FILE_LAT_FMT)
+                        trace_print_lat_context(iter);
+                else
+                        trace_print_context(iter);
         }
 
+        if (trace_seq_has_overflowed(s))
+                return TRACE_TYPE_PARTIAL_LINE;
+
         if (event)
                 return event->funcs->trace(iter, sym_flags, event);
 
-        if (!trace_seq_printf(s, "Unknown type %d\n", entry->type))
-                goto partial;
+        trace_seq_printf(s, "Unknown type %d\n", entry->type);
 
-        return TRACE_TYPE_HANDLED;
-partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
@@ -2676,22 +2684,20 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
 
         entry = iter->ent;
 
-        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
-                if (!trace_seq_printf(s, "%d %d %llu ",
-                                      entry->pid, iter->cpu, iter->ts))
-                        goto partial;
-        }
+        if (trace_flags & TRACE_ITER_CONTEXT_INFO)
+                trace_seq_printf(s, "%d %d %llu ",
+                                 entry->pid, iter->cpu, iter->ts);
+
+        if (trace_seq_has_overflowed(s))
+                return TRACE_TYPE_PARTIAL_LINE;
 
         event = ftrace_find_event(entry->type);
         if (event)
                 return event->funcs->raw(iter, 0, event);
 
-        if (!trace_seq_printf(s, "%d ?\n", entry->type))
-                goto partial;
+        trace_seq_printf(s, "%d ?\n", entry->type);
 
-        return TRACE_TYPE_HANDLED;
-partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
@@ -2704,9 +2710,11 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
         entry = iter->ent;
 
         if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
-                SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
-                SEQ_PUT_HEX_FIELD_RET(s, iter->cpu);
-                SEQ_PUT_HEX_FIELD_RET(s, iter->ts);
+                SEQ_PUT_HEX_FIELD(s, entry->pid);
+                SEQ_PUT_HEX_FIELD(s, iter->cpu);
+                SEQ_PUT_HEX_FIELD(s, iter->ts);
+                if (trace_seq_has_overflowed(s))
+                        return TRACE_TYPE_PARTIAL_LINE;
         }
 
         event = ftrace_find_event(entry->type);
@@ -2716,9 +2724,9 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
                         return ret;
         }
 
-        SEQ_PUT_FIELD_RET(s, newline);
+        SEQ_PUT_FIELD(s, newline);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
@@ -2730,9 +2738,11 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
         entry = iter->ent;
 
         if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
-                SEQ_PUT_FIELD_RET(s, entry->pid);
-                SEQ_PUT_FIELD_RET(s, iter->cpu);
-                SEQ_PUT_FIELD_RET(s, iter->ts);
+                SEQ_PUT_FIELD(s, entry->pid);
+                SEQ_PUT_FIELD(s, iter->cpu);
+                SEQ_PUT_FIELD(s, iter->ts);
+                if (trace_seq_has_overflowed(s))
+                        return TRACE_TYPE_PARTIAL_LINE;
         }
 
         event = ftrace_find_event(entry->type);
@@ -2778,10 +2788,12 @@ enum print_line_t print_trace_line(struct trace_iterator *iter)
 {
         enum print_line_t ret;
 
-        if (iter->lost_events &&
-            !trace_seq_printf(&iter->seq, "CPU:%d [LOST %lu EVENTS]\n",
-                                 iter->cpu, iter->lost_events))
-                return TRACE_TYPE_PARTIAL_LINE;
+        if (iter->lost_events) {
+                trace_seq_printf(&iter->seq, "CPU:%d [LOST %lu EVENTS]\n",
+                                 iter->cpu, iter->lost_events);
+                if (trace_seq_has_overflowed(&iter->seq))
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
 
         if (iter->trace && iter->trace->print_line) {
                 ret = iter->trace->print_line(iter);
@@ -2859,44 +2871,44 @@ static void test_ftrace_alive(struct seq_file *m)
 {
         if (!ftrace_is_dead())
                 return;
-        seq_printf(m, "# WARNING: FUNCTION TRACING IS CORRUPTED\n");
-        seq_printf(m, "#          MAY BE MISSING FUNCTION EVENTS\n");
+        seq_puts(m, "# WARNING: FUNCTION TRACING IS CORRUPTED\n"
+                    "#          MAY BE MISSING FUNCTION EVENTS\n");
 }
 
 #ifdef CONFIG_TRACER_MAX_TRACE
 static void show_snapshot_main_help(struct seq_file *m)
 {
-        seq_printf(m, "# echo 0 > snapshot : Clears and frees snapshot buffer\n");
-        seq_printf(m, "# echo 1 > snapshot : Allocates snapshot buffer, if not already allocated.\n");
-        seq_printf(m, "#                      Takes a snapshot of the main buffer.\n");
-        seq_printf(m, "# echo 2 > snapshot : Clears snapshot buffer (but does not allocate or free)\n");
-        seq_printf(m, "#                      (Doesn't have to be '2' works with any number that\n");
-        seq_printf(m, "#                       is not a '0' or '1')\n");
+        seq_puts(m, "# echo 0 > snapshot : Clears and frees snapshot buffer\n"
+                    "# echo 1 > snapshot : Allocates snapshot buffer, if not already allocated.\n"
+                    "#                      Takes a snapshot of the main buffer.\n"
+                    "# echo 2 > snapshot : Clears snapshot buffer (but does not allocate or free)\n"
+                    "#                      (Doesn't have to be '2' works with any number that\n"
+                    "#                       is not a '0' or '1')\n");
 }
 
 static void show_snapshot_percpu_help(struct seq_file *m)
 {
-        seq_printf(m, "# echo 0 > snapshot : Invalid for per_cpu snapshot file.\n");
+        seq_puts(m, "# echo 0 > snapshot : Invalid for per_cpu snapshot file.\n");
 #ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
-        seq_printf(m, "# echo 1 > snapshot : Allocates snapshot buffer, if not already allocated.\n");
-        seq_printf(m, "#                      Takes a snapshot of the main buffer for this cpu.\n");
+        seq_puts(m, "# echo 1 > snapshot : Allocates snapshot buffer, if not already allocated.\n"
+                    "#                      Takes a snapshot of the main buffer for this cpu.\n");
 #else
-        seq_printf(m, "# echo 1 > snapshot : Not supported with this kernel.\n");
-        seq_printf(m, "#                     Must use main snapshot file to allocate.\n");
+        seq_puts(m, "# echo 1 > snapshot : Not supported with this kernel.\n"
+                    "#                     Must use main snapshot file to allocate.\n");
 #endif
-        seq_printf(m, "# echo 2 > snapshot : Clears this cpu's snapshot buffer (but does not allocate)\n");
-        seq_printf(m, "#                      (Doesn't have to be '2' works with any number that\n");
-        seq_printf(m, "#                       is not a '0' or '1')\n");
+        seq_puts(m, "# echo 2 > snapshot : Clears this cpu's snapshot buffer (but does not allocate)\n"
+                    "#                      (Doesn't have to be '2' works with any number that\n"
+                    "#                       is not a '0' or '1')\n");
 }
 
 static void print_snapshot_help(struct seq_file *m, struct trace_iterator *iter)
 {
         if (iter->tr->allocated_snapshot)
-                seq_printf(m, "#\n# * Snapshot is allocated *\n#\n");
+                seq_puts(m, "#\n# * Snapshot is allocated *\n#\n");
         else
-                seq_printf(m, "#\n# * Snapshot is freed *\n#\n");
+                seq_puts(m, "#\n# * Snapshot is freed *\n#\n");
 
-        seq_printf(m, "# Snapshot commands:\n");
+        seq_puts(m, "# Snapshot commands:\n");
         if (iter->cpu_file == RING_BUFFER_ALL_CPUS)
                 show_snapshot_main_help(m);
         else
@@ -3250,7 +3262,7 @@ static int t_show(struct seq_file *m, void *v)
         if (!t)
                 return 0;
 
-        seq_printf(m, "%s", t->name);
+        seq_puts(m, t->name);
         if (t->next)
                 seq_putc(m, ' ');
         else
@@ -4313,6 +4325,8 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
                 goto out;
         }
 
+        trace_seq_init(&iter->seq);
+
         /*
          * We make a copy of the current tracer to avoid concurrent
          * changes on it while we are reading.
@@ -4434,15 +4448,12 @@ static int tracing_wait_pipe(struct file *filp)
 
                 mutex_unlock(&iter->mutex);
 
-                ret = wait_on_pipe(iter);
+                ret = wait_on_pipe(iter, false);
 
                 mutex_lock(&iter->mutex);
 
                 if (ret)
                         return ret;
-
-                if (signal_pending(current))
-                        return -EINTR;
         }
 
         return 1;
@@ -4509,18 +4520,18 @@ waitagain:
         trace_access_lock(iter->cpu_file);
         while (trace_find_next_entry_inc(iter) != NULL) {
                 enum print_line_t ret;
-                int len = iter->seq.len;
+                int save_len = iter->seq.seq.len;
 
                 ret = print_trace_line(iter);
                 if (ret == TRACE_TYPE_PARTIAL_LINE) {
                         /* don't print partial lines */
-                        iter->seq.len = len;
+                        iter->seq.seq.len = save_len;
                         break;
                 }
                 if (ret != TRACE_TYPE_NO_CONSUME)
                         trace_consume(iter);
 
-                if (iter->seq.len >= cnt)
+                if (trace_seq_used(&iter->seq) >= cnt)
                         break;
 
                 /*
@@ -4536,7 +4547,7 @@ waitagain:
 
         /* Now copy what we have to the user */
         sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
-        if (iter->seq.readpos >= iter->seq.len)
+        if (iter->seq.seq.readpos >= trace_seq_used(&iter->seq))
                 trace_seq_init(&iter->seq);
 
         /*
@@ -4570,20 +4581,33 @@ static size_t
 tracing_fill_pipe_page(size_t rem, struct trace_iterator *iter)
 {
         size_t count;
+        int save_len;
         int ret;
 
         /* Seq buffer is page-sized, exactly what we need. */
         for (;;) {
-                count = iter->seq.len;
+                save_len = iter->seq.seq.len;
                 ret = print_trace_line(iter);
-                count = iter->seq.len - count;
-                if (rem < count) {
-                        rem = 0;
-                        iter->seq.len -= count;
+
+                if (trace_seq_has_overflowed(&iter->seq)) {
+                        iter->seq.seq.len = save_len;
                         break;
                 }
+
+                /*
+                 * This should not be hit, because it should only
+                 * be set if the iter->seq overflowed. But check it
+                 * anyway to be safe.
+                 */
                 if (ret == TRACE_TYPE_PARTIAL_LINE) {
-                        iter->seq.len -= count;
+                        iter->seq.seq.len = save_len;
+                        break;
+                }
+
+                count = trace_seq_used(&iter->seq) - save_len;
+                if (rem < count) {
+                        rem = 0;
+                        iter->seq.seq.len = save_len;
                         break;
                 }
 
@@ -4664,13 +4688,13 @@ static ssize_t tracing_splice_read_pipe(struct file *filp,
                 /* Copy the data into the page, so we can start over. */
                 ret = trace_seq_to_buffer(&iter->seq,
                                           page_address(spd.pages[i]),
-                                          iter->seq.len);
+                                          trace_seq_used(&iter->seq));
                 if (ret < 0) {
                         __free_page(spd.pages[i]);
                         break;
                 }
                 spd.partial[i].offset = 0;
-                spd.partial[i].len = iter->seq.len;
+                spd.partial[i].len = trace_seq_used(&iter->seq);
 
                 trace_seq_init(&iter->seq);
         }
@@ -5372,16 +5396,12 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
                                 goto out_unlock;
                         }
                         mutex_unlock(&trace_types_lock);
-                        ret = wait_on_pipe(iter);
+                        ret = wait_on_pipe(iter, false);
                         mutex_lock(&trace_types_lock);
                         if (ret) {
                                 size = ret;
                                 goto out_unlock;
                         }
-                        if (signal_pending(current)) {
-                                size = -EINTR;
-                                goto out_unlock;
-                        }
                         goto again;
                 }
                 size = 0;
@@ -5500,7 +5520,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
         };
         struct buffer_ref *ref;
         int entries, size, i;
-        ssize_t ret;
+        ssize_t ret = 0;
 
         mutex_lock(&trace_types_lock);
 
@@ -5538,13 +5558,16 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                 int r;
 
                 ref = kzalloc(sizeof(*ref), GFP_KERNEL);
-                if (!ref)
+                if (!ref) {
+                        ret = -ENOMEM;
                         break;
+                }
 
                 ref->ref = 1;
                 ref->buffer = iter->trace_buffer->buffer;
                 ref->page = ring_buffer_alloc_read_page(ref->buffer, iter->cpu_file);
                 if (!ref->page) {
+                        ret = -ENOMEM;
                         kfree(ref);
                         break;
                 }
@@ -5582,19 +5605,19 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
 
         /* did we read anything? */
         if (!spd.nr_pages) {
+                if (ret)
+                        goto out;
+
                 if ((file->f_flags & O_NONBLOCK) || (flags & SPLICE_F_NONBLOCK)) {
                         ret = -EAGAIN;
                         goto out;
                 }
                 mutex_unlock(&trace_types_lock);
-                ret = wait_on_pipe(iter);
+                ret = wait_on_pipe(iter, true);
                 mutex_lock(&trace_types_lock);
                 if (ret)
                         goto out;
-                if (signal_pending(current)) {
-                        ret = -EINTR;
-                        goto out;
-                }
+
                 goto again;
         }
 
@@ -5671,7 +5694,8 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
         cnt = ring_buffer_read_events_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "read events: %ld\n", cnt);
 
-        count = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
+        count = simple_read_from_buffer(ubuf, count, ppos,
+                                        s->buffer, trace_seq_used(s));
 
         kfree(s);
 
@@ -5752,10 +5776,10 @@ ftrace_snapshot_print(struct seq_file *m, unsigned long ip,
 
         seq_printf(m, "%ps:", (void *)ip);
 
-        seq_printf(m, "snapshot");
+        seq_puts(m, "snapshot");
 
         if (count == -1)
-                seq_printf(m, ":unlimited\n");
+                seq_puts(m, ":unlimited\n");
         else
                 seq_printf(m, ":count=%ld\n", count);
 
@@ -6420,7 +6444,7 @@ static int instance_mkdir (struct inode *inode, struct dentry *dentry, umode_t m
         int ret;
 
         /* Paranoid: Make sure the parent is the "instances" directory */
-        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
         if (WARN_ON_ONCE(parent != trace_instance_dir))
                 return -ENOENT;
 
@@ -6447,7 +6471,7 @@ static int instance_rmdir(struct inode *inode, struct dentry *dentry)
         int ret;
 
         /* Paranoid: Make sure the parent is the "instances" directory */
-        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
         if (WARN_ON_ONCE(parent != trace_instance_dir))
                 return -ENOENT;
 
@@ -6634,11 +6658,19 @@ void
 trace_printk_seq(struct trace_seq *s)
 {
         /* Probably should print a warning here. */
-        if (s->len >= TRACE_MAX_PRINT)
-                s->len = TRACE_MAX_PRINT;
+        if (s->seq.len >= TRACE_MAX_PRINT)
+                s->seq.len = TRACE_MAX_PRINT;
+
+        /*
+         * More paranoid code. Although the buffer size is set to
+         * PAGE_SIZE, and TRACE_MAX_PRINT is 1000, this is just
+         * an extra layer of protection.
+         */
+        if (WARN_ON_ONCE(s->seq.len >= s->seq.size))
+                s->seq.len = s->seq.size - 1;
 
         /* should be zero ended, but we are paranoid. */
-        s->buffer[s->len] = 0;
+        s->buffer[s->seq.len] = 0;
 
         printk(KERN_TRACE "%s", s->buffer);
 
@@ -6877,6 +6909,19 @@ out:
         return ret;
 }
 
+void __init trace_init(void)
+{
+        if (tracepoint_printk) {
+                tracepoint_print_iter =
+                        kmalloc(sizeof(*tracepoint_print_iter), GFP_KERNEL);
+                if (WARN_ON(!tracepoint_print_iter))
+                        tracepoint_printk = 0;
+        }
+        tracer_alloc_buffers();
+        init_ftrace_syscalls();
+        trace_event_init();     
+}
+
 __init static int clear_boot_tracer(void)
 {
         /*
@@ -6896,6 +6941,5 @@ __init static int clear_boot_tracer(void)
         return 0;
 }
 
-early_initcall(tracer_alloc_buffers);
 fs_initcall(tracer_init_debugfs);
 late_initcall(clear_boot_tracer);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 385391fb1d3b..8de48bac1ce2 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -14,6 +14,7 @@
 #include <linux/trace_seq.h>
 #include <linux/ftrace_event.h>
 #include <linux/compiler.h>
+#include <linux/trace_seq.h>
 
 #ifdef CONFIG_FTRACE_SYSCALLS
 #include <asm/unistd.h>         /* For NR_SYSCALLS           */
@@ -569,15 +570,6 @@ void trace_init_global_iter(struct trace_iterator *iter);
 
 void tracing_iter_reset(struct trace_iterator *iter, int cpu);
 
-void tracing_sched_switch_trace(struct trace_array *tr,
-                                struct task_struct *prev,
-                                struct task_struct *next,
-                                unsigned long flags, int pc);
-
-void tracing_sched_wakeup_trace(struct trace_array *tr,
-                                struct task_struct *wakee,
-                                struct task_struct *cur,
-                                unsigned long flags, int pc);
 void trace_function(struct trace_array *tr,
                     unsigned long ip,
                     unsigned long parent_ip,
@@ -597,9 +589,6 @@ void set_graph_array(struct trace_array *tr);
 
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
-void tracing_sched_switch_assign_trace(struct trace_array *tr);
-void tracing_stop_sched_switch_record(void);
-void tracing_start_sched_switch_record(void);
 int register_tracer(struct tracer *type);
 int is_tracing_stopped(void);
 
@@ -719,6 +708,8 @@ enum print_line_t print_trace_line(struct trace_iterator *iter);
 
 extern unsigned long trace_flags;
 
+extern char trace_find_mark(unsigned long long duration);
+
 /* Standard output formatting function used for function return traces */
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 
@@ -737,7 +728,7 @@ extern unsigned long trace_flags;
 extern enum print_line_t
 print_graph_function_flags(struct trace_iterator *iter, u32 flags);
 extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
-extern enum print_line_t
+extern void
 trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
 extern void graph_trace_open(struct trace_iterator *iter);
 extern void graph_trace_close(struct trace_iterator *iter);
@@ -1310,4 +1301,18 @@ int perf_ftrace_event_register(struct ftrace_event_call *call,
 #define perf_ftrace_event_register NULL
 #endif
 
+#ifdef CONFIG_FTRACE_SYSCALLS
+void init_ftrace_syscalls(void);
+#else
+static inline void init_ftrace_syscalls(void) { }
+#endif
+
+#ifdef CONFIG_EVENT_TRACING
+void trace_event_init(void);
+#else
+static inline void __init trace_event_init(void) { }
+#endif
+
+extern struct trace_iterator *tracepoint_print_iter;
+
 #endif /* _LINUX_KERNEL_TRACE_H */
diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
index 697fb9bac8f0..7d6e2afde669 100644
--- a/kernel/trace/trace_branch.c
+++ b/kernel/trace/trace_branch.c
@@ -151,22 +151,21 @@ static enum print_line_t trace_branch_print(struct trace_iterator *iter,
 
         trace_assign_type(field, iter->ent);
 
-        if (trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",
-                             field->correct ? "  ok  " : " MISS ",
-                             field->func,
-                             field->file,
-                             field->line))
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",
+                         field->correct ? "  ok  " : " MISS ",
+                         field->func,
+                         field->file,
+                         field->line);
+
+        return trace_handle_return(&iter->seq);
 }
 
 static void branch_print_header(struct seq_file *s)
 {
         seq_puts(s, "#           TASK-PID    CPU#    TIMESTAMP  CORRECT"
-                "  FUNC:FILE:LINE\n");
-        seq_puts(s, "#              | |       |          |         |   "
-                "    |\n");
+                    "  FUNC:FILE:LINE\n"
+                    "#              | |       |          |         |   "
+                    "    |\n");
 }
 
 static struct trace_event_functions trace_branch_funcs = {
@@ -233,12 +232,12 @@ extern unsigned long __stop_annotated_branch_profile[];
 
 static int annotated_branch_stat_headers(struct seq_file *m)
 {
-        seq_printf(m, " correct incorrect  %% ");
-        seq_printf(m, "       Function                "
-                              "  File              Line\n"
-                              " ------- ---------  - "
-                              "       --------                "
-                              "  ----              ----\n");
+        seq_puts(m, " correct incorrect  % "
+                    "       Function                "
+                    "  File              Line\n"
+                    " ------- ---------  - "
+                    "       --------                "
+                    "  ----              ----\n");
         return 0;
 }
 
@@ -274,7 +273,7 @@ static int branch_stat_show(struct seq_file *m, void *v)
 
         seq_printf(m, "%8lu %8lu ",  p->correct, p->incorrect);
         if (percent < 0)
-                seq_printf(m, "  X ");
+                seq_puts(m, "  X ");
         else
                 seq_printf(m, "%3ld ", percent);
         seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
@@ -362,12 +361,12 @@ extern unsigned long __stop_branch_profile[];
 
 static int all_branch_stat_headers(struct seq_file *m)
 {
-        seq_printf(m, "   miss      hit    %% ");
-        seq_printf(m, "       Function                "
-                              "  File              Line\n"
-                              " ------- ---------  - "
-                              "       --------                "
-                              "  ----              ----\n");
+        seq_puts(m, "   miss      hit    % "
+                    "       Function                "
+                    "  File              Line\n"
+                    " ------- ---------  - "
+                    "       --------                "
+                    "  ----              ----\n");
         return 0;
 }
 
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index ef06ce7e9cf8..366a78a3e61e 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -212,8 +212,40 @@ void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer,
 }
 EXPORT_SYMBOL_GPL(ftrace_event_buffer_reserve);
 
+static DEFINE_SPINLOCK(tracepoint_iter_lock);
+
+static void output_printk(struct ftrace_event_buffer *fbuffer)
+{
+        struct ftrace_event_call *event_call;
+        struct trace_event *event;
+        unsigned long flags;
+        struct trace_iterator *iter = tracepoint_print_iter;
+
+        if (!iter)
+                return;
+
+        event_call = fbuffer->ftrace_file->event_call;
+        if (!event_call || !event_call->event.funcs ||
+            !event_call->event.funcs->trace)
+                return;
+
+        event = &fbuffer->ftrace_file->event_call->event;
+
+        spin_lock_irqsave(&tracepoint_iter_lock, flags);
+        trace_seq_init(&iter->seq);
+        iter->ent = fbuffer->entry;
+        event_call->event.funcs->trace(iter, 0, event);
+        trace_seq_putc(&iter->seq, 0);
+        printk("%s", iter->seq.buffer);
+
+        spin_unlock_irqrestore(&tracepoint_iter_lock, flags);
+}
+
 void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer)
 {
+        if (tracepoint_printk)
+                output_printk(fbuffer);
+
         event_trigger_unlock_commit(fbuffer->ftrace_file, fbuffer->buffer,
                                     fbuffer->event, fbuffer->entry,
                                     fbuffer->flags, fbuffer->pc);
@@ -461,7 +493,7 @@ static void remove_event_file_dir(struct ftrace_event_file *file)
 
         if (dir) {
                 spin_lock(&dir->d_lock);        /* probably unneeded */
-                list_for_each_entry(child, &dir->d_subdirs, d_u.d_child) {
+                list_for_each_entry(child, &dir->d_subdirs, d_child) {
                         if (child->d_inode)     /* probably unneeded */
                                 child->d_inode->i_private = NULL;
                 }
@@ -918,7 +950,7 @@ static int f_show(struct seq_file *m, void *v)
         case FORMAT_HEADER:
                 seq_printf(m, "name: %s\n", ftrace_event_name(call));
                 seq_printf(m, "ID: %d\n", call->event.type);
-                seq_printf(m, "format:\n");
+                seq_puts(m, "format:\n");
                 return 0;
 
         case FORMAT_FIELD_SEPERATOR:
@@ -1044,7 +1076,8 @@ event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
         mutex_unlock(&event_mutex);
 
         if (file)
-                r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
+                r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                            s->buffer, trace_seq_used(s));
 
         kfree(s);
 
@@ -1210,7 +1243,8 @@ subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
         trace_seq_init(s);
 
         print_subsystem_event_filter(system, s);
-        r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
+        r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                    s->buffer, trace_seq_used(s));
 
         kfree(s);
 
@@ -1265,7 +1299,8 @@ show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
         trace_seq_init(s);
 
         func(s);
-        r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
+        r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                    s->buffer, trace_seq_used(s));
 
         kfree(s);
 
@@ -1988,7 +2023,7 @@ event_enable_print(struct seq_file *m, unsigned long ip,
                    ftrace_event_name(data->file->event_call));
 
         if (data->count == -1)
-                seq_printf(m, ":unlimited\n");
+                seq_puts(m, ":unlimited\n");
         else
                 seq_printf(m, ":count=%ld\n", data->count);
 
@@ -2477,8 +2512,14 @@ static __init int event_trace_init(void)
 #endif
         return 0;
 }
-early_initcall(event_trace_memsetup);
-core_initcall(event_trace_enable);
+
+void __init trace_event_init(void)
+{
+        event_trace_memsetup();
+        init_ftrace_syscalls();
+        event_trace_enable();
+}
+
 fs_initcall(event_trace_init);
 
 #ifdef CONFIG_FTRACE_STARTUP_TEST
@@ -2513,8 +2554,11 @@ static __init int event_test_thread(void *unused)
         kfree(test_malloc);
 
         set_current_state(TASK_INTERRUPTIBLE);
-        while (!kthread_should_stop())
+        while (!kthread_should_stop()) {
                 schedule();
+                set_current_state(TASK_INTERRUPTIBLE);
+        }
+        __set_current_state(TASK_RUNNING);
 
         return 0;
 }
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 7a8c1528e141..ced69da0ff55 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -45,6 +45,7 @@ enum filter_op_ids
         OP_GT,
         OP_GE,
         OP_BAND,
+        OP_NOT,
         OP_NONE,
         OP_OPEN_PAREN,
 };
@@ -67,6 +68,7 @@ static struct filter_op filter_ops[] = {
         { OP_GT,        ">",            5 },
         { OP_GE,        ">=",           5 },
         { OP_BAND,      "&",            6 },
+        { OP_NOT,       "!",            6 },
         { OP_NONE,      "OP_NONE",      0 },
         { OP_OPEN_PAREN, "(",           0 },
 };
@@ -85,6 +87,7 @@ enum {
         FILT_ERR_MISSING_FIELD,
         FILT_ERR_INVALID_FILTER,
         FILT_ERR_IP_FIELD_ONLY,
+        FILT_ERR_ILLEGAL_NOT_OP,
 };
 
 static char *err_text[] = {
@@ -101,6 +104,7 @@ static char *err_text[] = {
         "Missing field name and/or value",
         "Meaningless filter expression",
         "Only 'ip' field is supported for function trace",
+        "Illegal use of '!'",
 };
 
 struct opstack_op {
@@ -139,6 +143,7 @@ struct pred_stack {
         int                     index;
 };
 
+/* If not of not match is equal to not of not, then it is a match */
 #define DEFINE_COMPARISON_PRED(type)                                    \
 static int filter_pred_##type(struct filter_pred *pred, void *event)    \
 {                                                                       \
@@ -166,7 +171,7 @@ static int filter_pred_##type(struct filter_pred *pred, void *event)	\
                 break;                                                  \
         }                                                               \
                                                                         \
-        return match;                                                   \
+        return !!match == !pred->not;                                   \
 }
 
 #define DEFINE_EQUALITY_PRED(size)                                      \
@@ -484,9 +489,10 @@ static int process_ops(struct filter_pred *preds,
                 if (!WARN_ON_ONCE(!pred->fn))
                         match = pred->fn(pred, rec);
                 if (!!match == type)
-                        return match;
+                        break;
         }
-        return match;
+        /* If not of not match is equal to not of not, then it is a match */
+        return !!match == !op->not;
 }
 
 struct filter_match_preds_data {
@@ -735,10 +741,10 @@ static int filter_set_pred(struct event_filter *filter,
                  * then this op can be folded.
                  */
                 if (left->index & FILTER_PRED_FOLD &&
-                    (left->op == dest->op ||
+                    ((left->op == dest->op && !left->not) ||
                      left->left == FILTER_PRED_INVALID) &&
                     right->index & FILTER_PRED_FOLD &&
-                    (right->op == dest->op ||
+                    ((right->op == dest->op && !right->not) ||
                      right->left == FILTER_PRED_INVALID))
                         dest->index |= FILTER_PRED_FOLD;
 
@@ -1028,7 +1034,7 @@ static int init_pred(struct filter_parse_state *ps,
         }
 
         if (pred->op == OP_NE)
-                pred->not = 1;
+                pred->not ^= 1;
 
         pred->fn = fn;
         return 0;
@@ -1590,6 +1596,17 @@ static int replace_preds(struct ftrace_event_call *call,
                         continue;
                 }
 
+                if (elt->op == OP_NOT) {
+                        if (!n_preds || operand1 || operand2) {
+                                parse_error(ps, FILT_ERR_ILLEGAL_NOT_OP, 0);
+                                err = -EINVAL;
+                                goto fail;
+                        }
+                        if (!dry_run)
+                                filter->preds[n_preds - 1].not ^= 1;
+                        continue;
+                }
+
                 if (WARN_ON(n_preds++ == MAX_FILTER_PRED)) {
                         parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
                         err = -ENOSPC;
diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_events_trigger.c
index 4747b476a030..8712df9decb4 100644
--- a/kernel/trace/trace_events_trigger.c
+++ b/kernel/trace/trace_events_trigger.c
@@ -373,7 +373,7 @@ event_trigger_print(const char *name, struct seq_file *m,
 {
         long count = (long)data;
 
-        seq_printf(m, "%s", name);
+        seq_puts(m, name);
 
         if (count == -1)
                 seq_puts(m, ":unlimited");
@@ -383,7 +383,7 @@ event_trigger_print(const char *name, struct seq_file *m,
         if (filter_str)
                 seq_printf(m, " if %s\n", filter_str);
         else
-                seq_puts(m, "\n");
+                seq_putc(m, '\n');
 
         return 0;
 }
@@ -1105,7 +1105,7 @@ event_enable_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
         if (data->filter_str)
                 seq_printf(m, " if %s\n", data->filter_str);
         else
-                seq_puts(m, "\n");
+                seq_putc(m, '\n');
 
         return 0;
 }
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 57f0ec962d2c..fcd41a166405 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -261,37 +261,74 @@ static struct tracer function_trace __tracer_data =
 };
 
 #ifdef CONFIG_DYNAMIC_FTRACE
-static int update_count(void **data)
+static void update_traceon_count(void **data, bool on)
 {
-        unsigned long *count = (long *)data;
+        long *count = (long *)data;
+        long old_count = *count;
 
-        if (!*count)
-                return 0;
+        /*
+         * Tracing gets disabled (or enabled) once per count.
+         * This function can be called at the same time on multiple CPUs.
+         * It is fine if both disable (or enable) tracing, as disabling
+         * (or enabling) the second time doesn't do anything as the
+         * state of the tracer is already disabled (or enabled).
+         * What needs to be synchronized in this case is that the count
+         * only gets decremented once, even if the tracer is disabled
+         * (or enabled) twice, as the second one is really a nop.
+         *
+         * The memory barriers guarantee that we only decrement the
+         * counter once. First the count is read to a local variable
+         * and a read barrier is used to make sure that it is loaded
+         * before checking if the tracer is in the state we want.
+         * If the tracer is not in the state we want, then the count
+         * is guaranteed to be the old count.
+         *
+         * Next the tracer is set to the state we want (disabled or enabled)
+         * then a write memory barrier is used to make sure that
+         * the new state is visible before changing the counter by
+         * one minus the old counter. This guarantees that another CPU
+         * executing this code will see the new state before seeing
+         * the new counter value, and would not do anything if the new
+         * counter is seen.
+         *
+         * Note, there is no synchronization between this and a user
+         * setting the tracing_on file. But we currently don't care
+         * about that.
+         */
+        if (!old_count)
+                return;
 
-        if (*count != -1)
-                (*count)--;
+        /* Make sure we see count before checking tracing state */
+        smp_rmb();
 
-        return 1;
+        if (on == !!tracing_is_on())
+                return;
+
+        if (on)
+                tracing_on();
+        else
+                tracing_off();
+
+        /* unlimited? */
+        if (old_count == -1)
+                return;
+
+        /* Make sure tracing state is visible before updating count */
+        smp_wmb();
+
+        *count = old_count - 1;
 }
 
 static void
 ftrace_traceon_count(unsigned long ip, unsigned long parent_ip, void **data)
 {
-        if (tracing_is_on())
-                return;
-
-        if (update_count(data))
-                tracing_on();
+        update_traceon_count(data, 1);
 }
 
 static void
 ftrace_traceoff_count(unsigned long ip, unsigned long parent_ip, void **data)
 {
-        if (!tracing_is_on())
-                return;
-
-        if (update_count(data))
-                tracing_off();
+        update_traceon_count(data, 0);
 }
 
 static void
@@ -330,11 +367,49 @@ ftrace_stacktrace(unsigned long ip, unsigned long parent_ip, void **data)
 static void
 ftrace_stacktrace_count(unsigned long ip, unsigned long parent_ip, void **data)
 {
-        if (!tracing_is_on())
-                return;
+        long *count = (long *)data;
+        long old_count;
+        long new_count;
 
-        if (update_count(data))
-                trace_dump_stack(STACK_SKIP);
+        /*
+         * Stack traces should only execute the number of times the
+         * user specified in the counter.
+         */
+        do {
+
+                if (!tracing_is_on())
+                        return;
+
+                old_count = *count;
+
+                if (!old_count)
+                        return;
+
+                /* unlimited? */
+                if (old_count == -1) {
+                        trace_dump_stack(STACK_SKIP);
+                        return;
+                }
+
+                new_count = old_count - 1;
+                new_count = cmpxchg(count, old_count, new_count);
+                if (new_count == old_count)
+                        trace_dump_stack(STACK_SKIP);
+
+        } while (new_count != old_count);
+}
+
+static int update_count(void **data)
+{
+        unsigned long *count = (long *)data;
+
+        if (!*count)
+                return 0;
+
+        if (*count != -1)
+                (*count)--;
+
+        return 1;
 }
 
 static void
@@ -361,7 +436,7 @@ ftrace_probe_print(const char *name, struct seq_file *m,
         seq_printf(m, "%ps:%s", (void *)ip, name);
 
         if (count == -1)
-                seq_printf(m, ":unlimited\n");
+                seq_puts(m, ":unlimited\n");
         else
                 seq_printf(m, ":count=%ld\n", count);
 
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index f0a0c982cde3..ba476009e5de 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -107,7 +107,7 @@ enum {
         FLAGS_FILL_END   = 3 << TRACE_GRAPH_PRINT_FILL_SHIFT,
 };
 
-static enum print_line_t
+static void
 print_graph_duration(unsigned long long duration, struct trace_seq *s,
                      u32 flags);
 
@@ -483,33 +483,24 @@ static int graph_trace_update_thresh(struct trace_array *tr)
 
 static int max_bytes_for_cpu;
 
-static enum print_line_t
-print_graph_cpu(struct trace_seq *s, int cpu)
+static void print_graph_cpu(struct trace_seq *s, int cpu)
 {
-        int ret;
-
         /*
          * Start with a space character - to make it stand out
          * to the right a bit when trace output is pasted into
          * email:
          */
-        ret = trace_seq_printf(s, " %*d) ", max_bytes_for_cpu, cpu);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_printf(s, " %*d) ", max_bytes_for_cpu, cpu);
 }
 
 #define TRACE_GRAPH_PROCINFO_LENGTH     14
 
-static enum print_line_t
-print_graph_proc(struct trace_seq *s, pid_t pid)
+static void print_graph_proc(struct trace_seq *s, pid_t pid)
 {
         char comm[TASK_COMM_LEN];
         /* sign + log10(MAX_INT) + '\0' */
         char pid_str[11];
         int spaces = 0;
-        int ret;
         int len;
         int i;
 
@@ -524,56 +515,43 @@ print_graph_proc(struct trace_seq *s, pid_t pid)
                 spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
 
         /* First spaces to align center */
-        for (i = 0; i < spaces / 2; i++) {
-                ret = trace_seq_putc(s, ' ');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        for (i = 0; i < spaces / 2; i++)
+                trace_seq_putc(s, ' ');
 
-        ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "%s-%s", comm, pid_str);
 
         /* Last spaces to align center */
-        for (i = 0; i < spaces - (spaces / 2); i++) {
-                ret = trace_seq_putc(s, ' ');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
-        return TRACE_TYPE_HANDLED;
+        for (i = 0; i < spaces - (spaces / 2); i++)
+                trace_seq_putc(s, ' ');
 }
 
 
-static enum print_line_t
-print_graph_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
+static void print_graph_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
 {
-        if (!trace_seq_putc(s, ' '))
-                return 0;
-
-        return trace_print_lat_fmt(s, entry);
+        trace_seq_putc(s, ' ');
+        trace_print_lat_fmt(s, entry);
 }
 
 /* If the pid changed since the last trace, output this event */
-static enum print_line_t
+static void
 verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
 {
         pid_t prev_pid;
         pid_t *last_pid;
-        int ret;
 
         if (!data)
-                return TRACE_TYPE_HANDLED;
+                return;
 
         last_pid = &(per_cpu_ptr(data->cpu_data, cpu)->last_pid);
 
         if (*last_pid == pid)
-                return TRACE_TYPE_HANDLED;
+                return;
 
         prev_pid = *last_pid;
         *last_pid = pid;
 
         if (prev_pid == -1)
-                return TRACE_TYPE_HANDLED;
+                return;
 /*
  * Context-switch trace line:
 
@@ -582,33 +560,12 @@ verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
  ------------------------------------------
 
  */
-        ret = trace_seq_puts(s,
-                " ------------------------------------------\n");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = print_graph_cpu(s, cpu);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = print_graph_proc(s, prev_pid);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = trace_seq_puts(s, " => ");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = print_graph_proc(s, pid);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = trace_seq_puts(s,
-                "\n ------------------------------------------\n\n");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_puts(s, " ------------------------------------------\n");
+        print_graph_cpu(s, cpu);
+        print_graph_proc(s, prev_pid);
+        trace_seq_puts(s, " => ");
+        print_graph_proc(s, pid);
+        trace_seq_puts(s, "\n ------------------------------------------\n\n");
 }
 
 static struct ftrace_graph_ret_entry *
@@ -682,175 +639,122 @@ get_return_for_leaf(struct trace_iterator *iter,
         return next;
 }
 
-static int print_graph_abs_time(u64 t, struct trace_seq *s)
+static void print_graph_abs_time(u64 t, struct trace_seq *s)
 {
         unsigned long usecs_rem;
 
         usecs_rem = do_div(t, NSEC_PER_SEC);
         usecs_rem /= 1000;
 
-        return trace_seq_printf(s, "%5lu.%06lu |  ",
-                        (unsigned long)t, usecs_rem);
+        trace_seq_printf(s, "%5lu.%06lu |  ",
+                         (unsigned long)t, usecs_rem);
 }
 
-static enum print_line_t
+static void
 print_graph_irq(struct trace_iterator *iter, unsigned long addr,
                 enum trace_type type, int cpu, pid_t pid, u32 flags)
 {
-        int ret;
         struct trace_seq *s = &iter->seq;
+        struct trace_entry *ent = iter->ent;
 
         if (addr < (unsigned long)__irqentry_text_start ||
                 addr >= (unsigned long)__irqentry_text_end)
-                return TRACE_TYPE_UNHANDLED;
+                return;
 
         if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
                 /* Absolute time */
-                if (flags & TRACE_GRAPH_PRINT_ABS_TIME) {
-                        ret = print_graph_abs_time(iter->ts, s);
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
+                if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
+                        print_graph_abs_time(iter->ts, s);
 
                 /* Cpu */
-                if (flags & TRACE_GRAPH_PRINT_CPU) {
-                        ret = print_graph_cpu(s, cpu);
-                        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
+                if (flags & TRACE_GRAPH_PRINT_CPU)
+                        print_graph_cpu(s, cpu);
 
                 /* Proc */
                 if (flags & TRACE_GRAPH_PRINT_PROC) {
-                        ret = print_graph_proc(s, pid);
-                        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                        ret = trace_seq_puts(s, " | ");
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
+                        print_graph_proc(s, pid);
+                        trace_seq_puts(s, " | ");
                 }
+
+                /* Latency format */
+                if (trace_flags & TRACE_ITER_LATENCY_FMT)
+                        print_graph_lat_fmt(s, ent);
         }
 
         /* No overhead */
-        ret = print_graph_duration(0, s, flags | FLAGS_FILL_START);
-        if (ret != TRACE_TYPE_HANDLED)
-                return ret;
+        print_graph_duration(0, s, flags | FLAGS_FILL_START);
 
         if (type == TRACE_GRAPH_ENT)
-                ret = trace_seq_puts(s, "==========>");
+                trace_seq_puts(s, "==========>");
         else
-                ret = trace_seq_puts(s, "<==========");
-
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = print_graph_duration(0, s, flags | FLAGS_FILL_END);
-        if (ret != TRACE_TYPE_HANDLED)
-                return ret;
-
-        ret = trace_seq_putc(s, '\n');
+                trace_seq_puts(s, "<==========");
 
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-        return TRACE_TYPE_HANDLED;
+        print_graph_duration(0, s, flags | FLAGS_FILL_END);
+        trace_seq_putc(s, '\n');
 }
 
-enum print_line_t
+void
 trace_print_graph_duration(unsigned long long duration, struct trace_seq *s)
 {
         unsigned long nsecs_rem = do_div(duration, 1000);
         /* log10(ULONG_MAX) + '\0' */
-        char msecs_str[21];
+        char usecs_str[21];
         char nsecs_str[5];
-        int ret, len;
+        int len;
         int i;
 
-        sprintf(msecs_str, "%lu", (unsigned long) duration);
+        sprintf(usecs_str, "%lu", (unsigned long) duration);
 
         /* Print msecs */
-        ret = trace_seq_printf(s, "%s", msecs_str);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "%s", usecs_str);
 
-        len = strlen(msecs_str);
+        len = strlen(usecs_str);
 
         /* Print nsecs (we don't want to exceed 7 numbers) */
         if (len < 7) {
                 size_t slen = min_t(size_t, sizeof(nsecs_str), 8UL - len);
 
                 snprintf(nsecs_str, slen, "%03lu", nsecs_rem);
-                ret = trace_seq_printf(s, ".%s", nsecs_str);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
+                trace_seq_printf(s, ".%s", nsecs_str);
                 len += strlen(nsecs_str);
         }
 
-        ret = trace_seq_puts(s, " us ");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_puts(s, " us ");
 
         /* Print remaining spaces to fit the row's width */
-        for (i = len; i < 7; i++) {
-                ret = trace_seq_putc(s, ' ');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
-        return TRACE_TYPE_HANDLED;
+        for (i = len; i < 7; i++)
+                trace_seq_putc(s, ' ');
 }
 
-static enum print_line_t
+static void
 print_graph_duration(unsigned long long duration, struct trace_seq *s,
                      u32 flags)
 {
-        int ret = -1;
-
         if (!(flags & TRACE_GRAPH_PRINT_DURATION) ||
             !(trace_flags & TRACE_ITER_CONTEXT_INFO))
-                        return TRACE_TYPE_HANDLED;
+                return;
 
         /* No real adata, just filling the column with spaces */
         switch (flags & TRACE_GRAPH_PRINT_FILL_MASK) {
         case FLAGS_FILL_FULL:
-                ret = trace_seq_puts(s, "              |  ");
-                return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+                trace_seq_puts(s, "              |  ");
+                return;
         case FLAGS_FILL_START:
-                ret = trace_seq_puts(s, "  ");
-                return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+                trace_seq_puts(s, "  ");
+                return;
         case FLAGS_FILL_END:
-                ret = trace_seq_puts(s, " |");
-                return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+                trace_seq_puts(s, " |");
+                return;
         }
 
         /* Signal a overhead of time execution to the output */
-        if (flags & TRACE_GRAPH_PRINT_OVERHEAD) {
-                /* Duration exceeded 100 msecs */
-                if (duration > 100000ULL)
-                        ret = trace_seq_puts(s, "! ");
-                /* Duration exceeded 10 msecs */
-                else if (duration > 10000ULL)
-                        ret = trace_seq_puts(s, "+ ");
-        }
-
-        /*
-         * The -1 means we either did not exceed the duration tresholds
-         * or we dont want to print out the overhead. Either way we need
-         * to fill out the space.
-         */
-        if (ret == -1)
-                ret = trace_seq_puts(s, "  ");
-
-        /* Catching here any failure happenned above */
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = trace_print_graph_duration(duration, s);
-        if (ret != TRACE_TYPE_HANDLED)
-                return ret;
-
-        ret = trace_seq_puts(s, "|  ");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        if (flags & TRACE_GRAPH_PRINT_OVERHEAD)
+                trace_seq_printf(s, "%c ", trace_find_mark(duration));
+        else
+                trace_seq_puts(s, "  ");
 
-        return TRACE_TYPE_HANDLED;
+        trace_print_graph_duration(duration, s);
+        trace_seq_puts(s, "|  ");
 }
 
 /* Case of a leaf function on its call entry */
@@ -864,7 +768,6 @@ print_graph_entry_leaf(struct trace_iterator *iter,
         struct ftrace_graph_ret *graph_ret;
         struct ftrace_graph_ent *call;
         unsigned long long duration;
-        int ret;
         int i;
 
         graph_ret = &ret_entry->ret;
@@ -890,22 +793,15 @@ print_graph_entry_leaf(struct trace_iterator *iter,
         }
 
         /* Overhead and duration */
-        ret = print_graph_duration(duration, s, flags);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
+        print_graph_duration(duration, s, flags);
 
         /* Function */
-        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
-                ret = trace_seq_putc(s, ' ');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++)
+                trace_seq_putc(s, ' ');
 
-        ret = trace_seq_printf(s, "%ps();\n", (void *)call->func);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "%ps();\n", (void *)call->func);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t
@@ -915,7 +811,6 @@ print_graph_entry_nested(struct trace_iterator *iter,
 {
         struct ftrace_graph_ent *call = &entry->graph_ent;
         struct fgraph_data *data = iter->private;
-        int ret;
         int i;
 
         if (data) {
@@ -931,19 +826,15 @@ print_graph_entry_nested(struct trace_iterator *iter,
         }
 
         /* No time */
-        ret = print_graph_duration(0, s, flags | FLAGS_FILL_FULL);
-        if (ret != TRACE_TYPE_HANDLED)
-                return ret;
+        print_graph_duration(0, s, flags | FLAGS_FILL_FULL);
 
         /* Function */
-        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
-                ret = trace_seq_putc(s, ' ');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++)
+                trace_seq_putc(s, ' ');
+
+        trace_seq_printf(s, "%ps() {\n", (void *)call->func);
 
-        ret = trace_seq_printf(s, "%ps() {\n", (void *)call->func);
-        if (!ret)
+        if (trace_seq_has_overflowed(s))
                 return TRACE_TYPE_PARTIAL_LINE;
 
         /*
@@ -953,62 +844,43 @@ print_graph_entry_nested(struct trace_iterator *iter,
         return TRACE_TYPE_NO_CONSUME;
 }
 
-static enum print_line_t
+static void
 print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
                      int type, unsigned long addr, u32 flags)
 {
         struct fgraph_data *data = iter->private;
         struct trace_entry *ent = iter->ent;
         int cpu = iter->cpu;
-        int ret;
 
         /* Pid */
-        if (verif_pid(s, ent->pid, cpu, data) == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
+        verif_pid(s, ent->pid, cpu, data);
 
-        if (type) {
+        if (type)
                 /* Interrupt */
-                ret = print_graph_irq(iter, addr, type, cpu, ent->pid, flags);
-                if (ret == TRACE_TYPE_PARTIAL_LINE)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+                print_graph_irq(iter, addr, type, cpu, ent->pid, flags);
 
         if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))
-                return 0;
+                return;
 
         /* Absolute time */
-        if (flags & TRACE_GRAPH_PRINT_ABS_TIME) {
-                ret = print_graph_abs_time(iter->ts, s);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
+                print_graph_abs_time(iter->ts, s);
 
         /* Cpu */
-        if (flags & TRACE_GRAPH_PRINT_CPU) {
-                ret = print_graph_cpu(s, cpu);
-                if (ret == TRACE_TYPE_PARTIAL_LINE)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        if (flags & TRACE_GRAPH_PRINT_CPU)
+                print_graph_cpu(s, cpu);
 
         /* Proc */
         if (flags & TRACE_GRAPH_PRINT_PROC) {
-                ret = print_graph_proc(s, ent->pid);
-                if (ret == TRACE_TYPE_PARTIAL_LINE)
-                        return TRACE_TYPE_PARTIAL_LINE;
-
-                ret = trace_seq_puts(s, " | ");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
+                print_graph_proc(s, ent->pid);
+                trace_seq_puts(s, " | ");
         }
 
         /* Latency format */
-        if (trace_flags & TRACE_ITER_LATENCY_FMT) {
-                ret = print_graph_lat_fmt(s, ent);
-                if (ret == TRACE_TYPE_PARTIAL_LINE)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        if (trace_flags & TRACE_ITER_LATENCY_FMT)
+                print_graph_lat_fmt(s, ent);
 
-        return 0;
+        return;
 }
 
 /*
@@ -1126,8 +998,7 @@ print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
         if (check_irq_entry(iter, flags, call->func, call->depth))
                 return TRACE_TYPE_HANDLED;
 
-        if (print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func, flags))
-                return TRACE_TYPE_PARTIAL_LINE;
+        print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func, flags);
 
         leaf_ret = get_return_for_leaf(iter, field);
         if (leaf_ret)
@@ -1160,7 +1031,6 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
         pid_t pid = ent->pid;
         int cpu = iter->cpu;
         int func_match = 1;
-        int ret;
         int i;
 
         if (check_irq_return(iter, flags, trace->depth))
@@ -1186,20 +1056,14 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
                 }
         }
 
-        if (print_graph_prologue(iter, s, 0, 0, flags))
-                return TRACE_TYPE_PARTIAL_LINE;
+        print_graph_prologue(iter, s, 0, 0, flags);
 
         /* Overhead and duration */
-        ret = print_graph_duration(duration, s, flags);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
+        print_graph_duration(duration, s, flags);
 
         /* Closing brace */
-        for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
-                ret = trace_seq_putc(s, ' ');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++)
+                trace_seq_putc(s, ' ');
 
         /*
          * If the return function does not have a matching entry,
@@ -1208,30 +1072,20 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
          * belongs to, write out the function name. Always do
          * that if the funcgraph-tail option is enabled.
          */
-        if (func_match && !(flags & TRACE_GRAPH_PRINT_TAIL)) {
-                ret = trace_seq_puts(s, "}\n");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        } else {
-                ret = trace_seq_printf(s, "} /* %ps */\n", (void *)trace->func);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        if (func_match && !(flags & TRACE_GRAPH_PRINT_TAIL))
+                trace_seq_puts(s, "}\n");
+        else
+                trace_seq_printf(s, "} /* %ps */\n", (void *)trace->func);
 
         /* Overrun */
-        if (flags & TRACE_GRAPH_PRINT_OVERRUN) {
-                ret = trace_seq_printf(s, " (Overruns: %lu)\n",
-                                        trace->overrun);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        if (flags & TRACE_GRAPH_PRINT_OVERRUN)
+                trace_seq_printf(s, " (Overruns: %lu)\n",
+                                 trace->overrun);
 
-        ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET,
-                              cpu, pid, flags);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
+        print_graph_irq(iter, trace->func, TRACE_GRAPH_RET,
+                        cpu, pid, flags);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t
@@ -1248,26 +1102,18 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
         if (data)
                 depth = per_cpu_ptr(data->cpu_data, iter->cpu)->depth;
 
-        if (print_graph_prologue(iter, s, 0, 0, flags))
-                return TRACE_TYPE_PARTIAL_LINE;
+        print_graph_prologue(iter, s, 0, 0, flags);
 
         /* No time */
-        ret = print_graph_duration(0, s, flags | FLAGS_FILL_FULL);
-        if (ret != TRACE_TYPE_HANDLED)
-                return ret;
+        print_graph_duration(0, s, flags | FLAGS_FILL_FULL);
 
         /* Indentation */
         if (depth > 0)
-                for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++) {
-                        ret = trace_seq_putc(s, ' ');
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
+                for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++)
+                        trace_seq_putc(s, ' ');
 
         /* The comment */
-        ret = trace_seq_puts(s, "/* ");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_puts(s, "/* ");
 
         switch (iter->ent->type) {
         case TRACE_BPRINT:
@@ -1290,17 +1136,18 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
                         return ret;
         }
 
+        if (trace_seq_has_overflowed(s))
+                goto out;
+
         /* Strip ending newline */
-        if (s->buffer[s->len - 1] == '\n') {
-                s->buffer[s->len - 1] = '\0';
-                s->len--;
+        if (s->buffer[s->seq.len - 1] == '\n') {
+                s->buffer[s->seq.len - 1] = '\0';
+                s->seq.len--;
         }
 
-        ret = trace_seq_puts(s, " */\n");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_puts(s, " */\n");
+ out:
+        return trace_handle_return(s);
 }
 
 
@@ -1407,32 +1254,32 @@ static void __print_graph_headers_flags(struct seq_file *s, u32 flags)
                 print_lat_header(s, flags);
 
         /* 1st line */
-        seq_printf(s, "#");
+        seq_putc(s, '#');
         if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
-                seq_printf(s, "     TIME       ");
+                seq_puts(s, "     TIME       ");
         if (flags & TRACE_GRAPH_PRINT_CPU)
-                seq_printf(s, " CPU");
+                seq_puts(s, " CPU");
         if (flags & TRACE_GRAPH_PRINT_PROC)
-                seq_printf(s, "  TASK/PID       ");
+                seq_puts(s, "  TASK/PID       ");
         if (lat)
-                seq_printf(s, "||||");
+                seq_puts(s, "||||");
         if (flags & TRACE_GRAPH_PRINT_DURATION)
-                seq_printf(s, "  DURATION   ");
-        seq_printf(s, "               FUNCTION CALLS\n");
+                seq_puts(s, "  DURATION   ");
+        seq_puts(s, "               FUNCTION CALLS\n");
 
         /* 2nd line */
-        seq_printf(s, "#");
+        seq_putc(s, '#');
         if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
-                seq_printf(s, "      |         ");
+                seq_puts(s, "      |         ");
         if (flags & TRACE_GRAPH_PRINT_CPU)
-                seq_printf(s, " |  ");
+                seq_puts(s, " |  ");
         if (flags & TRACE_GRAPH_PRINT_PROC)
-                seq_printf(s, "   |    |        ");
+                seq_puts(s, "   |    |        ");
         if (lat)
-                seq_printf(s, "||||");
+                seq_puts(s, "||||");
         if (flags & TRACE_GRAPH_PRINT_DURATION)
-                seq_printf(s, "   |   |      ");
-        seq_printf(s, "               |   |   |   |\n");
+                seq_puts(s, "   |   |      ");
+        seq_puts(s, "               |   |   |   |\n");
 }
 
 static void print_graph_headers(struct seq_file *s)
diff --git a/kernel/trace/trace_kdb.c b/kernel/trace/trace_kdb.c
index bd90e1b06088..3ccf5c2c1320 100644
--- a/kernel/trace/trace_kdb.c
+++ b/kernel/trace/trace_kdb.c
@@ -20,10 +20,12 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
 {
         /* use static because iter can be a bit big for the stack */
         static struct trace_iterator iter;
+        static struct ring_buffer_iter *buffer_iter[CONFIG_NR_CPUS];
         unsigned int old_userobj;
         int cnt = 0, cpu;
 
         trace_init_global_iter(&iter);
+        iter.buffer_iter = buffer_iter;
 
         for_each_tracing_cpu(cpu) {
                 atomic_inc(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
@@ -57,19 +59,19 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
                 ring_buffer_read_start(iter.buffer_iter[cpu_file]);
                 tracing_iter_reset(&iter, cpu_file);
         }
-        if (!trace_empty(&iter))
-                trace_find_next_entry_inc(&iter);
-        while (!trace_empty(&iter)) {
+
+        while (trace_find_next_entry_inc(&iter)) {
                 if (!cnt)
                         kdb_printf("---------------------------------\n");
                 cnt++;
 
-                if (trace_find_next_entry_inc(&iter) != NULL && !skip_lines)
+                if (!skip_lines) {
                         print_trace_line(&iter);
-                if (!skip_lines)
                         trace_printk_seq(&iter.seq);
-                else
+                } else {
                         skip_lines--;
+                }
+
                 if (KDB_FLAG(CMD_INTERRUPT))
                         goto out;
         }
@@ -86,9 +88,12 @@ out:
                 atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
         }
 
-        for_each_tracing_cpu(cpu)
-                if (iter.buffer_iter[cpu])
+        for_each_tracing_cpu(cpu) {
+                if (iter.buffer_iter[cpu]) {
                         ring_buffer_read_finish(iter.buffer_iter[cpu]);
+                        iter.buffer_iter[cpu] = NULL;
+                }
+        }
 }
 
 /*
@@ -127,8 +132,8 @@ static int kdb_ftdump(int argc, const char **argv)
 
 static __init int kdb_ftrace_register(void)
 {
-        kdb_register_repeat("ftdump", kdb_ftdump, "[skip_#lines] [cpu]",
-                            "Dump ftrace log", 0, KDB_REPEAT_NONE);
+        kdb_register_flags("ftdump", kdb_ftdump, "[skip_#lines] [cpu]",
+                            "Dump ftrace log", 0, KDB_ENABLE_ALWAYS_SAFE);
         return 0;
 }
 
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 282f6e4e5539..5edb518be345 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -826,7 +826,7 @@ static int probes_seq_show(struct seq_file *m, void *v)
         struct trace_kprobe *tk = v;
         int i;
 
-        seq_printf(m, "%c", trace_kprobe_is_return(tk) ? 'r' : 'p');
+        seq_putc(m, trace_kprobe_is_return(tk) ? 'r' : 'p');
         seq_printf(m, ":%s/%s", tk->tp.call.class->system,
                         ftrace_event_name(&tk->tp.call));
 
@@ -840,7 +840,7 @@ static int probes_seq_show(struct seq_file *m, void *v)
 
         for (i = 0; i < tk->tp.nr_args; i++)
                 seq_printf(m, " %s=%s", tk->tp.args[i].name, tk->tp.args[i].comm);
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         return 0;
 }
@@ -1024,27 +1024,22 @@ print_kprobe_event(struct trace_iterator *iter, int flags,
         field = (struct kprobe_trace_entry_head *)iter->ent;
         tp = container_of(event, struct trace_probe, call.event);
 
-        if (!trace_seq_printf(s, "%s: (", ftrace_event_name(&tp->call)))
-                goto partial;
+        trace_seq_printf(s, "%s: (", ftrace_event_name(&tp->call));
 
         if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
-                goto partial;
+                goto out;
 
-        if (!trace_seq_puts(s, ")"))
-                goto partial;
+        trace_seq_putc(s, ')');
 
         data = (u8 *)&field[1];
         for (i = 0; i < tp->nr_args; i++)
                 if (!tp->args[i].type->print(s, tp->args[i].name,
                                              data + tp->args[i].offset, field))
-                        goto partial;
-
-        if (!trace_seq_puts(s, "\n"))
-                goto partial;
+                        goto out;
 
-        return TRACE_TYPE_HANDLED;
-partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_putc(s, '\n');
+ out:
+        return trace_handle_return(s);
 }
 
 static enum print_line_t
@@ -1060,33 +1055,28 @@ print_kretprobe_event(struct trace_iterator *iter, int flags,
         field = (struct kretprobe_trace_entry_head *)iter->ent;
         tp = container_of(event, struct trace_probe, call.event);
 
-        if (!trace_seq_printf(s, "%s: (", ftrace_event_name(&tp->call)))
-                goto partial;
+        trace_seq_printf(s, "%s: (", ftrace_event_name(&tp->call));
 
         if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET))
-                goto partial;
+                goto out;
 
-        if (!trace_seq_puts(s, " <- "))
-                goto partial;
+        trace_seq_puts(s, " <- ");
 
         if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET))
-                goto partial;
+                goto out;
 
-        if (!trace_seq_puts(s, ")"))
-                goto partial;
+        trace_seq_putc(s, ')');
 
         data = (u8 *)&field[1];
         for (i = 0; i < tp->nr_args; i++)
                 if (!tp->args[i].type->print(s, tp->args[i].name,
                                              data + tp->args[i].offset, field))
-                        goto partial;
+                        goto out;
 
-        if (!trace_seq_puts(s, "\n"))
-                goto partial;
+        trace_seq_putc(s, '\n');
 
-        return TRACE_TYPE_HANDLED;
-partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+ out:
+        return trace_handle_return(s);
 }
 
 
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index 0abd9b863474..7a9ba62e9fef 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -59,17 +59,15 @@ static void mmio_trace_start(struct trace_array *tr)
         mmio_reset_data(tr);
 }
 
-static int mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
+static void mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
 {
-        int ret = 0;
         int i;
         resource_size_t start, end;
         const struct pci_driver *drv = pci_dev_driver(dev);
 
-        /* XXX: incomplete checks for trace_seq_printf() return value */
-        ret += trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
-                                dev->bus->number, dev->devfn,
-                                dev->vendor, dev->device, dev->irq);
+        trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
+                         dev->bus->number, dev->devfn,
+                         dev->vendor, dev->device, dev->irq);
         /*
          * XXX: is pci_resource_to_user() appropriate, since we are
          * supposed to interpret the __ioremap() phys_addr argument based on
@@ -77,21 +75,20 @@ static int mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
          */
         for (i = 0; i < 7; i++) {
                 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
-                ret += trace_seq_printf(s, " %llx",
+                trace_seq_printf(s, " %llx",
                         (unsigned long long)(start |
                         (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
         }
         for (i = 0; i < 7; i++) {
                 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
-                ret += trace_seq_printf(s, " %llx",
+                trace_seq_printf(s, " %llx",
                         dev->resource[i].start < dev->resource[i].end ?
                         (unsigned long long)(end - start) + 1 : 0);
         }
         if (drv)
-                ret += trace_seq_printf(s, " %s\n", drv->name);
+                trace_seq_printf(s, " %s\n", drv->name);
         else
-                ret += trace_seq_puts(s, " \n");
-        return ret;
+                trace_seq_puts(s, " \n");
 }
 
 static void destroy_header_iter(struct header_iter *hiter)
@@ -179,28 +176,27 @@ static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
         unsigned long long t    = ns2usecs(iter->ts);
         unsigned long usec_rem  = do_div(t, USEC_PER_SEC);
         unsigned secs           = (unsigned long)t;
-        int ret = 1;
 
         trace_assign_type(field, entry);
         rw = &field->rw;
 
         switch (rw->opcode) {
         case MMIO_READ:
-                ret = trace_seq_printf(s,
+                trace_seq_printf(s,
                         "R %d %u.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
                         rw->width, secs, usec_rem, rw->map_id,
                         (unsigned long long)rw->phys,
                         rw->value, rw->pc, 0);
                 break;
         case MMIO_WRITE:
-                ret = trace_seq_printf(s,
+                trace_seq_printf(s,
                         "W %d %u.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
                         rw->width, secs, usec_rem, rw->map_id,
                         (unsigned long long)rw->phys,
                         rw->value, rw->pc, 0);
                 break;
         case MMIO_UNKNOWN_OP:
-                ret = trace_seq_printf(s,
+                trace_seq_printf(s,
                         "UNKNOWN %u.%06lu %d 0x%llx %02lx,%02lx,"
                         "%02lx 0x%lx %d\n",
                         secs, usec_rem, rw->map_id,
@@ -209,12 +205,11 @@ static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
                         (rw->value >> 0) & 0xff, rw->pc, 0);
                 break;
         default:
-                ret = trace_seq_puts(s, "rw what?\n");
+                trace_seq_puts(s, "rw what?\n");
                 break;
         }
-        if (ret)
-                return TRACE_TYPE_HANDLED;
-        return TRACE_TYPE_PARTIAL_LINE;
+
+        return trace_handle_return(s);
 }
 
 static enum print_line_t mmio_print_map(struct trace_iterator *iter)
@@ -226,31 +221,29 @@ static enum print_line_t mmio_print_map(struct trace_iterator *iter)
         unsigned long long t    = ns2usecs(iter->ts);
         unsigned long usec_rem  = do_div(t, USEC_PER_SEC);
         unsigned secs           = (unsigned long)t;
-        int ret;
 
         trace_assign_type(field, entry);
         m = &field->map;
 
         switch (m->opcode) {
         case MMIO_PROBE:
-                ret = trace_seq_printf(s,
+                trace_seq_printf(s,
                         "MAP %u.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
                         secs, usec_rem, m->map_id,
                         (unsigned long long)m->phys, m->virt, m->len,
                         0UL, 0);
                 break;
         case MMIO_UNPROBE:
-                ret = trace_seq_printf(s,
+                trace_seq_printf(s,
                         "UNMAP %u.%06lu %d 0x%lx %d\n",
                         secs, usec_rem, m->map_id, 0UL, 0);
                 break;
         default:
-                ret = trace_seq_puts(s, "map what?\n");
+                trace_seq_puts(s, "map what?\n");
                 break;
         }
-        if (ret)
-                return TRACE_TYPE_HANDLED;
-        return TRACE_TYPE_PARTIAL_LINE;
+
+        return trace_handle_return(s);
 }
 
 static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
@@ -262,14 +255,11 @@ static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
         unsigned long long t    = ns2usecs(iter->ts);
         unsigned long usec_rem  = do_div(t, USEC_PER_SEC);
         unsigned secs           = (unsigned long)t;
-        int ret;
 
         /* The trailing newline must be in the message. */
-        ret = trace_seq_printf(s, "MARK %u.%06lu %s", secs, usec_rem, msg);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "MARK %u.%06lu %s", secs, usec_rem, msg);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t mmio_print_line(struct trace_iterator *iter)
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index c6977d5a9b12..b77b9a697619 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -25,15 +25,12 @@ enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter)
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry = iter->ent;
         struct bputs_entry *field;
-        int ret;
 
         trace_assign_type(field, entry);
 
-        ret = trace_seq_puts(s, field->str);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_puts(s, field->str);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)
@@ -41,15 +38,12 @@ enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry = iter->ent;
         struct bprint_entry *field;
-        int ret;
 
         trace_assign_type(field, entry);
 
-        ret = trace_seq_bprintf(s, field->fmt, field->buf);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_bprintf(s, field->fmt, field->buf);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
@@ -57,15 +51,12 @@ enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry = iter->ent;
         struct print_entry *field;
-        int ret;
 
         trace_assign_type(field, entry);
 
-        ret = trace_seq_puts(s, field->buf);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_puts(s, field->buf);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 const char *
@@ -124,7 +115,7 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 
         if (ret == (const char *)(trace_seq_buffer_ptr(p)))
                 trace_seq_printf(p, "0x%lx", val);
-                
+
         trace_seq_putc(p, 0);
 
         return ret;
@@ -193,7 +184,6 @@ int ftrace_raw_output_prep(struct trace_iterator *iter,
         struct trace_seq *s = &iter->seq;
         struct trace_seq *p = &iter->tmp_seq;
         struct trace_entry *entry;
-        int ret;
 
         event = container_of(trace_event, struct ftrace_event_call, event);
         entry = iter->ent;
@@ -204,11 +194,9 @@ int ftrace_raw_output_prep(struct trace_iterator *iter,
         }
 
         trace_seq_init(p);
-        ret = trace_seq_printf(s, "%s: ", ftrace_event_name(event));
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "%s: ", ftrace_event_name(event));
 
-        return 0;
+        return trace_handle_return(s);
 }
 EXPORT_SYMBOL(ftrace_raw_output_prep);
 
@@ -216,18 +204,11 @@ static int ftrace_output_raw(struct trace_iterator *iter, char *name,
                              char *fmt, va_list ap)
 {
         struct trace_seq *s = &iter->seq;
-        int ret;
-
-        ret = trace_seq_printf(s, "%s: ", name);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = trace_seq_vprintf(s, fmt, ap);
 
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "%s: ", name);
+        trace_seq_vprintf(s, fmt, ap);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...)
@@ -260,7 +241,7 @@ static inline const char *kretprobed(const char *name)
 }
 #endif /* CONFIG_KRETPROBES */
 
-static int
+static void
 seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
 #ifdef CONFIG_KALLSYMS
@@ -271,12 +252,11 @@ seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 
         name = kretprobed(str);
 
-        return trace_seq_printf(s, fmt, name);
+        trace_seq_printf(s, fmt, name);
 #endif
-        return 1;
 }
 
-static int
+static void
 seq_print_sym_offset(struct trace_seq *s, const char *fmt,
                      unsigned long address)
 {
@@ -287,9 +267,8 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
         sprint_symbol(str, address);
         name = kretprobed(str);
 
-        return trace_seq_printf(s, fmt, name);
+        trace_seq_printf(s, fmt, name);
 #endif
-        return 1;
 }
 
 #ifndef CONFIG_64BIT
@@ -320,14 +299,14 @@ int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
                 if (file) {
                         ret = trace_seq_path(s, &file->f_path);
                         if (ret)
-                                ret = trace_seq_printf(s, "[+0x%lx]",
-                                                       ip - vmstart);
+                                trace_seq_printf(s, "[+0x%lx]",
+                                                 ip - vmstart);
                 }
                 up_read(&mm->mmap_sem);
         }
         if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
-                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
-        return ret;
+                trace_seq_printf(s, " <" IP_FMT ">", ip);
+        return !trace_seq_has_overflowed(s);
 }
 
 int
@@ -335,7 +314,6 @@ seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
                       unsigned long sym_flags)
 {
         struct mm_struct *mm = NULL;
-        int ret = 1;
         unsigned int i;
 
         if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
@@ -354,48 +332,45 @@ seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
         for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
                 unsigned long ip = entry->caller[i];
 
-                if (ip == ULONG_MAX || !ret)
+                if (ip == ULONG_MAX || trace_seq_has_overflowed(s))
                         break;
-                if (ret)
-                        ret = trace_seq_puts(s, " => ");
+
+                trace_seq_puts(s, " => ");
+
                 if (!ip) {
-                        if (ret)
-                                ret = trace_seq_puts(s, "??");
-                        if (ret)
-                                ret = trace_seq_putc(s, '\n');
+                        trace_seq_puts(s, "??");
+                        trace_seq_putc(s, '\n');
                         continue;
                 }
-                if (!ret)
-                        break;
-                if (ret)
-                        ret = seq_print_user_ip(s, mm, ip, sym_flags);
-                ret = trace_seq_putc(s, '\n');
+
+                seq_print_user_ip(s, mm, ip, sym_flags);
+                trace_seq_putc(s, '\n');
         }
 
         if (mm)
                 mmput(mm);
-        return ret;
+
+        return !trace_seq_has_overflowed(s);
 }
 
 int
 seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
 {
-        int ret;
-
-        if (!ip)
-                return trace_seq_putc(s, '0');
+        if (!ip) {
+                trace_seq_putc(s, '0');
+                goto out;
+        }
 
         if (sym_flags & TRACE_ITER_SYM_OFFSET)
-                ret = seq_print_sym_offset(s, "%s", ip);
+                seq_print_sym_offset(s, "%s", ip);
         else
-                ret = seq_print_sym_short(s, "%s", ip);
-
-        if (!ret)
-                return 0;
+                seq_print_sym_short(s, "%s", ip);
 
         if (sym_flags & TRACE_ITER_SYM_ADDR)
-                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
-        return ret;
+                trace_seq_printf(s, " <" IP_FMT ">", ip);
+
+ out:
+        return !trace_seq_has_overflowed(s);
 }
 
 /**
@@ -413,7 +388,6 @@ int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
         char irqs_off;
         int hardirq;
         int softirq;
-        int ret;
 
         hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
         softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
@@ -445,16 +419,15 @@ int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
                 softirq ? 's' :
                 '.';
 
-        if (!trace_seq_printf(s, "%c%c%c",
-                              irqs_off, need_resched, hardsoft_irq))
-                return 0;
+        trace_seq_printf(s, "%c%c%c",
+                         irqs_off, need_resched, hardsoft_irq);
 
         if (entry->preempt_count)
-                ret = trace_seq_printf(s, "%x", entry->preempt_count);
+                trace_seq_printf(s, "%x", entry->preempt_count);
         else
-                ret = trace_seq_putc(s, '.');
+                trace_seq_putc(s, '.');
 
-        return ret;
+        return !trace_seq_has_overflowed(s);
 }
 
 static int
@@ -464,14 +437,38 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
 
         trace_find_cmdline(entry->pid, comm);
 
-        if (!trace_seq_printf(s, "%8.8s-%-5d %3d",
-                              comm, entry->pid, cpu))
-                return 0;
+        trace_seq_printf(s, "%8.8s-%-5d %3d",
+                         comm, entry->pid, cpu);
 
         return trace_print_lat_fmt(s, entry);
 }
 
-static unsigned long preempt_mark_thresh_us = 100;
+#undef MARK
+#define MARK(v, s) {.val = v, .sym = s}
+/* trace overhead mark */
+static const struct trace_mark {
+        unsigned long long      val; /* unit: nsec */
+        char                    sym;
+} mark[] = {
+        MARK(1000000000ULL      , '$'), /* 1 sec */
+        MARK(1000000ULL         , '#'), /* 1000 usecs */
+        MARK(100000ULL          , '!'), /* 100 usecs */
+        MARK(10000ULL           , '+'), /* 10 usecs */
+};
+#undef MARK
+
+char trace_find_mark(unsigned long long d)
+{
+        int i;
+        int size = ARRAY_SIZE(mark);
+
+        for (i = 0; i < size; i++) {
+                if (d >= mark[i].val)
+                        break;
+        }
+
+        return (i == size) ? ' ' : mark[i].sym;
+}
 
 static int
 lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
@@ -493,24 +490,28 @@ lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
                 unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC);
                 unsigned long rel_msec = (unsigned long)rel_ts;
 
-                return trace_seq_printf(
-                                s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",
-                                ns2usecs(iter->ts),
-                                abs_msec, abs_usec,
-                                rel_msec, rel_usec);
+                trace_seq_printf(
+                        s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",
+                        ns2usecs(iter->ts),
+                        abs_msec, abs_usec,
+                        rel_msec, rel_usec);
+
         } else if (verbose && !in_ns) {
-                return trace_seq_printf(
-                                s, "[%016llx] %lld (+%lld): ",
-                                iter->ts, abs_ts, rel_ts);
+                trace_seq_printf(
+                        s, "[%016llx] %lld (+%lld): ",
+                        iter->ts, abs_ts, rel_ts);
+
         } else if (!verbose && in_ns) {
-                return trace_seq_printf(
-                                s, " %4lldus%c: ",
-                                abs_ts,
-                                rel_ts > preempt_mark_thresh_us ? '!' :
-                                  rel_ts > 1 ? '+' : ' ');
+                trace_seq_printf(
+                        s, " %4lldus%c: ",
+                        abs_ts,
+                        trace_find_mark(rel_ts * NSEC_PER_USEC));
+
         } else { /* !verbose && !in_ns */
-                return trace_seq_printf(s, " %4lld: ", abs_ts);
+                trace_seq_printf(s, " %4lld: ", abs_ts);
         }
+
+        return !trace_seq_has_overflowed(s);
 }
 
 int trace_print_context(struct trace_iterator *iter)
@@ -520,34 +521,29 @@ int trace_print_context(struct trace_iterator *iter)
         unsigned long long t;
         unsigned long secs, usec_rem;
         char comm[TASK_COMM_LEN];
-        int ret;
 
         trace_find_cmdline(entry->pid, comm);
 
-        ret = trace_seq_printf(s, "%16s-%-5d [%03d] ",
+        trace_seq_printf(s, "%16s-%-5d [%03d] ",
                                comm, entry->pid, iter->cpu);
-        if (!ret)
-                return 0;
 
-        if (trace_flags & TRACE_ITER_IRQ_INFO) {
-                ret = trace_print_lat_fmt(s, entry);
-                if (!ret)
-                        return 0;
-        }
+        if (trace_flags & TRACE_ITER_IRQ_INFO)
+                trace_print_lat_fmt(s, entry);
 
         if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {
                 t = ns2usecs(iter->ts);
                 usec_rem = do_div(t, USEC_PER_SEC);
                 secs = (unsigned long)t;
-                return trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem);
+                trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem);
         } else
-                return trace_seq_printf(s, " %12llu: ", iter->ts);
+                trace_seq_printf(s, " %12llu: ", iter->ts);
+
+        return !trace_seq_has_overflowed(s);
 }
 
 int trace_print_lat_context(struct trace_iterator *iter)
 {
         u64 next_ts;
-        int ret;
         /* trace_find_next_entry will reset ent_size */
         int ent_size = iter->ent_size;
         struct trace_seq *s = &iter->seq;
@@ -567,18 +563,17 @@ int trace_print_lat_context(struct trace_iterator *iter)
 
                 trace_find_cmdline(entry->pid, comm);
 
-                ret = trace_seq_printf(
-                                s, "%16s %5d %3d %d %08x %08lx ",
-                                comm, entry->pid, iter->cpu, entry->flags,
-                                entry->preempt_count, iter->idx);
+                trace_seq_printf(
+                        s, "%16s %5d %3d %d %08x %08lx ",
+                        comm, entry->pid, iter->cpu, entry->flags,
+                        entry->preempt_count, iter->idx);
         } else {
-                ret = lat_print_generic(s, entry, iter->cpu);
+                lat_print_generic(s, entry, iter->cpu);
         }
 
-        if (ret)
-                ret = lat_print_timestamp(iter, next_ts);
+        lat_print_timestamp(iter, next_ts);
 
-        return ret;
+        return !trace_seq_has_overflowed(s);
 }
 
 static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
@@ -692,7 +687,7 @@ int register_ftrace_event(struct trace_event *event)
                                 goto out;
 
                 } else {
-                        
+
                         event->type = next_event_type++;
                         list = &ftrace_event_list;
                 }
@@ -764,10 +759,9 @@ EXPORT_SYMBOL_GPL(unregister_ftrace_event);
 enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags,
                                   struct trace_event *event)
 {
-        if (!trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type))
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(&iter->seq);
 }
 
 /* TRACE_FN */
@@ -779,24 +773,16 @@ static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        if (!seq_print_ip_sym(s, field->ip, flags))
-                goto partial;
+        seq_print_ip_sym(s, field->ip, flags);
 
         if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
-                if (!trace_seq_puts(s, " <-"))
-                        goto partial;
-                if (!seq_print_ip_sym(s,
-                                      field->parent_ip,
-                                      flags))
-                        goto partial;
+                trace_seq_puts(s, " <-");
+                seq_print_ip_sym(s, field->parent_ip, flags);
         }
-        if (!trace_seq_putc(s, '\n'))
-                goto partial;
 
-        return TRACE_TYPE_HANDLED;
+        trace_seq_putc(s, '\n');
 
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,
@@ -806,12 +792,11 @@ static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        if (!trace_seq_printf(&iter->seq, "%lx %lx\n",
-                              field->ip,
-                              field->parent_ip))
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(&iter->seq, "%lx %lx\n",
+                         field->ip,
+                         field->parent_ip);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(&iter->seq);
 }
 
 static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,
@@ -822,10 +807,10 @@ static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        SEQ_PUT_HEX_FIELD_RET(s, field->ip);
-        SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
+        SEQ_PUT_HEX_FIELD(s, field->ip);
+        SEQ_PUT_HEX_FIELD(s, field->parent_ip);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,
@@ -836,10 +821,10 @@ static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        SEQ_PUT_FIELD_RET(s, field->ip);
-        SEQ_PUT_FIELD_RET(s, field->parent_ip);
+        SEQ_PUT_FIELD(s, field->ip);
+        SEQ_PUT_FIELD(s, field->parent_ip);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static struct trace_event_functions trace_fn_funcs = {
@@ -868,18 +853,17 @@ static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
         T = task_state_char(field->next_state);
         S = task_state_char(field->prev_state);
         trace_find_cmdline(field->next_pid, comm);
-        if (!trace_seq_printf(&iter->seq,
-                              " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
-                              field->prev_pid,
-                              field->prev_prio,
-                              S, delim,
-                              field->next_cpu,
-                              field->next_pid,
-                              field->next_prio,
-                              T, comm))
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_printf(&iter->seq,
+                         " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
+                         field->prev_pid,
+                         field->prev_prio,
+                         S, delim,
+                         field->next_cpu,
+                         field->next_pid,
+                         field->next_prio,
+                         T, comm);
+
+        return trace_handle_return(&iter->seq);
 }
 
 static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags,
@@ -904,17 +888,16 @@ static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
         if (!S)
                 S = task_state_char(field->prev_state);
         T = task_state_char(field->next_state);
-        if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
-                              field->prev_pid,
-                              field->prev_prio,
-                              S,
-                              field->next_cpu,
-                              field->next_pid,
-                              field->next_prio,
-                              T))
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
+                         field->prev_pid,
+                         field->prev_prio,
+                         S,
+                         field->next_cpu,
+                         field->next_pid,
+                         field->next_prio,
+                         T);
+
+        return trace_handle_return(&iter->seq);
 }
 
 static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags,
@@ -942,15 +925,15 @@ static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
                 S = task_state_char(field->prev_state);
         T = task_state_char(field->next_state);
 
-        SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
-        SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
-        SEQ_PUT_HEX_FIELD_RET(s, S);
-        SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
-        SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
-        SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
-        SEQ_PUT_HEX_FIELD_RET(s, T);
+        SEQ_PUT_HEX_FIELD(s, field->prev_pid);
+        SEQ_PUT_HEX_FIELD(s, field->prev_prio);
+        SEQ_PUT_HEX_FIELD(s, S);
+        SEQ_PUT_HEX_FIELD(s, field->next_cpu);
+        SEQ_PUT_HEX_FIELD(s, field->next_pid);
+        SEQ_PUT_HEX_FIELD(s, field->next_prio);
+        SEQ_PUT_HEX_FIELD(s, T);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags,
@@ -973,14 +956,15 @@ static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
 
         trace_assign_type(field, iter->ent);
 
-        SEQ_PUT_FIELD_RET(s, field->prev_pid);
-        SEQ_PUT_FIELD_RET(s, field->prev_prio);
-        SEQ_PUT_FIELD_RET(s, field->prev_state);
-        SEQ_PUT_FIELD_RET(s, field->next_pid);
-        SEQ_PUT_FIELD_RET(s, field->next_prio);
-        SEQ_PUT_FIELD_RET(s, field->next_state);
+        SEQ_PUT_FIELD(s, field->prev_pid);
+        SEQ_PUT_FIELD(s, field->prev_prio);
+        SEQ_PUT_FIELD(s, field->prev_state);
+        SEQ_PUT_FIELD(s, field->next_cpu);
+        SEQ_PUT_FIELD(s, field->next_pid);
+        SEQ_PUT_FIELD(s, field->next_prio);
+        SEQ_PUT_FIELD(s, field->next_state);
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static struct trace_event_functions trace_ctx_funcs = {
@@ -1020,23 +1004,19 @@ static enum print_line_t trace_stack_print(struct trace_iterator *iter,
         trace_assign_type(field, iter->ent);
         end = (unsigned long *)((long)iter->ent + iter->ent_size);
 
-        if (!trace_seq_puts(s, "<stack trace>\n"))
-                goto partial;
+        trace_seq_puts(s, "<stack trace>\n");
 
         for (p = field->caller; p && *p != ULONG_MAX && p < end; p++) {
-                if (!trace_seq_puts(s, " => "))
-                        goto partial;
 
-                if (!seq_print_ip_sym(s, *p, flags))
-                        goto partial;
-                if (!trace_seq_putc(s, '\n'))
-                        goto partial;
-        }
+                if (trace_seq_has_overflowed(s))
+                        break;
 
-        return TRACE_TYPE_HANDLED;
+                trace_seq_puts(s, " => ");
+                seq_print_ip_sym(s, *p, flags);
+                trace_seq_putc(s, '\n');
+        }
 
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static struct trace_event_functions trace_stack_funcs = {
@@ -1057,16 +1037,10 @@ static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
 
         trace_assign_type(field, iter->ent);
 
-        if (!trace_seq_puts(s, "<user stack trace>\n"))
-                goto partial;
-
-        if (!seq_print_userip_objs(field, s, flags))
-                goto partial;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_puts(s, "<user stack trace>\n");
+        seq_print_userip_objs(field, s, flags);
 
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static struct trace_event_functions trace_user_stack_funcs = {
@@ -1089,19 +1063,11 @@ trace_bputs_print(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, entry);
 
-        if (!seq_print_ip_sym(s, field->ip, flags))
-                goto partial;
+        seq_print_ip_sym(s, field->ip, flags);
+        trace_seq_puts(s, ": ");
+        trace_seq_puts(s, field->str);
 
-        if (!trace_seq_puts(s, ": "))
-                goto partial;
-
-        if (!trace_seq_puts(s, field->str))
-                goto partial;
-
-        return TRACE_TYPE_HANDLED;
-
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 
@@ -1114,16 +1080,10 @@ trace_bputs_raw(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        if (!trace_seq_printf(s, ": %lx : ", field->ip))
-                goto partial;
-
-        if (!trace_seq_puts(s, field->str))
-                goto partial;
+        trace_seq_printf(s, ": %lx : ", field->ip);
+        trace_seq_puts(s, field->str);
 
-        return TRACE_TYPE_HANDLED;
-
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static struct trace_event_functions trace_bputs_funcs = {
@@ -1147,19 +1107,11 @@ trace_bprint_print(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, entry);
 
-        if (!seq_print_ip_sym(s, field->ip, flags))
-                goto partial;
-
-        if (!trace_seq_puts(s, ": "))
-                goto partial;
-
-        if (!trace_seq_bprintf(s, field->fmt, field->buf))
-                goto partial;
+        seq_print_ip_sym(s, field->ip, flags);
+        trace_seq_puts(s, ": ");
+        trace_seq_bprintf(s, field->fmt, field->buf);
 
-        return TRACE_TYPE_HANDLED;
-
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 
@@ -1172,16 +1124,10 @@ trace_bprint_raw(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        if (!trace_seq_printf(s, ": %lx : ", field->ip))
-                goto partial;
-
-        if (!trace_seq_bprintf(s, field->fmt, field->buf))
-                goto partial;
+        trace_seq_printf(s, ": %lx : ", field->ip);
+        trace_seq_bprintf(s, field->fmt, field->buf);
 
-        return TRACE_TYPE_HANDLED;
-
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static struct trace_event_functions trace_bprint_funcs = {
@@ -1203,16 +1149,10 @@ static enum print_line_t trace_print_print(struct trace_iterator *iter,
 
         trace_assign_type(field, iter->ent);
 
-        if (!seq_print_ip_sym(s, field->ip, flags))
-                goto partial;
-
-        if (!trace_seq_printf(s, ": %s", field->buf))
-                goto partial;
+        seq_print_ip_sym(s, field->ip, flags);
+        trace_seq_printf(s, ": %s", field->buf);
 
-        return TRACE_TYPE_HANDLED;
-
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,
@@ -1222,13 +1162,9 @@ static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,
 
         trace_assign_type(field, iter->ent);
 
-        if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf))
-                goto partial;
-
-        return TRACE_TYPE_HANDLED;
+        trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf);
 
- partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+        return trace_handle_return(&iter->seq);
 }
 
 static struct trace_event_functions trace_print_funcs = {
diff --git a/kernel/trace/trace_output.h b/kernel/trace/trace_output.h
index 80b25b585a70..8ef2c40efb3c 100644
--- a/kernel/trace/trace_output.h
+++ b/kernel/trace/trace_output.h
@@ -35,17 +35,11 @@ trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry);
 extern int __unregister_ftrace_event(struct trace_event *event);
 extern struct rw_semaphore trace_event_sem;
 
-#define SEQ_PUT_FIELD_RET(s, x)                         \
-do {                                                    \
-        if (!trace_seq_putmem(s, &(x), sizeof(x)))      \
-                return TRACE_TYPE_PARTIAL_LINE;         \
-} while (0)
-
-#define SEQ_PUT_HEX_FIELD_RET(s, x)                     \
-do {                                                    \
-        if (!trace_seq_putmem_hex(s, &(x), sizeof(x)))  \
-                return TRACE_TYPE_PARTIAL_LINE;         \
-} while (0)
+#define SEQ_PUT_FIELD(s, x)                             \
+        trace_seq_putmem(s, &(x), sizeof(x))
+
+#define SEQ_PUT_HEX_FIELD(s, x)                         \
+        trace_seq_putmem_hex(s, &(x), sizeof(x))
 
 #endif
 
diff --git a/kernel/trace/trace_printk.c b/kernel/trace/trace_printk.c
index 2900817ba65c..c4e70b6bd7fa 100644
--- a/kernel/trace/trace_printk.c
+++ b/kernel/trace/trace_printk.c
@@ -305,7 +305,7 @@ static int t_show(struct seq_file *m, void *v)
                         seq_puts(m, "\\t");
                         break;
                 case '\\':
-                        seq_puts(m, "\\");
+                        seq_putc(m, '\\');
                         break;
                 case '"':
                         seq_puts(m, "\\\"");
diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c
index d4b9fc22cd27..b983b2fd2ca1 100644
--- a/kernel/trace/trace_probe.c
+++ b/kernel/trace/trace_probe.c
@@ -40,7 +40,8 @@ const char *reserved_field_names[] = {
 int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, const char *name,   \
                                 void *data, void *ent)                  \
 {                                                                       \
-        return trace_seq_printf(s, " %s=" fmt, name, *(type *)data);    \
+        trace_seq_printf(s, " %s=" fmt, name, *(type *)data);           \
+        return !trace_seq_has_overflowed(s);                            \
 }                                                                       \
 const char PRINT_TYPE_FMT_NAME(type)[] = fmt;                           \
 NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(type));
@@ -61,10 +62,11 @@ int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s, const char *name,
         int len = *(u32 *)data >> 16;
 
         if (!len)
-                return trace_seq_printf(s, " %s=(fault)", name);
+                trace_seq_printf(s, " %s=(fault)", name);
         else
-                return trace_seq_printf(s, " %s=\"%s\"", name,
-                                        (const char *)get_loc_data(data, ent));
+                trace_seq_printf(s, " %s=\"%s\"", name,
+                                 (const char *)get_loc_data(data, ent));
+        return !trace_seq_has_overflowed(s);
 }
 NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(string));
 
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index 3f34dc9b40f3..2e293beb186e 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -14,122 +14,26 @@
 
 #include "trace.h"
 
-static struct trace_array       *ctx_trace;
-static int __read_mostly        tracer_enabled;
 static int                      sched_ref;
 static DEFINE_MUTEX(sched_register_mutex);
-static int                      sched_stopped;
-
-
-void
-tracing_sched_switch_trace(struct trace_array *tr,
-                           struct task_struct *prev,
-                           struct task_struct *next,
-                           unsigned long flags, int pc)
-{
-        struct ftrace_event_call *call = &event_context_switch;
-        struct ring_buffer *buffer = tr->trace_buffer.buffer;
-        struct ring_buffer_event *event;
-        struct ctx_switch_entry *entry;
-
-        event = trace_buffer_lock_reserve(buffer, TRACE_CTX,
-                                          sizeof(*entry), flags, pc);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->prev_pid                 = prev->pid;
-        entry->prev_prio                = prev->prio;
-        entry->prev_state               = prev->state;
-        entry->next_pid                 = next->pid;
-        entry->next_prio                = next->prio;
-        entry->next_state               = next->state;
-        entry->next_cpu = task_cpu(next);
-
-        if (!call_filter_check_discard(call, entry, buffer, event))
-                trace_buffer_unlock_commit(buffer, event, flags, pc);
-}
 
 static void
 probe_sched_switch(void *ignore, struct task_struct *prev, struct task_struct *next)
 {
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        int cpu;
-        int pc;
-
         if (unlikely(!sched_ref))
                 return;
 
         tracing_record_cmdline(prev);
         tracing_record_cmdline(next);
-
-        if (!tracer_enabled || sched_stopped)
-                return;
-
-        pc = preempt_count();
-        local_irq_save(flags);
-        cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(ctx_trace->trace_buffer.data, cpu);
-
-        if (likely(!atomic_read(&data->disabled)))
-                tracing_sched_switch_trace(ctx_trace, prev, next, flags, pc);
-
-        local_irq_restore(flags);
-}
-
-void
-tracing_sched_wakeup_trace(struct trace_array *tr,
-                           struct task_struct *wakee,
-                           struct task_struct *curr,
-                           unsigned long flags, int pc)
-{
-        struct ftrace_event_call *call = &event_wakeup;
-        struct ring_buffer_event *event;
-        struct ctx_switch_entry *entry;
-        struct ring_buffer *buffer = tr->trace_buffer.buffer;
-
-        event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
-                                          sizeof(*entry), flags, pc);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->prev_pid                 = curr->pid;
-        entry->prev_prio                = curr->prio;
-        entry->prev_state               = curr->state;
-        entry->next_pid                 = wakee->pid;
-        entry->next_prio                = wakee->prio;
-        entry->next_state               = wakee->state;
-        entry->next_cpu                 = task_cpu(wakee);
-
-        if (!call_filter_check_discard(call, entry, buffer, event))
-                trace_buffer_unlock_commit(buffer, event, flags, pc);
 }
 
 static void
 probe_sched_wakeup(void *ignore, struct task_struct *wakee, int success)
 {
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        int cpu, pc;
-
         if (unlikely(!sched_ref))
                 return;
 
         tracing_record_cmdline(current);
-
-        if (!tracer_enabled || sched_stopped)
-                return;
-
-        pc = preempt_count();
-        local_irq_save(flags);
-        cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(ctx_trace->trace_buffer.data, cpu);
-
-        if (likely(!atomic_read(&data->disabled)))
-                tracing_sched_wakeup_trace(ctx_trace, wakee, current,
-                                           flags, pc);
-
-        local_irq_restore(flags);
 }
 
 static int tracing_sched_register(void)
@@ -197,51 +101,3 @@ void tracing_stop_cmdline_record(void)
 {
         tracing_stop_sched_switch();
 }
-
-/**
- * tracing_start_sched_switch_record - start tracing context switches
- *
- * Turns on context switch tracing for a tracer.
- */
-void tracing_start_sched_switch_record(void)
-{
-        if (unlikely(!ctx_trace)) {
-                WARN_ON(1);
-                return;
-        }
-
-        tracing_start_sched_switch();
-
-        mutex_lock(&sched_register_mutex);
-        tracer_enabled++;
-        mutex_unlock(&sched_register_mutex);
-}
-
-/**
- * tracing_stop_sched_switch_record - start tracing context switches
- *
- * Turns off context switch tracing for a tracer.
- */
-void tracing_stop_sched_switch_record(void)
-{
-        mutex_lock(&sched_register_mutex);
-        tracer_enabled--;
-        WARN_ON(tracer_enabled < 0);
-        mutex_unlock(&sched_register_mutex);
-
-        tracing_stop_sched_switch();
-}
-
-/**
- * tracing_sched_switch_assign_trace - assign a trace array for ctx switch
- * @tr: trace array pointer to assign
- *
- * Some tracers might want to record the context switches in their
- * trace. This function lets those tracers assign the trace array
- * to use.
- */
-void tracing_sched_switch_assign_trace(struct trace_array *tr)
-{
-        ctx_trace = tr;
-}
-
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 19bd8928ce94..8fb84b362816 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -365,6 +365,62 @@ probe_wakeup_migrate_task(void *ignore, struct task_struct *task, int cpu)
         wakeup_current_cpu = cpu;
 }
 
+static void
+tracing_sched_switch_trace(struct trace_array *tr,
+                           struct task_struct *prev,
+                           struct task_struct *next,
+                           unsigned long flags, int pc)
+{
+        struct ftrace_event_call *call = &event_context_switch;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
+        struct ring_buffer_event *event;
+        struct ctx_switch_entry *entry;
+
+        event = trace_buffer_lock_reserve(buffer, TRACE_CTX,
+                                          sizeof(*entry), flags, pc);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        entry->prev_pid                 = prev->pid;
+        entry->prev_prio                = prev->prio;
+        entry->prev_state               = prev->state;
+        entry->next_pid                 = next->pid;
+        entry->next_prio                = next->prio;
+        entry->next_state               = next->state;
+        entry->next_cpu = task_cpu(next);
+
+        if (!call_filter_check_discard(call, entry, buffer, event))
+                trace_buffer_unlock_commit(buffer, event, flags, pc);
+}
+
+static void
+tracing_sched_wakeup_trace(struct trace_array *tr,
+                           struct task_struct *wakee,
+                           struct task_struct *curr,
+                           unsigned long flags, int pc)
+{
+        struct ftrace_event_call *call = &event_wakeup;
+        struct ring_buffer_event *event;
+        struct ctx_switch_entry *entry;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
+
+        event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
+                                          sizeof(*entry), flags, pc);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        entry->prev_pid                 = curr->pid;
+        entry->prev_prio                = curr->prio;
+        entry->prev_state               = curr->state;
+        entry->next_pid                 = wakee->pid;
+        entry->next_prio                = wakee->prio;
+        entry->next_state               = wakee->state;
+        entry->next_cpu                 = task_cpu(wakee);
+
+        if (!call_filter_check_discard(call, entry, buffer, event))
+                trace_buffer_unlock_commit(buffer, event, flags, pc);
+}
+
 static void notrace
 probe_wakeup_sched_switch(void *ignore,
                           struct task_struct *prev, struct task_struct *next)
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 5ef60499dc8e..b0f86ea77881 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -382,6 +382,8 @@ static int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 
         /* check the trace buffer */
         ret = trace_test_buffer(&tr->trace_buffer, &count);
+
+        ftrace_enabled = 1;
         tracing_start();
 
         /* we should only have one item */
@@ -679,6 +681,8 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 
         /* check the trace buffer */
         ret = trace_test_buffer(&tr->trace_buffer, &count);
+
+        ftrace_enabled = 1;
         trace->reset(tr);
         tracing_start();
 
@@ -1025,6 +1029,12 @@ trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
 #endif
 
 #ifdef CONFIG_SCHED_TRACER
+
+struct wakeup_test_data {
+        struct completion       is_ready;
+        int                     go;
+};
+
 static int trace_wakeup_test_thread(void *data)
 {
         /* Make this a -deadline thread */
@@ -1034,51 +1044,56 @@ static int trace_wakeup_test_thread(void *data)
                 .sched_deadline = 10000000ULL,
                 .sched_period = 10000000ULL
         };
-        struct completion *x = data;
+        struct wakeup_test_data *x = data;
 
         sched_setattr(current, &attr);
 
         /* Make it know we have a new prio */
-        complete(x);
+        complete(&x->is_ready);
 
         /* now go to sleep and let the test wake us up */
         set_current_state(TASK_INTERRUPTIBLE);
-        schedule();
+        while (!x->go) {
+                schedule();
+                set_current_state(TASK_INTERRUPTIBLE);
+        }
 
-        complete(x);
+        complete(&x->is_ready);
+
+        set_current_state(TASK_INTERRUPTIBLE);
 
         /* we are awake, now wait to disappear */
         while (!kthread_should_stop()) {
-                /*
-                 * This will likely be the system top priority
-                 * task, do short sleeps to let others run.
-                 */
-                msleep(100);
+                schedule();
+                set_current_state(TASK_INTERRUPTIBLE);
         }
 
+        __set_current_state(TASK_RUNNING);
+
         return 0;
 }
-
 int
 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
 {
         unsigned long save_max = tr->max_latency;
         struct task_struct *p;
-        struct completion is_ready;
+        struct wakeup_test_data data;
         unsigned long count;
         int ret;
 
-        init_completion(&is_ready);
+        memset(&data, 0, sizeof(data));
+
+        init_completion(&data.is_ready);
 
         /* create a -deadline thread */
-        p = kthread_run(trace_wakeup_test_thread, &is_ready, "ftrace-test");
+        p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
         if (IS_ERR(p)) {
                 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
                 return -1;
         }
 
         /* make sure the thread is running at -deadline policy */
-        wait_for_completion(&is_ready);
+        wait_for_completion(&data.is_ready);
 
         /* start the tracing */
         ret = tracer_init(trace, tr);
@@ -1099,18 +1114,20 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
                 msleep(100);
         }
 
-        init_completion(&is_ready);
+        init_completion(&data.is_ready);
+
+        data.go = 1;
+        /* memory barrier is in the wake_up_process() */
 
         wake_up_process(p);
 
         /* Wait for the task to wake up */
-        wait_for_completion(&is_ready);
+        wait_for_completion(&data.is_ready);
 
         /* stop the tracing. */
         tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(&tr->trace_buffer, NULL);
-        printk("ret = %d\n", ret);
         if (!ret)
                 ret = trace_test_buffer(&tr->max_buffer, &count);
 
diff --git a/kernel/trace/trace_seq.c b/kernel/trace/trace_seq.c
index 1f24ed99dca2..f8b45d8792f9 100644
--- a/kernel/trace/trace_seq.c
+++ b/kernel/trace/trace_seq.c
@@ -27,10 +27,19 @@
 #include <linux/trace_seq.h>
 
 /* How much buffer is left on the trace_seq? */
-#define TRACE_SEQ_BUF_LEFT(s) ((PAGE_SIZE - 1) - (s)->len)
+#define TRACE_SEQ_BUF_LEFT(s) seq_buf_buffer_left(&(s)->seq)
 
 /* How much buffer is written? */
-#define TRACE_SEQ_BUF_USED(s) min((s)->len, (unsigned int)(PAGE_SIZE - 1))
+#define TRACE_SEQ_BUF_USED(s) seq_buf_used(&(s)->seq)
+
+/*
+ * trace_seq should work with being initialized with 0s.
+ */
+static inline void __trace_seq_init(struct trace_seq *s)
+{
+        if (unlikely(!s->seq.size))
+                trace_seq_init(s);
+}
 
 /**
  * trace_print_seq - move the contents of trace_seq into a seq_file
@@ -43,10 +52,11 @@
  */
 int trace_print_seq(struct seq_file *m, struct trace_seq *s)
 {
-        unsigned int len = TRACE_SEQ_BUF_USED(s);
         int ret;
 
-        ret = seq_write(m, s->buffer, len);
+        __trace_seq_init(s);
+
+        ret = seq_buf_print_seq(m, &s->seq);
 
         /*
          * Only reset this buffer if we successfully wrote to the
@@ -69,34 +79,26 @@ int trace_print_seq(struct seq_file *m, struct trace_seq *s)
  * trace_seq_printf() is used to store strings into a special
  * buffer (@s). Then the output may be either used by
  * the sequencer or pulled into another buffer.
- *
- * Returns 1 if we successfully written all the contents to
- *   the buffer.
-  * Returns 0 if we the length to write is bigger than the
- *   reserved buffer space. In this case, nothing gets written.
  */
-int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+void trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
 {
-        unsigned int len = TRACE_SEQ_BUF_LEFT(s);
+        unsigned int save_len = s->seq.len;
         va_list ap;
-        int ret;
 
-        if (s->full || !len)
-                return 0;
+        if (s->full)
+                return;
+
+        __trace_seq_init(s);
 
         va_start(ap, fmt);
-        ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
+        seq_buf_vprintf(&s->seq, fmt, ap);
         va_end(ap);
 
         /* If we can't write it all, don't bother writing anything */
-        if (ret >= len) {
+        if (unlikely(seq_buf_has_overflowed(&s->seq))) {
+                s->seq.len = save_len;
                 s->full = 1;
-                return 0;
         }
-
-        s->len += ret;
-
-        return 1;
 }
 EXPORT_SYMBOL_GPL(trace_seq_printf);
 
@@ -107,25 +109,23 @@ EXPORT_SYMBOL_GPL(trace_seq_printf);
  * @nmaskbits:  The number of bits that are valid in @maskp
  *
  * Writes a ASCII representation of a bitmask string into @s.
- *
- * Returns 1 if we successfully written all the contents to
- *   the buffer.
- * Returns 0 if we the length to write is bigger than the
- *   reserved buffer space. In this case, nothing gets written.
  */
-int trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
+void trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
                       int nmaskbits)
 {
-        unsigned int len = TRACE_SEQ_BUF_LEFT(s);
-        int ret;
+        unsigned int save_len = s->seq.len;
 
-        if (s->full || !len)
-                return 0;
+        if (s->full)
+                return;
 
-        ret = bitmap_scnprintf(s->buffer, len, maskp, nmaskbits);
-        s->len += ret;
+        __trace_seq_init(s);
 
-        return 1;
+        seq_buf_bitmask(&s->seq, maskp, nmaskbits);
+
+        if (unlikely(seq_buf_has_overflowed(&s->seq))) {
+                s->seq.len = save_len;
+                s->full = 1;
+        }
 }
 EXPORT_SYMBOL_GPL(trace_seq_bitmask);
 
@@ -139,28 +139,23 @@ EXPORT_SYMBOL_GPL(trace_seq_bitmask);
  * trace_seq_printf is used to store strings into a special
  * buffer (@s). Then the output may be either used by
  * the sequencer or pulled into another buffer.
- *
- * Returns how much it wrote to the buffer.
  */
-int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+void trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
 {
-        unsigned int len = TRACE_SEQ_BUF_LEFT(s);
-        int ret;
+        unsigned int save_len = s->seq.len;
 
-        if (s->full || !len)
-                return 0;
+        if (s->full)
+                return;
 
-        ret = vsnprintf(s->buffer + s->len, len, fmt, args);
+        __trace_seq_init(s);
+
+        seq_buf_vprintf(&s->seq, fmt, args);
 
         /* If we can't write it all, don't bother writing anything */
-        if (ret >= len) {
+        if (unlikely(seq_buf_has_overflowed(&s->seq))) {
+                s->seq.len = save_len;
                 s->full = 1;
-                return 0;
         }
-
-        s->len += ret;
-
-        return len;
 }
 EXPORT_SYMBOL_GPL(trace_seq_vprintf);
 
@@ -178,28 +173,24 @@ EXPORT_SYMBOL_GPL(trace_seq_vprintf);
  *
  * This function will take the format and the binary array and finish
  * the conversion into the ASCII string within the buffer.
- *
- * Returns how much it wrote to the buffer.
  */
-int trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
+void trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
 {
-        unsigned int len = TRACE_SEQ_BUF_LEFT(s);
-        int ret;
+        unsigned int save_len = s->seq.len;
 
-        if (s->full || !len)
-                return 0;
+        if (s->full)
+                return;
+
+        __trace_seq_init(s);
 
-        ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
+        seq_buf_bprintf(&s->seq, fmt, binary);
 
         /* If we can't write it all, don't bother writing anything */
-        if (ret >= len) {
+        if (unlikely(seq_buf_has_overflowed(&s->seq))) {
+                s->seq.len = save_len;
                 s->full = 1;
-                return 0;
+                return;
         }
-
-        s->len += ret;
-
-        return len;
 }
 EXPORT_SYMBOL_GPL(trace_seq_bprintf);
 
@@ -212,25 +203,22 @@ EXPORT_SYMBOL_GPL(trace_seq_bprintf);
  * copy to user routines. This function records a simple string
  * into a special buffer (@s) for later retrieval by a sequencer
  * or other mechanism.
- *
- * Returns how much it wrote to the buffer.
  */
-int trace_seq_puts(struct trace_seq *s, const char *str)
+void trace_seq_puts(struct trace_seq *s, const char *str)
 {
         unsigned int len = strlen(str);
 
         if (s->full)
-                return 0;
+                return;
+
+        __trace_seq_init(s);
 
         if (len > TRACE_SEQ_BUF_LEFT(s)) {
                 s->full = 1;
-                return 0;
+                return;
         }
 
-        memcpy(s->buffer + s->len, str, len);
-        s->len += len;
-
-        return len;
+        seq_buf_putmem(&s->seq, str, len);
 }
 EXPORT_SYMBOL_GPL(trace_seq_puts);
 
@@ -243,22 +231,20 @@ EXPORT_SYMBOL_GPL(trace_seq_puts);
  * copy to user routines. This function records a simple charater
  * into a special buffer (@s) for later retrieval by a sequencer
  * or other mechanism.
- *
- * Returns how much it wrote to the buffer.
  */
-int trace_seq_putc(struct trace_seq *s, unsigned char c)
+void trace_seq_putc(struct trace_seq *s, unsigned char c)
 {
         if (s->full)
-                return 0;
+                return;
+
+        __trace_seq_init(s);
 
         if (TRACE_SEQ_BUF_LEFT(s) < 1) {
                 s->full = 1;
-                return 0;
+                return;
         }
 
-        s->buffer[s->len++] = c;
-
-        return 1;
+        seq_buf_putc(&s->seq, c);
 }
 EXPORT_SYMBOL_GPL(trace_seq_putc);
 
@@ -271,29 +257,23 @@ EXPORT_SYMBOL_GPL(trace_seq_putc);
  * There may be cases where raw memory needs to be written into the
  * buffer and a strcpy() would not work. Using this function allows
  * for such cases.
- *
- * Returns how much it wrote to the buffer.
  */
-int trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len)
+void trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len)
 {
         if (s->full)
-                return 0;
+                return;
+
+        __trace_seq_init(s);
 
         if (len > TRACE_SEQ_BUF_LEFT(s)) {
                 s->full = 1;
-                return 0;
+                return;
         }
 
-        memcpy(s->buffer + s->len, mem, len);
-        s->len += len;
-
-        return len;
+        seq_buf_putmem(&s->seq, mem, len);
 }
 EXPORT_SYMBOL_GPL(trace_seq_putmem);
 
-#define MAX_MEMHEX_BYTES        8U
-#define HEX_CHARS               (MAX_MEMHEX_BYTES*2 + 1)
-
 /**
  * trace_seq_putmem_hex - write raw memory into the buffer in ASCII hex
  * @s: trace sequence descriptor
@@ -303,41 +283,31 @@ EXPORT_SYMBOL_GPL(trace_seq_putmem);
  * This is similar to trace_seq_putmem() except instead of just copying the
  * raw memory into the buffer it writes its ASCII representation of it
  * in hex characters.
- *
- * Returns how much it wrote to the buffer.
  */
-int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
+void trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
                          unsigned int len)
 {
-        unsigned char hex[HEX_CHARS];
-        const unsigned char *data = mem;
-        unsigned int start_len;
-        int i, j;
-        int cnt = 0;
+        unsigned int save_len = s->seq.len;
 
         if (s->full)
-                return 0;
+                return;
 
-        while (len) {
-                start_len = min(len, HEX_CHARS - 1);
-#ifdef __BIG_ENDIAN
-                for (i = 0, j = 0; i < start_len; i++) {
-#else
-                for (i = start_len-1, j = 0; i >= 0; i--) {
-#endif
-                        hex[j++] = hex_asc_hi(data[i]);
-                        hex[j++] = hex_asc_lo(data[i]);
-                }
-                if (WARN_ON_ONCE(j == 0 || j/2 > len))
-                        break;
-
-                /* j increments twice per loop */
-                len -= j / 2;
-                hex[j++] = ' ';
-
-                cnt += trace_seq_putmem(s, hex, j);
+        __trace_seq_init(s);
+
+        /* Each byte is represented by two chars */
+        if (len * 2 > TRACE_SEQ_BUF_LEFT(s)) {
+                s->full = 1;
+                return;
+        }
+
+        /* The added spaces can still cause an overflow */
+        seq_buf_putmem_hex(&s->seq, mem, len);
+
+        if (unlikely(seq_buf_has_overflowed(&s->seq))) {
+                s->seq.len = save_len;
+                s->full = 1;
+                return;
         }
-        return cnt;
 }
 EXPORT_SYMBOL_GPL(trace_seq_putmem_hex);
 
@@ -355,30 +325,27 @@ EXPORT_SYMBOL_GPL(trace_seq_putmem_hex);
  */
 int trace_seq_path(struct trace_seq *s, const struct path *path)
 {
-        unsigned char *p;
+        unsigned int save_len = s->seq.len;
 
         if (s->full)
                 return 0;
 
+        __trace_seq_init(s);
+
         if (TRACE_SEQ_BUF_LEFT(s) < 1) {
                 s->full = 1;
                 return 0;
         }
 
-        p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
-        if (!IS_ERR(p)) {
-                p = mangle_path(s->buffer + s->len, p, "\n");
-                if (p) {
-                        s->len = p - s->buffer;
-                        return 1;
-                }
-        } else {
-                s->buffer[s->len++] = '?';
-                return 1;
+        seq_buf_path(&s->seq, path, "\n");
+
+        if (unlikely(seq_buf_has_overflowed(&s->seq))) {
+                s->seq.len = save_len;
+                s->full = 1;
+                return 0;
         }
 
-        s->full = 1;
-        return 0;
+        return 1;
 }
 EXPORT_SYMBOL_GPL(trace_seq_path);
 
@@ -404,25 +371,7 @@ EXPORT_SYMBOL_GPL(trace_seq_path);
  */
 int trace_seq_to_user(struct trace_seq *s, char __user *ubuf, int cnt)
 {
-        int len;
-        int ret;
-
-        if (!cnt)
-                return 0;
-
-        if (s->len <= s->readpos)
-                return -EBUSY;
-
-        len = s->len - s->readpos;
-        if (cnt > len)
-                cnt = len;
-        ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
-        if (ret == cnt)
-                return -EFAULT;
-
-        cnt -= ret;
-
-        s->readpos += cnt;
-        return cnt;
+        __trace_seq_init(s);
+        return seq_buf_to_user(&s->seq, ubuf, cnt);
 }
 EXPORT_SYMBOL_GPL(trace_seq_to_user);
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 8a4e5cb66a4c..16eddb308c33 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -13,7 +13,6 @@
 #include <linux/sysctl.h>
 #include <linux/init.h>
 #include <linux/fs.h>
-#include <linux/magic.h>
 
 #include <asm/setup.h>
 
@@ -171,8 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack)
                         i++;
         }
 
-        if ((current != &init_task &&
-                *(end_of_stack(current)) != STACK_END_MAGIC)) {
+        if (task_stack_end_corrupted(current)) {
                 print_max_stack();
                 BUG();
         }
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 759d5e004517..c6ee36fcbf90 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -114,7 +114,7 @@ print_syscall_enter(struct trace_iterator *iter, int flags,
         struct trace_entry *ent = iter->ent;
         struct syscall_trace_enter *trace;
         struct syscall_metadata *entry;
-        int i, ret, syscall;
+        int i, syscall;
 
         trace = (typeof(trace))ent;
         syscall = trace->nr;
@@ -128,35 +128,28 @@ print_syscall_enter(struct trace_iterator *iter, int flags,
                 goto end;
         }
 
-        ret = trace_seq_printf(s, "%s(", entry->name);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_printf(s, "%s(", entry->name);
 
         for (i = 0; i < entry->nb_args; i++) {
+
+                if (trace_seq_has_overflowed(s))
+                        goto end;
+
                 /* parameter types */
-                if (trace_flags & TRACE_ITER_VERBOSE) {
-                        ret = trace_seq_printf(s, "%s ", entry->types[i]);
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
+                if (trace_flags & TRACE_ITER_VERBOSE)
+                        trace_seq_printf(s, "%s ", entry->types[i]);
+
                 /* parameter values */
-                ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i],
-                                       trace->args[i],
-                                       i == entry->nb_args - 1 ? "" : ", ");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
+                trace_seq_printf(s, "%s: %lx%s", entry->args[i],
+                                 trace->args[i],
+                                 i == entry->nb_args - 1 ? "" : ", ");
         }
 
-        ret = trace_seq_putc(s, ')');
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
+        trace_seq_putc(s, ')');
 end:
-        ret =  trace_seq_putc(s, '\n');
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
+        trace_seq_putc(s, '\n');
 
-        return TRACE_TYPE_HANDLED;
+        return trace_handle_return(s);
 }
 
 static enum print_line_t
@@ -168,7 +161,6 @@ print_syscall_exit(struct trace_iterator *iter, int flags,
         struct syscall_trace_exit *trace;
         int syscall;
         struct syscall_metadata *entry;
-        int ret;
 
         trace = (typeof(trace))ent;
         syscall = trace->nr;
@@ -176,7 +168,7 @@ print_syscall_exit(struct trace_iterator *iter, int flags,
 
         if (!entry) {
                 trace_seq_putc(s, '\n');
-                return TRACE_TYPE_HANDLED;
+                goto out;
         }
 
         if (entry->exit_event->event.type != ent->type) {
@@ -184,12 +176,11 @@ print_syscall_exit(struct trace_iterator *iter, int flags,
                 return TRACE_TYPE_UNHANDLED;
         }
 
-        ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
+        trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
                                 trace->ret);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
 
-        return TRACE_TYPE_HANDLED;
+ out:
+        return trace_handle_return(s);
 }
 
 extern char *__bad_type_size(void);
@@ -313,7 +304,7 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
         int size;
 
         syscall_nr = trace_get_syscall_nr(current, regs);
-        if (syscall_nr < 0)
+        if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
                 return;
 
         /* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE) */
@@ -360,7 +351,7 @@ static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
         int syscall_nr;
 
         syscall_nr = trace_get_syscall_nr(current, regs);
-        if (syscall_nr < 0)
+        if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
                 return;
 
         /* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE()) */
@@ -425,7 +416,7 @@ static void unreg_event_syscall_enter(struct ftrace_event_file *file,
                 return;
         mutex_lock(&syscall_trace_lock);
         tr->sys_refcount_enter--;
-        rcu_assign_pointer(tr->enter_syscall_files[num], NULL);
+        RCU_INIT_POINTER(tr->enter_syscall_files[num], NULL);
         if (!tr->sys_refcount_enter)
                 unregister_trace_sys_enter(ftrace_syscall_enter, tr);
         mutex_unlock(&syscall_trace_lock);
@@ -463,7 +454,7 @@ static void unreg_event_syscall_exit(struct ftrace_event_file *file,
                 return;
         mutex_lock(&syscall_trace_lock);
         tr->sys_refcount_exit--;
-        rcu_assign_pointer(tr->exit_syscall_files[num], NULL);
+        RCU_INIT_POINTER(tr->exit_syscall_files[num], NULL);
         if (!tr->sys_refcount_exit)
                 unregister_trace_sys_exit(ftrace_syscall_exit, tr);
         mutex_unlock(&syscall_trace_lock);
@@ -523,7 +514,7 @@ unsigned long __init __weak arch_syscall_addr(int nr)
         return (unsigned long)sys_call_table[nr];
 }
 
-static int __init init_ftrace_syscalls(void)
+void __init init_ftrace_syscalls(void)
 {
         struct syscall_metadata *meta;
         unsigned long addr;
@@ -533,7 +524,7 @@ static int __init init_ftrace_syscalls(void)
                                     GFP_KERNEL);
         if (!syscalls_metadata) {
                 WARN_ON(1);
-                return -ENOMEM;
+                return;
         }
 
         for (i = 0; i < NR_syscalls; i++) {
@@ -545,10 +536,7 @@ static int __init init_ftrace_syscalls(void)
                 meta->syscall_nr = i;
                 syscalls_metadata[i] = meta;
         }
-
-        return 0;
 }
-early_initcall(init_ftrace_syscalls);
 
 #ifdef CONFIG_PERF_EVENTS
 
@@ -567,7 +555,7 @@ static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
         int size;
 
         syscall_nr = trace_get_syscall_nr(current, regs);
-        if (syscall_nr < 0)
+        if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
                 return;
         if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
                 return;
@@ -641,7 +629,7 @@ static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
         int size;
 
         syscall_nr = trace_get_syscall_nr(current, regs);
-        if (syscall_nr < 0)
+        if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
                 return;
         if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
                 return;
diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index 33ff6a24b802..8520acc34b18 100644
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -552,8 +552,7 @@ error:
         return ret;
 
 fail_address_parse:
-        if (inode)
-                iput(inode);
+        iput(inode);
 
         pr_info("Failed to parse address or file.\n");
 
@@ -606,7 +605,7 @@ static int probes_seq_show(struct seq_file *m, void *v)
         for (i = 0; i < tu->tp.nr_args; i++)
                 seq_printf(m, " %s=%s", tu->tp.args[i].name, tu->tp.args[i].comm);
 
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
         return 0;
 }
 
@@ -852,16 +851,14 @@ print_uprobe_event(struct trace_iterator *iter, int flags, struct trace_event *e
         tu = container_of(event, struct trace_uprobe, tp.call.event);
 
         if (is_ret_probe(tu)) {
-                if (!trace_seq_printf(s, "%s: (0x%lx <- 0x%lx)",
-                                        ftrace_event_name(&tu->tp.call),
-                                        entry->vaddr[1], entry->vaddr[0]))
-                        goto partial;
+                trace_seq_printf(s, "%s: (0x%lx <- 0x%lx)",
+                                 ftrace_event_name(&tu->tp.call),
+                                 entry->vaddr[1], entry->vaddr[0]);
                 data = DATAOF_TRACE_ENTRY(entry, true);
         } else {
-                if (!trace_seq_printf(s, "%s: (0x%lx)",
-                                        ftrace_event_name(&tu->tp.call),
-                                        entry->vaddr[0]))
-                        goto partial;
+                trace_seq_printf(s, "%s: (0x%lx)",
+                                 ftrace_event_name(&tu->tp.call),
+                                 entry->vaddr[0]);
                 data = DATAOF_TRACE_ENTRY(entry, false);
         }
 
@@ -869,14 +866,13 @@ print_uprobe_event(struct trace_iterator *iter, int flags, struct trace_event *e
                 struct probe_arg *parg = &tu->tp.args[i];
 
                 if (!parg->type->print(s, parg->name, data + parg->offset, entry))
-                        goto partial;
+                        goto out;
         }
 
-        if (trace_seq_puts(s, "\n"))
-                return TRACE_TYPE_HANDLED;
+        trace_seq_putc(s, '\n');
 
-partial:
-        return TRACE_TYPE_PARTIAL_LINE;
+ out:
+        return trace_handle_return(s);
 }
 
 typedef bool (*filter_func_t)(struct uprobe_consumer *self,