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