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