1 files changed, 46 insertions, 61 deletions

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index 6426d071a324..27b992fe8cec 100644
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -434,29 +434,14 @@ static void print_lockdep_off(const char *bug_msg)
 #endif
 }
 
-static int save_trace(struct stack_trace *trace)
+static int save_trace(struct lock_trace *trace)
 {
-        trace->nr_entries = 0;
-        trace->max_entries = MAX_STACK_TRACE_ENTRIES - nr_stack_trace_entries;
-        trace->entries = stack_trace + nr_stack_trace_entries;
-
-        trace->skip = 3;
-
-        save_stack_trace(trace);
-
-        /*
-         * Some daft arches put -1 at the end to indicate its a full trace.
-         *
-         * <rant> this is buggy anyway, since it takes a whole extra entry so a
-         * complete trace that maxes out the entries provided will be reported
-         * as incomplete, friggin useless </rant>
-         */
-        if (trace->nr_entries != 0 &&
-            trace->entries[trace->nr_entries-1] == ULONG_MAX)
-                trace->nr_entries--;
-
-        trace->max_entries = trace->nr_entries;
+        unsigned long *entries = stack_trace + nr_stack_trace_entries;
+        unsigned int max_entries;
 
+        trace->offset = nr_stack_trace_entries;
+        max_entries = MAX_STACK_TRACE_ENTRIES - nr_stack_trace_entries;
+        trace->nr_entries = stack_trace_save(entries, max_entries, 3);
         nr_stack_trace_entries += trace->nr_entries;
 
         if (nr_stack_trace_entries >= MAX_STACK_TRACE_ENTRIES-1) {
@@ -1207,7 +1192,7 @@ static struct lock_list *alloc_list_entry(void)
 static int add_lock_to_list(struct lock_class *this,
                             struct lock_class *links_to, struct list_head *head,
                             unsigned long ip, int distance,
-                            struct stack_trace *trace)
+                            struct lock_trace *trace)
 {
         struct lock_list *entry;
         /*
@@ -1426,6 +1411,13 @@ static inline int __bfs_backwards(struct lock_list *src_entry,
  * checking.
  */
 
+static void print_lock_trace(struct lock_trace *trace, unsigned int spaces)
+{
+        unsigned long *entries = stack_trace + trace->offset;
+
+        stack_trace_print(entries, trace->nr_entries, spaces);
+}
+
 /*
  * Print a dependency chain entry (this is only done when a deadlock
  * has been detected):
@@ -1438,8 +1430,7 @@ print_circular_bug_entry(struct lock_list *target, int depth)
         printk("\n-> #%u", depth);
         print_lock_name(target->class);
         printk(KERN_CONT ":\n");
-        print_stack_trace(&target->trace, 6);
-
+        print_lock_trace(&target->trace, 6);
         return 0;
 }
 
@@ -1533,10 +1524,9 @@ static inline int class_equal(struct lock_list *entry, void *data)
 }
 
 static noinline int print_circular_bug(struct lock_list *this,
-                                struct lock_list *target,
-                                struct held_lock *check_src,
-                                struct held_lock *check_tgt,
-                                struct stack_trace *trace)
+                                       struct lock_list *target,
+                                       struct held_lock *check_src,
+                                       struct held_lock *check_tgt)
 {
         struct task_struct *curr = current;
         struct lock_list *parent;
@@ -1758,7 +1748,7 @@ static void print_lock_class_header(struct lock_class *class, int depth)
 
                         len += printk("%*s   %s", depth, "", usage_str[bit]);
                         len += printk(KERN_CONT " at:\n");
-                        print_stack_trace(class->usage_traces + bit, len);
+                        print_lock_trace(class->usage_traces + bit, len);
                 }
         }
         printk("%*s }\n", depth, "");
@@ -1783,7 +1773,7 @@ print_shortest_lock_dependencies(struct lock_list *leaf,
         do {
                 print_lock_class_header(entry->class, depth);
                 printk("%*s ... acquired at:\n", depth, "");
-                print_stack_trace(&entry->trace, 2);
+                print_lock_trace(&entry->trace, 2);
                 printk("\n");
 
                 if (depth == 0 && (entry != root)) {
@@ -1896,14 +1886,14 @@ print_bad_irq_dependency(struct task_struct *curr,
         print_lock_name(backwards_entry->class);
         pr_warn("\n... which became %s-irq-safe at:\n", irqclass);
 
-        print_stack_trace(backwards_entry->class->usage_traces + bit1, 1);
+        print_lock_trace(backwards_entry->class->usage_traces + bit1, 1);
 
         pr_warn("\nto a %s-irq-unsafe lock:\n", irqclass);
         print_lock_name(forwards_entry->class);
         pr_warn("\n... which became %s-irq-unsafe at:\n", irqclass);
         pr_warn("...");
 
-        print_stack_trace(forwards_entry->class->usage_traces + bit2, 1);
+        print_lock_trace(forwards_entry->class->usage_traces + bit2, 1);
 
         pr_warn("\nother info that might help us debug this:\n\n");
         print_irq_lock_scenario(backwards_entry, forwards_entry,
@@ -2267,8 +2257,7 @@ check_deadlock(struct task_struct *curr, struct held_lock *next,
  */
 static int
 check_prev_add(struct task_struct *curr, struct held_lock *prev,
-               struct held_lock *next, int distance, struct stack_trace *trace,
-               int (*save)(struct stack_trace *trace))
+               struct held_lock *next, int distance, struct lock_trace *trace)
 {
         struct lock_list *uninitialized_var(target_entry);
         struct lock_list *entry;
@@ -2306,15 +2295,15 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
         this.parent = NULL;
         ret = check_noncircular(&this, hlock_class(prev), &target_entry);
         if (unlikely(!ret)) {
-                if (!trace->entries) {
+                if (!trace->nr_entries) {
                         /*
-                         * If @save fails here, the printing might trigger
-                         * a WARN but because of the !nr_entries it should
-                         * not do bad things.
+                         * If save_trace fails here, the printing might
+                         * trigger a WARN but because of the !nr_entries it
+                         * should not do bad things.
                          */
-                        save(trace);
+                        save_trace(trace);
                 }
-                return print_circular_bug(&this, target_entry, next, prev, trace);
+                return print_circular_bug(&this, target_entry, next, prev);
         }
         else if (unlikely(ret < 0))
                 return print_bfs_bug(ret);
@@ -2362,7 +2351,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
                 return print_bfs_bug(ret);
 
 
-        if (!trace->entries && !save(trace))
+        if (!trace->nr_entries && !save_trace(trace))
                 return 0;
 
         /*
@@ -2394,14 +2383,9 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
 static int
 check_prevs_add(struct task_struct *curr, struct held_lock *next)
 {
+        struct lock_trace trace = { .nr_entries = 0 };
         int depth = curr->lockdep_depth;
         struct held_lock *hlock;
-        struct stack_trace trace = {
-                .nr_entries = 0,
-                .max_entries = 0,
-                .entries = NULL,
-                .skip = 0,
-        };
 
         /*
          * Debugging checks.
@@ -2427,7 +2411,8 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)
                  * added:
                  */
                 if (hlock->read != 2 && hlock->check) {
-                        int ret = check_prev_add(curr, hlock, next, distance, &trace, save_trace);
+                        int ret = check_prev_add(curr, hlock, next, distance,
+                                                 &trace);
                         if (!ret)
                                 return 0;
 
@@ -2828,6 +2813,10 @@ static inline int validate_chain(struct task_struct *curr,
 {
         return 1;
 }
+
+static void print_lock_trace(struct lock_trace *trace, unsigned int spaces)
+{
+}
 #endif
 
 /*
@@ -2930,7 +2919,7 @@ print_usage_bug(struct task_struct *curr, struct held_lock *this,
         print_lock(this);
 
         pr_warn("{%s} state was registered at:\n", usage_str[prev_bit]);
-        print_stack_trace(hlock_class(this)->usage_traces + prev_bit, 1);
+        print_lock_trace(hlock_class(this)->usage_traces + prev_bit, 1);
 
         print_irqtrace_events(curr);
         pr_warn("\nother info that might help us debug this:\n");
@@ -4788,8 +4777,8 @@ static void free_zapped_rcu(struct rcu_head *ch)
                 return;
 
         raw_local_irq_save(flags);
-        if (!graph_lock())
-                goto out_irq;
+        arch_spin_lock(&lockdep_lock);
+        current->lockdep_recursion = 1;
 
         /* closed head */
         pf = delayed_free.pf + (delayed_free.index ^ 1);
@@ -4801,8 +4790,8 @@ static void free_zapped_rcu(struct rcu_head *ch)
          */
         call_rcu_zapped(delayed_free.pf + delayed_free.index);
 
-        graph_unlock();
-out_irq:
+        current->lockdep_recursion = 0;
+        arch_spin_unlock(&lockdep_lock);
         raw_local_irq_restore(flags);
 }
 
@@ -4843,21 +4832,17 @@ static void lockdep_free_key_range_reg(void *start, unsigned long size)
 {
         struct pending_free *pf;
         unsigned long flags;
-        int locked;
 
         init_data_structures_once();
 
         raw_local_irq_save(flags);
-        locked = graph_lock();
-        if (!locked)
-                goto out_irq;
-
+        arch_spin_lock(&lockdep_lock);
+        current->lockdep_recursion = 1;
         pf = get_pending_free();
         __lockdep_free_key_range(pf, start, size);
         call_rcu_zapped(pf);
-
-        graph_unlock();
-out_irq:
+        current->lockdep_recursion = 0;
+        arch_spin_unlock(&lockdep_lock);
         raw_local_irq_restore(flags);
 
         /*