11 files changed, 119 insertions, 98 deletions

diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index eccb4cf1e998..2326b04c95c4 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -423,7 +423,7 @@ struct ring_buffer_per_cpu {
         int                             cpu;
         struct ring_buffer              *buffer;
         spinlock_t                      reader_lock;    /* serialize readers */
-        raw_spinlock_t                  lock;
+        arch_spinlock_t                 lock;
         struct lock_class_key           lock_key;
         struct list_head                *pages;
         struct buffer_page              *head_page;     /* read from head */
@@ -998,7 +998,7 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
         cpu_buffer->buffer = buffer;
         spin_lock_init(&cpu_buffer->reader_lock);
         lockdep_set_class(&cpu_buffer->reader_lock, buffer->reader_lock_key);
-        cpu_buffer->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        cpu_buffer->lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 
         bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                             GFP_KERNEL, cpu_to_node(cpu));
@@ -2827,7 +2827,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         int ret;
 
         local_irq_save(flags);
-        __raw_spin_lock(&cpu_buffer->lock);
+        arch_spin_lock(&cpu_buffer->lock);
 
  again:
         /*
@@ -2916,7 +2916,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         goto again;
 
  out:
-        __raw_spin_unlock(&cpu_buffer->lock);
+        arch_spin_unlock(&cpu_buffer->lock);
         local_irq_restore(flags);
 
         return reader;
@@ -3279,9 +3279,9 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
         synchronize_sched();
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
-        __raw_spin_lock(&cpu_buffer->lock);
+        arch_spin_lock(&cpu_buffer->lock);
         rb_iter_reset(iter);
-        __raw_spin_unlock(&cpu_buffer->lock);
+        arch_spin_unlock(&cpu_buffer->lock);
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return iter;
@@ -3401,11 +3401,11 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         if (RB_WARN_ON(cpu_buffer, local_read(&cpu_buffer->committing)))
                 goto out;
 
-        __raw_spin_lock(&cpu_buffer->lock);
+        arch_spin_lock(&cpu_buffer->lock);
 
         rb_reset_cpu(cpu_buffer);
 
-        __raw_spin_unlock(&cpu_buffer->lock);
+        arch_spin_unlock(&cpu_buffer->lock);
 
  out:
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index d0a4c12d1f1c..0df1b0f2cb9e 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -12,7 +12,7 @@
  *  Copyright (C) 2004 William Lee Irwin III
  */
 #include <linux/ring_buffer.h>
-#include <linux/utsrelease.h>
+#include <generated/utsrelease.h>
 #include <linux/stacktrace.h>
 #include <linux/writeback.h>
 #include <linux/kallsyms.h>
@@ -86,17 +86,17 @@ static int dummy_set_flag(u32 old_flags, u32 bit, int set)
  */
 static int tracing_disabled = 1;
 
-DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
+DEFINE_PER_CPU(int, ftrace_cpu_disabled);
 
 static inline void ftrace_disable_cpu(void)
 {
         preempt_disable();
-        local_inc(&__get_cpu_var(ftrace_cpu_disabled));
+        __this_cpu_inc(per_cpu_var(ftrace_cpu_disabled));
 }
 
 static inline void ftrace_enable_cpu(void)
 {
-        local_dec(&__get_cpu_var(ftrace_cpu_disabled));
+        __this_cpu_dec(per_cpu_var(ftrace_cpu_disabled));
         preempt_enable();
 }
 
@@ -203,7 +203,7 @@ cycle_t ftrace_now(int cpu)
  */
 static struct trace_array       max_tr;
 
-static DEFINE_PER_CPU(struct trace_array_cpu, max_data);
+static DEFINE_PER_CPU(struct trace_array_cpu, max_tr_data);
 
 /* tracer_enabled is used to toggle activation of a tracer */
 static int                      tracer_enabled = 1;
@@ -492,15 +492,15 @@ static ssize_t trace_seq_to_buffer(struct trace_seq *s, void *buf, size_t cnt)
  * protected by per_cpu spinlocks. But the action of the swap
  * needs its own lock.
  *
- * This is defined as a raw_spinlock_t in order to help
+ * This is defined as a arch_spinlock_t in order to help
  * with performance when lockdep debugging is enabled.
  *
  * It is also used in other places outside the update_max_tr
  * so it needs to be defined outside of the
  * CONFIG_TRACER_MAX_TRACE.
  */
-static raw_spinlock_t ftrace_max_lock =
-        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+static arch_spinlock_t ftrace_max_lock =
+        (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 
 #ifdef CONFIG_TRACER_MAX_TRACE
 unsigned long __read_mostly     tracing_max_latency;
@@ -554,13 +554,13 @@ update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
                 return;
 
         WARN_ON_ONCE(!irqs_disabled());
-        __raw_spin_lock(&ftrace_max_lock);
+        arch_spin_lock(&ftrace_max_lock);
 
         tr->buffer = max_tr.buffer;
         max_tr.buffer = buf;
 
         __update_max_tr(tr, tsk, cpu);
-        __raw_spin_unlock(&ftrace_max_lock);
+        arch_spin_unlock(&ftrace_max_lock);
 }
 
 /**
@@ -580,7 +580,7 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
                 return;
 
         WARN_ON_ONCE(!irqs_disabled());
-        __raw_spin_lock(&ftrace_max_lock);
+        arch_spin_lock(&ftrace_max_lock);
 
         ftrace_disable_cpu();
 
@@ -602,7 +602,7 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
         WARN_ON_ONCE(ret && ret != -EAGAIN && ret != -EBUSY);
 
         __update_max_tr(tr, tsk, cpu);
-        __raw_spin_unlock(&ftrace_max_lock);
+        arch_spin_unlock(&ftrace_max_lock);
 }
 #endif /* CONFIG_TRACER_MAX_TRACE */
 
@@ -801,7 +801,7 @@ static unsigned map_pid_to_cmdline[PID_MAX_DEFAULT+1];
 static unsigned map_cmdline_to_pid[SAVED_CMDLINES];
 static char saved_cmdlines[SAVED_CMDLINES][TASK_COMM_LEN];
 static int cmdline_idx;
-static raw_spinlock_t trace_cmdline_lock = __RAW_SPIN_LOCK_UNLOCKED;
+static arch_spinlock_t trace_cmdline_lock = __ARCH_SPIN_LOCK_UNLOCKED;
 
 /* temporary disable recording */
 static atomic_t trace_record_cmdline_disabled __read_mostly;
@@ -914,7 +914,7 @@ static void trace_save_cmdline(struct task_struct *tsk)
          * nor do we want to disable interrupts,
          * so if we miss here, then better luck next time.
          */
-        if (!__raw_spin_trylock(&trace_cmdline_lock))
+        if (!arch_spin_trylock(&trace_cmdline_lock))
                 return;
 
         idx = map_pid_to_cmdline[tsk->pid];
@@ -939,7 +939,7 @@ static void trace_save_cmdline(struct task_struct *tsk)
 
         memcpy(&saved_cmdlines[idx], tsk->comm, TASK_COMM_LEN);
 
-        __raw_spin_unlock(&trace_cmdline_lock);
+        arch_spin_unlock(&trace_cmdline_lock);
 }
 
 void trace_find_cmdline(int pid, char comm[])
@@ -957,14 +957,14 @@ void trace_find_cmdline(int pid, char comm[])
         }
 
         preempt_disable();
-        __raw_spin_lock(&trace_cmdline_lock);
+        arch_spin_lock(&trace_cmdline_lock);
         map = map_pid_to_cmdline[pid];
         if (map != NO_CMDLINE_MAP)
                 strcpy(comm, saved_cmdlines[map]);
         else
                 strcpy(comm, "<...>");
 
-        __raw_spin_unlock(&trace_cmdline_lock);
+        arch_spin_unlock(&trace_cmdline_lock);
         preempt_enable();
 }
 
@@ -1084,7 +1084,7 @@ trace_function(struct trace_array *tr,
         struct ftrace_entry *entry;
 
         /* If we are reading the ring buffer, don't trace */
-        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+        if (unlikely(__this_cpu_read(per_cpu_var(ftrace_cpu_disabled))))
                 return;
 
         event = trace_buffer_lock_reserve(buffer, TRACE_FN, sizeof(*entry),
@@ -1266,8 +1266,8 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
  */
 int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
 {
-        static raw_spinlock_t trace_buf_lock =
-                (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        static arch_spinlock_t trace_buf_lock =
+                (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
         static u32 trace_buf[TRACE_BUF_SIZE];
 
         struct ftrace_event_call *call = &event_bprint;
@@ -1298,7 +1298,7 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
 
         /* Lockdep uses trace_printk for lock tracing */
         local_irq_save(flags);
-        __raw_spin_lock(&trace_buf_lock);
+        arch_spin_lock(&trace_buf_lock);
         len = vbin_printf(trace_buf, TRACE_BUF_SIZE, fmt, args);
 
         if (len > TRACE_BUF_SIZE || len < 0)
@@ -1319,7 +1319,7 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
                 ring_buffer_unlock_commit(buffer, event);
 
 out_unlock:
-        __raw_spin_unlock(&trace_buf_lock);
+        arch_spin_unlock(&trace_buf_lock);
         local_irq_restore(flags);
 
 out:
@@ -1349,7 +1349,7 @@ int trace_array_printk(struct trace_array *tr,
 int trace_array_vprintk(struct trace_array *tr,
                         unsigned long ip, const char *fmt, va_list args)
 {
-        static raw_spinlock_t trace_buf_lock = __RAW_SPIN_LOCK_UNLOCKED;
+        static arch_spinlock_t trace_buf_lock = __ARCH_SPIN_LOCK_UNLOCKED;
         static char trace_buf[TRACE_BUF_SIZE];
 
         struct ftrace_event_call *call = &event_print;
@@ -1375,7 +1375,7 @@ int trace_array_vprintk(struct trace_array *tr,
 
         pause_graph_tracing();
         raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&trace_buf_lock);
+        arch_spin_lock(&trace_buf_lock);
         len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
 
         size = sizeof(*entry) + len + 1;
@@ -1393,7 +1393,7 @@ int trace_array_vprintk(struct trace_array *tr,
                 ring_buffer_unlock_commit(buffer, event);
 
  out_unlock:
-        __raw_spin_unlock(&trace_buf_lock);
+        arch_spin_unlock(&trace_buf_lock);
         raw_local_irq_restore(irq_flags);
         unpause_graph_tracing();
  out:
@@ -2294,7 +2294,7 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
         mutex_lock(&tracing_cpumask_update_lock);
 
         local_irq_disable();
-        __raw_spin_lock(&ftrace_max_lock);
+        arch_spin_lock(&ftrace_max_lock);
         for_each_tracing_cpu(cpu) {
                 /*
                  * Increase/decrease the disabled counter if we are
@@ -2309,7 +2309,7 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                         atomic_dec(&global_trace.data[cpu]->disabled);
                 }
         }
-        __raw_spin_unlock(&ftrace_max_lock);
+        arch_spin_unlock(&ftrace_max_lock);
         local_irq_enable();
 
         cpumask_copy(tracing_cpumask, tracing_cpumask_new);
@@ -3122,7 +3122,7 @@ static void tracing_spd_release_pipe(struct splice_pipe_desc *spd,
         __free_page(spd->pages[idx]);
 }
 
-static struct pipe_buf_operations tracing_pipe_buf_ops = {
+static const struct pipe_buf_operations tracing_pipe_buf_ops = {
         .can_merge              = 0,
         .map                    = generic_pipe_buf_map,
         .unmap                  = generic_pipe_buf_unmap,
@@ -3612,7 +3612,7 @@ static void buffer_pipe_buf_get(struct pipe_inode_info *pipe,
 }
 
 /* Pipe buffer operations for a buffer. */
-static struct pipe_buf_operations buffer_pipe_buf_ops = {
+static const struct pipe_buf_operations buffer_pipe_buf_ops = {
         .can_merge              = 0,
         .map                    = generic_pipe_buf_map,
         .unmap                  = generic_pipe_buf_unmap,
@@ -4279,8 +4279,8 @@ trace_printk_seq(struct trace_seq *s)
 
 static void __ftrace_dump(bool disable_tracing)
 {
-        static raw_spinlock_t ftrace_dump_lock =
-                (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        static arch_spinlock_t ftrace_dump_lock =
+                (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
         /* use static because iter can be a bit big for the stack */
         static struct trace_iterator iter;
         unsigned int old_userobj;
@@ -4290,7 +4290,7 @@ static void __ftrace_dump(bool disable_tracing)
 
         /* only one dump */
         local_irq_save(flags);
-        __raw_spin_lock(&ftrace_dump_lock);
+        arch_spin_lock(&ftrace_dump_lock);
         if (dump_ran)
                 goto out;
 
@@ -4365,7 +4365,7 @@ static void __ftrace_dump(bool disable_tracing)
         }
 
  out:
-        __raw_spin_unlock(&ftrace_dump_lock);
+        arch_spin_unlock(&ftrace_dump_lock);
         local_irq_restore(flags);
 }
 
@@ -4426,7 +4426,7 @@ __init static int tracer_alloc_buffers(void)
         /* Allocate the first page for all buffers */
         for_each_tracing_cpu(i) {
                 global_trace.data[i] = &per_cpu(global_trace_cpu, i);
-                max_tr.data[i] = &per_cpu(max_data, i);
+                max_tr.data[i] = &per_cpu(max_tr_data, i);
         }
 
         trace_init_cmdlines();
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 1b18cb240c16..4df6a77eb196 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -443,7 +443,7 @@ extern int DYN_FTRACE_TEST_NAME(void);
 
 extern int ring_buffer_expanded;
 extern bool tracing_selftest_disabled;
-DECLARE_PER_CPU(local_t, ftrace_cpu_disabled);
+DECLARE_PER_CPU(int, ftrace_cpu_disabled);
 
 #ifdef CONFIG_FTRACE_STARTUP_TEST
 extern int trace_selftest_startup_function(struct tracer *trace,
diff --git a/kernel/trace/trace_clock.c b/kernel/trace/trace_clock.c
index 878c03f386ba..84a3a7ba072a 100644
--- a/kernel/trace/trace_clock.c
+++ b/kernel/trace/trace_clock.c
@@ -71,10 +71,10 @@ u64 notrace trace_clock(void)
 /* keep prev_time and lock in the same cacheline. */
 static struct {
         u64 prev_time;
-        raw_spinlock_t lock;
+        arch_spinlock_t lock;
 } trace_clock_struct ____cacheline_aligned_in_smp =
         {
-                .lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED,
+                .lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED,
         };
 
 u64 notrace trace_clock_global(void)
@@ -94,7 +94,7 @@ u64 notrace trace_clock_global(void)
         if (unlikely(in_nmi()))
                 goto out;
 
-        __raw_spin_lock(&trace_clock_struct.lock);
+        arch_spin_lock(&trace_clock_struct.lock);
 
         /*
          * TODO: if this happens often then maybe we should reset
@@ -106,7 +106,7 @@ u64 notrace trace_clock_global(void)
 
         trace_clock_struct.prev_time = now;
 
-        __raw_spin_unlock(&trace_clock_struct.lock);
+        arch_spin_unlock(&trace_clock_struct.lock);
 
  out:
         raw_local_irq_restore(flags);
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index a43d009c561a..b1342c5d37cf 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -187,7 +187,7 @@ static int __trace_graph_entry(struct trace_array *tr,
         struct ring_buffer *buffer = tr->buffer;
         struct ftrace_graph_ent_entry *entry;
 
-        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+        if (unlikely(__this_cpu_read(per_cpu_var(ftrace_cpu_disabled))))
                 return 0;
 
         event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_ENT,
@@ -251,7 +251,7 @@ static void __trace_graph_return(struct trace_array *tr,
         struct ring_buffer *buffer = tr->buffer;
         struct ftrace_graph_ret_entry *entry;
 
-        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+        if (unlikely(__this_cpu_read(per_cpu_var(ftrace_cpu_disabled))))
                 return;
 
         event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_RET,
diff --git a/kernel/trace/trace_hw_branches.c b/kernel/trace/trace_hw_branches.c
index 69543a905cd5..7b97000745f5 100644
--- a/kernel/trace/trace_hw_branches.c
+++ b/kernel/trace/trace_hw_branches.c
@@ -20,10 +20,10 @@
 
 #define BTS_BUFFER_SIZE (1 << 13)
 
-static DEFINE_PER_CPU(struct bts_tracer *, tracer);
-static DEFINE_PER_CPU(unsigned char[BTS_BUFFER_SIZE], buffer);
+static DEFINE_PER_CPU(struct bts_tracer *, hwb_tracer);
+static DEFINE_PER_CPU(unsigned char[BTS_BUFFER_SIZE], hwb_buffer);
 
-#define this_tracer per_cpu(tracer, smp_processor_id())
+#define this_tracer per_cpu(hwb_tracer, smp_processor_id())
 
 static int trace_hw_branches_enabled __read_mostly;
 static int trace_hw_branches_suspended __read_mostly;
@@ -32,12 +32,13 @@ static struct trace_array *hw_branch_trace __read_mostly;
 
 static void bts_trace_init_cpu(int cpu)
 {
-        per_cpu(tracer, cpu) =
-                ds_request_bts_cpu(cpu, per_cpu(buffer, cpu), BTS_BUFFER_SIZE,
-                                   NULL, (size_t)-1, BTS_KERNEL);
+        per_cpu(hwb_tracer, cpu) =
+                ds_request_bts_cpu(cpu, per_cpu(hwb_buffer, cpu),
+                                   BTS_BUFFER_SIZE, NULL, (size_t)-1,
+                                   BTS_KERNEL);
 
-        if (IS_ERR(per_cpu(tracer, cpu)))
-                per_cpu(tracer, cpu) = NULL;
+        if (IS_ERR(per_cpu(hwb_tracer, cpu)))
+                per_cpu(hwb_tracer, cpu) = NULL;
 }
 
 static int bts_trace_init(struct trace_array *tr)
@@ -51,7 +52,7 @@ static int bts_trace_init(struct trace_array *tr)
         for_each_online_cpu(cpu) {
                 bts_trace_init_cpu(cpu);
 
-                if (likely(per_cpu(tracer, cpu)))
+                if (likely(per_cpu(hwb_tracer, cpu)))
                         trace_hw_branches_enabled = 1;
         }
         trace_hw_branches_suspended = 0;
@@ -67,9 +68,9 @@ static void bts_trace_reset(struct trace_array *tr)
 
         get_online_cpus();
         for_each_online_cpu(cpu) {
-                if (likely(per_cpu(tracer, cpu))) {
-                        ds_release_bts(per_cpu(tracer, cpu));
-                        per_cpu(tracer, cpu) = NULL;
+                if (likely(per_cpu(hwb_tracer, cpu))) {
+                        ds_release_bts(per_cpu(hwb_tracer, cpu));
+                        per_cpu(hwb_tracer, cpu) = NULL;
                 }
         }
         trace_hw_branches_enabled = 0;
@@ -83,8 +84,8 @@ static void bts_trace_start(struct trace_array *tr)
 
         get_online_cpus();
         for_each_online_cpu(cpu)
-                if (likely(per_cpu(tracer, cpu)))
-                        ds_resume_bts(per_cpu(tracer, cpu));
+                if (likely(per_cpu(hwb_tracer, cpu)))
+                        ds_resume_bts(per_cpu(hwb_tracer, cpu));
         trace_hw_branches_suspended = 0;
         put_online_cpus();
 }
@@ -95,8 +96,8 @@ static void bts_trace_stop(struct trace_array *tr)
 
         get_online_cpus();
         for_each_online_cpu(cpu)
-                if (likely(per_cpu(tracer, cpu)))
-                        ds_suspend_bts(per_cpu(tracer, cpu));
+                if (likely(per_cpu(hwb_tracer, cpu)))
+                        ds_suspend_bts(per_cpu(hwb_tracer, cpu));
         trace_hw_branches_suspended = 1;
         put_online_cpus();
 }
@@ -114,16 +115,16 @@ static int __cpuinit bts_hotcpu_handler(struct notifier_block *nfb,
                         bts_trace_init_cpu(cpu);
 
                         if (trace_hw_branches_suspended &&
-                            likely(per_cpu(tracer, cpu)))
-                                ds_suspend_bts(per_cpu(tracer, cpu));
+                            likely(per_cpu(hwb_tracer, cpu)))
+                                ds_suspend_bts(per_cpu(hwb_tracer, cpu));
                 }
                 break;
 
         case CPU_DOWN_PREPARE:
                 /* The notification is sent with interrupts enabled. */
-                if (likely(per_cpu(tracer, cpu))) {
-                        ds_release_bts(per_cpu(tracer, cpu));
-                        per_cpu(tracer, cpu) = NULL;
+                if (likely(per_cpu(hwb_tracer, cpu))) {
+                        ds_release_bts(per_cpu(hwb_tracer, cpu));
+                        per_cpu(hwb_tracer, cpu) = NULL;
                 }
         }
 
@@ -258,8 +259,8 @@ static void trace_bts_prepare(struct trace_iterator *iter)
 
         get_online_cpus();
         for_each_online_cpu(cpu)
-                if (likely(per_cpu(tracer, cpu)))
-                        ds_suspend_bts(per_cpu(tracer, cpu));
+                if (likely(per_cpu(hwb_tracer, cpu)))
+                        ds_suspend_bts(per_cpu(hwb_tracer, cpu));
         /*
          * We need to collect the trace on the respective cpu since ftrace
          * implicitly adds the record for the current cpu.
@@ -268,8 +269,8 @@ static void trace_bts_prepare(struct trace_iterator *iter)
         on_each_cpu(trace_bts_cpu, iter->tr, 1);
 
         for_each_online_cpu(cpu)
-                if (likely(per_cpu(tracer, cpu)))
-                        ds_resume_bts(per_cpu(tracer, cpu));
+                if (likely(per_cpu(hwb_tracer, cpu)))
+                        ds_resume_bts(per_cpu(hwb_tracer, cpu));
         put_online_cpus();
 }
 
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 83f1e6ef7063..6ea90c0e2c96 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -282,6 +282,18 @@ static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
 static int kretprobe_dispatcher(struct kretprobe_instance *ri,
                                 struct pt_regs *regs);
 
+/* Check the name is good for event/group */
+static int check_event_name(const char *name)
+{
+        if (!isalpha(*name) && *name != '_')
+                return 0;
+        while (*++name != '\0') {
+                if (!isalpha(*name) && !isdigit(*name) && *name != '_')
+                        return 0;
+        }
+        return 1;
+}
+
 /*
  * Allocate new trace_probe and initialize it (including kprobes).
  */
@@ -293,10 +305,11 @@ static struct trace_probe *alloc_trace_probe(const char *group,
                                              int nargs, int is_return)
 {
         struct trace_probe *tp;
+        int ret = -ENOMEM;
 
         tp = kzalloc(SIZEOF_TRACE_PROBE(nargs), GFP_KERNEL);
         if (!tp)
-                return ERR_PTR(-ENOMEM);
+                return ERR_PTR(ret);
 
         if (symbol) {
                 tp->symbol = kstrdup(symbol, GFP_KERNEL);
@@ -312,14 +325,20 @@ static struct trace_probe *alloc_trace_probe(const char *group,
         else
                 tp->rp.kp.pre_handler = kprobe_dispatcher;
 
-        if (!event)
+        if (!event || !check_event_name(event)) {
+                ret = -EINVAL;
                 goto error;
+        }
+
         tp->call.name = kstrdup(event, GFP_KERNEL);
         if (!tp->call.name)
                 goto error;
 
-        if (!group)
+        if (!group || !check_event_name(group)) {
+                ret = -EINVAL;
                 goto error;
+        }
+
         tp->call.system = kstrdup(group, GFP_KERNEL);
         if (!tp->call.system)
                 goto error;
@@ -330,7 +349,7 @@ error:
         kfree(tp->call.name);
         kfree(tp->symbol);
         kfree(tp);
-        return ERR_PTR(-ENOMEM);
+        return ERR_PTR(ret);
 }
 
 static void free_probe_arg(struct probe_arg *arg)
@@ -695,10 +714,10 @@ static int create_trace_probe(int argc, char **argv)
         if (!event) {
                 /* Make a new event name */
                 if (symbol)
-                        snprintf(buf, MAX_EVENT_NAME_LEN, "%c@%s%+ld",
+                        snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld",
                                  is_return ? 'r' : 'p', symbol, offset);
                 else
-                        snprintf(buf, MAX_EVENT_NAME_LEN, "%c@0x%p",
+                        snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
                                  is_return ? 'r' : 'p', addr);
                 event = buf;
         }
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 26185d727676..0271742abb8d 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -28,8 +28,8 @@ static int			wakeup_current_cpu;
 static unsigned                 wakeup_prio = -1;
 static int                      wakeup_rt;
 
-static raw_spinlock_t wakeup_lock =
-        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+static arch_spinlock_t wakeup_lock =
+        (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 
 static void __wakeup_reset(struct trace_array *tr);
 
@@ -143,7 +143,7 @@ probe_wakeup_sched_switch(struct rq *rq, struct task_struct *prev,
                 goto out;
 
         local_irq_save(flags);
-        __raw_spin_lock(&wakeup_lock);
+        arch_spin_lock(&wakeup_lock);
 
         /* We could race with grabbing wakeup_lock */
         if (unlikely(!tracer_enabled || next != wakeup_task))
@@ -169,7 +169,7 @@ probe_wakeup_sched_switch(struct rq *rq, struct task_struct *prev,
 
 out_unlock:
         __wakeup_reset(wakeup_trace);
-        __raw_spin_unlock(&wakeup_lock);
+        arch_spin_unlock(&wakeup_lock);
         local_irq_restore(flags);
 out:
         atomic_dec(&wakeup_trace->data[cpu]->disabled);
@@ -193,9 +193,9 @@ static void wakeup_reset(struct trace_array *tr)
         tracing_reset_online_cpus(tr);
 
         local_irq_save(flags);
-        __raw_spin_lock(&wakeup_lock);
+        arch_spin_lock(&wakeup_lock);
         __wakeup_reset(tr);
-        __raw_spin_unlock(&wakeup_lock);
+        arch_spin_unlock(&wakeup_lock);
         local_irq_restore(flags);
 }
 
@@ -225,7 +225,7 @@ probe_wakeup(struct rq *rq, struct task_struct *p, int success)
                 goto out;
 
         /* interrupts should be off from try_to_wake_up */
-        __raw_spin_lock(&wakeup_lock);
+        arch_spin_lock(&wakeup_lock);
 
         /* check for races. */
         if (!tracer_enabled || p->prio >= wakeup_prio)
@@ -255,7 +255,7 @@ probe_wakeup(struct rq *rq, struct task_struct *p, int success)
         trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
 
 out_locked:
-        __raw_spin_unlock(&wakeup_lock);
+        arch_spin_unlock(&wakeup_lock);
 out:
         atomic_dec(&wakeup_trace->data[cpu]->disabled);
 }
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index dc98309e839a..280fea470d67 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -67,7 +67,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
 
         /* Don't allow flipping of max traces now */
         local_irq_save(flags);
-        __raw_spin_lock(&ftrace_max_lock);
+        arch_spin_lock(&ftrace_max_lock);
 
         cnt = ring_buffer_entries(tr->buffer);
 
@@ -85,7 +85,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
                         break;
         }
         tracing_on();
-        __raw_spin_unlock(&ftrace_max_lock);
+        arch_spin_unlock(&ftrace_max_lock);
         local_irq_restore(flags);
 
         if (count)
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 8504ac71e4e8..678a5120ee30 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -27,8 +27,8 @@ static struct stack_trace max_stack_trace = {
 };
 
 static unsigned long max_stack_size;
-static raw_spinlock_t max_stack_lock =
-        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+static arch_spinlock_t max_stack_lock =
+        (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 
 static int stack_trace_disabled __read_mostly;
 static DEFINE_PER_CPU(int, trace_active);
@@ -54,7 +54,7 @@ static inline void check_stack(void)
                 return;
 
         local_irq_save(flags);
-        __raw_spin_lock(&max_stack_lock);
+        arch_spin_lock(&max_stack_lock);
 
         /* a race could have already updated it */
         if (this_size <= max_stack_size)
@@ -103,7 +103,7 @@ static inline void check_stack(void)
         }
 
  out:
-        __raw_spin_unlock(&max_stack_lock);
+        arch_spin_unlock(&max_stack_lock);
         local_irq_restore(flags);
 }
 
@@ -171,9 +171,9 @@ stack_max_size_write(struct file *filp, const char __user *ubuf,
                 return ret;
 
         local_irq_save(flags);
-        __raw_spin_lock(&max_stack_lock);
+        arch_spin_lock(&max_stack_lock);
         *ptr = val;
-        __raw_spin_unlock(&max_stack_lock);
+        arch_spin_unlock(&max_stack_lock);
         local_irq_restore(flags);
 
         return count;
@@ -207,7 +207,7 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
         local_irq_disable();
-        __raw_spin_lock(&max_stack_lock);
+        arch_spin_lock(&max_stack_lock);
 
         if (*pos == 0)
                 return SEQ_START_TOKEN;
@@ -217,7 +217,7 @@ static void *t_start(struct seq_file *m, loff_t *pos)
 
 static void t_stop(struct seq_file *m, void *p)
 {
-        __raw_spin_unlock(&max_stack_lock);
+        arch_spin_unlock(&max_stack_lock);
         local_irq_enable();
 }
 
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index f6693969287d..a7974a552ca9 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -93,6 +93,7 @@ static const struct stacktrace_ops backtrace_ops = {
         .warning_symbol         = backtrace_warning_symbol,
         .stack                  = backtrace_stack,
         .address                = backtrace_address,
+        .walk_stack             = print_context_stack,
 };
 
 static int