906ad101eab3cf612eab214fa466c6ce872c08c5
[linux-2.6.git] / lib / spinlock_debug.c
1 /*
2  * Copyright 2005, Red Hat, Inc., Ingo Molnar
3  * Released under the General Public License (GPL).
4  *
5  * This file contains the spinlock/rwlock implementations for
6  * DEBUG_SPINLOCK.
7  */
8
9 #include <linux/config.h>
10 #include <linux/spinlock.h>
11 #include <linux/interrupt.h>
12 #include <linux/delay.h>
13
14 static void spin_bug(spinlock_t *lock, const char *msg)
15 {
16         static long print_once = 1;
17         struct task_struct *owner = NULL;
18
19         if (xchg(&print_once, 0)) {
20                 if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT)
21                         owner = lock->owner;
22                 printk("BUG: spinlock %s on CPU#%d, %s/%d\n",
23                         msg, smp_processor_id(), current->comm, current->pid);
24                 printk(" lock: %p, .magic: %08x, .owner: %s/%d, .owner_cpu: %d\n",
25                         lock, lock->magic,
26                         owner ? owner->comm : "<none>",
27                         owner ? owner->pid : -1,
28                         lock->owner_cpu);
29                 dump_stack();
30 #ifdef CONFIG_SMP
31                 /*
32                  * We cannot continue on SMP:
33                  */
34 //              panic("bad locking");
35 #endif
36         }
37 }
38
39 #define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg)
40
41 static inline void debug_spin_lock_before(spinlock_t *lock)
42 {
43         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
44         SPIN_BUG_ON(lock->owner == current, lock, "recursion");
45         SPIN_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
46                                                         lock, "cpu recursion");
47 }
48
49 static inline void debug_spin_lock_after(spinlock_t *lock)
50 {
51         lock->owner_cpu = raw_smp_processor_id();
52         lock->owner = current;
53 }
54
55 static inline void debug_spin_unlock(spinlock_t *lock)
56 {
57         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
58         SPIN_BUG_ON(!spin_is_locked(lock), lock, "already unlocked");
59         SPIN_BUG_ON(lock->owner != current, lock, "wrong owner");
60         SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
61                                                         lock, "wrong CPU");
62         lock->owner = SPINLOCK_OWNER_INIT;
63         lock->owner_cpu = -1;
64 }
65
66 static void __spin_lock_debug(spinlock_t *lock)
67 {
68         int print_once = 1;
69         u64 i;
70
71         for (;;) {
72                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
73                         cpu_relax();
74                         if (__raw_spin_trylock(&lock->raw_lock))
75                                 return;
76                 }
77                 /* lockup suspected: */
78                 if (print_once) {
79                         print_once = 0;
80                         printk("BUG: spinlock lockup on CPU#%d, %s/%d, %p\n",
81                                 smp_processor_id(), current->comm, current->pid,
82                                         lock);
83                         dump_stack();
84                 }
85         }
86 }
87
88 void _raw_spin_lock(spinlock_t *lock)
89 {
90         debug_spin_lock_before(lock);
91         if (unlikely(!__raw_spin_trylock(&lock->raw_lock)))
92                 __spin_lock_debug(lock);
93         debug_spin_lock_after(lock);
94 }
95
96 int _raw_spin_trylock(spinlock_t *lock)
97 {
98         int ret = __raw_spin_trylock(&lock->raw_lock);
99
100         if (ret)
101                 debug_spin_lock_after(lock);
102 #ifndef CONFIG_SMP
103         /*
104          * Must not happen on UP:
105          */
106         SPIN_BUG_ON(!ret, lock, "trylock failure on UP");
107 #endif
108         return ret;
109 }
110
111 void _raw_spin_unlock(spinlock_t *lock)
112 {
113         debug_spin_unlock(lock);
114         __raw_spin_unlock(&lock->raw_lock);
115 }
116
117 static void rwlock_bug(rwlock_t *lock, const char *msg)
118 {
119         static long print_once = 1;
120
121         if (xchg(&print_once, 0)) {
122                 printk("BUG: rwlock %s on CPU#%d, %s/%d, %p\n", msg,
123                         smp_processor_id(), current->comm, current->pid, lock);
124                 dump_stack();
125 #ifdef CONFIG_SMP
126                 /*
127                  * We cannot continue on SMP:
128                  */
129                 panic("bad locking");
130 #endif
131         }
132 }
133
134 #define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg)
135
136 static void __read_lock_debug(rwlock_t *lock)
137 {
138         int print_once = 1;
139         u64 i;
140
141         for (;;) {
142                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
143                         cpu_relax();
144                         if (__raw_read_trylock(&lock->raw_lock))
145                                 return;
146                 }
147                 /* lockup suspected: */
148                 if (print_once) {
149                         print_once = 0;
150                         printk("BUG: read-lock lockup on CPU#%d, %s/%d, %p\n",
151                                 smp_processor_id(), current->comm, current->pid,
152                                         lock);
153                         dump_stack();
154                 }
155         }
156 }
157
158 void _raw_read_lock(rwlock_t *lock)
159 {
160         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
161         if (unlikely(!__raw_read_trylock(&lock->raw_lock)))
162                 __read_lock_debug(lock);
163 }
164
165 int _raw_read_trylock(rwlock_t *lock)
166 {
167         int ret = __raw_read_trylock(&lock->raw_lock);
168
169 #ifndef CONFIG_SMP
170         /*
171          * Must not happen on UP:
172          */
173         RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
174 #endif
175         return ret;
176 }
177
178 void _raw_read_unlock(rwlock_t *lock)
179 {
180         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
181         __raw_read_unlock(&lock->raw_lock);
182 }
183
184 static inline void debug_write_lock_before(rwlock_t *lock)
185 {
186         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
187         RWLOCK_BUG_ON(lock->owner == current, lock, "recursion");
188         RWLOCK_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
189                                                         lock, "cpu recursion");
190 }
191
192 static inline void debug_write_lock_after(rwlock_t *lock)
193 {
194         lock->owner_cpu = raw_smp_processor_id();
195         lock->owner = current;
196 }
197
198 static inline void debug_write_unlock(rwlock_t *lock)
199 {
200         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
201         RWLOCK_BUG_ON(lock->owner != current, lock, "wrong owner");
202         RWLOCK_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
203                                                         lock, "wrong CPU");
204         lock->owner = SPINLOCK_OWNER_INIT;
205         lock->owner_cpu = -1;
206 }
207
208 static void __write_lock_debug(rwlock_t *lock)
209 {
210         int print_once = 1;
211         u64 i;
212
213         for (;;) {
214                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
215                         cpu_relax();
216                         if (__raw_write_trylock(&lock->raw_lock))
217                                 return;
218                 }
219                 /* lockup suspected: */
220                 if (print_once) {
221                         print_once = 0;
222                         printk("BUG: write-lock lockup on CPU#%d, %s/%d, %p\n",
223                                 smp_processor_id(), current->comm, current->pid,
224                                         lock);
225                         dump_stack();
226                 }
227         }
228 }
229
230 void _raw_write_lock(rwlock_t *lock)
231 {
232         debug_write_lock_before(lock);
233         if (unlikely(!__raw_write_trylock(&lock->raw_lock)))
234                 __write_lock_debug(lock);
235         debug_write_lock_after(lock);
236 }
237
238 int _raw_write_trylock(rwlock_t *lock)
239 {
240         int ret = __raw_write_trylock(&lock->raw_lock);
241
242         if (ret)
243                 debug_write_lock_after(lock);
244 #ifndef CONFIG_SMP
245         /*
246          * Must not happen on UP:
247          */
248         RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
249 #endif
250         return ret;
251 }
252
253 void _raw_write_unlock(rwlock_t *lock)
254 {
255         debug_write_unlock(lock);
256         __raw_write_unlock(&lock->raw_lock);
257 }