lib/locking-selftest.c

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

DEFINITIONS
