1 files changed, 232 insertions, 145 deletions

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index 34cdcbedda49..d06190fa5082 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) {
@@ -516,11 +501,11 @@ static char get_usage_char(struct lock_class *class, enum lock_usage_bit bit)
 {
         char c = '.';
 
-        if (class->usage_mask & lock_flag(bit + 2))
+        if (class->usage_mask & lock_flag(bit + LOCK_USAGE_DIR_MASK))
                 c = '+';
         if (class->usage_mask & lock_flag(bit)) {
                 c = '-';
-                if (class->usage_mask & lock_flag(bit + 2))
+                if (class->usage_mask & lock_flag(bit + LOCK_USAGE_DIR_MASK))
                         c = '?';
         }
 
@@ -649,6 +634,9 @@ static int static_obj(const void *obj)
                       end   = (unsigned long) &_end,
                       addr  = (unsigned long) obj;
 
+        if (arch_is_kernel_initmem_freed(addr))
+                return 0;
+
         /*
          * static variable?
          */
@@ -1207,7 +1195,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 +1414,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 +1433,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 +1527,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;
@@ -1676,19 +1669,25 @@ check_redundant(struct lock_list *root, struct lock_class *target,
 }
 
 #if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
+
+static inline int usage_accumulate(struct lock_list *entry, void *mask)
+{
+        *(unsigned long *)mask |= entry->class->usage_mask;
+
+        return 0;
+}
+
 /*
  * Forwards and backwards subgraph searching, for the purposes of
  * proving that two subgraphs can be connected by a new dependency
  * without creating any illegal irq-safe -> irq-unsafe lock dependency.
  */
 
-static inline int usage_match(struct lock_list *entry, void *bit)
+static inline int usage_match(struct lock_list *entry, void *mask)
 {
-        return entry->class->usage_mask & (1 << (enum lock_usage_bit)bit);
+        return entry->class->usage_mask & *(unsigned long *)mask;
 }
 
-
-
 /*
  * Find a node in the forwards-direction dependency sub-graph starting
  * at @root->class that matches @bit.
@@ -1700,14 +1699,14 @@ static inline int usage_match(struct lock_list *entry, void *bit)
  * Return <0 on error.
  */
 static int
-find_usage_forwards(struct lock_list *root, enum lock_usage_bit bit,
+find_usage_forwards(struct lock_list *root, unsigned long usage_mask,
                         struct lock_list **target_entry)
 {
         int result;
 
         debug_atomic_inc(nr_find_usage_forwards_checks);
 
-        result = __bfs_forwards(root, (void *)bit, usage_match, target_entry);
+        result = __bfs_forwards(root, &usage_mask, usage_match, target_entry);
 
         return result;
 }
@@ -1723,14 +1722,14 @@ find_usage_forwards(struct lock_list *root, enum lock_usage_bit bit,
  * Return <0 on error.
  */
 static int
-find_usage_backwards(struct lock_list *root, enum lock_usage_bit bit,
+find_usage_backwards(struct lock_list *root, unsigned long usage_mask,
                         struct lock_list **target_entry)
 {
         int result;
 
         debug_atomic_inc(nr_find_usage_backwards_checks);
 
-        result = __bfs_backwards(root, (void *)bit, usage_match, target_entry);
+        result = __bfs_backwards(root, &usage_mask, usage_match, target_entry);
 
         return result;
 }
@@ -1752,7 +1751,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, "");
@@ -1777,7 +1776,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)) {
@@ -1890,14 +1889,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,
@@ -1922,39 +1921,6 @@ print_bad_irq_dependency(struct task_struct *curr,
         return 0;
 }
 
-static int
-check_usage(struct task_struct *curr, struct held_lock *prev,
-            struct held_lock *next, enum lock_usage_bit bit_backwards,
-            enum lock_usage_bit bit_forwards, const char *irqclass)
-{
-        int ret;
-        struct lock_list this, that;
-        struct lock_list *uninitialized_var(target_entry);
-        struct lock_list *uninitialized_var(target_entry1);
-
-        this.parent = NULL;
-
-        this.class = hlock_class(prev);
-        ret = find_usage_backwards(&this, bit_backwards, &target_entry);
-        if (ret < 0)
-                return print_bfs_bug(ret);
-        if (ret == 1)
-                return ret;
-
-        that.parent = NULL;
-        that.class = hlock_class(next);
-        ret = find_usage_forwards(&that, bit_forwards, &target_entry1);
-        if (ret < 0)
-                return print_bfs_bug(ret);
-        if (ret == 1)
-                return ret;
-
-        return print_bad_irq_dependency(curr, &this, &that,
-                        target_entry, target_entry1,
-                        prev, next,
-                        bit_backwards, bit_forwards, irqclass);
-}
-
 static const char *state_names[] = {
 #define LOCKDEP_STATE(__STATE) \
         __stringify(__STATE),
@@ -1971,9 +1937,19 @@ static const char *state_rnames[] = {
 
 static inline const char *state_name(enum lock_usage_bit bit)
 {
-        return (bit & LOCK_USAGE_READ_MASK) ? state_rnames[bit >> 2] : state_names[bit >> 2];
+        if (bit & LOCK_USAGE_READ_MASK)
+                return state_rnames[bit >> LOCK_USAGE_DIR_MASK];
+        else
+                return state_names[bit >> LOCK_USAGE_DIR_MASK];
 }
 
+/*
+ * The bit number is encoded like:
+ *
+ *  bit0: 0 exclusive, 1 read lock
+ *  bit1: 0 used in irq, 1 irq enabled
+ *  bit2-n: state
+ */
 static int exclusive_bit(int new_bit)
 {
         int state = new_bit & LOCK_USAGE_STATE_MASK;
@@ -1985,45 +1961,160 @@ static int exclusive_bit(int new_bit)
         return state | (dir ^ LOCK_USAGE_DIR_MASK);
 }
 
+/*
+ * Observe that when given a bitmask where each bitnr is encoded as above, a
+ * right shift of the mask transforms the individual bitnrs as -1 and
+ * conversely, a left shift transforms into +1 for the individual bitnrs.
+ *
+ * So for all bits whose number have LOCK_ENABLED_* set (bitnr1 == 1), we can
+ * create the mask with those bit numbers using LOCK_USED_IN_* (bitnr1 == 0)
+ * instead by subtracting the bit number by 2, or shifting the mask right by 2.
+ *
+ * Similarly, bitnr1 == 0 becomes bitnr1 == 1 by adding 2, or shifting left 2.
+ *
+ * So split the mask (note that LOCKF_ENABLED_IRQ_ALL|LOCKF_USED_IN_IRQ_ALL is
+ * all bits set) and recompose with bitnr1 flipped.
+ */
+static unsigned long invert_dir_mask(unsigned long mask)
+{
+        unsigned long excl = 0;
+
+        /* Invert dir */
+        excl |= (mask & LOCKF_ENABLED_IRQ_ALL) >> LOCK_USAGE_DIR_MASK;
+        excl |= (mask & LOCKF_USED_IN_IRQ_ALL) << LOCK_USAGE_DIR_MASK;
+
+        return excl;
+}
+
+/*
+ * As above, we clear bitnr0 (LOCK_*_READ off) with bitmask ops. First, for all
+ * bits with bitnr0 set (LOCK_*_READ), add those with bitnr0 cleared (LOCK_*).
+ * And then mask out all bitnr0.
+ */
+static unsigned long exclusive_mask(unsigned long mask)
+{
+        unsigned long excl = invert_dir_mask(mask);
+
+        /* Strip read */
+        excl |= (excl & LOCKF_IRQ_READ) >> LOCK_USAGE_READ_MASK;
+        excl &= ~LOCKF_IRQ_READ;
+
+        return excl;
+}
+
+/*
+ * Retrieve the _possible_ original mask to which @mask is
+ * exclusive. Ie: this is the opposite of exclusive_mask().
+ * Note that 2 possible original bits can match an exclusive
+ * bit: one has LOCK_USAGE_READ_MASK set, the other has it
+ * cleared. So both are returned for each exclusive bit.
+ */
+static unsigned long original_mask(unsigned long mask)
+{
+        unsigned long excl = invert_dir_mask(mask);
+
+        /* Include read in existing usages */
+        excl |= (excl & LOCKF_IRQ) << LOCK_USAGE_READ_MASK;
+
+        return excl;
+}
+
+/*
+ * Find the first pair of bit match between an original
+ * usage mask and an exclusive usage mask.
+ */
+static int find_exclusive_match(unsigned long mask,
+                                unsigned long excl_mask,
+                                enum lock_usage_bit *bitp,
+                                enum lock_usage_bit *excl_bitp)
+{
+        int bit, excl;
+
+        for_each_set_bit(bit, &mask, LOCK_USED) {
+                excl = exclusive_bit(bit);
+                if (excl_mask & lock_flag(excl)) {
+                        *bitp = bit;
+                        *excl_bitp = excl;
+                        return 0;
+                }
+        }
+        return -1;
+}
+
+/*
+ * Prove that the new dependency does not connect a hardirq-safe(-read)
+ * lock with a hardirq-unsafe lock - to achieve this we search
+ * the backwards-subgraph starting at <prev>, and the
+ * forwards-subgraph starting at <next>:
+ */
 static int check_irq_usage(struct task_struct *curr, struct held_lock *prev,
-                           struct held_lock *next, enum lock_usage_bit bit)
+                           struct held_lock *next)
 {
+        unsigned long usage_mask = 0, forward_mask, backward_mask;
+        enum lock_usage_bit forward_bit = 0, backward_bit = 0;
+        struct lock_list *uninitialized_var(target_entry1);
+        struct lock_list *uninitialized_var(target_entry);
+        struct lock_list this, that;
+        int ret;
+
         /*
-         * Prove that the new dependency does not connect a hardirq-safe
-         * lock with a hardirq-unsafe lock - to achieve this we search
-         * the backwards-subgraph starting at <prev>, and the
-         * forwards-subgraph starting at <next>:
+         * Step 1: gather all hard/soft IRQs usages backward in an
+         * accumulated usage mask.
          */
-        if (!check_usage(curr, prev, next, bit,
-                           exclusive_bit(bit), state_name(bit)))
-                return 0;
+        this.parent = NULL;
+        this.class = hlock_class(prev);
+
+        ret = __bfs_backwards(&this, &usage_mask, usage_accumulate, NULL);
+        if (ret < 0)
+                return print_bfs_bug(ret);
 
-        bit++; /* _READ */
+        usage_mask &= LOCKF_USED_IN_IRQ_ALL;
+        if (!usage_mask)
+                return 1;
 
         /*
-         * Prove that the new dependency does not connect a hardirq-safe-read
-         * lock with a hardirq-unsafe lock - to achieve this we search
-         * the backwards-subgraph starting at <prev>, and the
-         * forwards-subgraph starting at <next>:
+         * Step 2: find exclusive uses forward that match the previous
+         * backward accumulated mask.
          */
-        if (!check_usage(curr, prev, next, bit,
-                           exclusive_bit(bit), state_name(bit)))
-                return 0;
+        forward_mask = exclusive_mask(usage_mask);
 
-        return 1;
-}
+        that.parent = NULL;
+        that.class = hlock_class(next);
 
-static int
-check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
-                struct held_lock *next)
-{
-#define LOCKDEP_STATE(__STATE)                                          \
-        if (!check_irq_usage(curr, prev, next, LOCK_USED_IN_##__STATE)) \
-                return 0;
-#include "lockdep_states.h"
-#undef LOCKDEP_STATE
+        ret = find_usage_forwards(&that, forward_mask, &target_entry1);
+        if (ret < 0)
+                return print_bfs_bug(ret);
+        if (ret == 1)
+                return ret;
 
-        return 1;
+        /*
+         * Step 3: we found a bad match! Now retrieve a lock from the backward
+         * list whose usage mask matches the exclusive usage mask from the
+         * lock found on the forward list.
+         */
+        backward_mask = original_mask(target_entry1->class->usage_mask);
+
+        ret = find_usage_backwards(&this, backward_mask, &target_entry);
+        if (ret < 0)
+                return print_bfs_bug(ret);
+        if (DEBUG_LOCKS_WARN_ON(ret == 1))
+                return 1;
+
+        /*
+         * Step 4: narrow down to a pair of incompatible usage bits
+         * and report it.
+         */
+        ret = find_exclusive_match(target_entry->class->usage_mask,
+                                   target_entry1->class->usage_mask,
+                                   &backward_bit, &forward_bit);
+        if (DEBUG_LOCKS_WARN_ON(ret == -1))
+                return 1;
+
+        return print_bad_irq_dependency(curr, &this, &that,
+                        target_entry, target_entry1,
+                        prev, next,
+                        backward_bit, forward_bit,
+                        state_name(backward_bit));
 }
 
 static void inc_chains(void)
@@ -2040,9 +2131,8 @@ static void inc_chains(void)
 
 #else
 
-static inline int
-check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
-                struct held_lock *next)
+static inline int check_irq_usage(struct task_struct *curr,
+                                  struct held_lock *prev, struct held_lock *next)
 {
         return 1;
 }
@@ -2170,8 +2260,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;
@@ -2209,20 +2298,20 @@ 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);
 
-        if (!check_prev_add_irq(curr, prev, next))
+        if (!check_irq_usage(curr, prev, next))
                 return 0;
 
         /*
@@ -2265,7 +2354,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;
 
         /*
@@ -2297,14 +2386,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.
@@ -2330,7 +2414,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;
 
@@ -2731,6 +2816,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
 
 /*
@@ -2784,6 +2873,12 @@ static void check_chain_key(struct task_struct *curr)
 #endif
 }
 
+static int mark_lock(struct task_struct *curr, struct held_lock *this,
+                     enum lock_usage_bit new_bit);
+
+#if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
+
+
 static void
 print_usage_bug_scenario(struct held_lock *lock)
 {
@@ -2827,7 +2922,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");
@@ -2853,10 +2948,6 @@ valid_state(struct task_struct *curr, struct held_lock *this,
         return 1;
 }
 
-static int mark_lock(struct task_struct *curr, struct held_lock *this,
-                     enum lock_usage_bit new_bit);
-
-#if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
 
 /*
  * print irq inversion bug:
@@ -2936,7 +3027,7 @@ check_usage_forwards(struct task_struct *curr, struct held_lock *this,
 
         root.parent = NULL;
         root.class = hlock_class(this);
-        ret = find_usage_forwards(&root, bit, &target_entry);
+        ret = find_usage_forwards(&root, lock_flag(bit), &target_entry);
         if (ret < 0)
                 return print_bfs_bug(ret);
         if (ret == 1)
@@ -2960,7 +3051,7 @@ check_usage_backwards(struct task_struct *curr, struct held_lock *this,
 
         root.parent = NULL;
         root.class = hlock_class(this);
-        ret = find_usage_backwards(&root, bit, &target_entry);
+        ret = find_usage_backwards(&root, lock_flag(bit), &target_entry);
         if (ret < 0)
                 return print_bfs_bug(ret);
         if (ret == 1)
@@ -3015,7 +3106,7 @@ static int (*state_verbose_f[])(struct lock_class *class) = {
 static inline int state_verbose(enum lock_usage_bit bit,
                                 struct lock_class *class)
 {
-        return state_verbose_f[bit >> 2](class);
+        return state_verbose_f[bit >> LOCK_USAGE_DIR_MASK](class);
 }
 
 typedef int (*check_usage_f)(struct task_struct *, struct held_lock *,
@@ -3157,7 +3248,7 @@ void lockdep_hardirqs_on(unsigned long ip)
         /*
          * See the fine text that goes along with this variable definition.
          */
-        if (DEBUG_LOCKS_WARN_ON(unlikely(early_boot_irqs_disabled)))
+        if (DEBUG_LOCKS_WARN_ON(early_boot_irqs_disabled))
                 return;
 
         /*
@@ -4689,8 +4780,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);
@@ -4702,8 +4793,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);
 }
 
@@ -4744,21 +4835,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);
 
         /*