ia64/linux-2.6.18-xen.hg

view lib/locking-selftest.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 * lib/locking-selftest.c
3 *
4 * Testsuite for various locking APIs: spinlocks, rwlocks,
5 * mutexes and rw-semaphores.
6 *
7 * It is checking both false positives and false negatives.
8 *
9 * Started by Ingo Molnar:
10 *
11 * Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
12 */
13 #include <linux/rwsem.h>
14 #include <linux/mutex.h>
15 #include <linux/sched.h>
16 #include <linux/delay.h>
17 #include <linux/module.h>
18 #include <linux/lockdep.h>
19 #include <linux/spinlock.h>
20 #include <linux/kallsyms.h>
21 #include <linux/interrupt.h>
22 #include <linux/debug_locks.h>
23 #include <linux/irqflags.h>
25 /*
26 * Change this to 1 if you want to see the failure printouts:
27 */
28 static unsigned int debug_locks_verbose;
30 static int __init setup_debug_locks_verbose(char *str)
31 {
32 get_option(&str, &debug_locks_verbose);
34 return 1;
35 }
37 __setup("debug_locks_verbose=", setup_debug_locks_verbose);
39 #define FAILURE 0
40 #define SUCCESS 1
42 #define LOCKTYPE_SPIN 0x1
43 #define LOCKTYPE_RWLOCK 0x2
44 #define LOCKTYPE_MUTEX 0x4
45 #define LOCKTYPE_RWSEM 0x8
47 /*
48 * Normal standalone locks, for the circular and irq-context
49 * dependency tests:
50 */
51 static DEFINE_SPINLOCK(lock_A);
52 static DEFINE_SPINLOCK(lock_B);
53 static DEFINE_SPINLOCK(lock_C);
54 static DEFINE_SPINLOCK(lock_D);
56 static DEFINE_RWLOCK(rwlock_A);
57 static DEFINE_RWLOCK(rwlock_B);
58 static DEFINE_RWLOCK(rwlock_C);
59 static DEFINE_RWLOCK(rwlock_D);
61 static DEFINE_MUTEX(mutex_A);
62 static DEFINE_MUTEX(mutex_B);
63 static DEFINE_MUTEX(mutex_C);
64 static DEFINE_MUTEX(mutex_D);
66 static DECLARE_RWSEM(rwsem_A);
67 static DECLARE_RWSEM(rwsem_B);
68 static DECLARE_RWSEM(rwsem_C);
69 static DECLARE_RWSEM(rwsem_D);
71 /*
72 * Locks that we initialize dynamically as well so that
73 * e.g. X1 and X2 becomes two instances of the same class,
74 * but X* and Y* are different classes. We do this so that
75 * we do not trigger a real lockup:
76 */
77 static DEFINE_SPINLOCK(lock_X1);
78 static DEFINE_SPINLOCK(lock_X2);
79 static DEFINE_SPINLOCK(lock_Y1);
80 static DEFINE_SPINLOCK(lock_Y2);
81 static DEFINE_SPINLOCK(lock_Z1);
82 static DEFINE_SPINLOCK(lock_Z2);
84 static DEFINE_RWLOCK(rwlock_X1);
85 static DEFINE_RWLOCK(rwlock_X2);
86 static DEFINE_RWLOCK(rwlock_Y1);
87 static DEFINE_RWLOCK(rwlock_Y2);
88 static DEFINE_RWLOCK(rwlock_Z1);
89 static DEFINE_RWLOCK(rwlock_Z2);
91 static DEFINE_MUTEX(mutex_X1);
92 static DEFINE_MUTEX(mutex_X2);
93 static DEFINE_MUTEX(mutex_Y1);
94 static DEFINE_MUTEX(mutex_Y2);
95 static DEFINE_MUTEX(mutex_Z1);
96 static DEFINE_MUTEX(mutex_Z2);
98 static DECLARE_RWSEM(rwsem_X1);
99 static DECLARE_RWSEM(rwsem_X2);
100 static DECLARE_RWSEM(rwsem_Y1);
101 static DECLARE_RWSEM(rwsem_Y2);
102 static DECLARE_RWSEM(rwsem_Z1);
103 static DECLARE_RWSEM(rwsem_Z2);
105 /*
106 * non-inlined runtime initializers, to let separate locks share
107 * the same lock-class:
108 */
109 #define INIT_CLASS_FUNC(class) \
110 static noinline void \
111 init_class_##class(spinlock_t *lock, rwlock_t *rwlock, struct mutex *mutex, \
112 struct rw_semaphore *rwsem) \
113 { \
114 spin_lock_init(lock); \
115 rwlock_init(rwlock); \
116 mutex_init(mutex); \
117 init_rwsem(rwsem); \
118 }
120 INIT_CLASS_FUNC(X)
121 INIT_CLASS_FUNC(Y)
122 INIT_CLASS_FUNC(Z)
124 static void init_shared_classes(void)
125 {
126 init_class_X(&lock_X1, &rwlock_X1, &mutex_X1, &rwsem_X1);
127 init_class_X(&lock_X2, &rwlock_X2, &mutex_X2, &rwsem_X2);
129 init_class_Y(&lock_Y1, &rwlock_Y1, &mutex_Y1, &rwsem_Y1);
130 init_class_Y(&lock_Y2, &rwlock_Y2, &mutex_Y2, &rwsem_Y2);
132 init_class_Z(&lock_Z1, &rwlock_Z1, &mutex_Z1, &rwsem_Z1);
133 init_class_Z(&lock_Z2, &rwlock_Z2, &mutex_Z2, &rwsem_Z2);
134 }
136 /*
137 * For spinlocks and rwlocks we also do hardirq-safe / softirq-safe tests.
138 * The following functions use a lock from a simulated hardirq/softirq
139 * context, causing the locks to be marked as hardirq-safe/softirq-safe:
140 */
142 #define HARDIRQ_DISABLE local_irq_disable
143 #define HARDIRQ_ENABLE local_irq_enable
145 #define HARDIRQ_ENTER() \
146 local_irq_disable(); \
147 irq_enter(); \
148 WARN_ON(!in_irq());
150 #define HARDIRQ_EXIT() \
151 __irq_exit(); \
152 local_irq_enable();
154 #define SOFTIRQ_DISABLE local_bh_disable
155 #define SOFTIRQ_ENABLE local_bh_enable
157 #define SOFTIRQ_ENTER() \
158 local_bh_disable(); \
159 local_irq_disable(); \
160 trace_softirq_enter(); \
161 WARN_ON(!in_softirq());
163 #define SOFTIRQ_EXIT() \
164 trace_softirq_exit(); \
165 local_irq_enable(); \
166 local_bh_enable();
168 /*
169 * Shortcuts for lock/unlock API variants, to keep
170 * the testcases compact:
171 */
172 #define L(x) spin_lock(&lock_##x)
173 #define U(x) spin_unlock(&lock_##x)
174 #define LU(x) L(x); U(x)
175 #define SI(x) spin_lock_init(&lock_##x)
177 #define WL(x) write_lock(&rwlock_##x)
178 #define WU(x) write_unlock(&rwlock_##x)
179 #define WLU(x) WL(x); WU(x)
181 #define RL(x) read_lock(&rwlock_##x)
182 #define RU(x) read_unlock(&rwlock_##x)
183 #define RLU(x) RL(x); RU(x)
184 #define RWI(x) rwlock_init(&rwlock_##x)
186 #define ML(x) mutex_lock(&mutex_##x)
187 #define MU(x) mutex_unlock(&mutex_##x)
188 #define MI(x) mutex_init(&mutex_##x)
190 #define WSL(x) down_write(&rwsem_##x)
191 #define WSU(x) up_write(&rwsem_##x)
193 #define RSL(x) down_read(&rwsem_##x)
194 #define RSU(x) up_read(&rwsem_##x)
195 #define RWSI(x) init_rwsem(&rwsem_##x)
197 #define LOCK_UNLOCK_2(x,y) LOCK(x); LOCK(y); UNLOCK(y); UNLOCK(x)
199 /*
200 * Generate different permutations of the same testcase, using
201 * the same basic lock-dependency/state events:
202 */
204 #define GENERATE_TESTCASE(name) \
205 \
206 static void name(void) { E(); }
208 #define GENERATE_PERMUTATIONS_2_EVENTS(name) \
209 \
210 static void name##_12(void) { E1(); E2(); } \
211 static void name##_21(void) { E2(); E1(); }
213 #define GENERATE_PERMUTATIONS_3_EVENTS(name) \
214 \
215 static void name##_123(void) { E1(); E2(); E3(); } \
216 static void name##_132(void) { E1(); E3(); E2(); } \
217 static void name##_213(void) { E2(); E1(); E3(); } \
218 static void name##_231(void) { E2(); E3(); E1(); } \
219 static void name##_312(void) { E3(); E1(); E2(); } \
220 static void name##_321(void) { E3(); E2(); E1(); }
222 /*
223 * AA deadlock:
224 */
226 #define E() \
227 \
228 LOCK(X1); \
229 LOCK(X2); /* this one should fail */
231 /*
232 * 6 testcases:
233 */
234 #include "locking-selftest-spin.h"
235 GENERATE_TESTCASE(AA_spin)
236 #include "locking-selftest-wlock.h"
237 GENERATE_TESTCASE(AA_wlock)
238 #include "locking-selftest-rlock.h"
239 GENERATE_TESTCASE(AA_rlock)
240 #include "locking-selftest-mutex.h"
241 GENERATE_TESTCASE(AA_mutex)
242 #include "locking-selftest-wsem.h"
243 GENERATE_TESTCASE(AA_wsem)
244 #include "locking-selftest-rsem.h"
245 GENERATE_TESTCASE(AA_rsem)
247 #undef E
249 /*
250 * Special-case for read-locking, they are
251 * allowed to recurse on the same lock class:
252 */
253 static void rlock_AA1(void)
254 {
255 RL(X1);
256 RL(X1); // this one should NOT fail
257 }
259 static void rlock_AA1B(void)
260 {
261 RL(X1);
262 RL(X2); // this one should NOT fail
263 }
265 static void rsem_AA1(void)
266 {
267 RSL(X1);
268 RSL(X1); // this one should fail
269 }
271 static void rsem_AA1B(void)
272 {
273 RSL(X1);
274 RSL(X2); // this one should fail
275 }
276 /*
277 * The mixing of read and write locks is not allowed:
278 */
279 static void rlock_AA2(void)
280 {
281 RL(X1);
282 WL(X2); // this one should fail
283 }
285 static void rsem_AA2(void)
286 {
287 RSL(X1);
288 WSL(X2); // this one should fail
289 }
291 static void rlock_AA3(void)
292 {
293 WL(X1);
294 RL(X2); // this one should fail
295 }
297 static void rsem_AA3(void)
298 {
299 WSL(X1);
300 RSL(X2); // this one should fail
301 }
303 /*
304 * ABBA deadlock:
305 */
307 #define E() \
308 \
309 LOCK_UNLOCK_2(A, B); \
310 LOCK_UNLOCK_2(B, A); /* fail */
312 /*
313 * 6 testcases:
314 */
315 #include "locking-selftest-spin.h"
316 GENERATE_TESTCASE(ABBA_spin)
317 #include "locking-selftest-wlock.h"
318 GENERATE_TESTCASE(ABBA_wlock)
319 #include "locking-selftest-rlock.h"
320 GENERATE_TESTCASE(ABBA_rlock)
321 #include "locking-selftest-mutex.h"
322 GENERATE_TESTCASE(ABBA_mutex)
323 #include "locking-selftest-wsem.h"
324 GENERATE_TESTCASE(ABBA_wsem)
325 #include "locking-selftest-rsem.h"
326 GENERATE_TESTCASE(ABBA_rsem)
328 #undef E
330 /*
331 * AB BC CA deadlock:
332 */
334 #define E() \
335 \
336 LOCK_UNLOCK_2(A, B); \
337 LOCK_UNLOCK_2(B, C); \
338 LOCK_UNLOCK_2(C, A); /* fail */
340 /*
341 * 6 testcases:
342 */
343 #include "locking-selftest-spin.h"
344 GENERATE_TESTCASE(ABBCCA_spin)
345 #include "locking-selftest-wlock.h"
346 GENERATE_TESTCASE(ABBCCA_wlock)
347 #include "locking-selftest-rlock.h"
348 GENERATE_TESTCASE(ABBCCA_rlock)
349 #include "locking-selftest-mutex.h"
350 GENERATE_TESTCASE(ABBCCA_mutex)
351 #include "locking-selftest-wsem.h"
352 GENERATE_TESTCASE(ABBCCA_wsem)
353 #include "locking-selftest-rsem.h"
354 GENERATE_TESTCASE(ABBCCA_rsem)
356 #undef E
358 /*
359 * AB CA BC deadlock:
360 */
362 #define E() \
363 \
364 LOCK_UNLOCK_2(A, B); \
365 LOCK_UNLOCK_2(C, A); \
366 LOCK_UNLOCK_2(B, C); /* fail */
368 /*
369 * 6 testcases:
370 */
371 #include "locking-selftest-spin.h"
372 GENERATE_TESTCASE(ABCABC_spin)
373 #include "locking-selftest-wlock.h"
374 GENERATE_TESTCASE(ABCABC_wlock)
375 #include "locking-selftest-rlock.h"
376 GENERATE_TESTCASE(ABCABC_rlock)
377 #include "locking-selftest-mutex.h"
378 GENERATE_TESTCASE(ABCABC_mutex)
379 #include "locking-selftest-wsem.h"
380 GENERATE_TESTCASE(ABCABC_wsem)
381 #include "locking-selftest-rsem.h"
382 GENERATE_TESTCASE(ABCABC_rsem)
384 #undef E
386 /*
387 * AB BC CD DA deadlock:
388 */
390 #define E() \
391 \
392 LOCK_UNLOCK_2(A, B); \
393 LOCK_UNLOCK_2(B, C); \
394 LOCK_UNLOCK_2(C, D); \
395 LOCK_UNLOCK_2(D, A); /* fail */
397 /*
398 * 6 testcases:
399 */
400 #include "locking-selftest-spin.h"
401 GENERATE_TESTCASE(ABBCCDDA_spin)
402 #include "locking-selftest-wlock.h"
403 GENERATE_TESTCASE(ABBCCDDA_wlock)
404 #include "locking-selftest-rlock.h"
405 GENERATE_TESTCASE(ABBCCDDA_rlock)
406 #include "locking-selftest-mutex.h"
407 GENERATE_TESTCASE(ABBCCDDA_mutex)
408 #include "locking-selftest-wsem.h"
409 GENERATE_TESTCASE(ABBCCDDA_wsem)
410 #include "locking-selftest-rsem.h"
411 GENERATE_TESTCASE(ABBCCDDA_rsem)
413 #undef E
415 /*
416 * AB CD BD DA deadlock:
417 */
418 #define E() \
419 \
420 LOCK_UNLOCK_2(A, B); \
421 LOCK_UNLOCK_2(C, D); \
422 LOCK_UNLOCK_2(B, D); \
423 LOCK_UNLOCK_2(D, A); /* fail */
425 /*
426 * 6 testcases:
427 */
428 #include "locking-selftest-spin.h"
429 GENERATE_TESTCASE(ABCDBDDA_spin)
430 #include "locking-selftest-wlock.h"
431 GENERATE_TESTCASE(ABCDBDDA_wlock)
432 #include "locking-selftest-rlock.h"
433 GENERATE_TESTCASE(ABCDBDDA_rlock)
434 #include "locking-selftest-mutex.h"
435 GENERATE_TESTCASE(ABCDBDDA_mutex)
436 #include "locking-selftest-wsem.h"
437 GENERATE_TESTCASE(ABCDBDDA_wsem)
438 #include "locking-selftest-rsem.h"
439 GENERATE_TESTCASE(ABCDBDDA_rsem)
441 #undef E
443 /*
444 * AB CD BC DA deadlock:
445 */
446 #define E() \
447 \
448 LOCK_UNLOCK_2(A, B); \
449 LOCK_UNLOCK_2(C, D); \
450 LOCK_UNLOCK_2(B, C); \
451 LOCK_UNLOCK_2(D, A); /* fail */
453 /*
454 * 6 testcases:
455 */
456 #include "locking-selftest-spin.h"
457 GENERATE_TESTCASE(ABCDBCDA_spin)
458 #include "locking-selftest-wlock.h"
459 GENERATE_TESTCASE(ABCDBCDA_wlock)
460 #include "locking-selftest-rlock.h"
461 GENERATE_TESTCASE(ABCDBCDA_rlock)
462 #include "locking-selftest-mutex.h"
463 GENERATE_TESTCASE(ABCDBCDA_mutex)
464 #include "locking-selftest-wsem.h"
465 GENERATE_TESTCASE(ABCDBCDA_wsem)
466 #include "locking-selftest-rsem.h"
467 GENERATE_TESTCASE(ABCDBCDA_rsem)
469 #undef E
471 /*
472 * Double unlock:
473 */
474 #define E() \
475 \
476 LOCK(A); \
477 UNLOCK(A); \
478 UNLOCK(A); /* fail */
480 /*
481 * 6 testcases:
482 */
483 #include "locking-selftest-spin.h"
484 GENERATE_TESTCASE(double_unlock_spin)
485 #include "locking-selftest-wlock.h"
486 GENERATE_TESTCASE(double_unlock_wlock)
487 #include "locking-selftest-rlock.h"
488 GENERATE_TESTCASE(double_unlock_rlock)
489 #include "locking-selftest-mutex.h"
490 GENERATE_TESTCASE(double_unlock_mutex)
491 #include "locking-selftest-wsem.h"
492 GENERATE_TESTCASE(double_unlock_wsem)
493 #include "locking-selftest-rsem.h"
494 GENERATE_TESTCASE(double_unlock_rsem)
496 #undef E
498 /*
499 * Bad unlock ordering:
500 */
501 #define E() \
502 \
503 LOCK(A); \
504 LOCK(B); \
505 UNLOCK(A); /* fail */ \
506 UNLOCK(B);
508 /*
509 * 6 testcases:
510 */
511 #include "locking-selftest-spin.h"
512 GENERATE_TESTCASE(bad_unlock_order_spin)
513 #include "locking-selftest-wlock.h"
514 GENERATE_TESTCASE(bad_unlock_order_wlock)
515 #include "locking-selftest-rlock.h"
516 GENERATE_TESTCASE(bad_unlock_order_rlock)
517 #include "locking-selftest-mutex.h"
518 GENERATE_TESTCASE(bad_unlock_order_mutex)
519 #include "locking-selftest-wsem.h"
520 GENERATE_TESTCASE(bad_unlock_order_wsem)
521 #include "locking-selftest-rsem.h"
522 GENERATE_TESTCASE(bad_unlock_order_rsem)
524 #undef E
526 /*
527 * initializing a held lock:
528 */
529 #define E() \
530 \
531 LOCK(A); \
532 INIT(A); /* fail */
534 /*
535 * 6 testcases:
536 */
537 #include "locking-selftest-spin.h"
538 GENERATE_TESTCASE(init_held_spin)
539 #include "locking-selftest-wlock.h"
540 GENERATE_TESTCASE(init_held_wlock)
541 #include "locking-selftest-rlock.h"
542 GENERATE_TESTCASE(init_held_rlock)
543 #include "locking-selftest-mutex.h"
544 GENERATE_TESTCASE(init_held_mutex)
545 #include "locking-selftest-wsem.h"
546 GENERATE_TESTCASE(init_held_wsem)
547 #include "locking-selftest-rsem.h"
548 GENERATE_TESTCASE(init_held_rsem)
550 #undef E
552 /*
553 * locking an irq-safe lock with irqs enabled:
554 */
555 #define E1() \
556 \
557 IRQ_ENTER(); \
558 LOCK(A); \
559 UNLOCK(A); \
560 IRQ_EXIT();
562 #define E2() \
563 \
564 LOCK(A); \
565 UNLOCK(A);
567 /*
568 * Generate 24 testcases:
569 */
570 #include "locking-selftest-spin-hardirq.h"
571 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
573 #include "locking-selftest-rlock-hardirq.h"
574 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
576 #include "locking-selftest-wlock-hardirq.h"
577 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
579 #include "locking-selftest-spin-softirq.h"
580 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
582 #include "locking-selftest-rlock-softirq.h"
583 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
585 #include "locking-selftest-wlock-softirq.h"
586 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_wlock)
588 #undef E1
589 #undef E2
591 /*
592 * Enabling hardirqs with a softirq-safe lock held:
593 */
594 #define E1() \
595 \
596 SOFTIRQ_ENTER(); \
597 LOCK(A); \
598 UNLOCK(A); \
599 SOFTIRQ_EXIT();
601 #define E2() \
602 \
603 HARDIRQ_DISABLE(); \
604 LOCK(A); \
605 HARDIRQ_ENABLE(); \
606 UNLOCK(A);
608 /*
609 * Generate 12 testcases:
610 */
611 #include "locking-selftest-spin.h"
612 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
614 #include "locking-selftest-wlock.h"
615 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
617 #include "locking-selftest-rlock.h"
618 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_rlock)
620 #undef E1
621 #undef E2
623 /*
624 * Enabling irqs with an irq-safe lock held:
625 */
626 #define E1() \
627 \
628 IRQ_ENTER(); \
629 LOCK(A); \
630 UNLOCK(A); \
631 IRQ_EXIT();
633 #define E2() \
634 \
635 IRQ_DISABLE(); \
636 LOCK(A); \
637 IRQ_ENABLE(); \
638 UNLOCK(A);
640 /*
641 * Generate 24 testcases:
642 */
643 #include "locking-selftest-spin-hardirq.h"
644 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
646 #include "locking-selftest-rlock-hardirq.h"
647 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
649 #include "locking-selftest-wlock-hardirq.h"
650 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
652 #include "locking-selftest-spin-softirq.h"
653 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
655 #include "locking-selftest-rlock-softirq.h"
656 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
658 #include "locking-selftest-wlock-softirq.h"
659 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_wlock)
661 #undef E1
662 #undef E2
664 /*
665 * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
666 */
667 #define E1() \
668 \
669 LOCK(A); \
670 LOCK(B); \
671 UNLOCK(B); \
672 UNLOCK(A); \
674 #define E2() \
675 \
676 LOCK(B); \
677 UNLOCK(B);
679 #define E3() \
680 \
681 IRQ_ENTER(); \
682 LOCK(A); \
683 UNLOCK(A); \
684 IRQ_EXIT();
686 /*
687 * Generate 36 testcases:
688 */
689 #include "locking-selftest-spin-hardirq.h"
690 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
692 #include "locking-selftest-rlock-hardirq.h"
693 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
695 #include "locking-selftest-wlock-hardirq.h"
696 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
698 #include "locking-selftest-spin-softirq.h"
699 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
701 #include "locking-selftest-rlock-softirq.h"
702 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
704 #include "locking-selftest-wlock-softirq.h"
705 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_wlock)
707 #undef E1
708 #undef E2
709 #undef E3
711 /*
712 * If a lock turns into softirq-safe, but earlier it took
713 * a softirq-unsafe lock:
714 */
716 #define E1() \
717 IRQ_DISABLE(); \
718 LOCK(A); \
719 LOCK(B); \
720 UNLOCK(B); \
721 UNLOCK(A); \
722 IRQ_ENABLE();
724 #define E2() \
725 LOCK(B); \
726 UNLOCK(B);
728 #define E3() \
729 IRQ_ENTER(); \
730 LOCK(A); \
731 UNLOCK(A); \
732 IRQ_EXIT();
734 /*
735 * Generate 36 testcases:
736 */
737 #include "locking-selftest-spin-hardirq.h"
738 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
740 #include "locking-selftest-rlock-hardirq.h"
741 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
743 #include "locking-selftest-wlock-hardirq.h"
744 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
746 #include "locking-selftest-spin-softirq.h"
747 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
749 #include "locking-selftest-rlock-softirq.h"
750 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
752 #include "locking-selftest-wlock-softirq.h"
753 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_wlock)
755 #undef E1
756 #undef E2
757 #undef E3
759 /*
760 * read-lock / write-lock irq inversion.
761 *
762 * Deadlock scenario:
763 *
764 * CPU#1 is at #1, i.e. it has write-locked A, but has not
765 * taken B yet.
766 *
767 * CPU#2 is at #2, i.e. it has locked B.
768 *
769 * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
770 *
771 * The deadlock occurs because CPU#1 will spin on B, and CPU#2
772 * will spin on A.
773 */
775 #define E1() \
776 \
777 IRQ_DISABLE(); \
778 WL(A); \
779 LOCK(B); \
780 UNLOCK(B); \
781 WU(A); \
782 IRQ_ENABLE();
784 #define E2() \
785 \
786 LOCK(B); \
787 UNLOCK(B);
789 #define E3() \
790 \
791 IRQ_ENTER(); \
792 RL(A); \
793 RU(A); \
794 IRQ_EXIT();
796 /*
797 * Generate 36 testcases:
798 */
799 #include "locking-selftest-spin-hardirq.h"
800 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
802 #include "locking-selftest-rlock-hardirq.h"
803 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
805 #include "locking-selftest-wlock-hardirq.h"
806 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
808 #include "locking-selftest-spin-softirq.h"
809 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
811 #include "locking-selftest-rlock-softirq.h"
812 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
814 #include "locking-selftest-wlock-softirq.h"
815 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
817 #undef E1
818 #undef E2
819 #undef E3
821 /*
822 * read-lock / write-lock recursion that is actually safe.
823 */
825 #define E1() \
826 \
827 IRQ_DISABLE(); \
828 WL(A); \
829 WU(A); \
830 IRQ_ENABLE();
832 #define E2() \
833 \
834 RL(A); \
835 RU(A); \
837 #define E3() \
838 \
839 IRQ_ENTER(); \
840 RL(A); \
841 L(B); \
842 U(B); \
843 RU(A); \
844 IRQ_EXIT();
846 /*
847 * Generate 12 testcases:
848 */
849 #include "locking-selftest-hardirq.h"
850 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard)
852 #include "locking-selftest-softirq.h"
853 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)
855 #undef E1
856 #undef E2
857 #undef E3
859 /*
860 * read-lock / write-lock recursion that is unsafe.
861 */
863 #define E1() \
864 \
865 IRQ_DISABLE(); \
866 L(B); \
867 WL(A); \
868 WU(A); \
869 U(B); \
870 IRQ_ENABLE();
872 #define E2() \
873 \
874 RL(A); \
875 RU(A); \
877 #define E3() \
878 \
879 IRQ_ENTER(); \
880 L(B); \
881 U(B); \
882 IRQ_EXIT();
884 /*
885 * Generate 12 testcases:
886 */
887 #include "locking-selftest-hardirq.h"
888 // GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard)
890 #include "locking-selftest-softirq.h"
891 // GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft)
893 #ifdef CONFIG_DEBUG_LOCK_ALLOC
894 # define I_SPINLOCK(x) lockdep_reset_lock(&lock_##x.dep_map)
895 # define I_RWLOCK(x) lockdep_reset_lock(&rwlock_##x.dep_map)
896 # define I_MUTEX(x) lockdep_reset_lock(&mutex_##x.dep_map)
897 # define I_RWSEM(x) lockdep_reset_lock(&rwsem_##x.dep_map)
898 #else
899 # define I_SPINLOCK(x)
900 # define I_RWLOCK(x)
901 # define I_MUTEX(x)
902 # define I_RWSEM(x)
903 #endif
905 #define I1(x) \
906 do { \
907 I_SPINLOCK(x); \
908 I_RWLOCK(x); \
909 I_MUTEX(x); \
910 I_RWSEM(x); \
911 } while (0)
913 #define I2(x) \
914 do { \
915 spin_lock_init(&lock_##x); \
916 rwlock_init(&rwlock_##x); \
917 mutex_init(&mutex_##x); \
918 init_rwsem(&rwsem_##x); \
919 } while (0)
921 static void reset_locks(void)
922 {
923 local_irq_disable();
924 I1(A); I1(B); I1(C); I1(D);
925 I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
926 lockdep_reset();
927 I2(A); I2(B); I2(C); I2(D);
928 init_shared_classes();
929 local_irq_enable();
930 }
932 #undef I
934 static int testcase_total;
935 static int testcase_successes;
936 static int expected_testcase_failures;
937 static int unexpected_testcase_failures;
939 static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
940 {
941 unsigned long saved_preempt_count = preempt_count();
942 int expected_failure = 0;
944 WARN_ON(irqs_disabled());
946 testcase_fn();
947 /*
948 * Filter out expected failures:
949 */
950 #ifndef CONFIG_PROVE_LOCKING
951 if ((lockclass_mask & LOCKTYPE_SPIN) && debug_locks != expected)
952 expected_failure = 1;
953 if ((lockclass_mask & LOCKTYPE_RWLOCK) && debug_locks != expected)
954 expected_failure = 1;
955 if ((lockclass_mask & LOCKTYPE_MUTEX) && debug_locks != expected)
956 expected_failure = 1;
957 if ((lockclass_mask & LOCKTYPE_RWSEM) && debug_locks != expected)
958 expected_failure = 1;
959 #endif
960 if (debug_locks != expected) {
961 if (expected_failure) {
962 expected_testcase_failures++;
963 printk("failed|");
964 } else {
965 unexpected_testcase_failures++;
966 printk("FAILED|");
967 }
968 } else {
969 testcase_successes++;
970 printk(" ok |");
971 }
972 testcase_total++;
974 if (debug_locks_verbose)
975 printk(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
976 lockclass_mask, debug_locks, expected);
977 /*
978 * Some tests (e.g. double-unlock) might corrupt the preemption
979 * count, so restore it:
980 */
981 preempt_count() = saved_preempt_count;
982 #ifdef CONFIG_TRACE_IRQFLAGS
983 if (softirq_count())
984 current->softirqs_enabled = 0;
985 else
986 current->softirqs_enabled = 1;
987 #endif
989 reset_locks();
990 }
992 static inline void print_testname(const char *testname)
993 {
994 printk("%33s:", testname);
995 }
997 #define DO_TESTCASE_1(desc, name, nr) \
998 print_testname(desc"/"#nr); \
999 dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1000 printk("\n");
1002 #define DO_TESTCASE_1B(desc, name, nr) \
1003 print_testname(desc"/"#nr); \
1004 dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1005 printk("\n");
1007 #define DO_TESTCASE_3(desc, name, nr) \
1008 print_testname(desc"/"#nr); \
1009 dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \
1010 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1011 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1012 printk("\n");
1014 #define DO_TESTCASE_3RW(desc, name, nr) \
1015 print_testname(desc"/"#nr); \
1016 dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
1017 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1018 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1019 printk("\n");
1021 #define DO_TESTCASE_6(desc, name) \
1022 print_testname(desc); \
1023 dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
1024 dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
1025 dotest(name##_rlock, FAILURE, LOCKTYPE_RWLOCK); \
1026 dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
1027 dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
1028 dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
1029 printk("\n");
1031 #define DO_TESTCASE_6_SUCCESS(desc, name) \
1032 print_testname(desc); \
1033 dotest(name##_spin, SUCCESS, LOCKTYPE_SPIN); \
1034 dotest(name##_wlock, SUCCESS, LOCKTYPE_RWLOCK); \
1035 dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
1036 dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX); \
1037 dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM); \
1038 dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM); \
1039 printk("\n");
1041 /*
1042 * 'read' variant: rlocks must not trigger.
1043 */
1044 #define DO_TESTCASE_6R(desc, name) \
1045 print_testname(desc); \
1046 dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
1047 dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
1048 dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
1049 dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
1050 dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
1051 dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
1052 printk("\n");
1054 #define DO_TESTCASE_2I(desc, name, nr) \
1055 DO_TESTCASE_1("hard-"desc, name##_hard, nr); \
1056 DO_TESTCASE_1("soft-"desc, name##_soft, nr);
1058 #define DO_TESTCASE_2IB(desc, name, nr) \
1059 DO_TESTCASE_1B("hard-"desc, name##_hard, nr); \
1060 DO_TESTCASE_1B("soft-"desc, name##_soft, nr);
1062 #define DO_TESTCASE_6I(desc, name, nr) \
1063 DO_TESTCASE_3("hard-"desc, name##_hard, nr); \
1064 DO_TESTCASE_3("soft-"desc, name##_soft, nr);
1066 #define DO_TESTCASE_6IRW(desc, name, nr) \
1067 DO_TESTCASE_3RW("hard-"desc, name##_hard, nr); \
1068 DO_TESTCASE_3RW("soft-"desc, name##_soft, nr);
1070 #define DO_TESTCASE_2x3(desc, name) \
1071 DO_TESTCASE_3(desc, name, 12); \
1072 DO_TESTCASE_3(desc, name, 21);
1074 #define DO_TESTCASE_2x6(desc, name) \
1075 DO_TESTCASE_6I(desc, name, 12); \
1076 DO_TESTCASE_6I(desc, name, 21);
1078 #define DO_TESTCASE_6x2(desc, name) \
1079 DO_TESTCASE_2I(desc, name, 123); \
1080 DO_TESTCASE_2I(desc, name, 132); \
1081 DO_TESTCASE_2I(desc, name, 213); \
1082 DO_TESTCASE_2I(desc, name, 231); \
1083 DO_TESTCASE_2I(desc, name, 312); \
1084 DO_TESTCASE_2I(desc, name, 321);
1086 #define DO_TESTCASE_6x2B(desc, name) \
1087 DO_TESTCASE_2IB(desc, name, 123); \
1088 DO_TESTCASE_2IB(desc, name, 132); \
1089 DO_TESTCASE_2IB(desc, name, 213); \
1090 DO_TESTCASE_2IB(desc, name, 231); \
1091 DO_TESTCASE_2IB(desc, name, 312); \
1092 DO_TESTCASE_2IB(desc, name, 321);
1094 #define DO_TESTCASE_6x6(desc, name) \
1095 DO_TESTCASE_6I(desc, name, 123); \
1096 DO_TESTCASE_6I(desc, name, 132); \
1097 DO_TESTCASE_6I(desc, name, 213); \
1098 DO_TESTCASE_6I(desc, name, 231); \
1099 DO_TESTCASE_6I(desc, name, 312); \
1100 DO_TESTCASE_6I(desc, name, 321);
1102 #define DO_TESTCASE_6x6RW(desc, name) \
1103 DO_TESTCASE_6IRW(desc, name, 123); \
1104 DO_TESTCASE_6IRW(desc, name, 132); \
1105 DO_TESTCASE_6IRW(desc, name, 213); \
1106 DO_TESTCASE_6IRW(desc, name, 231); \
1107 DO_TESTCASE_6IRW(desc, name, 312); \
1108 DO_TESTCASE_6IRW(desc, name, 321);
1111 void locking_selftest(void)
1113 /*
1114 * Got a locking failure before the selftest ran?
1115 */
1116 if (!debug_locks) {
1117 printk("----------------------------------\n");
1118 printk("| Locking API testsuite disabled |\n");
1119 printk("----------------------------------\n");
1120 return;
1123 /*
1124 * Run the testsuite:
1125 */
1126 printk("------------------------\n");
1127 printk("| Locking API testsuite:\n");
1128 printk("----------------------------------------------------------------------------\n");
1129 printk(" | spin |wlock |rlock |mutex | wsem | rsem |\n");
1130 printk(" --------------------------------------------------------------------------\n");
1132 init_shared_classes();
1133 debug_locks_silent = !debug_locks_verbose;
1135 DO_TESTCASE_6R("A-A deadlock", AA);
1136 DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
1137 DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
1138 DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
1139 DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
1140 DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
1141 DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
1142 DO_TESTCASE_6("double unlock", double_unlock);
1143 DO_TESTCASE_6("initialize held", init_held);
1144 DO_TESTCASE_6_SUCCESS("bad unlock order", bad_unlock_order);
1146 printk(" --------------------------------------------------------------------------\n");
1147 print_testname("recursive read-lock");
1148 printk(" |");
1149 dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
1150 printk(" |");
1151 dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
1152 printk("\n");
1154 print_testname("recursive read-lock #2");
1155 printk(" |");
1156 dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
1157 printk(" |");
1158 dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
1159 printk("\n");
1161 print_testname("mixed read-write-lock");
1162 printk(" |");
1163 dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
1164 printk(" |");
1165 dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
1166 printk("\n");
1168 print_testname("mixed write-read-lock");
1169 printk(" |");
1170 dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
1171 printk(" |");
1172 dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
1173 printk("\n");
1175 printk(" --------------------------------------------------------------------------\n");
1177 /*
1178 * irq-context testcases:
1179 */
1180 DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
1181 DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
1182 DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
1183 DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
1184 DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
1185 DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
1187 DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
1188 // DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
1190 if (unexpected_testcase_failures) {
1191 printk("-----------------------------------------------------------------\n");
1192 debug_locks = 0;
1193 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
1194 unexpected_testcase_failures, testcase_total);
1195 printk("-----------------------------------------------------------------\n");
1196 } else if (expected_testcase_failures && testcase_successes) {
1197 printk("--------------------------------------------------------\n");
1198 printk("%3d out of %3d testcases failed, as expected. |\n",
1199 expected_testcase_failures, testcase_total);
1200 printk("----------------------------------------------------\n");
1201 debug_locks = 1;
1202 } else if (expected_testcase_failures && !testcase_successes) {
1203 printk("--------------------------------------------------------\n");
1204 printk("All %3d testcases failed, as expected. |\n",
1205 expected_testcase_failures);
1206 printk("----------------------------------------\n");
1207 debug_locks = 1;
1208 } else {
1209 printk("-------------------------------------------------------\n");
1210 printk("Good, all %3d testcases passed! |\n",
1211 testcase_successes);
1212 printk("---------------------------------\n");
1213 debug_locks = 1;
1215 debug_locks_silent = 0;