Skip to contentSkip to conversation

locking/lockdep: Fix lock IRQ usage initialization bug

PATCH In review Yuyang Du 2 participants 6 messages Jun 10, 2019 – Jul 9, 2019 Locking primitives

lore
Share & tools
lore

Yuyang Du

author
#0 lore raw

PATCH 1/1 locking/lockdep: Fix lock IRQ usage initialization bug

The commit:

091806515124b20 ("locking/lockdep: Consolidate lock usage bit initialization")

misses marking LOCK_USED flag at IRQ usage initialization when CONFIG_TRACE_IRQFLAGS or CONFIG_PROVE_LOCKING is not defined. Fix it.

---
 kernel/locking/lockdep.c | 110 +++++++++++++++++++++++------------------------
 1 file changed, 53 insertions(+), 57 deletions(-)
kernel/locking/lockdep.c +53 -57
index 48a840a..c3db987 100644
@@ -3460,9 +3460,61 @@ void trace_softirqs_off(unsigned long ip)
 		debug_atomic_inc(redundant_softirqs_off);
 }
 
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+	return 2 * !!task->hardirq_context + !!task->softirq_context;
+}
+
+static int separate_irq_context(struct task_struct *curr,
+		struct held_lock *hlock)
+{
+	unsigned int depth = curr->lockdep_depth;
+
+	/*
+	 * Keep track of points where we cross into an interrupt context:
+	 */
+	if (depth) {
+		struct held_lock *prev_hlock;
+
+		prev_hlock = curr->held_locks + depth-1;
+		/*
+		 * If we cross into another context, reset the
+		 * hash key (this also prevents the checking and the
+		 * adding of the dependency to 'prev'):
+		 */
+		if (prev_hlock->irq_context != hlock->irq_context)
+			return 1;
+	}
+	return 0;
+}
+
+#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
+	return 1;
+}
+
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+	return 0;
+}
+
+static inline int separate_irq_context(struct task_struct *curr,
+		struct held_lock *hlock)
+{
+	return 0;
+}
+
+#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
+
 static int
 mark_usage(struct task_struct *curr, struct held_lock *hlock, int check)
 {
+#if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
 	if (!check)
 		goto lock_used;
 
@@ -3510,6 +3562,7 @@ void trace_softirqs_off(unsigned long ip)
 	}
 
 lock_used:
+#endif
 	/* mark it as used: */
 	if (!mark_lock(curr, hlock, LOCK_USED))
 		return 0;
@@ -3517,63 +3570,6 @@ void trace_softirqs_off(unsigned long ip)
 	return 1;
 }
 
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-	return 2 * !!task->hardirq_context + !!task->softirq_context;
-}
-
-static int separate_irq_context(struct task_struct *curr,
-		struct held_lock *hlock)
-{
-	unsigned int depth = curr->lockdep_depth;
-
-	/*
-	 * Keep track of points where we cross into an interrupt context:
-	 */
-	if (depth) {
-		struct held_lock *prev_hlock;
-
-		prev_hlock = curr->held_locks + depth-1;
-		/*
-		 * If we cross into another context, reset the
-		 * hash key (this also prevents the checking and the
-		 * adding of the dependency to 'prev'):
-		 */
-		if (prev_hlock->irq_context != hlock->irq_context)
-			return 1;
-	}
-	return 0;
-}
-
-#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
-	return 1;
-}
-
-static inline int
-mark_usage(struct task_struct *curr, struct held_lock *hlock, int check)
-{
-	return 1;
-}
-
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-	return 0;
-}
-
-static inline int separate_irq_context(struct task_struct *curr,
-		struct held_lock *hlock)
-{
-	return 0;
-}
-
-#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
-
 /*
  * Mark a lock with a usage bit, and validate the state transition:
  */
Signature · 1 line
1.8.3.1
#1 lore raw
Quoted 11 lines · Yuyang Du

The commit:

  091806515124b20 ("locking/lockdep: Consolidate lock usage bit initialization")

misses marking LOCK_USED flag at IRQ usage initialization when CONFIG_TRACE_IRQFLAGS
or CONFIG_PROVE_LOCKING is not defined. Fix it.

It works fine.

author
#2 lore raw

Great, thanks.

Quoted 15 lines · Qian Cai
Quoted 11 lines · Yuyang Du

The commit:

091806515124b20 ("locking/lockdep: Consolidate lock usage bit
initialization")

misses marking LOCK_USED flag at IRQ usage initialization when CONFIG_TRACE_IRQFLAGS
or CONFIG_PROVE_LOCKING is not defined. Fix it.

It works fine.

#3 lore raw
In reply to Yuyang Du

I saw Ingo send a pull request to Linus for 5.3 [1] includes the offensive commit "locking/lockdep: Consolidate lock usage bit initialization" but did not include this patch.

[1] https://lore.kernel.org/lkml/[email protected]/

Quoted 154 lines · Yuyang Du

The commit:

  091806515124b20 ("locking/lockdep: Consolidate lock usage bit initialization")

misses marking LOCK_USED flag at IRQ usage initialization when CONFIG_TRACE_IRQFLAGS
or CONFIG_PROVE_LOCKING is not defined. Fix it.

---
 kernel/locking/lockdep.c | 110 +++++++++++++++++++++++----------------------- -

 1 file changed, 53 insertions(+), 57 deletions(-)
kernel/locking/lockdep.c +0 -0
index 48a840a..c3db987 100644
@@ -3460,9 +3460,61 @@ void trace_softirqs_off(unsigned long ip)
  		debug_atomic_inc(redundant_softirqs_off);
  }

kernel/locking/lockdep.c +51 -0
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+	return 2 * !!task->hardirq_context + !!task->softirq_context;
+}
+
+static int separate_irq_context(struct task_struct *curr,
+		struct held_lock *hlock)
+{
+	unsigned int depth = curr->lockdep_depth;
+
+	/*
+	 * Keep track of points where we cross into an interrupt context:
+	 */
+	if (depth) {
+		struct held_lock *prev_hlock;
+
+		prev_hlock = curr->held_locks + depth-1;
+		/*
+		 * If we cross into another context, reset the
+		 * hash key (this also prevents the checking and the
+		 * adding of the dependency to 'prev'):
+		 */
+		if (prev_hlock->irq_context != hlock->irq_context)
+			return 1;
+	}
+	return 0;
+}
+
+#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
+	return 1;
+}
+
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+	return 0;
+}
+
+static inline int separate_irq_context(struct task_struct *curr,
+		struct held_lock *hlock)
+{
+	return 0;
+}
+
+#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
+

 static int
 mark_usage(struct task_struct *curr, struct held_lock *hlock, int check) {
+#if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) if (!check)
  goto lock_used;

kernel/locking/lockdep.c +0 -0
@@ -3510,6 +3562,7 @@ void trace_softirqs_off(unsigned long ip)
  	}


 lock_used:
+#endif
  /* mark it as used: */
  if (!mark_lock(curr, hlock, LOCK_USED))
  return 0;

kernel/locking/lockdep.c +0 -0
@@ -3517,63 +3570,6 @@ void trace_softirqs_off(unsigned long ip)
  	return 1;
  }

kernel/locking/lockdep.c +0 -57
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-	return 2 * !!task->hardirq_context + !!task->softirq_context;
-}
-
-static int separate_irq_context(struct task_struct *curr,
-		struct held_lock *hlock)
-{
-	unsigned int depth = curr->lockdep_depth;
-
-	/*
-	 * Keep track of points where we cross into an interrupt context:
-	 */
-	if (depth) {
-		struct held_lock *prev_hlock;
-
-		prev_hlock = curr->held_locks + depth-1;
-		/*
-		 * If we cross into another context, reset the
-		 * hash key (this also prevents the checking and the
-		 * adding of the dependency to 'prev'):
-		 */
-		if (prev_hlock->irq_context != hlock->irq_context)
-			return 1;
-	}
-	return 0;
-}
-
-#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
-	return 1;
-}
-
-static inline int
-mark_usage(struct task_struct *curr, struct held_lock *hlock, int check)
-{
-	return 1;
-}
-
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-	return 0;
-}
-
-static inline int separate_irq_context(struct task_struct *curr,
-		struct held_lock *hlock)
-{
-	return 0;
-}
-
-#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
-

 /*
  * Mark a lock with a usage bit, and validate the state transition:
  */

author
#4 lore raw

The problem should have been fixed with this in that pull:

locking/lockdep: Move mark_lock() inside CONFIG_TRACE_IRQFLAGS && CONFIG_PROVE_LOCKING

and this is a better fix than mine.

Thanks,
Yuyang

Quoted 162 lines · Qian Cai

I saw Ingo send a pull request to Linus for 5.3 [1] includes the offensive commit "locking/lockdep: Consolidate lock usage bit initialization" but did not include this patch.

[1] https://lore.kernel.org/lkml/[email protected]/

Quoted 154 lines · Yuyang Du

The commit:

091806515124b20 ("locking/lockdep: Consolidate lock usage bit
initialization")

misses marking LOCK_USED flag at IRQ usage initialization when CONFIG_TRACE_IRQFLAGS
or CONFIG_PROVE_LOCKING is not defined. Fix it.

---
 kernel/locking/lockdep.c | 110 +++++++++++++++++++++++-----------------------
(quoted diff) +0 -1
-
 1 file changed, 53 insertions(+), 57 deletions(-)
kernel/locking/lockdep.c +53 -57
index 48a840a..c3db987 100644
@@ -3460,9 +3460,61 @@ void trace_softirqs_off(unsigned long ip)
              debug_atomic_inc(redundant_softirqs_off);
 }
 
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+     return 2 * !!task->hardirq_context + !!task->softirq_context;
+}
+
+static int separate_irq_context(struct task_struct *curr,
+             struct held_lock *hlock)
+{
+     unsigned int depth = curr->lockdep_depth;
+
+     /*
+      * Keep track of points where we cross into an interrupt context:
+      */
+     if (depth) {
+             struct held_lock *prev_hlock;
+
+             prev_hlock = curr->held_locks + depth-1;
+             /*
+              * If we cross into another context, reset the
+              * hash key (this also prevents the checking and the
+              * adding of the dependency to 'prev'):
+              */
+             if (prev_hlock->irq_context != hlock->irq_context)
+                     return 1;
+     }
+     return 0;
+}
+
+#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
+     return 1;
+}
+
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+     return 0;
+}
+
+static inline int separate_irq_context(struct task_struct *curr,
+             struct held_lock *hlock)
+{
+     return 0;
+}
+
+#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
+
 static int
 mark_usage(struct task_struct *curr, struct held_lock *hlock, int check)
 {
+#if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
      if (!check)
              goto lock_used;
 
@@ -3510,6 +3562,7 @@ void trace_softirqs_off(unsigned long ip)
      }
 
 lock_used:
+#endif
      /* mark it as used: */
      if (!mark_lock(curr, hlock, LOCK_USED))
              return 0;
@@ -3517,63 +3570,6 @@ void trace_softirqs_off(unsigned long ip)
      return 1;
 }
 
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-     return 2 * !!task->hardirq_context + !!task->softirq_context;
-}
-
-static int separate_irq_context(struct task_struct *curr,
-             struct held_lock *hlock)
-{
-     unsigned int depth = curr->lockdep_depth;
-
-     /*
-      * Keep track of points where we cross into an interrupt context:
-      */
-     if (depth) {
-             struct held_lock *prev_hlock;
-
-             prev_hlock = curr->held_locks + depth-1;
-             /*
-              * If we cross into another context, reset the
-              * hash key (this also prevents the checking and the
-              * adding of the dependency to 'prev'):
-              */
-             if (prev_hlock->irq_context != hlock->irq_context)
-                     return 1;
-     }
-     return 0;
-}
-
-#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
-     return 1;
-}
-
-static inline int
-mark_usage(struct task_struct *curr, struct held_lock *hlock, int check)
-{
-     return 1;
-}
-
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-     return 0;
-}
-
-static inline int separate_irq_context(struct task_struct *curr,
-             struct held_lock *hlock)
-{
-     return 0;
-}
-
-#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
-
 /*
  * Mark a lock with a usage bit, and validate the state transition:
  */
#5 lore raw
Quoted 10 lines · Yuyang Du

The problem should have been fixed with this in that pull:

locking/lockdep: Move mark_lock() inside CONFIG_TRACE_IRQFLAGS && CONFIG_PROVE_LOCKING

and this is a better fix than mine.

I don’t think so. That commit was included in today’s linux-next, but I can still reproduce the issue there.

[ 8872.727085] DEBUG_LOCKS_WARN_ON(debug_atomic_read(nr_unused_locks) != nr_unused)
[ 8872.727113] WARNING: CPU: 60 PID: 124801 at kernel/locking/lockdep_proc.c:249 lockdep_stats_show+0xe44/0x11e0
[ 8872.727157] Modules linked in: brd ext4 crc16 mbcache jbd2 loop i2c_opal i2c_core ip_tables x_tables xfs sd_mod ahci libahci tg3 firmware_class libata libphy dm_mirror dm_region_hash dm_log dm_mod [last unloaded: dummy_del_mod]
[ 8872.727213] CPU: 60 PID: 124801 Comm: proc01 Tainted: G        W  O      5.2.0-next-20190708+ #1
[ 8872.727253] NIP:  c0000000001a97b4 LR: c0000000001a97b0 CTR: c0000000008c4660
[ 8872.727293] REGS: c000001c2e84f8e0 TRAP: 0700   Tainted: G        W  O       (5.2.0-next-20190708+)
[ 8872.727326] MSR:  9000000000029033 <SF,HV,EE,ME,IR,DR,RI,LE>  CR: 28888402  XER: 20040000
[ 8872.727371] CFAR: c00000000011a0d4 IRQMASK: 0 
               GPR00: c0000000001a97b0 c000001c2e84fb70 c0000000016f8b00 0000000000000044 
               GPR04: c00000000172c258 c0000000001b9288 4e5241575f534b43 75626564284e4f5f 
               GPR08: 0000001ffdd10000 0000000000000000 0000000000000000 212029736b636f6c 
               GPR12: 756e755f726e203d c000001ffffce400 0000000000000000 c0000000015bd610 
               GPR16: 0000000000000000 0000000000000000 0000000000000000 0000000000000dfd 
               GPR20: 0000000000000000 0000000000000000 0000000000000000 0000000000000000 
               GPR24: 0000000000000000 0000000000000000 0000000000000000 c000001fb7d0f0a8 
               GPR28: 0000000000000000 c00000000172c278 c00000000172c4c4 c00000000172ba18 
[ 8872.727698] NIP [c0000000001a97b4] lockdep_stats_show+0xe44/0x11e0
[ 8872.727742] LR [c0000000001a97b0] lockdep_stats_show+0xe40/0x11e0
[ 8872.727775] Call Trace:
[ 8872.727800] [c000001c2e84fb70] [c0000000001a97b0] lockdep_stats_show+0xe40/0x11e0 (unreliable)
[ 8872.727831] [c000001c2e84fca0] [c000000000492434] seq_read+0x1d4/0x620
[ 8872.727886] [c000001c2e84fd30] [c000000000515520] proc_reg_read+0x90/0x130
[ 8872.727938] [c000001c2e84fd60] [c000000000452d6c] __vfs_read+0x3c/0x70
[ 8872.727989] [c000001c2e84fd80] [c000000000452e5c] vfs_read+0xbc/0x1a0
[ 8872.728033] [c000001c2e84fdd0] [c0000000004532ec] ksys_read+0x7c/0x140
[ 8872.728073] [c000001c2e84fe20] [c00000000000ae08] system_call+0x5c/0x70
[ 8872.728126] Instruction dump:
[ 8872.728161] 419ef3b0 3d220003 392974fc 81290000 2f890000 409ef39c 3c82ff33 3c62ff33 
[ 8872.728194] 38841af8 386308e8 4bf708c1 60000000 <0fe00000> 4bfff37c 60000000 39200000 
[ 8872.728251] ---[ end trace 42d16c13415f9f32 ]---
Quoted 167 lines

Thanks,
Yuyang

Quoted 162 lines · Qian Cai

I saw Ingo send a pull request to Linus for 5.3 [1] includes the offensive commit "locking/lockdep: Consolidate lock usage bit initialization" but did not include this patch.

[1] https://lore.kernel.org/lkml/[email protected]/

Quoted 154 lines · Yuyang Du

The commit:

091806515124b20 ("locking/lockdep: Consolidate lock usage bit
initialization")

misses marking LOCK_USED flag at IRQ usage initialization when CONFIG_TRACE_IRQFLAGS
or CONFIG_PROVE_LOCKING is not defined. Fix it.

---
kernel/locking/lockdep.c | 110 +++++++++++++++++++++++----------------------- -

1 file changed, 53 insertions(+), 57 deletions(-)
kernel/locking/lockdep.c +51 -0
index 48a840a..c3db987 100644
@@ -3460,9 +3460,61 @@ void trace_softirqs_off(unsigned long ip)
             debug_atomic_inc(redundant_softirqs_off);
 }
 
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+     return 2 * !!task->hardirq_context + !!task->softirq_context;
+}
+
+static int separate_irq_context(struct task_struct *curr,
+             struct held_lock *hlock)
+{
+     unsigned int depth = curr->lockdep_depth;
+
+     /*
+      * Keep track of points where we cross into an interrupt context:
+      */
+     if (depth) {
+             struct held_lock *prev_hlock;
+
+             prev_hlock = curr->held_locks + depth-1;
+             /*
+              * If we cross into another context, reset the
+              * hash key (this also prevents the checking and the
+              * adding of the dependency to 'prev'):
+              */
+             if (prev_hlock->irq_context != hlock->irq_context)
+                     return 1;
+     }
+     return 0;
+}
+
+#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
+     return 1;
+}
+
+static inline unsigned int task_irq_context(struct task_struct *task)
+{
+     return 0;
+}
+
+static inline int separate_irq_context(struct task_struct *curr,
+             struct held_lock *hlock)
+{
+     return 0;
+}
+
+#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
+

static int
mark_usage(struct task_struct *curr, struct held_lock *hlock, int check) {

kernel/locking/lockdep.c +1 -0
+#if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
     if (!check)
             goto lock_used;
@@ -3510,6 +3562,7 @@ void trace_softirqs_off(unsigned long ip)
     }
 

lock_used:

kernel/locking/lockdep.c +1 -57
+#endif
     /* mark it as used: */
     if (!mark_lock(curr, hlock, LOCK_USED))
             return 0;
@@ -3517,63 +3570,6 @@ void trace_softirqs_off(unsigned long ip)
     return 1;
 }
 
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-     return 2 * !!task->hardirq_context + !!task->softirq_context;
-}
-
-static int separate_irq_context(struct task_struct *curr,
-             struct held_lock *hlock)
-{
-     unsigned int depth = curr->lockdep_depth;
-
-     /*
-      * Keep track of points where we cross into an interrupt context:
-      */
-     if (depth) {
-             struct held_lock *prev_hlock;
-
-             prev_hlock = curr->held_locks + depth-1;
-             /*
-              * If we cross into another context, reset the
-              * hash key (this also prevents the checking and the
-              * adding of the dependency to 'prev'):
-              */
-             if (prev_hlock->irq_context != hlock->irq_context)
-                     return 1;
-     }
-     return 0;
-}
-
-#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); /* Impossible innit? when we don't have TRACE_IRQFLAG */
-     return 1;
-}
-
-static inline int
-mark_usage(struct task_struct *curr, struct held_lock *hlock, int check)
-{
-     return 1;
-}
-
-static inline unsigned int task_irq_context(struct task_struct *task)
-{
-     return 0;
-}
-
-static inline int separate_irq_context(struct task_struct *curr,
-             struct held_lock *hlock)
-{
-     return 0;
-}
-
-#endif /* defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING) */
-
 /*
 * Mark a lock with a usage bit, and validate the state transition:
 */