forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f 
 kernel/lib/locking-selftest.c
....@@ -28,6 +28,7 @@
2828  * Change this to 1 if you want to see the failure printouts:
2929  */
3030 static unsigned int debug_locks_verbose;
31
+unsigned int force_read_lock_recursive;
3132 
3233 static DEFINE_WD_CLASS(ww_lockdep);
3334 
....@@ -185,6 +186,7 @@
185186 #define HARDIRQ_ENTER()				\
186187 	local_irq_disable();			\
187188 	__irq_enter();				\
189
+	lockdep_hardirq_threaded();		\
188190 	WARN_ON(!in_irq());
189191 
190192 #define HARDIRQ_EXIT()				\
....@@ -393,6 +395,49 @@
393395 	WSL(X1);
394396 	WSU(X1);
395397 	MU(Y1); // should fail
398
+}
399
+
400
+/*
401
+ * read_lock(A)
402
+ * spin_lock(B)
403
+ *		spin_lock(B)
404
+ *		write_lock(A)
405
+ *
406
+ * This test case is aimed at poking whether the chain cache prevents us from
407
+ * detecting a read-lock/lock-write deadlock: if the chain cache doesn't differ
408
+ * read/write locks, the following case may happen
409
+ *
410
+ * 	{ read_lock(A)->lock(B) dependency exists }
411
+ *
412
+ * 	P0:
413
+ * 	lock(B);
414
+ * 	read_lock(A);
415
+ *
416
+ *	{ Not a deadlock, B -> A is added in the chain cache }
417
+ *
418
+ *	P1:
419
+ *	lock(B);
420
+ *	write_lock(A);
421
+ *
422
+ *	{ B->A found in chain cache, not reported as a deadlock }
423
+ *
424
+ */
425
+static void rlock_chaincache_ABBA1(void)
426
+{
427
+	RL(X1);
428
+	L(Y1);
429
+	U(Y1);
430
+	RU(X1);
431
+
432
+	L(Y1);
433
+	RL(X1);
434
+	RU(X1);
435
+	U(Y1);
436
+
437
+	L(Y1);
438
+	WL(X1);
439
+	WU(X1);
440
+	U(Y1); // should fail
396441 }
397442 
398443 /*
....@@ -991,6 +1036,133 @@
9911036 #undef E3
9921037 
9931038 /*
1039
+ * write-read / write-read / write-read deadlock even if read is recursive
1040
+ */
1041
+
1042
+#define E1()				\
1043
+					\
1044
+	WL(X1);				\
1045
+	RL(Y1);				\
1046
+	RU(Y1);				\
1047
+	WU(X1);
1048
+
1049
+#define E2()				\
1050
+					\
1051
+	WL(Y1);				\
1052
+	RL(Z1);				\
1053
+	RU(Z1);				\
1054
+	WU(Y1);
1055
+
1056
+#define E3()				\
1057
+					\
1058
+	WL(Z1);				\
1059
+	RL(X1);				\
1060
+	RU(X1);				\
1061
+	WU(Z1);
1062
+
1063
+#include "locking-selftest-rlock.h"
1064
+GENERATE_PERMUTATIONS_3_EVENTS(W1R2_W2R3_W3R1)
1065
+
1066
+#undef E1
1067
+#undef E2
1068
+#undef E3
1069
+
1070
+/*
1071
+ * write-write / read-read / write-read deadlock even if read is recursive
1072
+ */
1073
+
1074
+#define E1()				\
1075
+					\
1076
+	WL(X1);				\
1077
+	WL(Y1);				\
1078
+	WU(Y1);				\
1079
+	WU(X1);
1080
+
1081
+#define E2()				\
1082
+					\
1083
+	RL(Y1);				\
1084
+	RL(Z1);				\
1085
+	RU(Z1);				\
1086
+	RU(Y1);
1087
+
1088
+#define E3()				\
1089
+					\
1090
+	WL(Z1);				\
1091
+	RL(X1);				\
1092
+	RU(X1);				\
1093
+	WU(Z1);
1094
+
1095
+#include "locking-selftest-rlock.h"
1096
+GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_W3R1)
1097
+
1098
+#undef E1
1099
+#undef E2
1100
+#undef E3
1101
+
1102
+/*
1103
+ * write-write / read-read / read-write is not deadlock when read is recursive
1104
+ */
1105
+
1106
+#define E1()				\
1107
+					\
1108
+	WL(X1);				\
1109
+	WL(Y1);				\
1110
+	WU(Y1);				\
1111
+	WU(X1);
1112
+
1113
+#define E2()				\
1114
+					\
1115
+	RL(Y1);				\
1116
+	RL(Z1);				\
1117
+	RU(Z1);				\
1118
+	RU(Y1);
1119
+
1120
+#define E3()				\
1121
+					\
1122
+	RL(Z1);				\
1123
+	WL(X1);				\
1124
+	WU(X1);				\
1125
+	RU(Z1);
1126
+
1127
+#include "locking-selftest-rlock.h"
1128
+GENERATE_PERMUTATIONS_3_EVENTS(W1R2_R2R3_W3W1)
1129
+
1130
+#undef E1
1131
+#undef E2
1132
+#undef E3
1133
+
1134
+/*
1135
+ * write-read / read-read / write-write is not deadlock when read is recursive
1136
+ */
1137
+
1138
+#define E1()				\
1139
+					\
1140
+	WL(X1);				\
1141
+	RL(Y1);				\
1142
+	RU(Y1);				\
1143
+	WU(X1);
1144
+
1145
+#define E2()				\
1146
+					\
1147
+	RL(Y1);				\
1148
+	RL(Z1);				\
1149
+	RU(Z1);				\
1150
+	RU(Y1);
1151
+
1152
+#define E3()				\
1153
+					\
1154
+	WL(Z1);				\
1155
+	WL(X1);				\
1156
+	WU(X1);				\
1157
+	WU(Z1);
1158
+
1159
+#include "locking-selftest-rlock.h"
1160
+GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_R3W1)
1161
+
1162
+#undef E1
1163
+#undef E2
1164
+#undef E3
1165
+/*
9941166  * read-lock / write-lock recursion that is actually safe.
9951167  */
9961168 
....@@ -1009,20 +1181,28 @@
10091181 #define E3()				\
10101182 					\
10111183 	IRQ_ENTER();			\
1012
-	RL(A);				\
1184
+	LOCK(A);			\
10131185 	L(B);				\
10141186 	U(B);				\
1015
-	RU(A);				\
1187
+	UNLOCK(A);			\
10161188 	IRQ_EXIT();
10171189 
10181190 /*
1019
- * Generate 12 testcases:
1191
+ * Generate 24 testcases:
10201192  */
10211193 #include "locking-selftest-hardirq.h"
1022
-GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard)
1194
+#include "locking-selftest-rlock.h"
1195
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_rlock)
1196
+
1197
+#include "locking-selftest-wlock.h"
1198
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_wlock)
10231199 
10241200 #include "locking-selftest-softirq.h"
1025
-GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)
1201
+#include "locking-selftest-rlock.h"
1202
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_rlock)
1203
+
1204
+#include "locking-selftest-wlock.h"
1205
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_wlock)
10261206 
10271207 #undef E1
10281208 #undef E2
....@@ -1036,8 +1216,8 @@
10361216 					\
10371217 	IRQ_DISABLE();			\
10381218 	L(B);				\
1039
-	WL(A);				\
1040
-	WU(A);				\
1219
+	LOCK(A);			\
1220
+	UNLOCK(A);			\
10411221 	U(B);				\
10421222 	IRQ_ENABLE();
10431223 
....@@ -1054,13 +1234,75 @@
10541234 	IRQ_EXIT();
10551235 
10561236 /*
1057
- * Generate 12 testcases:
1237
+ * Generate 24 testcases:
10581238  */
10591239 #include "locking-selftest-hardirq.h"
1060
-// GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard)
1240
+#include "locking-selftest-rlock.h"
1241
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_rlock)
1242
+
1243
+#include "locking-selftest-wlock.h"
1244
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_wlock)
10611245 
10621246 #include "locking-selftest-softirq.h"
1063
-// GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft)
1247
+#include "locking-selftest-rlock.h"
1248
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_rlock)
1249
+
1250
+#include "locking-selftest-wlock.h"
1251
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_wlock)
1252
+
1253
+#undef E1
1254
+#undef E2
1255
+#undef E3
1256
+/*
1257
+ * read-lock / write-lock recursion that is unsafe.
1258
+ *
1259
+ * A is a ENABLED_*_READ lock
1260
+ * B is a USED_IN_*_READ lock
1261
+ *
1262
+ * read_lock(A);
1263
+ *			write_lock(B);
1264
+ * <interrupt>
1265
+ * read_lock(B);
1266
+ * 			write_lock(A); // if this one is read_lock(), no deadlock
1267
+ */
1268
+
1269
+#define E1()				\
1270
+					\
1271
+	IRQ_DISABLE();			\
1272
+	WL(B);				\
1273
+	LOCK(A);			\
1274
+	UNLOCK(A);			\
1275
+	WU(B);				\
1276
+	IRQ_ENABLE();
1277
+
1278
+#define E2()				\
1279
+					\
1280
+	RL(A);				\
1281
+	RU(A);				\
1282
+
1283
+#define E3()				\
1284
+					\
1285
+	IRQ_ENTER();			\
1286
+	RL(B);				\
1287
+	RU(B);				\
1288
+	IRQ_EXIT();
1289
+
1290
+/*
1291
+ * Generate 24 testcases:
1292
+ */
1293
+#include "locking-selftest-hardirq.h"
1294
+#include "locking-selftest-rlock.h"
1295
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_rlock)
1296
+
1297
+#include "locking-selftest-wlock.h"
1298
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_wlock)
1299
+
1300
+#include "locking-selftest-softirq.h"
1301
+#include "locking-selftest-rlock.h"
1302
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_rlock)
1303
+
1304
+#include "locking-selftest-wlock.h"
1305
+GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock)
10641306 
10651307 #ifdef CONFIG_DEBUG_LOCK_ALLOC
10661308 # define I_SPINLOCK(x)	lockdep_reset_lock(&lock_##x.dep_map)
....@@ -1199,6 +1441,19 @@
11991441 	dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK);		\
12001442 	pr_cont("\n");
12011443 
1444
+#define DO_TESTCASE_1RR(desc, name, nr)				\
1445
+	print_testname(desc"/"#nr);				\
1446
+	pr_cont("             |");				\
1447
+	dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK);		\
1448
+	pr_cont("\n");
1449
+
1450
+#define DO_TESTCASE_1RRB(desc, name, nr)			\
1451
+	print_testname(desc"/"#nr);				\
1452
+	pr_cont("             |");				\
1453
+	dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK);		\
1454
+	pr_cont("\n");
1455
+
1456
+
12021457 #define DO_TESTCASE_3(desc, name, nr)				\
12031458 	print_testname(desc"/"#nr);				\
12041459 	dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN);	\
....@@ -1212,6 +1467,25 @@
12121467 	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\
12131468 	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\
12141469 	pr_cont("\n");
1470
+
1471
+#define DO_TESTCASE_2RW(desc, name, nr)				\
1472
+	print_testname(desc"/"#nr);				\
1473
+	pr_cont("      |");					\
1474
+	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\
1475
+	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\
1476
+	pr_cont("\n");
1477
+
1478
+#define DO_TESTCASE_2x2RW(desc, name, nr)			\
1479
+	DO_TESTCASE_2RW("hard-"desc, name##_hard, nr)		\
1480
+	DO_TESTCASE_2RW("soft-"desc, name##_soft, nr)		\
1481
+
1482
+#define DO_TESTCASE_6x2x2RW(desc, name)				\
1483
+	DO_TESTCASE_2x2RW(desc, name, 123);			\
1484
+	DO_TESTCASE_2x2RW(desc, name, 132);			\
1485
+	DO_TESTCASE_2x2RW(desc, name, 213);			\
1486
+	DO_TESTCASE_2x2RW(desc, name, 231);			\
1487
+	DO_TESTCASE_2x2RW(desc, name, 312);			\
1488
+	DO_TESTCASE_2x2RW(desc, name, 321);
12151489 
12161490 #define DO_TESTCASE_6(desc, name)				\
12171491 	print_testname(desc);					\
....@@ -1288,6 +1562,22 @@
12881562 	DO_TESTCASE_2IB(desc, name, 231);			\
12891563 	DO_TESTCASE_2IB(desc, name, 312);			\
12901564 	DO_TESTCASE_2IB(desc, name, 321);
1565
+
1566
+#define DO_TESTCASE_6x1RR(desc, name)				\
1567
+	DO_TESTCASE_1RR(desc, name, 123);			\
1568
+	DO_TESTCASE_1RR(desc, name, 132);			\
1569
+	DO_TESTCASE_1RR(desc, name, 213);			\
1570
+	DO_TESTCASE_1RR(desc, name, 231);			\
1571
+	DO_TESTCASE_1RR(desc, name, 312);			\
1572
+	DO_TESTCASE_1RR(desc, name, 321);
1573
+
1574
+#define DO_TESTCASE_6x1RRB(desc, name)				\
1575
+	DO_TESTCASE_1RRB(desc, name, 123);			\
1576
+	DO_TESTCASE_1RRB(desc, name, 132);			\
1577
+	DO_TESTCASE_1RRB(desc, name, 213);			\
1578
+	DO_TESTCASE_1RRB(desc, name, 231);			\
1579
+	DO_TESTCASE_1RRB(desc, name, 312);			\
1580
+	DO_TESTCASE_1RRB(desc, name, 321);
12911581 
12921582 #define DO_TESTCASE_6x6(desc, name)				\
12931583 	DO_TESTCASE_6I(desc, name, 123);			\
....@@ -1475,7 +1765,7 @@
14751765 
14761766 	mutex_lock(&o2.base);
14771767 	o2.ctx = &t2;
1478
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1768
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
14791769 
14801770 	WWAI(&t);
14811771 	t2 = t;
....@@ -1500,7 +1790,7 @@
15001790 	int ret;
15011791 
15021792 	mutex_lock(&o2.base);
1503
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1793
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
15041794 	o2.ctx = &t2;
15051795 
15061796 	WWAI(&t);
....@@ -1527,7 +1817,7 @@
15271817 
15281818 	mutex_lock(&o2.base);
15291819 	o2.ctx = &t2;
1530
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1820
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
15311821 
15321822 	WWAI(&t);
15331823 	t2 = t;
....@@ -1551,7 +1841,7 @@
15511841 	int ret;
15521842 
15531843 	mutex_lock(&o2.base);
1554
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1844
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
15551845 	o2.ctx = &t2;
15561846 
15571847 	WWAI(&t);
....@@ -1576,7 +1866,7 @@
15761866 	int ret;
15771867 
15781868 	mutex_lock(&o2.base);
1579
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1869
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
15801870 	o2.ctx = &t2;
15811871 
15821872 	WWAI(&t);
....@@ -1597,7 +1887,7 @@
15971887 	int ret;
15981888 
15991889 	mutex_lock(&o2.base);
1600
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1890
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
16011891 	o2.ctx = &t2;
16021892 
16031893 	WWAI(&t);
....@@ -1618,11 +1908,11 @@
16181908 	int ret;
16191909 
16201910 	mutex_lock(&o2.base);
1621
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1911
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
16221912 	o2.ctx = &t2;
16231913 
16241914 	mutex_lock(&o3.base);
1625
-	mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
1915
+	mutex_release(&o3.base.dep_map, _THIS_IP_);
16261916 	o3.ctx = &t2;
16271917 
16281918 	WWAI(&t);
....@@ -1644,11 +1934,11 @@
16441934 	int ret;
16451935 
16461936 	mutex_lock(&o2.base);
1647
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1937
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
16481938 	o2.ctx = &t2;
16491939 
16501940 	mutex_lock(&o3.base);
1651
-	mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
1941
+	mutex_release(&o3.base.dep_map, _THIS_IP_);
16521942 	o3.ctx = &t2;
16531943 
16541944 	WWAI(&t);
....@@ -1669,7 +1959,7 @@
16691959 	int ret;
16701960 
16711961 	mutex_lock(&o2.base);
1672
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1962
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
16731963 	o2.ctx = &t2;
16741964 
16751965 	WWAI(&t);
....@@ -1694,7 +1984,7 @@
16941984 	int ret;
16951985 
16961986 	mutex_lock(&o2.base);
1697
-	mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1987
+	mutex_release(&o2.base.dep_map, _THIS_IP_);
16981988 	o2.ctx = &t2;
16991989 
17001990 	WWAI(&t);
....@@ -1966,6 +2256,108 @@
19662256 	pr_cont("\n");
19672257 }
19682258 
2259
+
2260
+/*
2261
+ * <in hardirq handler>
2262
+ * read_lock(&A);
2263
+ *			<hardirq disable>
2264
+ *			spin_lock(&B);
2265
+ * spin_lock(&B);
2266
+ *			read_lock(&A);
2267
+ *
2268
+ * is a deadlock.
2269
+ */
2270
+static void queued_read_lock_hardirq_RE_Er(void)
2271
+{
2272
+	HARDIRQ_ENTER();
2273
+	read_lock(&rwlock_A);
2274
+	LOCK(B);
2275
+	UNLOCK(B);
2276
+	read_unlock(&rwlock_A);
2277
+	HARDIRQ_EXIT();
2278
+
2279
+	HARDIRQ_DISABLE();
2280
+	LOCK(B);
2281
+	read_lock(&rwlock_A);
2282
+	read_unlock(&rwlock_A);
2283
+	UNLOCK(B);
2284
+	HARDIRQ_ENABLE();
2285
+}
2286
+
2287
+/*
2288
+ * <in hardirq handler>
2289
+ * spin_lock(&B);
2290
+ *			<hardirq disable>
2291
+ *			read_lock(&A);
2292
+ * read_lock(&A);
2293
+ *			spin_lock(&B);
2294
+ *
2295
+ * is not a deadlock.
2296
+ */
2297
+static void queued_read_lock_hardirq_ER_rE(void)
2298
+{
2299
+	HARDIRQ_ENTER();
2300
+	LOCK(B);
2301
+	read_lock(&rwlock_A);
2302
+	read_unlock(&rwlock_A);
2303
+	UNLOCK(B);
2304
+	HARDIRQ_EXIT();
2305
+
2306
+	HARDIRQ_DISABLE();
2307
+	read_lock(&rwlock_A);
2308
+	LOCK(B);
2309
+	UNLOCK(B);
2310
+	read_unlock(&rwlock_A);
2311
+	HARDIRQ_ENABLE();
2312
+}
2313
+
2314
+/*
2315
+ * <hardirq disable>
2316
+ * spin_lock(&B);
2317
+ *			read_lock(&A);
2318
+ *			<in hardirq handler>
2319
+ *			spin_lock(&B);
2320
+ * read_lock(&A);
2321
+ *
2322
+ * is a deadlock. Because the two read_lock()s are both non-recursive readers.
2323
+ */
2324
+static void queued_read_lock_hardirq_inversion(void)
2325
+{
2326
+
2327
+	HARDIRQ_ENTER();
2328
+	LOCK(B);
2329
+	UNLOCK(B);
2330
+	HARDIRQ_EXIT();
2331
+
2332
+	HARDIRQ_DISABLE();
2333
+	LOCK(B);
2334
+	read_lock(&rwlock_A);
2335
+	read_unlock(&rwlock_A);
2336
+	UNLOCK(B);
2337
+	HARDIRQ_ENABLE();
2338
+
2339
+	read_lock(&rwlock_A);
2340
+	read_unlock(&rwlock_A);
2341
+}
2342
+
2343
+static void queued_read_lock_tests(void)
2344
+{
2345
+	printk("  --------------------------------------------------------------------------\n");
2346
+	printk("  | queued read lock tests |\n");
2347
+	printk("  ---------------------------\n");
2348
+	print_testname("hardirq read-lock/lock-read");
2349
+	dotest(queued_read_lock_hardirq_RE_Er, FAILURE, LOCKTYPE_RWLOCK);
2350
+	pr_cont("\n");
2351
+
2352
+	print_testname("hardirq lock-read/read-lock");
2353
+	dotest(queued_read_lock_hardirq_ER_rE, SUCCESS, LOCKTYPE_RWLOCK);
2354
+	pr_cont("\n");
2355
+
2356
+	print_testname("hardirq inversion");
2357
+	dotest(queued_read_lock_hardirq_inversion, FAILURE, LOCKTYPE_RWLOCK);
2358
+	pr_cont("\n");
2359
+}
2360
+
19692361 void locking_selftest(void)
19702362 {
19712363 	/*
....@@ -1979,6 +2371,11 @@
19792371 	}
19802372 
19812373 	/*
2374
+	 * treats read_lock() as recursive read locks for testing purpose
2375
+	 */
2376
+	force_read_lock_recursive = 1;
2377
+
2378
+	/*
19822379 	 * Run the testsuite:
19832380 	 */
19842381 	printk("------------------------\n");
....@@ -1989,6 +2386,7 @@
19892386 
19902387 	init_shared_classes();
19912388 	debug_locks_silent = !debug_locks_verbose;
2389
+	lockdep_set_selftest_task(current);
19922390 
19932391 	DO_TESTCASE_6R("A-A deadlock", AA);
19942392 	DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
....@@ -2032,14 +2430,6 @@
20322430 	print_testname("mixed read-lock/lock-write ABBA");
20332431 	pr_cont("             |");
20342432 	dotest(rlock_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2035
-#ifdef CONFIG_PROVE_LOCKING
2036
-	/*
2037
-	 * Lockdep does indeed fail here, but there's nothing we can do about
2038
-	 * that now.  Don't kill lockdep for it.
2039
-	 */
2040
-	unexpected_testcase_failures--;
2041
-#endif
2042
-
20432433 	pr_cont("             |");
20442434 	dotest(rwsem_ABBA1, FAILURE, LOCKTYPE_RWSEM);
20452435 
....@@ -2055,6 +2445,15 @@
20552445 	pr_cont("             |");
20562446 	dotest(rwsem_ABBA3, FAILURE, LOCKTYPE_RWSEM);
20572447 
2448
+	print_testname("chain cached mixed R-L/L-W ABBA");
2449
+	pr_cont("             |");
2450
+	dotest(rlock_chaincache_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2451
+
2452
+	DO_TESTCASE_6x1RRB("rlock W1R2/W2R3/W3R1", W1R2_W2R3_W3R1);
2453
+	DO_TESTCASE_6x1RRB("rlock W1W2/R2R3/W3R1", W1W2_R2R3_W3R1);
2454
+	DO_TESTCASE_6x1RR("rlock W1W2/R2R3/R3W1", W1W2_R2R3_R3W1);
2455
+	DO_TESTCASE_6x1RR("rlock W1R2/R2R3/W3W1", W1R2_R2R3_W3W1);
2456
+
20582457 	printk("  --------------------------------------------------------------------------\n");
20592458 
20602459 	/*
....@@ -2067,10 +2466,18 @@
20672466 	DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
20682467 	DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
20692468 
2070
-	DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
2071
-//	DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
2469
+	DO_TESTCASE_6x2x2RW("irq read-recursion", irq_read_recursion);
2470
+	DO_TESTCASE_6x2x2RW("irq read-recursion #2", irq_read_recursion2);
2471
+	DO_TESTCASE_6x2x2RW("irq read-recursion #3", irq_read_recursion3);
20722472 
20732473 	ww_tests();
2474
+
2475
+	force_read_lock_recursive = 0;
2476
+	/*
2477
+	 * queued_read_lock() specific test cases can be put here
2478
+	 */
2479
+	if (IS_ENABLED(CONFIG_QUEUED_RWLOCKS))
2480
+		queued_read_lock_tests();
20742481 
20752482 	if (unexpected_testcase_failures) {
20762483 		printk("-----------------------------------------------------------------\n");
....@@ -2097,5 +2504,6 @@
20972504 		printk("---------------------------------\n");
20982505 		debug_locks = 1;
20992506 	}
2507
+	lockdep_set_selftest_task(NULL);
21002508 	debug_locks_silent = 0;
21012509 }