add xenomai

hc

2024-11-01 2f529f9b558ca1c1bd74be7437a84e4711743404

 kernel/include/linux/lockdep.h
..
..
@@ -214,29 +214,30 @@
214
214
  * of dependencies wrong: they are either too broad (they need a class-split)
215
215
  * or they are too narrow (they suffer from a false class-split):
216
216
  */
217
-#define lockdep_set_class(lock, key)				\
218
-	lockdep_init_map_type(&(lock)->dep_map, #key, key, 0,	\
219
-			      (lock)->dep_map.wait_type_inner,	\
220
-			      (lock)->dep_map.wait_type_outer,	\
221
-			      (lock)->dep_map.lock_type)
217
+#define lockdep_set_class(lock, key)					\
218
+	lockdep_init_map_type(LOCKDEP_ALT_DEPMAP(lock), #key, key, 0,	\
219
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_inner,	\
220
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_outer,	\
221
+			LOCKDEP_ALT_DEPMAP(lock)->lock_type)
222
222
 
223
-#define lockdep_set_class_and_name(lock, key, name)		\
224
-	lockdep_init_map_type(&(lock)->dep_map, name, key, 0,	\
225
-			      (lock)->dep_map.wait_type_inner,	\
226
-			      (lock)->dep_map.wait_type_outer,	\
227
-			      (lock)->dep_map.lock_type)
223
+#define lockdep_set_class_and_name(lock, key, name)			\
224
+	lockdep_init_map_type(LOCKDEP_ALT_DEPMAP(lock), name, key, 0,	\
225
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_inner,	\
226
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_outer,	\
227
+			LOCKDEP_ALT_DEPMAP(lock)->lock_type)
228
228
 
229
-#define lockdep_set_class_and_subclass(lock, key, sub)		\
230
-	lockdep_init_map_type(&(lock)->dep_map, #key, key, sub,	\
231
-			      (lock)->dep_map.wait_type_inner,	\
232
-			      (lock)->dep_map.wait_type_outer,	\
233
-			      (lock)->dep_map.lock_type)
229
+#define lockdep_set_class_and_subclass(lock, key, sub)			\
230
+	lockdep_init_map_type(LOCKDEP_ALT_DEPMAP(lock), #key, key, sub,	\
231
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_inner,	\
232
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_outer,	\
233
+			LOCKDEP_ALT_DEPMAP(lock)->lock_type)
234
234
 
235
235
 #define lockdep_set_subclass(lock, sub)					\
236
-	lockdep_init_map_type(&(lock)->dep_map, #lock, (lock)->dep_map.key, sub,\
237
-			      (lock)->dep_map.wait_type_inner,		\
238
-			      (lock)->dep_map.wait_type_outer,		\
239
-			      (lock)->dep_map.lock_type)
236
+	lockdep_init_map_type(LOCKDEP_ALT_DEPMAP(lock), #lock,		\
237
+			LOCKDEP_ALT_DEPMAP(lock)->key, sub,		\
238
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_inner,	\
239
+			LOCKDEP_ALT_DEPMAP(lock)->wait_type_outer,	\
240
+			LOCKDEP_ALT_DEPMAP(lock)->lock_type)
240
241
 
241
242
 #define lockdep_set_novalidate_class(lock) \
242
243
 	lockdep_set_class_and_name(lock, &__lockdep_no_validate__, #lock)
..
..
@@ -244,7 +245,8 @@
244
245
 /*
245
246
  * Compare locking classes
246
247
  */
247
-#define lockdep_match_class(lock, key) lockdep_match_key(&(lock)->dep_map, key)
248
+#define lockdep_match_class(lock, key) \
249
+	lockdep_match_key(LOCKDEP_ALT_DEPMAP(lock), key)
248
250
 
249
251
 static inline int lockdep_match_key(struct lockdep_map *lock,
250
252
 				    struct lock_class_key *key)
..
..
@@ -282,8 +284,8 @@
282
284
 	return lock_is_held_type(lock, -1);
283
285
 }
284
286
 
285
-#define lockdep_is_held(lock)		lock_is_held(&(lock)->dep_map)
286
-#define lockdep_is_held_type(lock, r)	lock_is_held_type(&(lock)->dep_map, (r))
287
+#define lockdep_is_held(lock)		lock_is_held(LOCKDEP_ALT_DEPMAP(lock))
288
+#define lockdep_is_held_type(lock, r)	lock_is_held_type(LOCKDEP_ALT_DEPMAP(lock), (r))
287
289
 
288
290
 extern void lock_set_class(struct lockdep_map *lock, const char *name,
289
291
 			   struct lock_class_key *key, unsigned int subclass,
..
..
@@ -306,26 +308,27 @@
306
308
 #define lockdep_depth(tsk)	(debug_locks ? (tsk)->lockdep_depth : 0)
307
309
 
308
310
 #define lockdep_assert_held(l)	do {				\
309
-		WARN_ON(debug_locks && !lockdep_is_held(l));	\
311
+		WARN_ON(debug_locks && !LOCKDEP_HARD_DEBUG_RET(l, 1, lockdep_is_held(l))); \
310
312
 	} while (0)
311
313
 
312
314
 #define lockdep_assert_held_write(l)	do {			\
313
-		WARN_ON(debug_locks && !lockdep_is_held_type(l, 0));	\
315
+		WARN_ON(debug_locks && !LOCKDEP_HARD_DEBUG_RET(l, 1, lockdep_is_held_type(l, 0))); \
314
316
 	} while (0)
315
317
 
316
318
 #define lockdep_assert_held_read(l)	do {				\
317
-		WARN_ON(debug_locks && !lockdep_is_held_type(l, 1));	\
319
+		WARN_ON(debug_locks && !LOCKDEP_HARD_DEBUG_RET(l, 1, lockdep_is_held_type(l, 1))); \
318
320
 	} while (0)
319
321
 
320
322
 #define lockdep_assert_held_once(l)	do {				\
321
-		WARN_ON_ONCE(debug_locks && !lockdep_is_held(l));	\
323
+		WARN_ON_ONCE(debug_locks && !LOCKDEP_HARD_DEBUG_RET(l, 1, lockdep_is_held(l))); \
322
324
 	} while (0)
323
325
 
324
326
 #define lockdep_recursing(tsk)	((tsk)->lockdep_recursion)
325
327
 
326
-#define lockdep_pin_lock(l)	lock_pin_lock(&(l)->dep_map)
327
-#define lockdep_repin_lock(l,c)	lock_repin_lock(&(l)->dep_map, (c))
328
-#define lockdep_unpin_lock(l,c)	lock_unpin_lock(&(l)->dep_map, (c))
328
+#define lockdep_pin_lock(l)	LOCKDEP_HARD_DEBUG_RET(l, ({ struct pin_cookie cookie; cookie;} ), \
329
+							lock_pin_lock(LOCKDEP_ALT_DEPMAP(l)))
330
+#define lockdep_repin_lock(l,c)	LOCKDEP_HARD_DEBUG(l,, lock_repin_lock(LOCKDEP_ALT_DEPMAP(l), (c)))
331
+#define lockdep_unpin_lock(l,c)	LOCKDEP_HARD_DEBUG(l,, lock_unpin_lock(LOCKDEP_ALT_DEPMAP(l), (c)))
329
332
 
330
333
 #else /* !CONFIG_LOCKDEP */
331
334
 
..
..
@@ -552,22 +555,22 @@
552
555
 #ifdef CONFIG_PROVE_LOCKING
553
556
 # define might_lock(lock)						\
554
557
 do {									\
555
-	typecheck(struct lockdep_map *, &(lock)->dep_map);		\
556
-	lock_acquire(&(lock)->dep_map, 0, 0, 0, 1, NULL, _THIS_IP_);	\
557
-	lock_release(&(lock)->dep_map, _THIS_IP_);			\
558
+	typecheck(struct lockdep_map *, LOCKDEP_ALT_DEPMAP(lock));	\
559
+	lock_acquire(LOCKDEP_ALT_DEPMAP(lock), 0, 0, 0, 1, NULL, _THIS_IP_);	\
560
+	lock_release(LOCKDEP_ALT_DEPMAP(lock), _THIS_IP_);			\
558
561
 } while (0)
559
562
 # define might_lock_read(lock)						\
560
563
 do {									\
561
-	typecheck(struct lockdep_map *, &(lock)->dep_map);		\
562
-	lock_acquire(&(lock)->dep_map, 0, 0, 1, 1, NULL, _THIS_IP_);	\
563
-	lock_release(&(lock)->dep_map, _THIS_IP_);			\
564
+	typecheck(struct lockdep_map *, LOCKDEP_ALT_DEPMAP(lock));	\
565
+	lock_acquire(LOCKDEP_ALT_DEPMAP(lock), 0, 0, 1, 1, NULL, _THIS_IP_); \
566
+	lock_release(LOCKDEP_ALT_DEPMAP(lock), _THIS_IP_);		\
564
567
 } while (0)
565
568
 # define might_lock_nested(lock, subclass)				\
566
569
 do {									\
567
-	typecheck(struct lockdep_map *, &(lock)->dep_map);		\
568
-	lock_acquire(&(lock)->dep_map, subclass, 0, 1, 1, NULL,		\
570
+	typecheck(struct lockdep_map *, LOCKDEP_ALT_DEPMAP(lock));	\
571
+	lock_acquire(LOCKDEP_ALT_DEPMAP(lock), subclass, 0, 1, 1, NULL,	\
569
572
 		     _THIS_IP_);					\
570
-	lock_release(&(lock)->dep_map, _THIS_IP_);			\
573
+	lock_release(LOCKDEP_ALT_DEPMAP(lock), _THIS_IP_);		\
571
574
 } while (0)
572
575
 
573
576
 DECLARE_PER_CPU(int, hardirqs_enabled);
..
..
@@ -576,14 +579,32 @@
576
579
 
577
580
 #define __lockdep_enabled	(debug_locks && !this_cpu_read(lockdep_recursion))
578
581
 
582
+#define __lockdep_check_irqs_enabled()					\
583
+	({ !hard_irqs_disabled() &&					\
584
+		(running_oob() || this_cpu_read(hardirqs_enabled)); })
585
+
579
586
 #define lockdep_assert_irqs_enabled()					\
580
-do {									\
581
-	WARN_ON_ONCE(__lockdep_enabled && !this_cpu_read(hardirqs_enabled)); \
582
-} while (0)
587
+	do {								\
588
+		WARN_ON_ONCE(__lockdep_enabled &&			\
589
+			!__lockdep_check_irqs_enabled());		\
590
+	} while (0)
591
+
592
+#define __lockdep_check_irqs_disabled()					\
593
+	({ hard_irqs_disabled() ||					\
594
+		(running_inband() && !this_cpu_read(hardirqs_enabled)); })
583
595
 
584
596
 #define lockdep_assert_irqs_disabled()					\
597
+	  do {								\
598
+		  WARN_ON_ONCE(__lockdep_enabled &&			\
599
+			  !__lockdep_check_irqs_disabled());		\
600
+	  } while (0)
601
+
602
+#define lockdep_read_irqs_state()					\
603
+	({ this_cpu_read(hardirqs_enabled); })
604
+
605
+#define lockdep_write_irqs_state(__state)				\
585
606
 do {									\
586
-	WARN_ON_ONCE(__lockdep_enabled && this_cpu_read(hardirqs_enabled)); \
607
+	this_cpu_write(hardirqs_enabled, __state);			\
587
608
 } while (0)
588
609
 
589
610
 #define lockdep_assert_in_irq()						\
..
..
@@ -596,7 +617,7 @@
596
617
 	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_COUNT)	&&		\
597
618
 		     __lockdep_enabled			&&		\
598
619
 		     (preempt_count() != 0		||		\
599
-		      !this_cpu_read(hardirqs_enabled)));		\
620
+		     __lockdep_check_irqs_disabled()));			\
600
621
 } while (0)
601
622
 
602
623
 #define lockdep_assert_preemption_disabled()				\
..
..
@@ -604,7 +625,7 @@
604
625
 	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_COUNT)	&&		\
605
626
 		     __lockdep_enabled			&&		\
606
627
 		     (preempt_count() == 0		&&		\
607
-		      this_cpu_read(hardirqs_enabled)));		\
628
+		     __lockdep_check_irqs_enabled()));			\
608
629
 } while (0)
609
630
 
610
631
 #else
..
..
@@ -614,6 +635,8 @@
614
635
 
615
636
 # define lockdep_assert_irqs_enabled() do { } while (0)
616
637
 # define lockdep_assert_irqs_disabled() do { } while (0)
638
+# define lockdep_read_irqs_state() 0
639
+# define lockdep_write_irqs_state(__state) do { (void)(__state); } while (0)
617
640
 # define lockdep_assert_in_irq() do { } while (0)
618
641
 
619
642
 # define lockdep_assert_preemption_enabled() do { } while (0)