lib/locking-selftest.c

   1 /*
   2  * lib/locking-selftest.c
   3  *
   4  * Testsuite for various locking APIs: spinlocks, rwlocks,
   5  * mutexes and rw-semaphores.
   6  *
   7  * It is checking both false positives and false negatives.
   8  *
   9  * Started by Ingo Molnar:
  10  *
  11  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  12  */
  13 #include <linux/rwsem.h>
  14 #include <linux/mutex.h>
  15 #include <linux/ww_mutex.h>
  16 #include <linux/sched.h>
  17 #include <linux/delay.h>
  18 #include <linux/lockdep.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/kallsyms.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/debug_locks.h>
  23 #include <linux/irqflags.h>
  24 #include <linux/rtmutex.h>
  25
  26 /*
  27  * Change this to 1 if you want to see the failure printouts:
  28  */
  29 static unsigned int debug_locks_verbose;
  30
  31 static DEFINE_WW_CLASS(ww_lockdep);
  32
  33 static int __init setup_debug_locks_verbose(char *str)
  34 {
  35         get_option(&str, &debug_locks_verbose);
  36
  37         return 1;
  38 }
  39
  40 __setup("debug_locks_verbose=", setup_debug_locks_verbose);
  41
  42 #define FAILURE         0
  43 #define SUCCESS         1
  44
  45 #define LOCKTYPE_SPIN   0x1
  46 #define LOCKTYPE_RWLOCK 0x2
  47 #define LOCKTYPE_MUTEX  0x4
  48 #define LOCKTYPE_RWSEM  0x8
  49 #define LOCKTYPE_WW     0x10
  50 #define LOCKTYPE_RTMUTEX 0x20
  51
  52 static struct ww_acquire_ctx t, t2;
  53 static struct ww_mutex o, o2, o3;
  54
  55 /*
  56  * Normal standalone locks, for the circular and irq-context
  57  * dependency tests:
  58  */
  59 static DEFINE_RAW_SPINLOCK(lock_A);
  60 static DEFINE_RAW_SPINLOCK(lock_B);
  61 static DEFINE_RAW_SPINLOCK(lock_C);
  62 static DEFINE_RAW_SPINLOCK(lock_D);
  63
  64 static DEFINE_RWLOCK(rwlock_A);
  65 static DEFINE_RWLOCK(rwlock_B);
  66 static DEFINE_RWLOCK(rwlock_C);
  67 static DEFINE_RWLOCK(rwlock_D);
  68
  69 static DEFINE_MUTEX(mutex_A);
  70 static DEFINE_MUTEX(mutex_B);
  71 static DEFINE_MUTEX(mutex_C);
  72 static DEFINE_MUTEX(mutex_D);
  73
  74 static DECLARE_RWSEM(rwsem_A);
  75 static DECLARE_RWSEM(rwsem_B);
  76 static DECLARE_RWSEM(rwsem_C);
  77 static DECLARE_RWSEM(rwsem_D);
  78
  79 #ifdef CONFIG_RT_MUTEXES
  80
  81 static DEFINE_RT_MUTEX(rtmutex_A);
  82 static DEFINE_RT_MUTEX(rtmutex_B);
  83 static DEFINE_RT_MUTEX(rtmutex_C);
  84 static DEFINE_RT_MUTEX(rtmutex_D);
  85
  86 #endif
  87
  88 /*
  89  * Locks that we initialize dynamically as well so that
  90  * e.g. X1 and X2 becomes two instances of the same class,
  91  * but X* and Y* are different classes. We do this so that
  92  * we do not trigger a real lockup:
  93  */
  94 static DEFINE_RAW_SPINLOCK(lock_X1);
  95 static DEFINE_RAW_SPINLOCK(lock_X2);
  96 static DEFINE_RAW_SPINLOCK(lock_Y1);
  97 static DEFINE_RAW_SPINLOCK(lock_Y2);
  98 static DEFINE_RAW_SPINLOCK(lock_Z1);
  99 static DEFINE_RAW_SPINLOCK(lock_Z2);
 100
 101 static DEFINE_RWLOCK(rwlock_X1);
 102 static DEFINE_RWLOCK(rwlock_X2);
 103 static DEFINE_RWLOCK(rwlock_Y1);
 104 static DEFINE_RWLOCK(rwlock_Y2);
 105 static DEFINE_RWLOCK(rwlock_Z1);
 106 static DEFINE_RWLOCK(rwlock_Z2);
 107
 108 static DEFINE_MUTEX(mutex_X1);
 109 static DEFINE_MUTEX(mutex_X2);
 110 static DEFINE_MUTEX(mutex_Y1);
 111 static DEFINE_MUTEX(mutex_Y2);
 112 static DEFINE_MUTEX(mutex_Z1);
 113 static DEFINE_MUTEX(mutex_Z2);
 114
 115 static DECLARE_RWSEM(rwsem_X1);
 116 static DECLARE_RWSEM(rwsem_X2);
 117 static DECLARE_RWSEM(rwsem_Y1);
 118 static DECLARE_RWSEM(rwsem_Y2);
 119 static DECLARE_RWSEM(rwsem_Z1);
 120 static DECLARE_RWSEM(rwsem_Z2);
 121
 122 #ifdef CONFIG_RT_MUTEXES
 123
 124 static DEFINE_RT_MUTEX(rtmutex_X1);
 125 static DEFINE_RT_MUTEX(rtmutex_X2);
 126 static DEFINE_RT_MUTEX(rtmutex_Y1);
 127 static DEFINE_RT_MUTEX(rtmutex_Y2);
 128 static DEFINE_RT_MUTEX(rtmutex_Z1);
 129 static DEFINE_RT_MUTEX(rtmutex_Z2);
 130
 131 #endif
 132
 133 /*
 134  * non-inlined runtime initializers, to let separate locks share
 135  * the same lock-class:
 136  */
 137 #define INIT_CLASS_FUNC(class)                          \
 138 static noinline void                                    \
 139 init_class_##class(raw_spinlock_t *lock, rwlock_t *rwlock, \
 140         struct mutex *mutex, struct rw_semaphore *rwsem)\
 141 {                                                       \
 142         raw_spin_lock_init(lock);                       \
 143         rwlock_init(rwlock);                            \
 144         mutex_init(mutex);                              \
 145         init_rwsem(rwsem);                              \
 146 }
 147
 148 INIT_CLASS_FUNC(X)
 149 INIT_CLASS_FUNC(Y)
 150 INIT_CLASS_FUNC(Z)
 151
 152 static void init_shared_classes(void)
 153 {
 154 #ifdef CONFIG_RT_MUTEXES
 155         static struct lock_class_key rt_X, rt_Y, rt_Z;
 156
 157         __rt_mutex_init(&rtmutex_X1, __func__, &rt_X);
 158         __rt_mutex_init(&rtmutex_X2, __func__, &rt_X);
 159         __rt_mutex_init(&rtmutex_Y1, __func__, &rt_Y);
 160         __rt_mutex_init(&rtmutex_Y2, __func__, &rt_Y);
 161         __rt_mutex_init(&rtmutex_Z1, __func__, &rt_Z);
 162         __rt_mutex_init(&rtmutex_Z2, __func__, &rt_Z);
 163 #endif
 164
 165         init_class_X(&lock_X1, &rwlock_X1, &mutex_X1, &rwsem_X1);
 166         init_class_X(&lock_X2, &rwlock_X2, &mutex_X2, &rwsem_X2);
 167
 168         init_class_Y(&lock_Y1, &rwlock_Y1, &mutex_Y1, &rwsem_Y1);
 169         init_class_Y(&lock_Y2, &rwlock_Y2, &mutex_Y2, &rwsem_Y2);
 170
 171         init_class_Z(&lock_Z1, &rwlock_Z1, &mutex_Z1, &rwsem_Z1);
 172         init_class_Z(&lock_Z2, &rwlock_Z2, &mutex_Z2, &rwsem_Z2);
 173 }
 174
 175 /*
 176  * For spinlocks and rwlocks we also do hardirq-safe / softirq-safe tests.
 177  * The following functions use a lock from a simulated hardirq/softirq
 178  * context, causing the locks to be marked as hardirq-safe/softirq-safe:
 179  */
 180
 181 #define HARDIRQ_DISABLE         local_irq_disable
 182 #define HARDIRQ_ENABLE          local_irq_enable
 183
 184 #define HARDIRQ_ENTER()                         \
 185         local_irq_disable();                    \
 186         __irq_enter();                          \
 187         WARN_ON(!in_irq());
 188
 189 #define HARDIRQ_EXIT()                          \
 190         __irq_exit();                           \
 191         local_irq_enable();
 192
 193 #define SOFTIRQ_DISABLE         local_bh_disable
 194 #define SOFTIRQ_ENABLE          local_bh_enable
 195
 196 #define SOFTIRQ_ENTER()                         \
 197                 local_bh_disable();             \
 198                 local_irq_disable();            \
 199                 lockdep_softirq_enter();        \
 200                 WARN_ON(!in_softirq());
 201
 202 #define SOFTIRQ_EXIT()                          \
 203                 lockdep_softirq_exit();         \
 204                 local_irq_enable();             \
 205                 local_bh_enable();
 206
 207 /*
 208  * Shortcuts for lock/unlock API variants, to keep
 209  * the testcases compact:
 210  */
 211 #define L(x)                    raw_spin_lock(&lock_##x)
 212 #define U(x)                    raw_spin_unlock(&lock_##x)
 213 #define LU(x)                   L(x); U(x)
 214 #define SI(x)                   raw_spin_lock_init(&lock_##x)
 215
 216 #define WL(x)                   write_lock(&rwlock_##x)
 217 #define WU(x)                   write_unlock(&rwlock_##x)
 218 #define WLU(x)                  WL(x); WU(x)
 219
 220 #define RL(x)                   read_lock(&rwlock_##x)
 221 #define RU(x)                   read_unlock(&rwlock_##x)
 222 #define RLU(x)                  RL(x); RU(x)
 223 #define RWI(x)                  rwlock_init(&rwlock_##x)
 224
 225 #define ML(x)                   mutex_lock(&mutex_##x)
 226 #define MU(x)                   mutex_unlock(&mutex_##x)
 227 #define MI(x)                   mutex_init(&mutex_##x)
 228
 229 #define RTL(x)                  rt_mutex_lock(&rtmutex_##x)
 230 #define RTU(x)                  rt_mutex_unlock(&rtmutex_##x)
 231 #define RTI(x)                  rt_mutex_init(&rtmutex_##x)
 232
 233 #define WSL(x)                  down_write(&rwsem_##x)
 234 #define WSU(x)                  up_write(&rwsem_##x)
 235
 236 #define RSL(x)                  down_read(&rwsem_##x)
 237 #define RSU(x)                  up_read(&rwsem_##x)
 238 #define RWSI(x)                 init_rwsem(&rwsem_##x)
 239
 240 #ifndef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
 241 #define WWAI(x)                 ww_acquire_init(x, &ww_lockdep)
 242 #else
 243 #define WWAI(x)                 do { ww_acquire_init(x, &ww_lockdep); (x)->deadlock_inject_countdown = ~0U; } while (0)
 244 #endif
 245 #define WWAD(x)                 ww_acquire_done(x)
 246 #define WWAF(x)                 ww_acquire_fini(x)
 247
 248 #define WWL(x, c)               ww_mutex_lock(x, c)
 249 #define WWT(x)                  ww_mutex_trylock(x)
 250 #define WWL1(x)                 ww_mutex_lock(x, NULL)
 251 #define WWU(x)                  ww_mutex_unlock(x)
 252
 253
 254 #define LOCK_UNLOCK_2(x,y)      LOCK(x); LOCK(y); UNLOCK(y); UNLOCK(x)
 255
 256 /*
 257  * Generate different permutations of the same testcase, using
 258  * the same basic lock-dependency/state events:
 259  */
 260
 261 #define GENERATE_TESTCASE(name)                 \
 262                                                 \
 263 static void name(void) { E(); }
 264
 265 #define GENERATE_PERMUTATIONS_2_EVENTS(name)    \
 266                                                 \
 267 static void name##_12(void) { E1(); E2(); }     \
 268 static void name##_21(void) { E2(); E1(); }
 269
 270 #define GENERATE_PERMUTATIONS_3_EVENTS(name)            \
 271                                                         \
 272 static void name##_123(void) { E1(); E2(); E3(); }      \
 273 static void name##_132(void) { E1(); E3(); E2(); }      \
 274 static void name##_213(void) { E2(); E1(); E3(); }      \
 275 static void name##_231(void) { E2(); E3(); E1(); }      \
 276 static void name##_312(void) { E3(); E1(); E2(); }      \
 277 static void name##_321(void) { E3(); E2(); E1(); }
 278
 279 /*
 280  * AA deadlock:
 281  */
 282
 283 #define E()                                     \
 284                                                 \
 285         LOCK(X1);                               \
 286         LOCK(X2); /* this one should fail */
 287
 288 /*
 289  * 6 testcases:
 290  */
 291 #include "locking-selftest-spin.h"
 292 GENERATE_TESTCASE(AA_spin)
 293 #include "locking-selftest-wlock.h"
 294 GENERATE_TESTCASE(AA_wlock)
 295 #include "locking-selftest-rlock.h"
 296 GENERATE_TESTCASE(AA_rlock)
 297 #include "locking-selftest-mutex.h"
 298 GENERATE_TESTCASE(AA_mutex)
 299 #include "locking-selftest-wsem.h"
 300 GENERATE_TESTCASE(AA_wsem)
 301 #include "locking-selftest-rsem.h"
 302 GENERATE_TESTCASE(AA_rsem)
 303
 304 #ifdef CONFIG_RT_MUTEXES
 305 #include "locking-selftest-rtmutex.h"
 306 GENERATE_TESTCASE(AA_rtmutex);
 307 #endif
 308
 309 #undef E
 310
 311 /*
 312  * Special-case for read-locking, they are
 313  * allowed to recurse on the same lock class:
 314  */
 315 static void rlock_AA1(void)
 316 {
 317         RL(X1);
 318         RL(X1); // this one should NOT fail
 319 }
 320
 321 static void rlock_AA1B(void)
 322 {
 323         RL(X1);
 324         RL(X2); // this one should NOT fail
 325 }
 326
 327 static void rsem_AA1(void)
 328 {
 329         RSL(X1);
 330         RSL(X1); // this one should fail
 331 }
 332
 333 static void rsem_AA1B(void)
 334 {
 335         RSL(X1);
 336         RSL(X2); // this one should fail
 337 }
 338 /*
 339  * The mixing of read and write locks is not allowed:
 340  */
 341 static void rlock_AA2(void)
 342 {
 343         RL(X1);
 344         WL(X2); // this one should fail
 345 }
 346
 347 static void rsem_AA2(void)
 348 {
 349         RSL(X1);
 350         WSL(X2); // this one should fail
 351 }
 352
 353 static void rlock_AA3(void)
 354 {
 355         WL(X1);
 356         RL(X2); // this one should fail
 357 }
 358
 359 static void rsem_AA3(void)
 360 {
 361         WSL(X1);
 362         RSL(X2); // this one should fail
 363 }
 364
 365 /*
 366  * ABBA deadlock:
 367  */
 368
 369 #define E()                                     \
 370                                                 \
 371         LOCK_UNLOCK_2(A, B);                    \
 372         LOCK_UNLOCK_2(B, A); /* fail */
 373
 374 /*
 375  * 6 testcases:
 376  */
 377 #include "locking-selftest-spin.h"
 378 GENERATE_TESTCASE(ABBA_spin)
 379 #include "locking-selftest-wlock.h"
 380 GENERATE_TESTCASE(ABBA_wlock)
 381 #include "locking-selftest-rlock.h"
 382 GENERATE_TESTCASE(ABBA_rlock)
 383 #include "locking-selftest-mutex.h"
 384 GENERATE_TESTCASE(ABBA_mutex)
 385 #include "locking-selftest-wsem.h"
 386 GENERATE_TESTCASE(ABBA_wsem)
 387 #include "locking-selftest-rsem.h"
 388 GENERATE_TESTCASE(ABBA_rsem)
 389
 390 #ifdef CONFIG_RT_MUTEXES
 391 #include "locking-selftest-rtmutex.h"
 392 GENERATE_TESTCASE(ABBA_rtmutex);
 393 #endif
 394
 395 #undef E
 396
 397 /*
 398  * AB BC CA deadlock:
 399  */
 400
 401 #define E()                                     \
 402                                                 \
 403         LOCK_UNLOCK_2(A, B);                    \
 404         LOCK_UNLOCK_2(B, C);                    \
 405         LOCK_UNLOCK_2(C, A); /* fail */
 406
 407 /*
 408  * 6 testcases:
 409  */
 410 #include "locking-selftest-spin.h"
 411 GENERATE_TESTCASE(ABBCCA_spin)
 412 #include "locking-selftest-wlock.h"
 413 GENERATE_TESTCASE(ABBCCA_wlock)
 414 #include "locking-selftest-rlock.h"
 415 GENERATE_TESTCASE(ABBCCA_rlock)
 416 #include "locking-selftest-mutex.h"
 417 GENERATE_TESTCASE(ABBCCA_mutex)
 418 #include "locking-selftest-wsem.h"
 419 GENERATE_TESTCASE(ABBCCA_wsem)
 420 #include "locking-selftest-rsem.h"
 421 GENERATE_TESTCASE(ABBCCA_rsem)
 422
 423 #ifdef CONFIG_RT_MUTEXES
 424 #include "locking-selftest-rtmutex.h"
 425 GENERATE_TESTCASE(ABBCCA_rtmutex);
 426 #endif
 427
 428 #undef E
 429
 430 /*
 431  * AB CA BC deadlock:
 432  */
 433
 434 #define E()                                     \
 435                                                 \
 436         LOCK_UNLOCK_2(A, B);                    \
 437         LOCK_UNLOCK_2(C, A);                    \
 438         LOCK_UNLOCK_2(B, C); /* fail */
 439
 440 /*
 441  * 6 testcases:
 442  */
 443 #include "locking-selftest-spin.h"
 444 GENERATE_TESTCASE(ABCABC_spin)
 445 #include "locking-selftest-wlock.h"
 446 GENERATE_TESTCASE(ABCABC_wlock)
 447 #include "locking-selftest-rlock.h"
 448 GENERATE_TESTCASE(ABCABC_rlock)
 449 #include "locking-selftest-mutex.h"
 450 GENERATE_TESTCASE(ABCABC_mutex)
 451 #include "locking-selftest-wsem.h"
 452 GENERATE_TESTCASE(ABCABC_wsem)
 453 #include "locking-selftest-rsem.h"
 454 GENERATE_TESTCASE(ABCABC_rsem)
 455
 456 #ifdef CONFIG_RT_MUTEXES
 457 #include "locking-selftest-rtmutex.h"
 458 GENERATE_TESTCASE(ABCABC_rtmutex);
 459 #endif
 460
 461 #undef E
 462
 463 /*
 464  * AB BC CD DA deadlock:
 465  */
 466
 467 #define E()                                     \
 468                                                 \
 469         LOCK_UNLOCK_2(A, B);                    \
 470         LOCK_UNLOCK_2(B, C);                    \
 471         LOCK_UNLOCK_2(C, D);                    \
 472         LOCK_UNLOCK_2(D, A); /* fail */
 473
 474 /*
 475  * 6 testcases:
 476  */
 477 #include "locking-selftest-spin.h"
 478 GENERATE_TESTCASE(ABBCCDDA_spin)
 479 #include "locking-selftest-wlock.h"
 480 GENERATE_TESTCASE(ABBCCDDA_wlock)
 481 #include "locking-selftest-rlock.h"
 482 GENERATE_TESTCASE(ABBCCDDA_rlock)
 483 #include "locking-selftest-mutex.h"
 484 GENERATE_TESTCASE(ABBCCDDA_mutex)
 485 #include "locking-selftest-wsem.h"
 486 GENERATE_TESTCASE(ABBCCDDA_wsem)
 487 #include "locking-selftest-rsem.h"
 488 GENERATE_TESTCASE(ABBCCDDA_rsem)
 489
 490 #ifdef CONFIG_RT_MUTEXES
 491 #include "locking-selftest-rtmutex.h"
 492 GENERATE_TESTCASE(ABBCCDDA_rtmutex);
 493 #endif
 494
 495 #undef E
 496
 497 /*
 498  * AB CD BD DA deadlock:
 499  */
 500 #define E()                                     \
 501                                                 \
 502         LOCK_UNLOCK_2(A, B);                    \
 503         LOCK_UNLOCK_2(C, D);                    \
 504         LOCK_UNLOCK_2(B, D);                    \
 505         LOCK_UNLOCK_2(D, A); /* fail */
 506
 507 /*
 508  * 6 testcases:
 509  */
 510 #include "locking-selftest-spin.h"
 511 GENERATE_TESTCASE(ABCDBDDA_spin)
 512 #include "locking-selftest-wlock.h"
 513 GENERATE_TESTCASE(ABCDBDDA_wlock)
 514 #include "locking-selftest-rlock.h"
 515 GENERATE_TESTCASE(ABCDBDDA_rlock)
 516 #include "locking-selftest-mutex.h"
 517 GENERATE_TESTCASE(ABCDBDDA_mutex)
 518 #include "locking-selftest-wsem.h"
 519 GENERATE_TESTCASE(ABCDBDDA_wsem)
 520 #include "locking-selftest-rsem.h"
 521 GENERATE_TESTCASE(ABCDBDDA_rsem)
 522
 523 #ifdef CONFIG_RT_MUTEXES
 524 #include "locking-selftest-rtmutex.h"
 525 GENERATE_TESTCASE(ABCDBDDA_rtmutex);
 526 #endif
 527
 528 #undef E
 529
 530 /*
 531  * AB CD BC DA deadlock:
 532  */
 533 #define E()                                     \
 534                                                 \
 535         LOCK_UNLOCK_2(A, B);                    \
 536         LOCK_UNLOCK_2(C, D);                    \
 537         LOCK_UNLOCK_2(B, C);                    \
 538         LOCK_UNLOCK_2(D, A); /* fail */
 539
 540 /*
 541  * 6 testcases:
 542  */
 543 #include "locking-selftest-spin.h"
 544 GENERATE_TESTCASE(ABCDBCDA_spin)
 545 #include "locking-selftest-wlock.h"
 546 GENERATE_TESTCASE(ABCDBCDA_wlock)
 547 #include "locking-selftest-rlock.h"
 548 GENERATE_TESTCASE(ABCDBCDA_rlock)
 549 #include "locking-selftest-mutex.h"
 550 GENERATE_TESTCASE(ABCDBCDA_mutex)
 551 #include "locking-selftest-wsem.h"
 552 GENERATE_TESTCASE(ABCDBCDA_wsem)
 553 #include "locking-selftest-rsem.h"
 554 GENERATE_TESTCASE(ABCDBCDA_rsem)
 555
 556 #ifdef CONFIG_RT_MUTEXES
 557 #include "locking-selftest-rtmutex.h"
 558 GENERATE_TESTCASE(ABCDBCDA_rtmutex);
 559 #endif
 560
 561 #undef E
 562
 563 /*
 564  * Double unlock:
 565  */
 566 #define E()                                     \
 567                                                 \
 568         LOCK(A);                                \
 569         UNLOCK(A);                              \
 570         UNLOCK(A); /* fail */
 571
 572 /*
 573  * 6 testcases:
 574  */
 575 #include "locking-selftest-spin.h"
 576 GENERATE_TESTCASE(double_unlock_spin)
 577 #include "locking-selftest-wlock.h"
 578 GENERATE_TESTCASE(double_unlock_wlock)
 579 #include "locking-selftest-rlock.h"
 580 GENERATE_TESTCASE(double_unlock_rlock)
 581 #include "locking-selftest-mutex.h"
 582 GENERATE_TESTCASE(double_unlock_mutex)
 583 #include "locking-selftest-wsem.h"
 584 GENERATE_TESTCASE(double_unlock_wsem)
 585 #include "locking-selftest-rsem.h"
 586 GENERATE_TESTCASE(double_unlock_rsem)
 587
 588 #ifdef CONFIG_RT_MUTEXES
 589 #include "locking-selftest-rtmutex.h"
 590 GENERATE_TESTCASE(double_unlock_rtmutex);
 591 #endif
 592
 593 #undef E
 594
 595 /*
 596  * initializing a held lock:
 597  */
 598 #define E()                                     \
 599                                                 \
 600         LOCK(A);                                \
 601         INIT(A); /* fail */
 602
 603 /*
 604  * 6 testcases:
 605  */
 606 #include "locking-selftest-spin.h"
 607 GENERATE_TESTCASE(init_held_spin)
 608 #include "locking-selftest-wlock.h"
 609 GENERATE_TESTCASE(init_held_wlock)
 610 #include "locking-selftest-rlock.h"
 611 GENERATE_TESTCASE(init_held_rlock)
 612 #include "locking-selftest-mutex.h"
 613 GENERATE_TESTCASE(init_held_mutex)
 614 #include "locking-selftest-wsem.h"
 615 GENERATE_TESTCASE(init_held_wsem)
 616 #include "locking-selftest-rsem.h"
 617 GENERATE_TESTCASE(init_held_rsem)
 618
 619 #ifdef CONFIG_RT_MUTEXES
 620 #include "locking-selftest-rtmutex.h"
 621 GENERATE_TESTCASE(init_held_rtmutex);
 622 #endif
 623
 624 #undef E
 625
 626 /*
 627  * locking an irq-safe lock with irqs enabled:
 628  */
 629 #define E1()                            \
 630                                         \
 631         IRQ_ENTER();                    \
 632         LOCK(A);                        \
 633         UNLOCK(A);                      \
 634         IRQ_EXIT();
 635
 636 #define E2()                            \
 637                                         \
 638         LOCK(A);                        \
 639         UNLOCK(A);
 640
 641 /*
 642  * Generate 24 testcases:
 643  */
 644 #include "locking-selftest-spin-hardirq.h"
 645 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
 646
 647 #include "locking-selftest-rlock-hardirq.h"
 648 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
 649
 650 #include "locking-selftest-wlock-hardirq.h"
 651 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
 652
 653 #include "locking-selftest-spin-softirq.h"
 654 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
 655
 656 #include "locking-selftest-rlock-softirq.h"
 657 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
 658
 659 #include "locking-selftest-wlock-softirq.h"
 660 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_wlock)
 661
 662 #undef E1
 663 #undef E2
 664
 665 /*
 666  * Enabling hardirqs with a softirq-safe lock held:
 667  */
 668 #define E1()                            \
 669                                         \
 670         SOFTIRQ_ENTER();                \
 671         LOCK(A);                        \
 672         UNLOCK(A);                      \
 673         SOFTIRQ_EXIT();
 674
 675 #define E2()                            \
 676                                         \
 677         HARDIRQ_DISABLE();              \
 678         LOCK(A);                        \
 679         HARDIRQ_ENABLE();               \
 680         UNLOCK(A);
 681
 682 /*
 683  * Generate 12 testcases:
 684  */
 685 #include "locking-selftest-spin.h"
 686 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
 687
 688 #include "locking-selftest-wlock.h"
 689 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
 690
 691 #include "locking-selftest-rlock.h"
 692 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_rlock)
 693
 694 #undef E1
 695 #undef E2
 696
 697 /*
 698  * Enabling irqs with an irq-safe lock held:
 699  */
 700 #define E1()                            \
 701                                         \
 702         IRQ_ENTER();                    \
 703         LOCK(A);                        \
 704         UNLOCK(A);                      \
 705         IRQ_EXIT();
 706
 707 #define E2()                            \
 708                                         \
 709         IRQ_DISABLE();                  \
 710         LOCK(A);                        \
 711         IRQ_ENABLE();                   \
 712         UNLOCK(A);
 713
 714 /*
 715  * Generate 24 testcases:
 716  */
 717 #include "locking-selftest-spin-hardirq.h"
 718 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
 719
 720 #include "locking-selftest-rlock-hardirq.h"
 721 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
 722
 723 #include "locking-selftest-wlock-hardirq.h"
 724 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
 725
 726 #include "locking-selftest-spin-softirq.h"
 727 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
 728
 729 #include "locking-selftest-rlock-softirq.h"
 730 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
 731
 732 #include "locking-selftest-wlock-softirq.h"
 733 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_wlock)
 734
 735 #undef E1
 736 #undef E2
 737
 738 /*
 739  * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
 740  */
 741 #define E1()                            \
 742                                         \
 743         LOCK(A);                        \
 744         LOCK(B);                        \
 745         UNLOCK(B);                      \
 746         UNLOCK(A);                      \
 747
 748 #define E2()                            \
 749                                         \
 750         LOCK(B);                        \
 751         UNLOCK(B);
 752
 753 #define E3()                            \
 754                                         \
 755         IRQ_ENTER();                    \
 756         LOCK(A);                        \
 757         UNLOCK(A);                      \
 758         IRQ_EXIT();
 759
 760 /*
 761  * Generate 36 testcases:
 762  */
 763 #include "locking-selftest-spin-hardirq.h"
 764 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
 765
 766 #include "locking-selftest-rlock-hardirq.h"
 767 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
 768
 769 #include "locking-selftest-wlock-hardirq.h"
 770 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
 771
 772 #include "locking-selftest-spin-softirq.h"
 773 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
 774
 775 #include "locking-selftest-rlock-softirq.h"
 776 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
 777
 778 #include "locking-selftest-wlock-softirq.h"
 779 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_wlock)
 780
 781 #undef E1
 782 #undef E2
 783 #undef E3
 784
 785 /*
 786  * If a lock turns into softirq-safe, but earlier it took
 787  * a softirq-unsafe lock:
 788  */
 789
 790 #define E1()                            \
 791         IRQ_DISABLE();                  \
 792         LOCK(A);                        \
 793         LOCK(B);                        \
 794         UNLOCK(B);                      \
 795         UNLOCK(A);                      \
 796         IRQ_ENABLE();
 797
 798 #define E2()                            \
 799         LOCK(B);                        \
 800         UNLOCK(B);
 801
 802 #define E3()                            \
 803         IRQ_ENTER();                    \
 804         LOCK(A);                        \
 805         UNLOCK(A);                      \
 806         IRQ_EXIT();
 807
 808 /*
 809  * Generate 36 testcases:
 810  */
 811 #include "locking-selftest-spin-hardirq.h"
 812 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
 813
 814 #include "locking-selftest-rlock-hardirq.h"
 815 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
 816
 817 #include "locking-selftest-wlock-hardirq.h"
 818 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
 819
 820 #include "locking-selftest-spin-softirq.h"
 821 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
 822
 823 #include "locking-selftest-rlock-softirq.h"
 824 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
 825
 826 #include "locking-selftest-wlock-softirq.h"
 827 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_wlock)
 828
 829 #undef E1
 830 #undef E2
 831 #undef E3
 832
 833 /*
 834  * read-lock / write-lock irq inversion.
 835  *
 836  * Deadlock scenario:
 837  *
 838  * CPU#1 is at #1, i.e. it has write-locked A, but has not
 839  * taken B yet.
 840  *
 841  * CPU#2 is at #2, i.e. it has locked B.
 842  *
 843  * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
 844  *
 845  * The deadlock occurs because CPU#1 will spin on B, and CPU#2
 846  * will spin on A.
 847  */
 848
 849 #define E1()                            \
 850                                         \
 851         IRQ_DISABLE();                  \
 852         WL(A);                          \
 853         LOCK(B);                        \
 854         UNLOCK(B);                      \
 855         WU(A);                          \
 856         IRQ_ENABLE();
 857
 858 #define E2()                            \
 859                                         \
 860         LOCK(B);                        \
 861         UNLOCK(B);
 862
 863 #define E3()                            \
 864                                         \
 865         IRQ_ENTER();                    \
 866         RL(A);                          \
 867         RU(A);                          \
 868         IRQ_EXIT();
 869
 870 /*
 871  * Generate 36 testcases:
 872  */
 873 #include "locking-selftest-spin-hardirq.h"
 874 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
 875
 876 #include "locking-selftest-rlock-hardirq.h"
 877 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
 878
 879 #include "locking-selftest-wlock-hardirq.h"
 880 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
 881
 882 #include "locking-selftest-spin-softirq.h"
 883 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
 884
 885 #include "locking-selftest-rlock-softirq.h"
 886 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
 887
 888 #include "locking-selftest-wlock-softirq.h"
 889 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
 890
 891 #undef E1
 892 #undef E2
 893 #undef E3
 894
 895 /*
 896  * read-lock / write-lock recursion that is actually safe.
 897  */
 898
 899 #define E1()                            \
 900                                         \
 901         IRQ_DISABLE();                  \
 902         WL(A);                          \
 903         WU(A);                          \
 904         IRQ_ENABLE();
 905
 906 #define E2()                            \
 907                                         \
 908         RL(A);                          \
 909         RU(A);                          \
 910
 911 #define E3()                            \
 912                                         \
 913         IRQ_ENTER();                    \
 914         RL(A);                          \
 915         L(B);                           \
 916         U(B);                           \
 917         RU(A);                          \
 918         IRQ_EXIT();
 919
 920 /*
 921  * Generate 12 testcases:
 922  */
 923 #include "locking-selftest-hardirq.h"
 924 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard)
 925
 926 #include "locking-selftest-softirq.h"
 927 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)
 928
 929 #undef E1
 930 #undef E2
 931 #undef E3
 932
 933 /*
 934  * read-lock / write-lock recursion that is unsafe.
 935  */
 936
 937 #define E1()                            \
 938                                         \
 939         IRQ_DISABLE();                  \
 940         L(B);                           \
 941         WL(A);                          \
 942         WU(A);                          \
 943         U(B);                           \
 944         IRQ_ENABLE();
 945
 946 #define E2()                            \
 947                                         \
 948         RL(A);                          \
 949         RU(A);                          \
 950
 951 #define E3()                            \
 952                                         \
 953         IRQ_ENTER();                    \
 954         L(B);                           \
 955         U(B);                           \
 956         IRQ_EXIT();
 957
 958 /*
 959  * Generate 12 testcases:
 960  */
 961 #include "locking-selftest-hardirq.h"
 962 // GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard)
 963
 964 #include "locking-selftest-softirq.h"
 965 // GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft)
 966
 967 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 968 # define I_SPINLOCK(x)  lockdep_reset_lock(&lock_##x.dep_map)
 969 # define I_RWLOCK(x)    lockdep_reset_lock(&rwlock_##x.dep_map)
 970 # define I_MUTEX(x)     lockdep_reset_lock(&mutex_##x.dep_map)
 971 # define I_RWSEM(x)     lockdep_reset_lock(&rwsem_##x.dep_map)
 972 # define I_WW(x)        lockdep_reset_lock(&x.dep_map)
 973 #ifdef CONFIG_RT_MUTEXES
 974 # define I_RTMUTEX(x)   lockdep_reset_lock(&rtmutex_##x.dep_map)
 975 #endif
 976 #else
 977 # define I_SPINLOCK(x)
 978 # define I_RWLOCK(x)
 979 # define I_MUTEX(x)
 980 # define I_RWSEM(x)
 981 # define I_WW(x)
 982 #endif
 983
 984 #ifndef I_RTMUTEX
 985 # define I_RTMUTEX(x)
 986 #endif
 987
 988 #ifdef CONFIG_RT_MUTEXES
 989 #define I2_RTMUTEX(x)   rt_mutex_init(&rtmutex_##x)
 990 #else
 991 #define I2_RTMUTEX(x)
 992 #endif
 993
 994 #define I1(x)                                   \
 995         do {                                    \
 996                 I_SPINLOCK(x);                  \
 997                 I_RWLOCK(x);                    \
 998                 I_MUTEX(x);                     \
 999                 I_RWSEM(x);                     \
1000                 I_RTMUTEX(x);                   \
1001         } while (0)
1002
1003 #define I2(x)                                   \
1004         do {                                    \
1005                 raw_spin_lock_init(&lock_##x);  \
1006                 rwlock_init(&rwlock_##x);       \
1007                 mutex_init(&mutex_##x);         \
1008                 init_rwsem(&rwsem_##x);         \
1009                 I2_RTMUTEX(x);                  \
1010         } while (0)
1011
1012 static void reset_locks(void)
1013 {
1014         local_irq_disable();
1015         lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
1016         lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
1017
1018         I1(A); I1(B); I1(C); I1(D);
1019         I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
1020         I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
1021         lockdep_reset();
1022         I2(A); I2(B); I2(C); I2(D);
1023         init_shared_classes();
1024
1025         ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
1026         memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
1027         memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));
1028         memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));
1029         local_irq_enable();
1030 }
1031
1032 #undef I
1033
1034 static int testcase_total;
1035 static int testcase_successes;
1036 static int expected_testcase_failures;
1037 static int unexpected_testcase_failures;
1038
1039 static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
1040 {
1041         unsigned long saved_preempt_count = preempt_count();
1042
1043         WARN_ON(irqs_disabled());
1044
1045         testcase_fn();
1046         /*
1047          * Filter out expected failures:
1048          */
1049 #ifndef CONFIG_PROVE_LOCKING
1050         if (expected == FAILURE && debug_locks) {
1051                 expected_testcase_failures++;
1052                 pr_cont("failed|");
1053         }
1054         else
1055 #endif
1056         if (debug_locks != expected) {
1057                 unexpected_testcase_failures++;
1058                 pr_cont("FAILED|");
1059
1060                 dump_stack();
1061         } else {
1062                 testcase_successes++;
1063                 pr_cont("  ok  |");
1064         }
1065         testcase_total++;
1066
1067         if (debug_locks_verbose)
1068                 pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
1069                         lockclass_mask, debug_locks, expected);
1070         /*
1071          * Some tests (e.g. double-unlock) might corrupt the preemption
1072          * count, so restore it:
1073          */
1074         preempt_count_set(saved_preempt_count);
1075 #ifdef CONFIG_TRACE_IRQFLAGS
1076         if (softirq_count())
1077                 current->softirqs_enabled = 0;
1078         else
1079                 current->softirqs_enabled = 1;
1080 #endif
1081
1082         reset_locks();
1083 }
1084
1085 #ifdef CONFIG_RT_MUTEXES
1086 #define dotest_rt(fn, e, m)     dotest((fn), (e), (m))
1087 #else
1088 #define dotest_rt(fn, e, m)
1089 #endif
1090
1091 static inline void print_testname(const char *testname)
1092 {
1093         printk("%33s:", testname);
1094 }
1095
1096 #define DO_TESTCASE_1(desc, name, nr)                           \
1097         print_testname(desc"/"#nr);                             \
1098         dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK);          \
1099         pr_cont("\n");
1100
1101 #define DO_TESTCASE_1B(desc, name, nr)                          \
1102         print_testname(desc"/"#nr);                             \
1103         dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK);          \
1104         pr_cont("\n");
1105
1106 #define DO_TESTCASE_3(desc, name, nr)                           \
1107         print_testname(desc"/"#nr);                             \
1108         dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN);       \
1109         dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);    \
1110         dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);    \
1111         pr_cont("\n");
1112
1113 #define DO_TESTCASE_3RW(desc, name, nr)                         \
1114         print_testname(desc"/"#nr);                             \
1115         dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
1116         dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);    \
1117         dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);    \
1118         pr_cont("\n");
1119
1120 #define DO_TESTCASE_6(desc, name)                               \
1121         print_testname(desc);                                   \
1122         dotest(name##_spin, FAILURE, LOCKTYPE_SPIN);            \
1123         dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK);         \
1124         dotest(name##_rlock, FAILURE, LOCKTYPE_RWLOCK);         \
1125         dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX);          \
1126         dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM);           \
1127         dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM);           \
1128         dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX);   \
1129         pr_cont("\n");
1130
1131 #define DO_TESTCASE_6_SUCCESS(desc, name)                       \
1132         print_testname(desc);                                   \
1133         dotest(name##_spin, SUCCESS, LOCKTYPE_SPIN);            \
1134         dotest(name##_wlock, SUCCESS, LOCKTYPE_RWLOCK);         \
1135         dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK);         \
1136         dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX);          \
1137         dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM);           \
1138         dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM);           \
1139         dotest_rt(name##_rtmutex, SUCCESS, LOCKTYPE_RTMUTEX);   \
1140         pr_cont("\n");
1141
1142 /*
1143  * 'read' variant: rlocks must not trigger.
1144  */
1145 #define DO_TESTCASE_6R(desc, name)                              \
1146         print_testname(desc);                                   \
1147         dotest(name##_spin, FAILURE, LOCKTYPE_SPIN);            \
1148         dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK);         \
1149         dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK);         \
1150         dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX);          \
1151         dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM);           \
1152         dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM);           \
1153         dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX);   \
1154         pr_cont("\n");
1155
1156 #define DO_TESTCASE_2I(desc, name, nr)                          \
1157         DO_TESTCASE_1("hard-"desc, name##_hard, nr);            \
1158         DO_TESTCASE_1("soft-"desc, name##_soft, nr);
1159
1160 #define DO_TESTCASE_2IB(desc, name, nr)                         \
1161         DO_TESTCASE_1B("hard-"desc, name##_hard, nr);           \
1162         DO_TESTCASE_1B("soft-"desc, name##_soft, nr);
1163
1164 #define DO_TESTCASE_6I(desc, name, nr)                          \
1165         DO_TESTCASE_3("hard-"desc, name##_hard, nr);            \
1166         DO_TESTCASE_3("soft-"desc, name##_soft, nr);
1167
1168 #define DO_TESTCASE_6IRW(desc, name, nr)                        \
1169         DO_TESTCASE_3RW("hard-"desc, name##_hard, nr);          \
1170         DO_TESTCASE_3RW("soft-"desc, name##_soft, nr);
1171
1172 #define DO_TESTCASE_2x3(desc, name)                             \
1173         DO_TESTCASE_3(desc, name, 12);                          \
1174         DO_TESTCASE_3(desc, name, 21);
1175
1176 #define DO_TESTCASE_2x6(desc, name)                             \
1177         DO_TESTCASE_6I(desc, name, 12);                         \
1178         DO_TESTCASE_6I(desc, name, 21);
1179
1180 #define DO_TESTCASE_6x2(desc, name)                             \
1181         DO_TESTCASE_2I(desc, name, 123);                        \
1182         DO_TESTCASE_2I(desc, name, 132);                        \
1183         DO_TESTCASE_2I(desc, name, 213);                        \
1184         DO_TESTCASE_2I(desc, name, 231);                        \
1185         DO_TESTCASE_2I(desc, name, 312);                        \
1186         DO_TESTCASE_2I(desc, name, 321);
1187
1188 #define DO_TESTCASE_6x2B(desc, name)                            \
1189         DO_TESTCASE_2IB(desc, name, 123);                       \
1190         DO_TESTCASE_2IB(desc, name, 132);                       \
1191         DO_TESTCASE_2IB(desc, name, 213);                       \
1192         DO_TESTCASE_2IB(desc, name, 231);                       \
1193         DO_TESTCASE_2IB(desc, name, 312);                       \
1194         DO_TESTCASE_2IB(desc, name, 321);
1195
1196 #define DO_TESTCASE_6x6(desc, name)                             \
1197         DO_TESTCASE_6I(desc, name, 123);                        \
1198         DO_TESTCASE_6I(desc, name, 132);                        \
1199         DO_TESTCASE_6I(desc, name, 213);                        \
1200         DO_TESTCASE_6I(desc, name, 231);                        \
1201         DO_TESTCASE_6I(desc, name, 312);                        \
1202         DO_TESTCASE_6I(desc, name, 321);
1203
1204 #define DO_TESTCASE_6x6RW(desc, name)                           \
1205         DO_TESTCASE_6IRW(desc, name, 123);                      \
1206         DO_TESTCASE_6IRW(desc, name, 132);                      \
1207         DO_TESTCASE_6IRW(desc, name, 213);                      \
1208         DO_TESTCASE_6IRW(desc, name, 231);                      \
1209         DO_TESTCASE_6IRW(desc, name, 312);                      \
1210         DO_TESTCASE_6IRW(desc, name, 321);
1211
1212 static void ww_test_fail_acquire(void)
1213 {
1214         int ret;
1215
1216         WWAI(&t);
1217         t.stamp++;
1218
1219         ret = WWL(&o, &t);
1220
1221         if (WARN_ON(!o.ctx) ||
1222             WARN_ON(ret))
1223                 return;
1224
1225         /* No lockdep test, pure API */
1226         ret = WWL(&o, &t);
1227         WARN_ON(ret != -EALREADY);
1228
1229         ret = WWT(&o);
1230         WARN_ON(ret);
1231
1232         t2 = t;
1233         t2.stamp++;
1234         ret = WWL(&o, &t2);
1235         WARN_ON(ret != -EDEADLK);
1236         WWU(&o);
1237
1238         if (WWT(&o))
1239                 WWU(&o);
1240 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1241         else
1242                 DEBUG_LOCKS_WARN_ON(1);
1243 #endif
1244 }
1245
1246 static void ww_test_normal(void)
1247 {
1248         int ret;
1249
1250         WWAI(&t);
1251
1252         /*
1253          * None of the ww_mutex codepaths should be taken in the 'normal'
1254          * mutex calls. The easiest way to verify this is by using the
1255          * normal mutex calls, and making sure o.ctx is unmodified.
1256          */
1257
1258         /* mutex_lock (and indirectly, mutex_lock_nested) */
1259         o.ctx = (void *)~0UL;
1260         mutex_lock(&o.base);
1261         mutex_unlock(&o.base);
1262         WARN_ON(o.ctx != (void *)~0UL);
1263
1264         /* mutex_lock_interruptible (and *_nested) */
1265         o.ctx = (void *)~0UL;
1266         ret = mutex_lock_interruptible(&o.base);
1267         if (!ret)
1268                 mutex_unlock(&o.base);
1269         else
1270                 WARN_ON(1);
1271         WARN_ON(o.ctx != (void *)~0UL);
1272
1273         /* mutex_lock_killable (and *_nested) */
1274         o.ctx = (void *)~0UL;
1275         ret = mutex_lock_killable(&o.base);
1276         if (!ret)
1277                 mutex_unlock(&o.base);
1278         else
1279                 WARN_ON(1);
1280         WARN_ON(o.ctx != (void *)~0UL);
1281
1282         /* trylock, succeeding */
1283         o.ctx = (void *)~0UL;
1284         ret = mutex_trylock(&o.base);
1285         WARN_ON(!ret);
1286         if (ret)
1287                 mutex_unlock(&o.base);
1288         else
1289                 WARN_ON(1);
1290         WARN_ON(o.ctx != (void *)~0UL);
1291
1292         /* trylock, failing */
1293         o.ctx = (void *)~0UL;
1294         mutex_lock(&o.base);
1295         ret = mutex_trylock(&o.base);
1296         WARN_ON(ret);
1297         mutex_unlock(&o.base);
1298         WARN_ON(o.ctx != (void *)~0UL);
1299
1300         /* nest_lock */
1301         o.ctx = (void *)~0UL;
1302         mutex_lock_nest_lock(&o.base, &t);
1303         mutex_unlock(&o.base);
1304         WARN_ON(o.ctx != (void *)~0UL);
1305 }
1306
1307 static void ww_test_two_contexts(void)
1308 {
1309         WWAI(&t);
1310         WWAI(&t2);
1311 }
1312
1313 static void ww_test_diff_class(void)
1314 {
1315         WWAI(&t);
1316 #ifdef CONFIG_DEBUG_MUTEXES
1317         t.ww_class = NULL;
1318 #endif
1319         WWL(&o, &t);
1320 }
1321
1322 static void ww_test_context_done_twice(void)
1323 {
1324         WWAI(&t);
1325         WWAD(&t);
1326         WWAD(&t);
1327         WWAF(&t);
1328 }
1329
1330 static void ww_test_context_unlock_twice(void)
1331 {
1332         WWAI(&t);
1333         WWAD(&t);
1334         WWAF(&t);
1335         WWAF(&t);
1336 }
1337
1338 static void ww_test_context_fini_early(void)
1339 {
1340         WWAI(&t);
1341         WWL(&o, &t);
1342         WWAD(&t);
1343         WWAF(&t);
1344 }
1345
1346 static void ww_test_context_lock_after_done(void)
1347 {
1348         WWAI(&t);
1349         WWAD(&t);
1350         WWL(&o, &t);
1351 }
1352
1353 static void ww_test_object_unlock_twice(void)
1354 {
1355         WWL1(&o);
1356         WWU(&o);
1357         WWU(&o);
1358 }
1359
1360 static void ww_test_object_lock_unbalanced(void)
1361 {
1362         WWAI(&t);
1363         WWL(&o, &t);
1364         t.acquired = 0;
1365         WWU(&o);
1366         WWAF(&t);
1367 }
1368
1369 static void ww_test_object_lock_stale_context(void)
1370 {
1371         WWAI(&t);
1372         o.ctx = &t2;
1373         WWL(&o, &t);
1374 }
1375
1376 static void ww_test_edeadlk_normal(void)
1377 {
1378         int ret;
1379
1380         mutex_lock(&o2.base);
1381         o2.ctx = &t2;
1382         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1383
1384         WWAI(&t);
1385         t2 = t;
1386         t2.stamp--;
1387
1388         ret = WWL(&o, &t);
1389         WARN_ON(ret);
1390
1391         ret = WWL(&o2, &t);
1392         WARN_ON(ret != -EDEADLK);
1393
1394         o2.ctx = NULL;
1395         mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1396         mutex_unlock(&o2.base);
1397         WWU(&o);
1398
1399         WWL(&o2, &t);
1400 }
1401
1402 static void ww_test_edeadlk_normal_slow(void)
1403 {
1404         int ret;
1405
1406         mutex_lock(&o2.base);
1407         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1408         o2.ctx = &t2;
1409
1410         WWAI(&t);
1411         t2 = t;
1412         t2.stamp--;
1413
1414         ret = WWL(&o, &t);
1415         WARN_ON(ret);
1416
1417         ret = WWL(&o2, &t);
1418         WARN_ON(ret != -EDEADLK);
1419
1420         o2.ctx = NULL;
1421         mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1422         mutex_unlock(&o2.base);
1423         WWU(&o);
1424
1425         ww_mutex_lock_slow(&o2, &t);
1426 }
1427
1428 static void ww_test_edeadlk_no_unlock(void)
1429 {
1430         int ret;
1431
1432         mutex_lock(&o2.base);
1433         o2.ctx = &t2;
1434         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1435
1436         WWAI(&t);
1437         t2 = t;
1438         t2.stamp--;
1439
1440         ret = WWL(&o, &t);
1441         WARN_ON(ret);
1442
1443         ret = WWL(&o2, &t);
1444         WARN_ON(ret != -EDEADLK);
1445
1446         o2.ctx = NULL;
1447         mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1448         mutex_unlock(&o2.base);
1449
1450         WWL(&o2, &t);
1451 }
1452
1453 static void ww_test_edeadlk_no_unlock_slow(void)
1454 {
1455         int ret;
1456
1457         mutex_lock(&o2.base);
1458         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1459         o2.ctx = &t2;
1460
1461         WWAI(&t);
1462         t2 = t;
1463         t2.stamp--;
1464
1465         ret = WWL(&o, &t);
1466         WARN_ON(ret);
1467
1468         ret = WWL(&o2, &t);
1469         WARN_ON(ret != -EDEADLK);
1470
1471         o2.ctx = NULL;
1472         mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1473         mutex_unlock(&o2.base);
1474
1475         ww_mutex_lock_slow(&o2, &t);
1476 }
1477
1478 static void ww_test_edeadlk_acquire_more(void)
1479 {
1480         int ret;
1481
1482         mutex_lock(&o2.base);
1483         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1484         o2.ctx = &t2;
1485
1486         WWAI(&t);
1487         t2 = t;
1488         t2.stamp--;
1489
1490         ret = WWL(&o, &t);
1491         WARN_ON(ret);
1492
1493         ret = WWL(&o2, &t);
1494         WARN_ON(ret != -EDEADLK);
1495
1496         ret = WWL(&o3, &t);
1497 }
1498
1499 static void ww_test_edeadlk_acquire_more_slow(void)
1500 {
1501         int ret;
1502
1503         mutex_lock(&o2.base);
1504         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1505         o2.ctx = &t2;
1506
1507         WWAI(&t);
1508         t2 = t;
1509         t2.stamp--;
1510
1511         ret = WWL(&o, &t);
1512         WARN_ON(ret);
1513
1514         ret = WWL(&o2, &t);
1515         WARN_ON(ret != -EDEADLK);
1516
1517         ww_mutex_lock_slow(&o3, &t);
1518 }
1519
1520 static void ww_test_edeadlk_acquire_more_edeadlk(void)
1521 {
1522         int ret;
1523
1524         mutex_lock(&o2.base);
1525         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1526         o2.ctx = &t2;
1527
1528         mutex_lock(&o3.base);
1529         mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
1530         o3.ctx = &t2;
1531
1532         WWAI(&t);
1533         t2 = t;
1534         t2.stamp--;
1535
1536         ret = WWL(&o, &t);
1537         WARN_ON(ret);
1538
1539         ret = WWL(&o2, &t);
1540         WARN_ON(ret != -EDEADLK);
1541
1542         ret = WWL(&o3, &t);
1543         WARN_ON(ret != -EDEADLK);
1544 }
1545
1546 static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
1547 {
1548         int ret;
1549
1550         mutex_lock(&o2.base);
1551         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1552         o2.ctx = &t2;
1553
1554         mutex_lock(&o3.base);
1555         mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
1556         o3.ctx = &t2;
1557
1558         WWAI(&t);
1559         t2 = t;
1560         t2.stamp--;
1561
1562         ret = WWL(&o, &t);
1563         WARN_ON(ret);
1564
1565         ret = WWL(&o2, &t);
1566         WARN_ON(ret != -EDEADLK);
1567
1568         ww_mutex_lock_slow(&o3, &t);
1569 }
1570
1571 static void ww_test_edeadlk_acquire_wrong(void)
1572 {
1573         int ret;
1574
1575         mutex_lock(&o2.base);
1576         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1577         o2.ctx = &t2;
1578
1579         WWAI(&t);
1580         t2 = t;
1581         t2.stamp--;
1582
1583         ret = WWL(&o, &t);
1584         WARN_ON(ret);
1585
1586         ret = WWL(&o2, &t);
1587         WARN_ON(ret != -EDEADLK);
1588         if (!ret)
1589                 WWU(&o2);
1590
1591         WWU(&o);
1592
1593         ret = WWL(&o3, &t);
1594 }
1595
1596 static void ww_test_edeadlk_acquire_wrong_slow(void)
1597 {
1598         int ret;
1599
1600         mutex_lock(&o2.base);
1601         mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1602         o2.ctx = &t2;
1603
1604         WWAI(&t);
1605         t2 = t;
1606         t2.stamp--;
1607
1608         ret = WWL(&o, &t);
1609         WARN_ON(ret);
1610
1611         ret = WWL(&o2, &t);
1612         WARN_ON(ret != -EDEADLK);
1613         if (!ret)
1614                 WWU(&o2);
1615
1616         WWU(&o);
1617
1618         ww_mutex_lock_slow(&o3, &t);
1619 }
1620
1621 static void ww_test_spin_nest_unlocked(void)
1622 {
1623         raw_spin_lock_nest_lock(&lock_A, &o.base);
1624         U(A);
1625 }
1626
1627 static void ww_test_unneeded_slow(void)
1628 {
1629         WWAI(&t);
1630
1631         ww_mutex_lock_slow(&o, &t);
1632 }
1633
1634 static void ww_test_context_block(void)
1635 {
1636         int ret;
1637
1638         WWAI(&t);
1639
1640         ret = WWL(&o, &t);
1641         WARN_ON(ret);
1642         WWL1(&o2);
1643 }
1644
1645 static void ww_test_context_try(void)
1646 {
1647         int ret;
1648
1649         WWAI(&t);
1650
1651         ret = WWL(&o, &t);
1652         WARN_ON(ret);
1653
1654         ret = WWT(&o2);
1655         WARN_ON(!ret);
1656         WWU(&o2);
1657         WWU(&o);
1658 }
1659
1660 static void ww_test_context_context(void)
1661 {
1662         int ret;
1663
1664         WWAI(&t);
1665
1666         ret = WWL(&o, &t);
1667         WARN_ON(ret);
1668
1669         ret = WWL(&o2, &t);
1670         WARN_ON(ret);
1671
1672         WWU(&o2);
1673         WWU(&o);
1674 }
1675
1676 static void ww_test_try_block(void)
1677 {
1678         bool ret;
1679
1680         ret = WWT(&o);
1681         WARN_ON(!ret);
1682
1683         WWL1(&o2);
1684         WWU(&o2);
1685         WWU(&o);
1686 }
1687
1688 static void ww_test_try_try(void)
1689 {
1690         bool ret;
1691
1692         ret = WWT(&o);
1693         WARN_ON(!ret);
1694         ret = WWT(&o2);
1695         WARN_ON(!ret);
1696         WWU(&o2);
1697         WWU(&o);
1698 }
1699
1700 static void ww_test_try_context(void)
1701 {
1702         int ret;
1703
1704         ret = WWT(&o);
1705         WARN_ON(!ret);
1706
1707         WWAI(&t);
1708
1709         ret = WWL(&o2, &t);
1710         WARN_ON(ret);
1711 }
1712
1713 static void ww_test_block_block(void)
1714 {
1715         WWL1(&o);
1716         WWL1(&o2);
1717 }
1718
1719 static void ww_test_block_try(void)
1720 {
1721         bool ret;
1722
1723         WWL1(&o);
1724         ret = WWT(&o2);
1725         WARN_ON(!ret);
1726 }
1727
1728 static void ww_test_block_context(void)
1729 {
1730         int ret;
1731
1732         WWL1(&o);
1733         WWAI(&t);
1734
1735         ret = WWL(&o2, &t);
1736         WARN_ON(ret);
1737 }
1738
1739 static void ww_test_spin_block(void)
1740 {
1741         L(A);
1742         U(A);
1743
1744         WWL1(&o);
1745         L(A);
1746         U(A);
1747         WWU(&o);
1748
1749         L(A);
1750         WWL1(&o);
1751         WWU(&o);
1752         U(A);
1753 }
1754
1755 static void ww_test_spin_try(void)
1756 {
1757         bool ret;
1758
1759         L(A);
1760         U(A);
1761
1762         ret = WWT(&o);
1763         WARN_ON(!ret);
1764         L(A);
1765         U(A);
1766         WWU(&o);
1767
1768         L(A);
1769         ret = WWT(&o);
1770         WARN_ON(!ret);
1771         WWU(&o);
1772         U(A);
1773 }
1774
1775 static void ww_test_spin_context(void)
1776 {
1777         int ret;
1778
1779         L(A);
1780         U(A);
1781
1782         WWAI(&t);
1783
1784         ret = WWL(&o, &t);
1785         WARN_ON(ret);
1786         L(A);
1787         U(A);
1788         WWU(&o);
1789
1790         L(A);
1791         ret = WWL(&o, &t);
1792         WARN_ON(ret);
1793         WWU(&o);
1794         U(A);
1795 }
1796
1797 static void ww_tests(void)
1798 {
1799         printk("  --------------------------------------------------------------------------\n");
1800         printk("  | Wound/wait tests |\n");
1801         printk("  ---------------------\n");
1802
1803         print_testname("ww api failures");
1804         dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);
1805         dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
1806         dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
1807         pr_cont("\n");
1808
1809         print_testname("ww contexts mixing");
1810         dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
1811         dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
1812         pr_cont("\n");
1813
1814         print_testname("finishing ww context");
1815         dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
1816         dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);
1817         dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);
1818         dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
1819         pr_cont("\n");
1820
1821         print_testname("locking mismatches");
1822         dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
1823         dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
1824         dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
1825         pr_cont("\n");
1826
1827         print_testname("EDEADLK handling");
1828         dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
1829         dotest(ww_test_edeadlk_normal_slow, SUCCESS, LOCKTYPE_WW);
1830         dotest(ww_test_edeadlk_no_unlock, FAILURE, LOCKTYPE_WW);
1831         dotest(ww_test_edeadlk_no_unlock_slow, FAILURE, LOCKTYPE_WW);
1832         dotest(ww_test_edeadlk_acquire_more, FAILURE, LOCKTYPE_WW);
1833         dotest(ww_test_edeadlk_acquire_more_slow, FAILURE, LOCKTYPE_WW);
1834         dotest(ww_test_edeadlk_acquire_more_edeadlk, FAILURE, LOCKTYPE_WW);
1835         dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
1836         dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
1837         dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
1838         pr_cont("\n");
1839
1840         print_testname("spinlock nest unlocked");
1841         dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
1842         pr_cont("\n");
1843
1844         printk("  -----------------------------------------------------\n");
1845         printk("                                 |block | try  |context|\n");
1846         printk("  -----------------------------------------------------\n");
1847
1848         print_testname("context");
1849         dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);
1850         dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
1851         dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
1852         pr_cont("\n");
1853
1854         print_testname("try");
1855         dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
1856         dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
1857         dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
1858         pr_cont("\n");
1859
1860         print_testname("block");
1861         dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
1862         dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
1863         dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
1864         pr_cont("\n");
1865
1866         print_testname("spinlock");
1867         dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
1868         dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
1869         dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
1870         pr_cont("\n");
1871 }
1872
1873 void locking_selftest(void)
1874 {
1875         /*
1876          * Got a locking failure before the selftest ran?
1877          */
1878         if (!debug_locks) {
1879                 printk("----------------------------------\n");
1880                 printk("| Locking API testsuite disabled |\n");
1881                 printk("----------------------------------\n");
1882                 return;
1883         }
1884
1885         /*
1886          * Run the testsuite:
1887          */
1888         printk("------------------------\n");
1889         printk("| Locking API testsuite:\n");
1890         printk("----------------------------------------------------------------------------\n");
1891         printk("                                 | spin |wlock |rlock |mutex | wsem | rsem |\n");
1892         printk("  --------------------------------------------------------------------------\n");
1893
1894         init_shared_classes();
1895         debug_locks_silent = !debug_locks_verbose;
1896
1897         DO_TESTCASE_6R("A-A deadlock", AA);
1898         DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
1899         DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
1900         DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
1901         DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
1902         DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
1903         DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
1904         DO_TESTCASE_6("double unlock", double_unlock);
1905         DO_TESTCASE_6("initialize held", init_held);
1906
1907         printk("  --------------------------------------------------------------------------\n");
1908         print_testname("recursive read-lock");
1909         pr_cont("             |");
1910         dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
1911         pr_cont("             |");
1912         dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
1913         pr_cont("\n");
1914
1915         print_testname("recursive read-lock #2");
1916         pr_cont("             |");
1917         dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
1918         pr_cont("             |");
1919         dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
1920         pr_cont("\n");
1921
1922         print_testname("mixed read-write-lock");
1923         pr_cont("             |");
1924         dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
1925         pr_cont("             |");
1926         dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
1927         pr_cont("\n");
1928
1929         print_testname("mixed write-read-lock");
1930         pr_cont("             |");
1931         dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
1932         pr_cont("             |");
1933         dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
1934         pr_cont("\n");
1935
1936         printk("  --------------------------------------------------------------------------\n");
1937
1938         /*
1939          * irq-context testcases:
1940          */
1941         DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
1942         DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
1943         DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
1944         DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
1945         DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
1946         DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
1947
1948         DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
1949 //      DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
1950
1951         ww_tests();
1952
1953         if (unexpected_testcase_failures) {
1954                 printk("-----------------------------------------------------------------\n");
1955                 debug_locks = 0;
1956                 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
1957                         unexpected_testcase_failures, testcase_total);
1958                 printk("-----------------------------------------------------------------\n");
1959         } else if (expected_testcase_failures && testcase_successes) {
1960                 printk("--------------------------------------------------------\n");
1961                 printk("%3d out of %3d testcases failed, as expected. |\n",
1962                         expected_testcase_failures, testcase_total);
1963                 printk("----------------------------------------------------\n");
1964                 debug_locks = 1;
1965         } else if (expected_testcase_failures && !testcase_successes) {
1966                 printk("--------------------------------------------------------\n");
1967                 printk("All %3d testcases failed, as expected. |\n",
1968                         expected_testcase_failures);
1969                 printk("----------------------------------------\n");
1970                 debug_locks = 1;
1971         } else {
1972                 printk("-------------------------------------------------------\n");
1973                 printk("Good, all %3d testcases passed! |\n",
1974                         testcase_successes);
1975                 printk("---------------------------------\n");
1976                 debug_locks = 1;
1977         }
1978         debug_locks_silent = 0;
1979 }