V4L/DVB (4446): Add support for the Artec T14
[linux-2.6] / 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/spinlock.h>
10 #include <linux/interrupt.h>
11 #include <linux/debug_locks.h>
12 #include <linux/delay.h>
13 #include <linux/module.h>
14
15 void __spin_lock_init(spinlock_t *lock, const char *name,
16                       struct lock_class_key *key)
17 {
18 #ifdef CONFIG_DEBUG_LOCK_ALLOC
19         /*
20          * Make sure we are not reinitializing a held lock:
21          */
22         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
23         lockdep_init_map(&lock->dep_map, name, key);
24 #endif
25         lock->raw_lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
26         lock->magic = SPINLOCK_MAGIC;
27         lock->owner = SPINLOCK_OWNER_INIT;
28         lock->owner_cpu = -1;
29 }
30
31 EXPORT_SYMBOL(__spin_lock_init);
32
33 void __rwlock_init(rwlock_t *lock, const char *name,
34                    struct lock_class_key *key)
35 {
36 #ifdef CONFIG_DEBUG_LOCK_ALLOC
37         /*
38          * Make sure we are not reinitializing a held lock:
39          */
40         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
41         lockdep_init_map(&lock->dep_map, name, key);
42 #endif
43         lock->raw_lock = (raw_rwlock_t) __RAW_RW_LOCK_UNLOCKED;
44         lock->magic = RWLOCK_MAGIC;
45         lock->owner = SPINLOCK_OWNER_INIT;
46         lock->owner_cpu = -1;
47 }
48
49 EXPORT_SYMBOL(__rwlock_init);
50
51 static void spin_bug(spinlock_t *lock, const char *msg)
52 {
53         struct task_struct *owner = NULL;
54
55         if (!debug_locks_off())
56                 return;
57
58         if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT)
59                 owner = lock->owner;
60         printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n",
61                 msg, raw_smp_processor_id(),
62                 current->comm, current->pid);
63         printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, "
64                         ".owner_cpu: %d\n",
65                 lock, lock->magic,
66                 owner ? owner->comm : "<none>",
67                 owner ? owner->pid : -1,
68                 lock->owner_cpu);
69         dump_stack();
70 }
71
72 #define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg)
73
74 static inline void
75 debug_spin_lock_before(spinlock_t *lock)
76 {
77         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
78         SPIN_BUG_ON(lock->owner == current, lock, "recursion");
79         SPIN_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
80                                                         lock, "cpu recursion");
81 }
82
83 static inline void debug_spin_lock_after(spinlock_t *lock)
84 {
85         lock->owner_cpu = raw_smp_processor_id();
86         lock->owner = current;
87 }
88
89 static inline void debug_spin_unlock(spinlock_t *lock)
90 {
91         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
92         SPIN_BUG_ON(!spin_is_locked(lock), lock, "already unlocked");
93         SPIN_BUG_ON(lock->owner != current, lock, "wrong owner");
94         SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
95                                                         lock, "wrong CPU");
96         lock->owner = SPINLOCK_OWNER_INIT;
97         lock->owner_cpu = -1;
98 }
99
100 static void __spin_lock_debug(spinlock_t *lock)
101 {
102         int print_once = 1;
103         u64 i;
104
105         for (;;) {
106                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
107                         if (__raw_spin_trylock(&lock->raw_lock))
108                                 return;
109                         __delay(1);
110                 }
111                 /* lockup suspected: */
112                 if (print_once) {
113                         print_once = 0;
114                         printk(KERN_EMERG "BUG: spinlock lockup on CPU#%d, "
115                                         "%s/%d, %p\n",
116                                 raw_smp_processor_id(), current->comm,
117                                 current->pid, lock);
118                         dump_stack();
119                 }
120         }
121 }
122
123 void _raw_spin_lock(spinlock_t *lock)
124 {
125         debug_spin_lock_before(lock);
126         if (unlikely(!__raw_spin_trylock(&lock->raw_lock)))
127                 __spin_lock_debug(lock);
128         debug_spin_lock_after(lock);
129 }
130
131 int _raw_spin_trylock(spinlock_t *lock)
132 {
133         int ret = __raw_spin_trylock(&lock->raw_lock);
134
135         if (ret)
136                 debug_spin_lock_after(lock);
137 #ifndef CONFIG_SMP
138         /*
139          * Must not happen on UP:
140          */
141         SPIN_BUG_ON(!ret, lock, "trylock failure on UP");
142 #endif
143         return ret;
144 }
145
146 void _raw_spin_unlock(spinlock_t *lock)
147 {
148         debug_spin_unlock(lock);
149         __raw_spin_unlock(&lock->raw_lock);
150 }
151
152 static void rwlock_bug(rwlock_t *lock, const char *msg)
153 {
154         if (!debug_locks_off())
155                 return;
156
157         printk(KERN_EMERG "BUG: rwlock %s on CPU#%d, %s/%d, %p\n",
158                 msg, raw_smp_processor_id(), current->comm,
159                 current->pid, lock);
160         dump_stack();
161 }
162
163 #define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg)
164
165 #if 0           /* __write_lock_debug() can lock up - maybe this can too? */
166 static void __read_lock_debug(rwlock_t *lock)
167 {
168         int print_once = 1;
169         u64 i;
170
171         for (;;) {
172                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
173                         if (__raw_read_trylock(&lock->raw_lock))
174                                 return;
175                         __delay(1);
176                 }
177                 /* lockup suspected: */
178                 if (print_once) {
179                         print_once = 0;
180                         printk(KERN_EMERG "BUG: read-lock lockup on CPU#%d, "
181                                         "%s/%d, %p\n",
182                                 raw_smp_processor_id(), current->comm,
183                                 current->pid, lock);
184                         dump_stack();
185                 }
186         }
187 }
188 #endif
189
190 void _raw_read_lock(rwlock_t *lock)
191 {
192         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
193         __raw_read_lock(&lock->raw_lock);
194 }
195
196 int _raw_read_trylock(rwlock_t *lock)
197 {
198         int ret = __raw_read_trylock(&lock->raw_lock);
199
200 #ifndef CONFIG_SMP
201         /*
202          * Must not happen on UP:
203          */
204         RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
205 #endif
206         return ret;
207 }
208
209 void _raw_read_unlock(rwlock_t *lock)
210 {
211         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
212         __raw_read_unlock(&lock->raw_lock);
213 }
214
215 static inline void debug_write_lock_before(rwlock_t *lock)
216 {
217         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
218         RWLOCK_BUG_ON(lock->owner == current, lock, "recursion");
219         RWLOCK_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
220                                                         lock, "cpu recursion");
221 }
222
223 static inline void debug_write_lock_after(rwlock_t *lock)
224 {
225         lock->owner_cpu = raw_smp_processor_id();
226         lock->owner = current;
227 }
228
229 static inline void debug_write_unlock(rwlock_t *lock)
230 {
231         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
232         RWLOCK_BUG_ON(lock->owner != current, lock, "wrong owner");
233         RWLOCK_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
234                                                         lock, "wrong CPU");
235         lock->owner = SPINLOCK_OWNER_INIT;
236         lock->owner_cpu = -1;
237 }
238
239 #if 0           /* This can cause lockups */
240 static void __write_lock_debug(rwlock_t *lock)
241 {
242         int print_once = 1;
243         u64 i;
244
245         for (;;) {
246                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
247                         if (__raw_write_trylock(&lock->raw_lock))
248                                 return;
249                         __delay(1);
250                 }
251                 /* lockup suspected: */
252                 if (print_once) {
253                         print_once = 0;
254                         printk(KERN_EMERG "BUG: write-lock lockup on CPU#%d, "
255                                         "%s/%d, %p\n",
256                                 raw_smp_processor_id(), current->comm,
257                                 current->pid, lock);
258                         dump_stack();
259                 }
260         }
261 }
262 #endif
263
264 void _raw_write_lock(rwlock_t *lock)
265 {
266         debug_write_lock_before(lock);
267         __raw_write_lock(&lock->raw_lock);
268         debug_write_lock_after(lock);
269 }
270
271 int _raw_write_trylock(rwlock_t *lock)
272 {
273         int ret = __raw_write_trylock(&lock->raw_lock);
274
275         if (ret)
276                 debug_write_lock_after(lock);
277 #ifndef CONFIG_SMP
278         /*
279          * Must not happen on UP:
280          */
281         RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
282 #endif
283         return ret;
284 }
285
286 void _raw_write_unlock(rwlock_t *lock)
287 {
288         debug_write_unlock(lock);
289         __raw_write_unlock(&lock->raw_lock);
290 }