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