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