Merge branch 'core-locking-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

* 'core-locking-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (27 commits)
  rtmutex: Add missing rcu_read_unlock() in debug_rt_mutex_print_deadlock()
  lockdep: Comment all warnings
  lib: atomic64: Change the type of local lock to raw_spinlock_t
  locking, lib/atomic64: Annotate atomic64_lock::lock as raw
  locking, x86, iommu: Annotate qi->q_lock as raw
  locking, x86, iommu: Annotate irq_2_ir_lock as raw
  locking, x86, iommu: Annotate iommu->register_lock as raw
  locking, dma, ipu: Annotate bank_lock as raw
  locking, ARM: Annotate low level hw locks as raw
  locking, drivers/dca: Annotate dca_lock as raw
  locking, powerpc: Annotate uic->lock as raw
  locking, x86: mce: Annotate cmci_discover_lock as raw
  locking, ACPI: Annotate c3_lock as raw
  locking, oprofile: Annotate oprofilefs lock as raw
  locking, video: Annotate vga console lock as raw
  locking, latencytop: Annotate latency_lock as raw
  locking, timer_stats: Annotate table_lock as raw
  locking, rwsem: Annotate inner lock as raw
  locking, semaphores: Annotate inner lock as raw
  locking, sched: Annotate thread_group_cputimer as raw
  ...

Fix up conflicts in kernel/posix-cpu-timers.c manually: making
cputimer->cputime a raw lock conflicted with the ABBA fix in commit
bcd5cff7216f ("cputimer: Cure lock inversion").

13 files changed, 279 insertions, 194 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 1d2b6ceea95d..453100a4159d 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -265,7 +265,7 @@ list_for_each_entry(_root, &roots, root_list)
 /* the list of cgroups eligible for automatic release. Protected by
  * release_list_lock */
 static LIST_HEAD(release_list);
-static DEFINE_SPINLOCK(release_list_lock);
+static DEFINE_RAW_SPINLOCK(release_list_lock);
 static void cgroup_release_agent(struct work_struct *work);
 static DECLARE_WORK(release_agent_work, cgroup_release_agent);
 static void check_for_release(struct cgroup *cgrp);
@@ -4014,11 +4014,11 @@ again:
         finish_wait(&cgroup_rmdir_waitq, &wait);
         clear_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags);
 
-        spin_lock(&release_list_lock);
+        raw_spin_lock(&release_list_lock);
         set_bit(CGRP_REMOVED, &cgrp->flags);
         if (!list_empty(&cgrp->release_list))
                 list_del_init(&cgrp->release_list);
-        spin_unlock(&release_list_lock);
+        raw_spin_unlock(&release_list_lock);
 
         cgroup_lock_hierarchy(cgrp->root);
         /* delete this cgroup from parent->children */
@@ -4671,13 +4671,13 @@ static void check_for_release(struct cgroup *cgrp)
                  * already queued for a userspace notification, queue
                  * it now */
                 int need_schedule_work = 0;
-                spin_lock(&release_list_lock);
+                raw_spin_lock(&release_list_lock);
                 if (!cgroup_is_removed(cgrp) &&
                     list_empty(&cgrp->release_list)) {
                         list_add(&cgrp->release_list, &release_list);
                         need_schedule_work = 1;
                 }
-                spin_unlock(&release_list_lock);
+                raw_spin_unlock(&release_list_lock);
                 if (need_schedule_work)
                         schedule_work(&release_agent_work);
         }
@@ -4729,7 +4729,7 @@ static void cgroup_release_agent(struct work_struct *work)
 {
         BUG_ON(work != &release_agent_work);
         mutex_lock(&cgroup_mutex);
-        spin_lock(&release_list_lock);
+        raw_spin_lock(&release_list_lock);
         while (!list_empty(&release_list)) {
                 char *argv[3], *envp[3];
                 int i;
@@ -4738,7 +4738,7 @@ static void cgroup_release_agent(struct work_struct *work)
                                                     struct cgroup,
                                                     release_list);
                 list_del_init(&cgrp->release_list);
-                spin_unlock(&release_list_lock);
+                raw_spin_unlock(&release_list_lock);
                 pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
                 if (!pathbuf)
                         goto continue_free;
@@ -4768,9 +4768,9 @@ static void cgroup_release_agent(struct work_struct *work)
  continue_free:
                 kfree(pathbuf);
                 kfree(agentbuf);
-                spin_lock(&release_list_lock);
+                raw_spin_lock(&release_list_lock);
         }
-        spin_unlock(&release_list_lock);
+        raw_spin_unlock(&release_list_lock);
         mutex_unlock(&cgroup_mutex);
 }
 
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index b30fd54eb985..2f193d0ba7f2 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -78,10 +78,10 @@ static bool kprobes_all_disarmed;
 static DEFINE_MUTEX(kprobe_mutex);
 static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
 static struct {
-        spinlock_t lock ____cacheline_aligned_in_smp;
+        raw_spinlock_t lock ____cacheline_aligned_in_smp;
 } kretprobe_table_locks[KPROBE_TABLE_SIZE];
 
-static spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
+static raw_spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
 {
         return &(kretprobe_table_locks[hash].lock);
 }
@@ -1013,9 +1013,9 @@ void __kprobes recycle_rp_inst(struct kretprobe_instance *ri,
         hlist_del(&ri->hlist);
         INIT_HLIST_NODE(&ri->hlist);
         if (likely(rp)) {
-                spin_lock(&rp->lock);
+                raw_spin_lock(&rp->lock);
                 hlist_add_head(&ri->hlist, &rp->free_instances);
-                spin_unlock(&rp->lock);
+                raw_spin_unlock(&rp->lock);
         } else
                 /* Unregistering */
                 hlist_add_head(&ri->hlist, head);
@@ -1026,19 +1026,19 @@ void __kprobes kretprobe_hash_lock(struct task_struct *tsk,
 __acquires(hlist_lock)
 {
         unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
-        spinlock_t *hlist_lock;
+        raw_spinlock_t *hlist_lock;
 
         *head = &kretprobe_inst_table[hash];
         hlist_lock = kretprobe_table_lock_ptr(hash);
-        spin_lock_irqsave(hlist_lock, *flags);
+        raw_spin_lock_irqsave(hlist_lock, *flags);
 }
 
 static void __kprobes kretprobe_table_lock(unsigned long hash,
         unsigned long *flags)
 __acquires(hlist_lock)
 {
-        spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
-        spin_lock_irqsave(hlist_lock, *flags);
+        raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
+        raw_spin_lock_irqsave(hlist_lock, *flags);
 }
 
 void __kprobes kretprobe_hash_unlock(struct task_struct *tsk,
@@ -1046,18 +1046,18 @@ void __kprobes kretprobe_hash_unlock(struct task_struct *tsk,
 __releases(hlist_lock)
 {
         unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
-        spinlock_t *hlist_lock;
+        raw_spinlock_t *hlist_lock;
 
         hlist_lock = kretprobe_table_lock_ptr(hash);
-        spin_unlock_irqrestore(hlist_lock, *flags);
+        raw_spin_unlock_irqrestore(hlist_lock, *flags);
 }
 
 static void __kprobes kretprobe_table_unlock(unsigned long hash,
        unsigned long *flags)
 __releases(hlist_lock)
 {
-        spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
-        spin_unlock_irqrestore(hlist_lock, *flags);
+        raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
+        raw_spin_unlock_irqrestore(hlist_lock, *flags);
 }
 
 /*
@@ -1663,12 +1663,12 @@ static int __kprobes pre_handler_kretprobe(struct kprobe *p,
 
         /*TODO: consider to only swap the RA after the last pre_handler fired */
         hash = hash_ptr(current, KPROBE_HASH_BITS);
-        spin_lock_irqsave(&rp->lock, flags);
+        raw_spin_lock_irqsave(&rp->lock, flags);
         if (!hlist_empty(&rp->free_instances)) {
                 ri = hlist_entry(rp->free_instances.first,
                                 struct kretprobe_instance, hlist);
                 hlist_del(&ri->hlist);
-                spin_unlock_irqrestore(&rp->lock, flags);
+                raw_spin_unlock_irqrestore(&rp->lock, flags);
 
                 ri->rp = rp;
                 ri->task = current;
@@ -1685,7 +1685,7 @@ static int __kprobes pre_handler_kretprobe(struct kprobe *p,
                 kretprobe_table_unlock(hash, &flags);
         } else {
                 rp->nmissed++;
-                spin_unlock_irqrestore(&rp->lock, flags);
+                raw_spin_unlock_irqrestore(&rp->lock, flags);
         }
         return 0;
 }
@@ -1721,7 +1721,7 @@ int __kprobes register_kretprobe(struct kretprobe *rp)
                 rp->maxactive = num_possible_cpus();
 #endif
         }
-        spin_lock_init(&rp->lock);
+        raw_spin_lock_init(&rp->lock);
         INIT_HLIST_HEAD(&rp->free_instances);
         for (i = 0; i < rp->maxactive; i++) {
                 inst = kmalloc(sizeof(struct kretprobe_instance) +
@@ -1959,7 +1959,7 @@ static int __init init_kprobes(void)
         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
                 INIT_HLIST_HEAD(&kprobe_table[i]);
                 INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
-                spin_lock_init(&(kretprobe_table_locks[i].lock));
+                raw_spin_lock_init(&(kretprobe_table_locks[i].lock));
         }
 
         /*
diff --git a/kernel/latencytop.c b/kernel/latencytop.c
index 376066e10413..4ac8ebfcab59 100644
--- a/kernel/latencytop.c
+++ b/kernel/latencytop.c
@@ -58,7 +58,7 @@
 #include <linux/list.h>
 #include <linux/stacktrace.h>
 
-static DEFINE_SPINLOCK(latency_lock);
+static DEFINE_RAW_SPINLOCK(latency_lock);
 
 #define MAXLR 128
 static struct latency_record latency_record[MAXLR];
@@ -72,19 +72,19 @@ void clear_all_latency_tracing(struct task_struct *p)
         if (!latencytop_enabled)
                 return;
 
-        spin_lock_irqsave(&latency_lock, flags);
+        raw_spin_lock_irqsave(&latency_lock, flags);
         memset(&p->latency_record, 0, sizeof(p->latency_record));
         p->latency_record_count = 0;
-        spin_unlock_irqrestore(&latency_lock, flags);
+        raw_spin_unlock_irqrestore(&latency_lock, flags);
 }
 
 static void clear_global_latency_tracing(void)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&latency_lock, flags);
+        raw_spin_lock_irqsave(&latency_lock, flags);
         memset(&latency_record, 0, sizeof(latency_record));
-        spin_unlock_irqrestore(&latency_lock, flags);
+        raw_spin_unlock_irqrestore(&latency_lock, flags);
 }
 
 static void __sched
@@ -190,7 +190,7 @@ __account_scheduler_latency(struct task_struct *tsk, int usecs, int inter)
         lat.max = usecs;
         store_stacktrace(tsk, &lat);
 
-        spin_lock_irqsave(&latency_lock, flags);
+        raw_spin_lock_irqsave(&latency_lock, flags);
 
         account_global_scheduler_latency(tsk, &lat);
 
@@ -231,7 +231,7 @@ __account_scheduler_latency(struct task_struct *tsk, int usecs, int inter)
         memcpy(&tsk->latency_record[i], &lat, sizeof(struct latency_record));
 
 out_unlock:
-        spin_unlock_irqrestore(&latency_lock, flags);
+        raw_spin_unlock_irqrestore(&latency_lock, flags);
 }
 
 static int lstats_show(struct seq_file *m, void *v)
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 91d67ce3a8d5..c081fa967c8f 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -96,8 +96,13 @@ static int graph_lock(void)
 
 static inline int graph_unlock(void)
 {
-        if (debug_locks && !arch_spin_is_locked(&lockdep_lock))
+        if (debug_locks && !arch_spin_is_locked(&lockdep_lock)) {
+                /*
+                 * The lockdep graph lock isn't locked while we expect it to
+                 * be, we're confused now, bye!
+                 */
                 return DEBUG_LOCKS_WARN_ON(1);
+        }
 
         current->lockdep_recursion--;
         arch_spin_unlock(&lockdep_lock);
@@ -134,6 +139,9 @@ static struct lock_class lock_classes[MAX_LOCKDEP_KEYS];
 static inline struct lock_class *hlock_class(struct held_lock *hlock)
 {
         if (!hlock->class_idx) {
+                /*
+                 * Someone passed in garbage, we give up.
+                 */
                 DEBUG_LOCKS_WARN_ON(1);
                 return NULL;
         }
@@ -687,6 +695,10 @@ look_up_lock_class(struct lockdep_map *lock, unsigned int subclass)
          */
         list_for_each_entry(class, hash_head, hash_entry) {
                 if (class->key == key) {
+                        /*
+                         * Huh! same key, different name? Did someone trample
+                         * on some memory? We're most confused.
+                         */
                         WARN_ON_ONCE(class->name != lock->name);
                         return class;
                 }
@@ -800,6 +812,10 @@ out_unlock_set:
         else if (subclass < NR_LOCKDEP_CACHING_CLASSES)
                 lock->class_cache[subclass] = class;
 
+        /*
+         * Hash collision, did we smoke some? We found a class with a matching
+         * hash but the subclass -- which is hashed in -- didn't match.
+         */
         if (DEBUG_LOCKS_WARN_ON(class->subclass != subclass))
                 return NULL;
 
@@ -926,7 +942,7 @@ static inline void mark_lock_accessed(struct lock_list *lock,
         unsigned long nr;
 
         nr = lock - list_entries;
-        WARN_ON(nr >= nr_list_entries);
+        WARN_ON(nr >= nr_list_entries); /* Out-of-bounds, input fail */
         lock->parent = parent;
         lock->class->dep_gen_id = lockdep_dependency_gen_id;
 }
@@ -936,7 +952,7 @@ static inline unsigned long lock_accessed(struct lock_list *lock)
         unsigned long nr;
 
         nr = lock - list_entries;
-        WARN_ON(nr >= nr_list_entries);
+        WARN_ON(nr >= nr_list_entries); /* Out-of-bounds, input fail */
         return lock->class->dep_gen_id == lockdep_dependency_gen_id;
 }
 
@@ -1196,6 +1212,9 @@ static noinline int print_bfs_bug(int ret)
         if (!debug_locks_off_graph_unlock())
                 return 0;
 
+        /*
+         * Breadth-first-search failed, graph got corrupted?
+         */
         WARN(1, "lockdep bfs error:%d\n", ret);
 
         return 0;
@@ -1944,6 +1963,11 @@ out_bug:
         if (!debug_locks_off_graph_unlock())
                 return 0;
 
+        /*
+         * Clearly we all shouldn't be here, but since we made it we
+         * can reliable say we messed up our state. See the above two
+         * gotos for reasons why we could possibly end up here.
+         */
         WARN_ON(1);
 
         return 0;
@@ -1975,6 +1999,11 @@ static inline int lookup_chain_cache(struct task_struct *curr,
         struct held_lock *hlock_curr, *hlock_next;
         int i, j;
 
+        /*
+         * We might need to take the graph lock, ensure we've got IRQs
+         * disabled to make this an IRQ-safe lock.. for recursion reasons
+         * lockdep won't complain about its own locking errors.
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return 0;
         /*
@@ -2126,6 +2155,10 @@ static void check_chain_key(struct task_struct *curr)
                 hlock = curr->held_locks + i;
                 if (chain_key != hlock->prev_chain_key) {
                         debug_locks_off();
+                        /*
+                         * We got mighty confused, our chain keys don't match
+                         * with what we expect, someone trample on our task state?
+                         */
                         WARN(1, "hm#1, depth: %u [%u], %016Lx != %016Lx\n",
                                 curr->lockdep_depth, i,
                                 (unsigned long long)chain_key,
@@ -2133,6 +2166,9 @@ static void check_chain_key(struct task_struct *curr)
                         return;
                 }
                 id = hlock->class_idx - 1;
+                /*
+                 * Whoops ran out of static storage again?
+                 */
                 if (DEBUG_LOCKS_WARN_ON(id >= MAX_LOCKDEP_KEYS))
                         return;
 
@@ -2144,6 +2180,10 @@ static void check_chain_key(struct task_struct *curr)
         }
         if (chain_key != curr->curr_chain_key) {
                 debug_locks_off();
+                /*
+                 * More smoking hash instead of calculating it, damn see these
+                 * numbers float.. I bet that a pink elephant stepped on my memory.
+                 */
                 WARN(1, "hm#2, depth: %u [%u], %016Lx != %016Lx\n",
                         curr->lockdep_depth, i,
                         (unsigned long long)chain_key,
@@ -2525,12 +2565,24 @@ void trace_hardirqs_on_caller(unsigned long ip)
                 return;
         }
 
+        /*
+         * We're enabling irqs and according to our state above irqs weren't
+         * already enabled, yet we find the hardware thinks they are in fact
+         * enabled.. someone messed up their IRQ state tracing.
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return;
 
+        /*
+         * See the fine text that goes along with this variable definition.
+         */
         if (DEBUG_LOCKS_WARN_ON(unlikely(early_boot_irqs_disabled)))
                 return;
 
+        /*
+         * Can't allow enabling interrupts while in an interrupt handler,
+         * that's general bad form and such. Recursion, limited stack etc..
+         */
         if (DEBUG_LOCKS_WARN_ON(current->hardirq_context))
                 return;
 
@@ -2558,6 +2610,10 @@ void trace_hardirqs_off_caller(unsigned long ip)
         if (unlikely(!debug_locks || current->lockdep_recursion))
                 return;
 
+        /*
+         * So we're supposed to get called after you mask local IRQs, but for
+         * some reason the hardware doesn't quite think you did a proper job.
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return;
 
@@ -2590,6 +2646,10 @@ void trace_softirqs_on(unsigned long ip)
         if (unlikely(!debug_locks || current->lockdep_recursion))
                 return;
 
+        /*
+         * We fancy IRQs being disabled here, see softirq.c, avoids
+         * funny state and nesting things.
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return;
 
@@ -2626,6 +2686,9 @@ void trace_softirqs_off(unsigned long ip)
         if (unlikely(!debug_locks || current->lockdep_recursion))
                 return;
 
+        /*
+         * We fancy IRQs being disabled here, see softirq.c
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return;
 
@@ -2637,6 +2700,9 @@ void trace_softirqs_off(unsigned long ip)
                 curr->softirq_disable_ip = ip;
                 curr->softirq_disable_event = ++curr->irq_events;
                 debug_atomic_inc(softirqs_off_events);
+                /*
+                 * Whoops, we wanted softirqs off, so why aren't they?
+                 */
                 DEBUG_LOCKS_WARN_ON(!softirq_count());
         } else
                 debug_atomic_inc(redundant_softirqs_off);
@@ -2661,6 +2727,9 @@ static void __lockdep_trace_alloc(gfp_t gfp_mask, unsigned long flags)
         if (!(gfp_mask & __GFP_FS))
                 return;
 
+        /*
+         * Oi! Can't be having __GFP_FS allocations with IRQs disabled.
+         */
         if (DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags)))
                 return;
 
@@ -2773,13 +2842,13 @@ static int separate_irq_context(struct task_struct *curr,
         return 0;
 }
 
-#else
+#else /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
 
 static inline
 int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
                 enum lock_usage_bit new_bit)
 {
-        WARN_ON(1);
+        WARN_ON(1); /* Impossible innit? when we don't have TRACE_IRQFLAG */
         return 1;
 }
 
@@ -2799,7 +2868,7 @@ void lockdep_trace_alloc(gfp_t gfp_mask)
 {
 }
 
-#endif
+#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
 
 /*
  * Mark a lock with a usage bit, and validate the state transition:
@@ -2880,6 +2949,9 @@ void lockdep_init_map(struct lockdep_map *lock, const char *name,
         lock->cpu = raw_smp_processor_id();
 #endif
 
+        /*
+         * Can't be having no nameless bastards around this place!
+         */
         if (DEBUG_LOCKS_WARN_ON(!name)) {
                 lock->name = "NULL";
                 return;
@@ -2887,6 +2959,9 @@ void lockdep_init_map(struct lockdep_map *lock, const char *name,
 
         lock->name = name;
 
+        /*
+         * No key, no joy, we need to hash something.
+         */
         if (DEBUG_LOCKS_WARN_ON(!key))
                 return;
         /*
@@ -2894,6 +2969,9 @@ void lockdep_init_map(struct lockdep_map *lock, const char *name,
          */
         if (!static_obj(key)) {
                 printk("BUG: key %p not in .data!\n", key);
+                /*
+                 * What it says above ^^^^^, I suggest you read it.
+                 */
                 DEBUG_LOCKS_WARN_ON(1);
                 return;
         }
@@ -2932,6 +3010,11 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
         if (unlikely(!debug_locks))
                 return 0;
 
+        /*
+         * Lockdep should run with IRQs disabled, otherwise we could
+         * get an interrupt which would want to take locks, which would
+         * end up in lockdep and have you got a head-ache already?
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return 0;
 
@@ -2963,6 +3046,9 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
          * dependency checks are done)
          */
         depth = curr->lockdep_depth;
+        /*
+         * Ran out of static storage for our per-task lock stack again have we?
+         */
         if (DEBUG_LOCKS_WARN_ON(depth >= MAX_LOCK_DEPTH))
                 return 0;
 
@@ -2981,6 +3067,10 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
         }
 
         hlock = curr->held_locks + depth;
+        /*
+         * Plain impossible, we just registered it and checked it weren't no
+         * NULL like.. I bet this mushroom I ate was good!
+         */
         if (DEBUG_LOCKS_WARN_ON(!class))
                 return 0;
         hlock->class_idx = class_idx;
@@ -3015,11 +3105,17 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
          * the hash, not class->key.
          */
         id = class - lock_classes;
+        /*
+         * Whoops, we did it again.. ran straight out of our static allocation.
+         */
         if (DEBUG_LOCKS_WARN_ON(id >= MAX_LOCKDEP_KEYS))
                 return 0;
 
         chain_key = curr->curr_chain_key;
         if (!depth) {
+                /*
+                 * How can we have a chain hash when we ain't got no keys?!
+                 */
                 if (DEBUG_LOCKS_WARN_ON(chain_key != 0))
                         return 0;
                 chain_head = 1;
@@ -3091,6 +3187,9 @@ static int check_unlock(struct task_struct *curr, struct lockdep_map *lock,
 {
         if (unlikely(!debug_locks))
                 return 0;
+        /*
+         * Lockdep should run with IRQs disabled, recursion, head-ache, etc..
+         */
         if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                 return 0;
 
@@ -3120,6 +3219,11 @@ static int match_held_lock(struct held_lock *hlock, struct lockdep_map *lock)
                 if (!class)
                         return 0;
 
+                /*
+                 * References, but not a lock we're actually ref-counting?
+                 * State got messed up, follow the sites that change ->references
+                 * and try to make sense of it.
+                 */
                 if (DEBUG_LOCKS_WARN_ON(!hlock->nest_lock))
                         return 0;
 
@@ -3142,6 +3246,10 @@ __lock_set_class(struct lockdep_map *lock, const char *name,
         int i;
 
         depth = curr->lockdep_depth;
+        /*
+         * This function is about (re)setting the class of a held lock,
+         * yet we're not actually holding any locks. Naughty user!
+         */
         if (DEBUG_LOCKS_WARN_ON(!depth))
                 return 0;
 
@@ -3177,6 +3285,10 @@ found_it:
                         return 0;
         }
 
+        /*
+         * I took it apart and put it back together again, except now I have
+         * these 'spare' parts.. where shall I put them.
+         */
         if (DEBUG_LOCKS_WARN_ON(curr->lockdep_depth != depth))
                 return 0;
         return 1;
@@ -3201,6 +3313,10 @@ lock_release_non_nested(struct task_struct *curr,
          * of held locks:
          */
         depth = curr->lockdep_depth;
+        /*
+         * So we're all set to release this lock.. wait what lock? We don't
+         * own any locks, you've been drinking again?
+         */
         if (DEBUG_LOCKS_WARN_ON(!depth))
                 return 0;
 
@@ -3253,6 +3369,10 @@ found_it:
                         return 0;
         }
 
+        /*
+         * We had N bottles of beer on the wall, we drank one, but now
+         * there's not N-1 bottles of beer left on the wall...
+         */
         if (DEBUG_LOCKS_WARN_ON(curr->lockdep_depth != depth - 1))
                 return 0;
         return 1;
@@ -3283,6 +3403,9 @@ static int lock_release_nested(struct task_struct *curr,
                 return lock_release_non_nested(curr, lock, ip);
         curr->lockdep_depth--;
 
+        /*
+         * No more locks, but somehow we've got hash left over, who left it?
+         */
         if (DEBUG_LOCKS_WARN_ON(!depth && (hlock->prev_chain_key != 0)))
                 return 0;
 
@@ -3365,10 +3488,13 @@ static void check_flags(unsigned long flags)
          * check if not in hardirq contexts:
          */
         if (!hardirq_count()) {
-                if (softirq_count())
+                if (softirq_count()) {
+                        /* like the above, but with softirqs */
                         DEBUG_LOCKS_WARN_ON(current->softirqs_enabled);
-                else
+                } else {
+                        /* lick the above, does it taste good? */
                         DEBUG_LOCKS_WARN_ON(!current->softirqs_enabled);
+                }
         }
 
         if (!debug_locks)
@@ -3506,6 +3632,10 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
         int i, contention_point, contending_point;
 
         depth = curr->lockdep_depth;
+        /*
+         * Whee, we contended on this lock, except it seems we're not
+         * actually trying to acquire anything much at all..
+         */
         if (DEBUG_LOCKS_WARN_ON(!depth))
                 return;
 
@@ -3555,6 +3685,10 @@ __lock_acquired(struct lockdep_map *lock, unsigned long ip)
         int i, cpu;
 
         depth = curr->lockdep_depth;
+        /*
+         * Yay, we acquired ownership of this lock we didn't try to
+         * acquire, how the heck did that happen?
+         */
         if (DEBUG_LOCKS_WARN_ON(!depth))
                 return;
 
@@ -3759,8 +3893,12 @@ void lockdep_reset_lock(struct lockdep_map *lock)
                                 match |= class == lock->class_cache[j];
 
                         if (unlikely(match)) {
-                                if (debug_locks_off_graph_unlock())
+                                if (debug_locks_off_graph_unlock()) {
+                                        /*
+                                         * We all just reset everything, how did it match?
+                                         */
                                         WARN_ON(1);
+                                }
                                 goto out_restore;
                         }
                 }
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 640ded8f5c48..e7cb76dc18f5 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -282,13 +282,13 @@ void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times)
                  * it.
                  */
                 thread_group_cputime(tsk, &sum);
-                spin_lock_irqsave(&cputimer->lock, flags);
+                raw_spin_lock_irqsave(&cputimer->lock, flags);
                 cputimer->running = 1;
                 update_gt_cputime(&cputimer->cputime, &sum);
         } else
-                spin_lock_irqsave(&cputimer->lock, flags);
+                raw_spin_lock_irqsave(&cputimer->lock, flags);
         *times = cputimer->cputime;
-        spin_unlock_irqrestore(&cputimer->lock, flags);
+        raw_spin_unlock_irqrestore(&cputimer->lock, flags);
 }
 
 /*
@@ -999,9 +999,9 @@ static void stop_process_timers(struct signal_struct *sig)
         struct thread_group_cputimer *cputimer = &sig->cputimer;
         unsigned long flags;
 
-        spin_lock_irqsave(&cputimer->lock, flags);
+        raw_spin_lock_irqsave(&cputimer->lock, flags);
         cputimer->running = 0;
-        spin_unlock_irqrestore(&cputimer->lock, flags);
+        raw_spin_unlock_irqrestore(&cputimer->lock, flags);
 }
 
 static u32 onecputick;
@@ -1291,9 +1291,9 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
         if (sig->cputimer.running) {
                 struct task_cputime group_sample;
 
-                spin_lock(&sig->cputimer.lock);
+                raw_spin_lock(&sig->cputimer.lock);
                 group_sample = sig->cputimer.cputime;
-                spin_unlock(&sig->cputimer.lock);
+                raw_spin_unlock(&sig->cputimer.lock);
 
                 if (task_cputime_expired(&group_sample, &sig->cputime_expires))
                         return 1;
diff --git a/kernel/printk.c b/kernel/printk.c
index 28a40d8171b8..b7da18391c38 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -100,7 +100,7 @@ static int console_locked, console_suspended;
  * It is also used in interesting ways to provide interlocking in
  * console_unlock();.
  */
-static DEFINE_SPINLOCK(logbuf_lock);
+static DEFINE_RAW_SPINLOCK(logbuf_lock);
 
 #define LOG_BUF_MASK (log_buf_len-1)
 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
@@ -212,7 +212,7 @@ void __init setup_log_buf(int early)
                 return;
         }
 
-        spin_lock_irqsave(&logbuf_lock, flags);
+        raw_spin_lock_irqsave(&logbuf_lock, flags);
         log_buf_len = new_log_buf_len;
         log_buf = new_log_buf;
         new_log_buf_len = 0;
@@ -230,7 +230,7 @@ void __init setup_log_buf(int early)
         log_start -= offset;
         con_start -= offset;
         log_end -= offset;
-        spin_unlock_irqrestore(&logbuf_lock, flags);
+        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 
         pr_info("log_buf_len: %d\n", log_buf_len);
         pr_info("early log buf free: %d(%d%%)\n",
@@ -365,18 +365,18 @@ int do_syslog(int type, char __user *buf, int len, bool from_file)
                 if (error)
                         goto out;
                 i = 0;
-                spin_lock_irq(&logbuf_lock);
+                raw_spin_lock_irq(&logbuf_lock);
                 while (!error && (log_start != log_end) && i < len) {
                         c = LOG_BUF(log_start);
                         log_start++;
-                        spin_unlock_irq(&logbuf_lock);
+                        raw_spin_unlock_irq(&logbuf_lock);
                         error = __put_user(c,buf);
                         buf++;
                         i++;
                         cond_resched();
-                        spin_lock_irq(&logbuf_lock);
+                        raw_spin_lock_irq(&logbuf_lock);
                 }
-                spin_unlock_irq(&logbuf_lock);
+                raw_spin_unlock_irq(&logbuf_lock);
                 if (!error)
                         error = i;
                 break;
@@ -399,7 +399,7 @@ int do_syslog(int type, char __user *buf, int len, bool from_file)
                 count = len;
                 if (count > log_buf_len)
                         count = log_buf_len;
-                spin_lock_irq(&logbuf_lock);
+                raw_spin_lock_irq(&logbuf_lock);
                 if (count > logged_chars)
                         count = logged_chars;
                 if (do_clear)
@@ -416,12 +416,12 @@ int do_syslog(int type, char __user *buf, int len, bool from_file)
                         if (j + log_buf_len < log_end)
                                 break;
                         c = LOG_BUF(j);
-                        spin_unlock_irq(&logbuf_lock);
+                        raw_spin_unlock_irq(&logbuf_lock);
                         error = __put_user(c,&buf[count-1-i]);
                         cond_resched();
-                        spin_lock_irq(&logbuf_lock);
+                        raw_spin_lock_irq(&logbuf_lock);
                 }
-                spin_unlock_irq(&logbuf_lock);
+                raw_spin_unlock_irq(&logbuf_lock);
                 if (error)
                         break;
                 error = i;
@@ -689,7 +689,7 @@ static void zap_locks(void)
         oops_timestamp = jiffies;
 
         /* If a crash is occurring, make sure we can't deadlock */
-        spin_lock_init(&logbuf_lock);
+        raw_spin_lock_init(&logbuf_lock);
         /* And make sure that we print immediately */
         sema_init(&console_sem, 1);
 }
@@ -802,9 +802,9 @@ static int console_trylock_for_printk(unsigned int cpu)
                 }
         }
         printk_cpu = UINT_MAX;
-        spin_unlock(&logbuf_lock);
         if (wake)
                 up(&console_sem);
+        raw_spin_unlock(&logbuf_lock);
         return retval;
 }
 static const char recursion_bug_msg [] =
@@ -864,7 +864,7 @@ asmlinkage int vprintk(const char *fmt, va_list args)
         }
 
         lockdep_off();
-        spin_lock(&logbuf_lock);
+        raw_spin_lock(&logbuf_lock);
         printk_cpu = this_cpu;
 
         if (recursion_bug) {
@@ -1257,14 +1257,14 @@ void console_unlock(void)
 
 again:
         for ( ; ; ) {
-                spin_lock_irqsave(&logbuf_lock, flags);
+                raw_spin_lock_irqsave(&logbuf_lock, flags);
                 wake_klogd |= log_start - log_end;
                 if (con_start == log_end)
                         break;                  /* Nothing to print */
                 _con_start = con_start;
                 _log_end = log_end;
                 con_start = log_end;            /* Flush */
-                spin_unlock(&logbuf_lock);
+                raw_spin_unlock(&logbuf_lock);
                 stop_critical_timings();        /* don't trace print latency */
                 call_console_drivers(_con_start, _log_end);
                 start_critical_timings();
@@ -1276,7 +1276,7 @@ again:
         if (unlikely(exclusive_console))
                 exclusive_console = NULL;
 
-        spin_unlock(&logbuf_lock);
+        raw_spin_unlock(&logbuf_lock);
 
         up(&console_sem);
 
@@ -1286,13 +1286,13 @@ again:
          * there's a new owner and the console_unlock() from them will do the
          * flush, no worries.
          */
-        spin_lock(&logbuf_lock);
+        raw_spin_lock(&logbuf_lock);
         if (con_start != log_end)
                 retry = 1;
-        spin_unlock_irqrestore(&logbuf_lock, flags);
         if (retry && console_trylock())
                 goto again;
 
+        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
         if (wake_klogd)
                 wake_up_klogd();
 }
@@ -1522,9 +1522,9 @@ void register_console(struct console *newcon)
                  * console_unlock(); will print out the buffered messages
                  * for us.
                  */
-                spin_lock_irqsave(&logbuf_lock, flags);
+                raw_spin_lock_irqsave(&logbuf_lock, flags);
                 con_start = log_start;
-                spin_unlock_irqrestore(&logbuf_lock, flags);
+                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
                 /*
                  * We're about to replay the log buffer.  Only do this to the
                  * just-registered console to avoid excessive message spam to
@@ -1731,10 +1731,10 @@ void kmsg_dump(enum kmsg_dump_reason reason)
         /* Theoretically, the log could move on after we do this, but
            there's not a lot we can do about that. The new messages
            will overwrite the start of what we dump. */
-        spin_lock_irqsave(&logbuf_lock, flags);
+        raw_spin_lock_irqsave(&logbuf_lock, flags);
         end = log_end & LOG_BUF_MASK;
         chars = logged_chars;
-        spin_unlock_irqrestore(&logbuf_lock, flags);
+        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 
         if (chars > end) {
                 s1 = log_buf + log_buf_len - chars + end;
diff --git a/kernel/rtmutex-debug.c b/kernel/rtmutex-debug.c
index 3c7cbc2c33be..a2e7e7210f3e 100644
--- a/kernel/rtmutex-debug.c
+++ b/kernel/rtmutex-debug.c
@@ -29,61 +29,6 @@
 
 #include "rtmutex_common.h"
 
-# define TRACE_WARN_ON(x)                       WARN_ON(x)
-# define TRACE_BUG_ON(x)                        BUG_ON(x)
-
-# define TRACE_OFF()                                            \
-do {                                                            \
-        if (rt_trace_on) {                                      \
-                rt_trace_on = 0;                                \
-                console_verbose();                              \
-                if (raw_spin_is_locked(&current->pi_lock))      \
-                        raw_spin_unlock(&current->pi_lock);     \
-        }                                                       \
-} while (0)
-
-# define TRACE_OFF_NOLOCK()                                     \
-do {                                                            \
-        if (rt_trace_on) {                                      \
-                rt_trace_on = 0;                                \
-                console_verbose();                              \
-        }                                                       \
-} while (0)
-
-# define TRACE_BUG_LOCKED()                     \
-do {                                            \
-        TRACE_OFF();                            \
-        BUG();                                  \
-} while (0)
-
-# define TRACE_WARN_ON_LOCKED(c)                \
-do {                                            \
-        if (unlikely(c)) {                      \
-                TRACE_OFF();                    \
-                WARN_ON(1);                     \
-        }                                       \
-} while (0)
-
-# define TRACE_BUG_ON_LOCKED(c)                 \
-do {                                            \
-        if (unlikely(c))                        \
-                TRACE_BUG_LOCKED();             \
-} while (0)
-
-#ifdef CONFIG_SMP
-# define SMP_TRACE_BUG_ON_LOCKED(c)     TRACE_BUG_ON_LOCKED(c)
-#else
-# define SMP_TRACE_BUG_ON_LOCKED(c)     do { } while (0)
-#endif
-
-/*
- * deadlock detection flag. We turn it off when we detect
- * the first problem because we dont want to recurse back
- * into the tracing code when doing error printk or
- * executing a BUG():
- */
-static int rt_trace_on = 1;
-
 static void printk_task(struct task_struct *p)
 {
         if (p)
@@ -111,8 +56,8 @@ static void printk_lock(struct rt_mutex *lock, int print_owner)
 
 void rt_mutex_debug_task_free(struct task_struct *task)
 {
-        WARN_ON(!plist_head_empty(&task->pi_waiters));
-        WARN_ON(task->pi_blocked_on);
+        DEBUG_LOCKS_WARN_ON(!plist_head_empty(&task->pi_waiters));
+        DEBUG_LOCKS_WARN_ON(task->pi_blocked_on);
 }
 
 /*
@@ -125,7 +70,7 @@ void debug_rt_mutex_deadlock(int detect, struct rt_mutex_waiter *act_waiter,
 {
         struct task_struct *task;
 
-        if (!rt_trace_on || detect || !act_waiter)
+        if (!debug_locks || detect || !act_waiter)
                 return;
 
         task = rt_mutex_owner(act_waiter->lock);
@@ -139,7 +84,7 @@ void debug_rt_mutex_print_deadlock(struct rt_mutex_waiter *waiter)
 {
         struct task_struct *task;
 
-        if (!waiter->deadlock_lock || !rt_trace_on)
+        if (!waiter->deadlock_lock || !debug_locks)
                 return;
 
         rcu_read_lock();
@@ -149,7 +94,10 @@ void debug_rt_mutex_print_deadlock(struct rt_mutex_waiter *waiter)
                 return;
         }
 
-        TRACE_OFF_NOLOCK();
+        if (!debug_locks_off()) {
+                rcu_read_unlock();
+                return;
+        }
 
         printk("\n============================================\n");
         printk(  "[ BUG: circular locking deadlock detected! ]\n");
@@ -180,7 +128,6 @@ void debug_rt_mutex_print_deadlock(struct rt_mutex_waiter *waiter)
 
         printk("[ turning off deadlock detection."
                "Please report this trace. ]\n\n");
-        local_irq_disable();
 }
 
 void debug_rt_mutex_lock(struct rt_mutex *lock)
@@ -189,7 +136,7 @@ void debug_rt_mutex_lock(struct rt_mutex *lock)
 
 void debug_rt_mutex_unlock(struct rt_mutex *lock)
 {
-        TRACE_WARN_ON_LOCKED(rt_mutex_owner(lock) != current);
+        DEBUG_LOCKS_WARN_ON(rt_mutex_owner(lock) != current);
 }
 
 void
@@ -199,7 +146,7 @@ debug_rt_mutex_proxy_lock(struct rt_mutex *lock, struct task_struct *powner)
 
 void debug_rt_mutex_proxy_unlock(struct rt_mutex *lock)
 {
-        TRACE_WARN_ON_LOCKED(!rt_mutex_owner(lock));
+        DEBUG_LOCKS_WARN_ON(!rt_mutex_owner(lock));
 }
 
 void debug_rt_mutex_init_waiter(struct rt_mutex_waiter *waiter)
@@ -213,8 +160,8 @@ void debug_rt_mutex_init_waiter(struct rt_mutex_waiter *waiter)
 void debug_rt_mutex_free_waiter(struct rt_mutex_waiter *waiter)
 {
         put_pid(waiter->deadlock_task_pid);
-        TRACE_WARN_ON(!plist_node_empty(&waiter->list_entry));
-        TRACE_WARN_ON(!plist_node_empty(&waiter->pi_list_entry));
+        DEBUG_LOCKS_WARN_ON(!plist_node_empty(&waiter->list_entry));
+        DEBUG_LOCKS_WARN_ON(!plist_node_empty(&waiter->pi_list_entry));
         memset(waiter, 0x22, sizeof(*waiter));
 }
 
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index 331e01bcd026..87f9e36ea56e 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -282,10 +282,10 @@ static inline void account_group_user_time(struct task_struct *tsk,
         if (!cputimer->running)
                 return;
 
-        spin_lock(&cputimer->lock);
+        raw_spin_lock(&cputimer->lock);
         cputimer->cputime.utime =
                 cputime_add(cputimer->cputime.utime, cputime);
-        spin_unlock(&cputimer->lock);
+        raw_spin_unlock(&cputimer->lock);
 }
 
 /**
@@ -306,10 +306,10 @@ static inline void account_group_system_time(struct task_struct *tsk,
         if (!cputimer->running)
                 return;
 
-        spin_lock(&cputimer->lock);
+        raw_spin_lock(&cputimer->lock);
         cputimer->cputime.stime =
                 cputime_add(cputimer->cputime.stime, cputime);
-        spin_unlock(&cputimer->lock);
+        raw_spin_unlock(&cputimer->lock);
 }
 
 /**
@@ -330,7 +330,7 @@ static inline void account_group_exec_runtime(struct task_struct *tsk,
         if (!cputimer->running)
                 return;
 
-        spin_lock(&cputimer->lock);
+        raw_spin_lock(&cputimer->lock);
         cputimer->cputime.sum_exec_runtime += ns;
-        spin_unlock(&cputimer->lock);
+        raw_spin_unlock(&cputimer->lock);
 }
diff --git a/kernel/semaphore.c b/kernel/semaphore.c
index 94a62c0d4ade..d831841e55a7 100644
--- a/kernel/semaphore.c
+++ b/kernel/semaphore.c
@@ -54,12 +54,12 @@ void down(struct semaphore *sem)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
                 sem->count--;
         else
                 __down(sem);
-        spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->lock, flags);
 }
 EXPORT_SYMBOL(down);
 
@@ -77,12 +77,12 @@ int down_interruptible(struct semaphore *sem)
         unsigned long flags;
         int result = 0;
 
-        spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
                 sem->count--;
         else
                 result = __down_interruptible(sem);
-        spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->lock, flags);
 
         return result;
 }
@@ -103,12 +103,12 @@ int down_killable(struct semaphore *sem)
         unsigned long flags;
         int result = 0;
 
-        spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
                 sem->count--;
         else
                 result = __down_killable(sem);
-        spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->lock, flags);
 
         return result;
 }
@@ -132,11 +132,11 @@ int down_trylock(struct semaphore *sem)
         unsigned long flags;
         int count;
 
-        spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->lock, flags);
         count = sem->count - 1;
         if (likely(count >= 0))
                 sem->count = count;
-        spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->lock, flags);
 
         return (count < 0);
 }
@@ -157,12 +157,12 @@ int down_timeout(struct semaphore *sem, long jiffies)
         unsigned long flags;
         int result = 0;
 
-        spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
                 sem->count--;
         else
                 result = __down_timeout(sem, jiffies);
-        spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->lock, flags);
 
         return result;
 }
@@ -179,12 +179,12 @@ void up(struct semaphore *sem)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(list_empty(&sem->wait_list)))
                 sem->count++;
         else
                 __up(sem);
-        spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->lock, flags);
 }
 EXPORT_SYMBOL(up);
 
@@ -217,9 +217,9 @@ static inline int __sched __down_common(struct semaphore *sem, long state,
                 if (timeout <= 0)
                         goto timed_out;
                 __set_task_state(task, state);
-                spin_unlock_irq(&sem->lock);
+                raw_spin_unlock_irq(&sem->lock);
                 timeout = schedule_timeout(timeout);
-                spin_lock_irq(&sem->lock);
+                raw_spin_lock_irq(&sem->lock);
                 if (waiter.up)
                         return 0;
         }
diff --git a/kernel/time/timer_stats.c b/kernel/time/timer_stats.c
index a5d0a3a85dd8..0b537f27b559 100644
--- a/kernel/time/timer_stats.c
+++ b/kernel/time/timer_stats.c
@@ -81,7 +81,7 @@ struct entry {
 /*
  * Spinlock protecting the tables - not taken during lookup:
  */
-static DEFINE_SPINLOCK(table_lock);
+static DEFINE_RAW_SPINLOCK(table_lock);
 
 /*
  * Per-CPU lookup locks for fast hash lookup:
@@ -188,7 +188,7 @@ static struct entry *tstat_lookup(struct entry *entry, char *comm)
         prev = NULL;
         curr = *head;
 
-        spin_lock(&table_lock);
+        raw_spin_lock(&table_lock);
         /*
          * Make sure we have not raced with another CPU:
          */
@@ -215,7 +215,7 @@ static struct entry *tstat_lookup(struct entry *entry, char *comm)
                         *head = curr;
         }
  out_unlock:
-        spin_unlock(&table_lock);
+        raw_spin_unlock(&table_lock);
 
         return curr;
 }
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 731201bf4acc..f2f821acc597 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -478,7 +478,7 @@ struct ring_buffer_per_cpu {
         int                             cpu;
         atomic_t                        record_disabled;
         struct ring_buffer              *buffer;
-        spinlock_t                      reader_lock;    /* serialize readers */
+        raw_spinlock_t                  reader_lock;    /* serialize readers */
         arch_spinlock_t                 lock;
         struct lock_class_key           lock_key;
         struct list_head                *pages;
@@ -1062,7 +1062,7 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 
         cpu_buffer->cpu = cpu;
         cpu_buffer->buffer = buffer;
-        spin_lock_init(&cpu_buffer->reader_lock);
+        raw_spin_lock_init(&cpu_buffer->reader_lock);
         lockdep_set_class(&cpu_buffer->reader_lock, buffer->reader_lock_key);
         cpu_buffer->lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 
@@ -1259,7 +1259,7 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
         struct list_head *p;
         unsigned i;
 
-        spin_lock_irq(&cpu_buffer->reader_lock);
+        raw_spin_lock_irq(&cpu_buffer->reader_lock);
         rb_head_page_deactivate(cpu_buffer);
 
         for (i = 0; i < nr_pages; i++) {
@@ -1277,7 +1277,7 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
         rb_check_pages(cpu_buffer);
 
 out:
-        spin_unlock_irq(&cpu_buffer->reader_lock);
+        raw_spin_unlock_irq(&cpu_buffer->reader_lock);
 }
 
 static void
@@ -1288,7 +1288,7 @@ rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
         struct list_head *p;
         unsigned i;
 
-        spin_lock_irq(&cpu_buffer->reader_lock);
+        raw_spin_lock_irq(&cpu_buffer->reader_lock);
         rb_head_page_deactivate(cpu_buffer);
 
         for (i = 0; i < nr_pages; i++) {
@@ -1303,7 +1303,7 @@ rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
         rb_check_pages(cpu_buffer);
 
 out:
-        spin_unlock_irq(&cpu_buffer->reader_lock);
+        raw_spin_unlock_irq(&cpu_buffer->reader_lock);
 }
 
 /**
@@ -2804,9 +2804,9 @@ void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
 
         cpu_buffer = iter->cpu_buffer;
 
-        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         rb_iter_reset(iter);
-        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_iter_reset);
 
@@ -3265,12 +3265,12 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts,
  again:
         local_irq_save(flags);
         if (dolock)
-                spin_lock(&cpu_buffer->reader_lock);
+                raw_spin_lock(&cpu_buffer->reader_lock);
         event = rb_buffer_peek(cpu_buffer, ts, lost_events);
         if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 rb_advance_reader(cpu_buffer);
         if (dolock)
-                spin_unlock(&cpu_buffer->reader_lock);
+                raw_spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
         if (event && event->type_len == RINGBUF_TYPE_PADDING)
@@ -3295,9 +3295,9 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         unsigned long flags;
 
  again:
-        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         event = rb_iter_peek(iter, ts);
-        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 goto again;
@@ -3337,7 +3337,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts,
         cpu_buffer = buffer->buffers[cpu];
         local_irq_save(flags);
         if (dolock)
-                spin_lock(&cpu_buffer->reader_lock);
+                raw_spin_lock(&cpu_buffer->reader_lock);
 
         event = rb_buffer_peek(cpu_buffer, ts, lost_events);
         if (event) {
@@ -3346,7 +3346,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts,
         }
 
         if (dolock)
-                spin_unlock(&cpu_buffer->reader_lock);
+                raw_spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
  out:
@@ -3438,11 +3438,11 @@ ring_buffer_read_start(struct ring_buffer_iter *iter)
 
         cpu_buffer = iter->cpu_buffer;
 
-        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         arch_spin_lock(&cpu_buffer->lock);
         rb_iter_reset(iter);
         arch_spin_unlock(&cpu_buffer->lock);
-        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_read_start);
 
@@ -3477,7 +3477,7 @@ ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
         unsigned long flags;
 
-        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
  again:
         event = rb_iter_peek(iter, ts);
         if (!event)
@@ -3488,7 +3488,7 @@ ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
 
         rb_advance_iter(iter);
  out:
-        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return event;
 }
@@ -3557,7 +3557,7 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
 
         atomic_inc(&cpu_buffer->record_disabled);
 
-        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
         if (RB_WARN_ON(cpu_buffer, local_read(&cpu_buffer->committing)))
                 goto out;
@@ -3569,7 +3569,7 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         arch_spin_unlock(&cpu_buffer->lock);
 
  out:
-        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         atomic_dec(&cpu_buffer->record_disabled);
 }
@@ -3607,10 +3607,10 @@ int ring_buffer_empty(struct ring_buffer *buffer)
                 cpu_buffer = buffer->buffers[cpu];
                 local_irq_save(flags);
                 if (dolock)
-                        spin_lock(&cpu_buffer->reader_lock);
+                        raw_spin_lock(&cpu_buffer->reader_lock);
                 ret = rb_per_cpu_empty(cpu_buffer);
                 if (dolock)
-                        spin_unlock(&cpu_buffer->reader_lock);
+                        raw_spin_unlock(&cpu_buffer->reader_lock);
                 local_irq_restore(flags);
 
                 if (!ret)
@@ -3641,10 +3641,10 @@ int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
         cpu_buffer = buffer->buffers[cpu];
         local_irq_save(flags);
         if (dolock)
-                spin_lock(&cpu_buffer->reader_lock);
+                raw_spin_lock(&cpu_buffer->reader_lock);
         ret = rb_per_cpu_empty(cpu_buffer);
         if (dolock)
-                spin_unlock(&cpu_buffer->reader_lock);
+                raw_spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
         return ret;
@@ -3841,7 +3841,7 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
         if (!bpage)
                 goto out;
 
-        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
         reader = rb_get_reader_page(cpu_buffer);
         if (!reader)
@@ -3964,7 +3964,7 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
                 memset(&bpage->data[commit], 0, BUF_PAGE_SIZE - commit);
 
  out_unlock:
-        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
  out:
         return ret;
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index e5df02c69b1d..0c8bdeeb358b 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -341,7 +341,7 @@ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
         TRACE_ITER_GRAPH_TIME | TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE;
 
 static int trace_stop_count;
-static DEFINE_SPINLOCK(tracing_start_lock);
+static DEFINE_RAW_SPINLOCK(tracing_start_lock);
 
 static void wakeup_work_handler(struct work_struct *work)
 {
@@ -960,7 +960,7 @@ void tracing_start(void)
         if (tracing_disabled)
                 return;
 
-        spin_lock_irqsave(&tracing_start_lock, flags);
+        raw_spin_lock_irqsave(&tracing_start_lock, flags);
         if (--trace_stop_count) {
                 if (trace_stop_count < 0) {
                         /* Someone screwed up their debugging */
@@ -985,7 +985,7 @@ void tracing_start(void)
 
         ftrace_start();
  out:
-        spin_unlock_irqrestore(&tracing_start_lock, flags);
+        raw_spin_unlock_irqrestore(&tracing_start_lock, flags);
 }
 
 /**
@@ -1000,7 +1000,7 @@ void tracing_stop(void)
         unsigned long flags;
 
         ftrace_stop();
-        spin_lock_irqsave(&tracing_start_lock, flags);
+        raw_spin_lock_irqsave(&tracing_start_lock, flags);
         if (trace_stop_count++)
                 goto out;
 
@@ -1018,7 +1018,7 @@ void tracing_stop(void)
         arch_spin_unlock(&ftrace_max_lock);
 
  out:
-        spin_unlock_irqrestore(&tracing_start_lock, flags);
+        raw_spin_unlock_irqrestore(&tracing_start_lock, flags);
 }
 
 void trace_stop_cmdline_recording(void);
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 667aa8cc0cfc..11186212068c 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -23,7 +23,7 @@ static int				tracer_enabled __read_mostly;
 
 static DEFINE_PER_CPU(int, tracing_cpu);
 
-static DEFINE_SPINLOCK(max_trace_lock);
+static DEFINE_RAW_SPINLOCK(max_trace_lock);
 
 enum {
         TRACER_IRQS_OFF         = (1 << 1),
@@ -321,7 +321,7 @@ check_critical_timing(struct trace_array *tr,
         if (!report_latency(delta))
                 goto out;
 
-        spin_lock_irqsave(&max_trace_lock, flags);
+        raw_spin_lock_irqsave(&max_trace_lock, flags);
 
         /* check if we are still the max latency */
         if (!report_latency(delta))
@@ -344,7 +344,7 @@ check_critical_timing(struct trace_array *tr,
         max_sequence++;
 
 out_unlock:
-        spin_unlock_irqrestore(&max_trace_lock, flags);
+        raw_spin_unlock_irqrestore(&max_trace_lock, flags);
 
 out:
         data->critical_sequence = max_sequence;