lib/locking-selftest.c

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