linux/lib/locking-selftest.c
<<
>>
Prefs
   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 */
  30static unsigned int debug_locks_verbose;
  31
  32static DEFINE_WD_CLASS(ww_lockdep);
  33
  34static 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
  53static struct ww_acquire_ctx t, t2;
  54static struct ww_mutex o, o2, o3;
  55
  56/*
  57 * Normal standalone locks, for the circular and irq-context
  58 * dependency tests:
  59 */
  60static DEFINE_RAW_SPINLOCK(lock_A);
  61static DEFINE_RAW_SPINLOCK(lock_B);
  62static DEFINE_RAW_SPINLOCK(lock_C);
  63static DEFINE_RAW_SPINLOCK(lock_D);
  64
  65static DEFINE_RWLOCK(rwlock_A);
  66static DEFINE_RWLOCK(rwlock_B);
  67static DEFINE_RWLOCK(rwlock_C);
  68static DEFINE_RWLOCK(rwlock_D);
  69
  70static DEFINE_MUTEX(mutex_A);
  71static DEFINE_MUTEX(mutex_B);
  72static DEFINE_MUTEX(mutex_C);
  73static DEFINE_MUTEX(mutex_D);
  74
  75static DECLARE_RWSEM(rwsem_A);
  76static DECLARE_RWSEM(rwsem_B);
  77static DECLARE_RWSEM(rwsem_C);
  78static DECLARE_RWSEM(rwsem_D);
  79
  80#ifdef CONFIG_RT_MUTEXES
  81
  82static DEFINE_RT_MUTEX(rtmutex_A);
  83static DEFINE_RT_MUTEX(rtmutex_B);
  84static DEFINE_RT_MUTEX(rtmutex_C);
  85static 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 */
  95static DEFINE_RAW_SPINLOCK(lock_X1);
  96static DEFINE_RAW_SPINLOCK(lock_X2);
  97static DEFINE_RAW_SPINLOCK(lock_Y1);
  98static DEFINE_RAW_SPINLOCK(lock_Y2);
  99static DEFINE_RAW_SPINLOCK(lock_Z1);
 100static DEFINE_RAW_SPINLOCK(lock_Z2);
 101
 102static DEFINE_RWLOCK(rwlock_X1);
 103static DEFINE_RWLOCK(rwlock_X2);
 104static DEFINE_RWLOCK(rwlock_Y1);
 105static DEFINE_RWLOCK(rwlock_Y2);
 106static DEFINE_RWLOCK(rwlock_Z1);
 107static DEFINE_RWLOCK(rwlock_Z2);
 108
 109static DEFINE_MUTEX(mutex_X1);
 110static DEFINE_MUTEX(mutex_X2);
 111static DEFINE_MUTEX(mutex_Y1);
 112static DEFINE_MUTEX(mutex_Y2);
 113static DEFINE_MUTEX(mutex_Z1);
 114static DEFINE_MUTEX(mutex_Z2);
 115
 116static DECLARE_RWSEM(rwsem_X1);
 117static DECLARE_RWSEM(rwsem_X2);
 118static DECLARE_RWSEM(rwsem_Y1);
 119static DECLARE_RWSEM(rwsem_Y2);
 120static DECLARE_RWSEM(rwsem_Z1);
 121static DECLARE_RWSEM(rwsem_Z2);
 122
 123#ifdef CONFIG_RT_MUTEXES
 124
 125static DEFINE_RT_MUTEX(rtmutex_X1);
 126static DEFINE_RT_MUTEX(rtmutex_X2);
 127static DEFINE_RT_MUTEX(rtmutex_Y1);
 128static DEFINE_RT_MUTEX(rtmutex_Y2);
 129static DEFINE_RT_MUTEX(rtmutex_Z1);
 130static 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)                          \
 139static noinline void                                    \
 140init_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
 149INIT_CLASS_FUNC(X)
 150INIT_CLASS_FUNC(Y)
 151INIT_CLASS_FUNC(Z)
 152
 153static 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                                                \
 264static void name(void) { E(); }
 265
 266#define GENERATE_PERMUTATIONS_2_EVENTS(name)    \
 267                                                \
 268static void name##_12(void) { E1(); E2(); }     \
 269static void name##_21(void) { E2(); E1(); }
 270
 271#define GENERATE_PERMUTATIONS_3_EVENTS(name)            \
 272                                                        \
 273static void name##_123(void) { E1(); E2(); E3(); }      \
 274static void name##_132(void) { E1(); E3(); E2(); }      \
 275static void name##_213(void) { E2(); E1(); E3(); }      \
 276static void name##_231(void) { E2(); E3(); E1(); }      \
 277static void name##_312(void) { E3(); E1(); E2(); }      \
 278static 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"
 293GENERATE_TESTCASE(AA_spin)
 294#include "locking-selftest-wlock.h"
 295GENERATE_TESTCASE(AA_wlock)
 296#include "locking-selftest-rlock.h"
 297GENERATE_TESTCASE(AA_rlock)
 298#include "locking-selftest-mutex.h"
 299GENERATE_TESTCASE(AA_mutex)
 300#include "locking-selftest-wsem.h"
 301GENERATE_TESTCASE(AA_wsem)
 302#include "locking-selftest-rsem.h"
 303GENERATE_TESTCASE(AA_rsem)
 304
 305#ifdef CONFIG_RT_MUTEXES
 306#include "locking-selftest-rtmutex.h"
 307GENERATE_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 */
 316static void rlock_AA1(void)
 317{
 318        RL(X1);
 319        RL(X1); // this one should NOT fail
 320}
 321
 322static void rlock_AA1B(void)
 323{
 324        RL(X1);
 325        RL(X2); // this one should NOT fail
 326}
 327
 328static void rsem_AA1(void)
 329{
 330        RSL(X1);
 331        RSL(X1); // this one should fail
 332}
 333
 334static 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 */
 342static void rlock_AA2(void)
 343{
 344        RL(X1);
 345        WL(X2); // this one should fail
 346}
 347
 348static void rsem_AA2(void)
 349{
 350        RSL(X1);
 351        WSL(X2); // this one should fail
 352}
 353
 354static void rlock_AA3(void)
 355{
 356        WL(X1);
 357        RL(X2); // this one should fail
 358}
 359
 360static 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 */
 372static 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
 385static 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 */
 404static 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
 417static 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 */
 437static 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
 450static 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"
 476GENERATE_TESTCASE(ABBA_spin)
 477#include "locking-selftest-wlock.h"
 478GENERATE_TESTCASE(ABBA_wlock)
 479#include "locking-selftest-rlock.h"
 480GENERATE_TESTCASE(ABBA_rlock)
 481#include "locking-selftest-mutex.h"
 482GENERATE_TESTCASE(ABBA_mutex)
 483#include "locking-selftest-wsem.h"
 484GENERATE_TESTCASE(ABBA_wsem)
 485#include "locking-selftest-rsem.h"
 486GENERATE_TESTCASE(ABBA_rsem)
 487
 488#ifdef CONFIG_RT_MUTEXES
 489#include "locking-selftest-rtmutex.h"
 490GENERATE_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"
 509GENERATE_TESTCASE(ABBCCA_spin)
 510#include "locking-selftest-wlock.h"
 511GENERATE_TESTCASE(ABBCCA_wlock)
 512#include "locking-selftest-rlock.h"
 513GENERATE_TESTCASE(ABBCCA_rlock)
 514#include "locking-selftest-mutex.h"
 515GENERATE_TESTCASE(ABBCCA_mutex)
 516#include "locking-selftest-wsem.h"
 517GENERATE_TESTCASE(ABBCCA_wsem)
 518#include "locking-selftest-rsem.h"
 519GENERATE_TESTCASE(ABBCCA_rsem)
 520
 521#ifdef CONFIG_RT_MUTEXES
 522#include "locking-selftest-rtmutex.h"
 523GENERATE_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"
 542GENERATE_TESTCASE(ABCABC_spin)
 543#include "locking-selftest-wlock.h"
 544GENERATE_TESTCASE(ABCABC_wlock)
 545#include "locking-selftest-rlock.h"
 546GENERATE_TESTCASE(ABCABC_rlock)
 547#include "locking-selftest-mutex.h"
 548GENERATE_TESTCASE(ABCABC_mutex)
 549#include "locking-selftest-wsem.h"
 550GENERATE_TESTCASE(ABCABC_wsem)
 551#include "locking-selftest-rsem.h"
 552GENERATE_TESTCASE(ABCABC_rsem)
 553
 554#ifdef CONFIG_RT_MUTEXES
 555#include "locking-selftest-rtmutex.h"
 556GENERATE_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"
 576GENERATE_TESTCASE(ABBCCDDA_spin)
 577#include "locking-selftest-wlock.h"
 578GENERATE_TESTCASE(ABBCCDDA_wlock)
 579#include "locking-selftest-rlock.h"
 580GENERATE_TESTCASE(ABBCCDDA_rlock)
 581#include "locking-selftest-mutex.h"
 582GENERATE_TESTCASE(ABBCCDDA_mutex)
 583#include "locking-selftest-wsem.h"
 584GENERATE_TESTCASE(ABBCCDDA_wsem)
 585#include "locking-selftest-rsem.h"
 586GENERATE_TESTCASE(ABBCCDDA_rsem)
 587
 588#ifdef CONFIG_RT_MUTEXES
 589#include "locking-selftest-rtmutex.h"
 590GENERATE_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"
 609GENERATE_TESTCASE(ABCDBDDA_spin)
 610#include "locking-selftest-wlock.h"
 611GENERATE_TESTCASE(ABCDBDDA_wlock)
 612#include "locking-selftest-rlock.h"
 613GENERATE_TESTCASE(ABCDBDDA_rlock)
 614#include "locking-selftest-mutex.h"
 615GENERATE_TESTCASE(ABCDBDDA_mutex)
 616#include "locking-selftest-wsem.h"
 617GENERATE_TESTCASE(ABCDBDDA_wsem)
 618#include "locking-selftest-rsem.h"
 619GENERATE_TESTCASE(ABCDBDDA_rsem)
 620
 621#ifdef CONFIG_RT_MUTEXES
 622#include "locking-selftest-rtmutex.h"
 623GENERATE_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"
 642GENERATE_TESTCASE(ABCDBCDA_spin)
 643#include "locking-selftest-wlock.h"
 644GENERATE_TESTCASE(ABCDBCDA_wlock)
 645#include "locking-selftest-rlock.h"
 646GENERATE_TESTCASE(ABCDBCDA_rlock)
 647#include "locking-selftest-mutex.h"
 648GENERATE_TESTCASE(ABCDBCDA_mutex)
 649#include "locking-selftest-wsem.h"
 650GENERATE_TESTCASE(ABCDBCDA_wsem)
 651#include "locking-selftest-rsem.h"
 652GENERATE_TESTCASE(ABCDBCDA_rsem)
 653
 654#ifdef CONFIG_RT_MUTEXES
 655#include "locking-selftest-rtmutex.h"
 656GENERATE_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"
 674GENERATE_TESTCASE(double_unlock_spin)
 675#include "locking-selftest-wlock.h"
 676GENERATE_TESTCASE(double_unlock_wlock)
 677#include "locking-selftest-rlock.h"
 678GENERATE_TESTCASE(double_unlock_rlock)
 679#include "locking-selftest-mutex.h"
 680GENERATE_TESTCASE(double_unlock_mutex)
 681#include "locking-selftest-wsem.h"
 682GENERATE_TESTCASE(double_unlock_wsem)
 683#include "locking-selftest-rsem.h"
 684GENERATE_TESTCASE(double_unlock_rsem)
 685
 686#ifdef CONFIG_RT_MUTEXES
 687#include "locking-selftest-rtmutex.h"
 688GENERATE_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"
 705GENERATE_TESTCASE(init_held_spin)
 706#include "locking-selftest-wlock.h"
 707GENERATE_TESTCASE(init_held_wlock)
 708#include "locking-selftest-rlock.h"
 709GENERATE_TESTCASE(init_held_rlock)
 710#include "locking-selftest-mutex.h"
 711GENERATE_TESTCASE(init_held_mutex)
 712#include "locking-selftest-wsem.h"
 713GENERATE_TESTCASE(init_held_wsem)
 714#include "locking-selftest-rsem.h"
 715GENERATE_TESTCASE(init_held_rsem)
 716
 717#ifdef CONFIG_RT_MUTEXES
 718#include "locking-selftest-rtmutex.h"
 719GENERATE_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"
 743GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
 744
 745#include "locking-selftest-rlock-hardirq.h"
 746GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
 747
 748#include "locking-selftest-wlock-hardirq.h"
 749GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
 750
 751#include "locking-selftest-spin-softirq.h"
 752GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
 753
 754#include "locking-selftest-rlock-softirq.h"
 755GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
 756
 757#include "locking-selftest-wlock-softirq.h"
 758GENERATE_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"
 784GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
 785
 786#include "locking-selftest-wlock.h"
 787GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
 788
 789#include "locking-selftest-rlock.h"
 790GENERATE_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"
 816GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
 817
 818#include "locking-selftest-rlock-hardirq.h"
 819GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
 820
 821#include "locking-selftest-wlock-hardirq.h"
 822GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
 823
 824#include "locking-selftest-spin-softirq.h"
 825GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
 826
 827#include "locking-selftest-rlock-softirq.h"
 828GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
 829
 830#include "locking-selftest-wlock-softirq.h"
 831GENERATE_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"
 862GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
 863
 864#include "locking-selftest-rlock-hardirq.h"
 865GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
 866
 867#include "locking-selftest-wlock-hardirq.h"
 868GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
 869
 870#include "locking-selftest-spin-softirq.h"
 871GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
 872
 873#include "locking-selftest-rlock-softirq.h"
 874GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
 875
 876#include "locking-selftest-wlock-softirq.h"
 877GENERATE_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"
 910GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
 911
 912#include "locking-selftest-rlock-hardirq.h"
 913GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
 914
 915#include "locking-selftest-wlock-hardirq.h"
 916GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
 917
 918#include "locking-selftest-spin-softirq.h"
 919GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
 920
 921#include "locking-selftest-rlock-softirq.h"
 922GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
 923
 924#include "locking-selftest-wlock-softirq.h"
 925GENERATE_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"
 972GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
 973
 974#include "locking-selftest-rlock-hardirq.h"
 975GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
 976
 977#include "locking-selftest-wlock-hardirq.h"
 978GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
 979
 980#include "locking-selftest-spin-softirq.h"
 981GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
 982
 983#include "locking-selftest-rlock-softirq.h"
 984GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
 985
 986#include "locking-selftest-wlock-softirq.h"
 987GENERATE_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"
1022GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard)
1023
1024#include "locking-selftest-softirq.h"
1025GENERATE_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
1110static 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
1132static int testcase_total;
1133static int testcase_successes;
1134static int expected_testcase_failures;
1135static int unexpected_testcase_failures;
1136
1137static 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
1187static 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
1308static 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
1342static 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
1403static void ww_test_two_contexts(void)
1404{
1405        WWAI(&t);
1406        WWAI(&t2);
1407}
1408
1409static 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
1418static void ww_test_context_done_twice(void)
1419{
1420        WWAI(&t);
1421        WWAD(&t);
1422        WWAD(&t);
1423        WWAF(&t);
1424}
1425
1426static void ww_test_context_unlock_twice(void)
1427{
1428        WWAI(&t);
1429        WWAD(&t);
1430        WWAF(&t);
1431        WWAF(&t);
1432}
1433
1434static void ww_test_context_fini_early(void)
1435{
1436        WWAI(&t);
1437        WWL(&o, &t);
1438        WWAD(&t);
1439        WWAF(&t);
1440}
1441
1442static void ww_test_context_lock_after_done(void)
1443{
1444        WWAI(&t);
1445        WWAD(&t);
1446        WWL(&o, &t);
1447}
1448
1449static void ww_test_object_unlock_twice(void)
1450{
1451        WWL1(&o);
1452        WWU(&o);
1453        WWU(&o);
1454}
1455
1456static 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
1465static void ww_test_object_lock_stale_context(void)
1466{
1467        WWAI(&t);
1468        o.ctx = &t2;
1469        WWL(&o, &t);
1470}
1471
1472static 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
1498static 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
1524static 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
1549static 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
1574static 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
1595static 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
1616static 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
1642static 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
1667static 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
1692static 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
1717static void ww_test_spin_nest_unlocked(void)
1718{
1719        raw_spin_lock_nest_lock(&lock_A, &o.base);
1720        U(A);
1721}
1722
1723static void ww_test_unneeded_slow(void)
1724{
1725        WWAI(&t);
1726
1727        ww_mutex_lock_slow(&o, &t);
1728}
1729
1730static 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
1741static 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
1756static 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
1772static 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
1784static 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
1796static 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
1809static void ww_test_block_block(void)
1810{
1811        WWL1(&o);
1812        WWL1(&o2);
1813}
1814
1815static void ww_test_block_try(void)
1816{
1817        bool ret;
1818
1819        WWL1(&o);
1820        ret = WWT(&o2);
1821        WARN_ON(!ret);
1822}
1823
1824static 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
1835static 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
1851static 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
1871static 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
1893static 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
1969void 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
1993        DO_TESTCASE_6R("A-A deadlock", AA);
1994        DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
1995        DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
1996        DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
1997        DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
1998        DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
1999        DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
2000        DO_TESTCASE_6("double unlock", double_unlock);
2001        DO_TESTCASE_6("initialize held", init_held);
2002
2003        printk("  --------------------------------------------------------------------------\n");
2004        print_testname("recursive read-lock");
2005        pr_cont("             |");
2006        dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
2007        pr_cont("             |");
2008        dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
2009        pr_cont("\n");
2010
2011        print_testname("recursive read-lock #2");
2012        pr_cont("             |");
2013        dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
2014        pr_cont("             |");
2015        dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
2016        pr_cont("\n");
2017
2018        print_testname("mixed read-write-lock");
2019        pr_cont("             |");
2020        dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
2021        pr_cont("             |");
2022        dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
2023        pr_cont("\n");
2024
2025        print_testname("mixed write-read-lock");
2026        pr_cont("             |");
2027        dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
2028        pr_cont("             |");
2029        dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
2030        pr_cont("\n");
2031
2032        print_testname("mixed read-lock/lock-write ABBA");
2033        pr_cont("             |");
2034        dotest(rlock_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2035#ifdef CONFIG_PROVE_LOCKING
2036        /*
2037         * Lockdep does indeed fail here, but there's nothing we can do about
2038         * that now.  Don't kill lockdep for it.
2039         */
2040        unexpected_testcase_failures--;
2041#endif
2042
2043        pr_cont("             |");
2044        dotest(rwsem_ABBA1, FAILURE, LOCKTYPE_RWSEM);
2045
2046        print_testname("mixed read-lock/lock-read ABBA");
2047        pr_cont("             |");
2048        dotest(rlock_ABBA2, SUCCESS, LOCKTYPE_RWLOCK);
2049        pr_cont("             |");
2050        dotest(rwsem_ABBA2, FAILURE, LOCKTYPE_RWSEM);
2051
2052        print_testname("mixed write-lock/lock-write ABBA");
2053        pr_cont("             |");
2054        dotest(rlock_ABBA3, FAILURE, LOCKTYPE_RWLOCK);
2055        pr_cont("             |");
2056        dotest(rwsem_ABBA3, FAILURE, LOCKTYPE_RWSEM);
2057
2058        printk("  --------------------------------------------------------------------------\n");
2059
2060        /*
2061         * irq-context testcases:
2062         */
2063        DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
2064        DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
2065        DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
2066        DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
2067        DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
2068        DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
2069
2070        DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
2071//      DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
2072
2073        ww_tests();
2074
2075        if (unexpected_testcase_failures) {
2076                printk("-----------------------------------------------------------------\n");
2077                debug_locks = 0;
2078                printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
2079                        unexpected_testcase_failures, testcase_total);
2080                printk("-----------------------------------------------------------------\n");
2081        } else if (expected_testcase_failures && testcase_successes) {
2082                printk("--------------------------------------------------------\n");
2083                printk("%3d out of %3d testcases failed, as expected. |\n",
2084                        expected_testcase_failures, testcase_total);
2085                printk("----------------------------------------------------\n");
2086                debug_locks = 1;
2087        } else if (expected_testcase_failures && !testcase_successes) {
2088                printk("--------------------------------------------------------\n");
2089                printk("All %3d testcases failed, as expected. |\n",
2090                        expected_testcase_failures);
2091                printk("----------------------------------------\n");
2092                debug_locks = 1;
2093        } else {
2094                printk("-------------------------------------------------------\n");
2095                printk("Good, all %3d testcases passed! |\n",
2096                        testcase_successes);
2097                printk("---------------------------------\n");
2098                debug_locks = 1;
2099        }
2100        debug_locks_silent = 0;
2101}
2102