lib/locking-selftest.c

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