Commit | Line | Data |
---|---|---|
408894ee IM |
1 | /* |
2 | * kernel/mutex-debug.c | |
3 | * | |
4 | * Debugging code for mutexes | |
5 | * | |
6 | * Started by Ingo Molnar: | |
7 | * | |
8 | * Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> | |
9 | * | |
10 | * lock debugging, locking tree, deadlock detection started by: | |
11 | * | |
12 | * Copyright (C) 2004, LynuxWorks, Inc., Igor Manyilov, Bill Huey | |
13 | * Released under the General Public License (GPL). | |
14 | */ | |
15 | #include <linux/mutex.h> | |
16 | #include <linux/sched.h> | |
17 | #include <linux/delay.h> | |
18 | #include <linux/module.h> | |
a7807a32 | 19 | #include <linux/poison.h> |
408894ee IM |
20 | #include <linux/spinlock.h> |
21 | #include <linux/kallsyms.h> | |
22 | #include <linux/interrupt.h> | |
23 | ||
408894ee IM |
24 | #include "mutex-debug.h" |
25 | ||
26 | /* | |
27 | * We need a global lock when we walk through the multi-process | |
28 | * lock tree. Only used in the deadlock-debugging case. | |
29 | */ | |
30 | DEFINE_SPINLOCK(debug_mutex_lock); | |
31 | ||
32 | /* | |
33 | * All locks held by all tasks, in a single global list: | |
34 | */ | |
35 | LIST_HEAD(debug_mutex_held_locks); | |
36 | ||
37 | /* | |
38 | * In the debug case we carry the caller's instruction pointer into | |
39 | * other functions, but we dont want the function argument overhead | |
40 | * in the nondebug case - hence these macros: | |
41 | */ | |
42 | #define __IP_DECL__ , unsigned long ip | |
43 | #define __IP__ , ip | |
44 | #define __RET_IP__ , (unsigned long)__builtin_return_address(0) | |
45 | ||
46 | /* | |
47 | * "mutex debugging enabled" flag. We turn it off when we detect | |
48 | * the first problem because we dont want to recurse back | |
49 | * into the tracing code when doing error printk or | |
50 | * executing a BUG(): | |
51 | */ | |
52 | int debug_mutex_on = 1; | |
53 | ||
54 | static void printk_task(struct task_struct *p) | |
55 | { | |
56 | if (p) | |
57 | printk("%16s:%5d [%p, %3d]", p->comm, p->pid, p, p->prio); | |
58 | else | |
59 | printk("<none>"); | |
60 | } | |
61 | ||
62 | static void printk_ti(struct thread_info *ti) | |
63 | { | |
64 | if (ti) | |
65 | printk_task(ti->task); | |
66 | else | |
67 | printk("<none>"); | |
68 | } | |
69 | ||
70 | static void printk_task_short(struct task_struct *p) | |
71 | { | |
72 | if (p) | |
73 | printk("%s/%d [%p, %3d]", p->comm, p->pid, p, p->prio); | |
74 | else | |
75 | printk("<none>"); | |
76 | } | |
77 | ||
78 | static void printk_lock(struct mutex *lock, int print_owner) | |
79 | { | |
80 | printk(" [%p] {%s}\n", lock, lock->name); | |
81 | ||
82 | if (print_owner && lock->owner) { | |
83 | printk(".. held by: "); | |
84 | printk_ti(lock->owner); | |
85 | printk("\n"); | |
86 | } | |
87 | if (lock->owner) { | |
88 | printk("... acquired at: "); | |
89 | print_symbol("%s\n", lock->acquire_ip); | |
90 | } | |
91 | } | |
92 | ||
93 | /* | |
94 | * printk locks held by a task: | |
95 | */ | |
96 | static void show_task_locks(struct task_struct *p) | |
97 | { | |
98 | switch (p->state) { | |
99 | case TASK_RUNNING: printk("R"); break; | |
100 | case TASK_INTERRUPTIBLE: printk("S"); break; | |
101 | case TASK_UNINTERRUPTIBLE: printk("D"); break; | |
102 | case TASK_STOPPED: printk("T"); break; | |
103 | case EXIT_ZOMBIE: printk("Z"); break; | |
104 | case EXIT_DEAD: printk("X"); break; | |
105 | default: printk("?"); break; | |
106 | } | |
107 | printk_task(p); | |
108 | if (p->blocked_on) { | |
109 | struct mutex *lock = p->blocked_on->lock; | |
110 | ||
111 | printk(" blocked on mutex:"); | |
112 | printk_lock(lock, 1); | |
113 | } else | |
114 | printk(" (not blocked on mutex)\n"); | |
115 | } | |
116 | ||
117 | /* | |
118 | * printk all locks held in the system (if filter == NULL), | |
119 | * or all locks belonging to a single task (if filter != NULL): | |
120 | */ | |
121 | void show_held_locks(struct task_struct *filter) | |
122 | { | |
123 | struct list_head *curr, *cursor = NULL; | |
124 | struct mutex *lock; | |
125 | struct thread_info *t; | |
126 | unsigned long flags; | |
127 | int count = 0; | |
128 | ||
129 | if (filter) { | |
130 | printk("------------------------------\n"); | |
131 | printk("| showing all locks held by: | ("); | |
132 | printk_task_short(filter); | |
133 | printk("):\n"); | |
134 | printk("------------------------------\n"); | |
135 | } else { | |
136 | printk("---------------------------\n"); | |
137 | printk("| showing all locks held: |\n"); | |
138 | printk("---------------------------\n"); | |
139 | } | |
140 | ||
141 | /* | |
142 | * Play safe and acquire the global trace lock. We | |
143 | * cannot printk with that lock held so we iterate | |
144 | * very carefully: | |
145 | */ | |
146 | next: | |
147 | debug_spin_lock_save(&debug_mutex_lock, flags); | |
148 | list_for_each(curr, &debug_mutex_held_locks) { | |
149 | if (cursor && curr != cursor) | |
150 | continue; | |
151 | lock = list_entry(curr, struct mutex, held_list); | |
152 | t = lock->owner; | |
153 | if (filter && (t != filter->thread_info)) | |
154 | continue; | |
155 | count++; | |
156 | cursor = curr->next; | |
1fb00c6c | 157 | debug_spin_unlock_restore(&debug_mutex_lock, flags); |
408894ee IM |
158 | |
159 | printk("\n#%03d: ", count); | |
160 | printk_lock(lock, filter ? 0 : 1); | |
161 | goto next; | |
162 | } | |
1fb00c6c | 163 | debug_spin_unlock_restore(&debug_mutex_lock, flags); |
408894ee IM |
164 | printk("\n"); |
165 | } | |
166 | ||
167 | void mutex_debug_show_all_locks(void) | |
168 | { | |
169 | struct task_struct *g, *p; | |
170 | int count = 10; | |
171 | int unlock = 1; | |
172 | ||
173 | printk("\nShowing all blocking locks in the system:\n"); | |
174 | ||
175 | /* | |
176 | * Here we try to get the tasklist_lock as hard as possible, | |
177 | * if not successful after 2 seconds we ignore it (but keep | |
178 | * trying). This is to enable a debug printout even if a | |
179 | * tasklist_lock-holding task deadlocks or crashes. | |
180 | */ | |
181 | retry: | |
182 | if (!read_trylock(&tasklist_lock)) { | |
183 | if (count == 10) | |
184 | printk("hm, tasklist_lock locked, retrying... "); | |
185 | if (count) { | |
186 | count--; | |
187 | printk(" #%d", 10-count); | |
188 | mdelay(200); | |
189 | goto retry; | |
190 | } | |
191 | printk(" ignoring it.\n"); | |
192 | unlock = 0; | |
193 | } | |
194 | if (count != 10) | |
195 | printk(" locked it.\n"); | |
196 | ||
197 | do_each_thread(g, p) { | |
198 | show_task_locks(p); | |
199 | if (!unlock) | |
200 | if (read_trylock(&tasklist_lock)) | |
201 | unlock = 1; | |
202 | } while_each_thread(g, p); | |
203 | ||
204 | printk("\n"); | |
205 | show_held_locks(NULL); | |
206 | printk("=============================================\n\n"); | |
207 | ||
208 | if (unlock) | |
209 | read_unlock(&tasklist_lock); | |
210 | } | |
211 | ||
212 | static void report_deadlock(struct task_struct *task, struct mutex *lock, | |
213 | struct mutex *lockblk, unsigned long ip) | |
214 | { | |
215 | printk("\n%s/%d is trying to acquire this lock:\n", | |
216 | current->comm, current->pid); | |
217 | printk_lock(lock, 1); | |
218 | printk("... trying at: "); | |
219 | print_symbol("%s\n", ip); | |
220 | show_held_locks(current); | |
221 | ||
222 | if (lockblk) { | |
223 | printk("but %s/%d is deadlocking current task %s/%d!\n\n", | |
224 | task->comm, task->pid, current->comm, current->pid); | |
225 | printk("\n%s/%d is blocked on this lock:\n", | |
226 | task->comm, task->pid); | |
227 | printk_lock(lockblk, 1); | |
228 | ||
229 | show_held_locks(task); | |
230 | ||
231 | printk("\n%s/%d's [blocked] stackdump:\n\n", | |
232 | task->comm, task->pid); | |
233 | show_stack(task, NULL); | |
234 | } | |
235 | ||
236 | printk("\n%s/%d's [current] stackdump:\n\n", | |
237 | current->comm, current->pid); | |
238 | dump_stack(); | |
239 | mutex_debug_show_all_locks(); | |
240 | printk("[ turning off deadlock detection. Please report this. ]\n\n"); | |
241 | local_irq_disable(); | |
242 | } | |
243 | ||
244 | /* | |
245 | * Recursively check for mutex deadlocks: | |
246 | */ | |
247 | static int check_deadlock(struct mutex *lock, int depth, | |
248 | struct thread_info *ti, unsigned long ip) | |
249 | { | |
250 | struct mutex *lockblk; | |
251 | struct task_struct *task; | |
252 | ||
253 | if (!debug_mutex_on) | |
254 | return 0; | |
255 | ||
256 | ti = lock->owner; | |
257 | if (!ti) | |
258 | return 0; | |
259 | ||
260 | task = ti->task; | |
261 | lockblk = NULL; | |
262 | if (task->blocked_on) | |
263 | lockblk = task->blocked_on->lock; | |
264 | ||
265 | /* Self-deadlock: */ | |
266 | if (current == task) { | |
267 | DEBUG_OFF(); | |
268 | if (depth) | |
269 | return 1; | |
270 | printk("\n==========================================\n"); | |
271 | printk( "[ BUG: lock recursion deadlock detected! |\n"); | |
272 | printk( "------------------------------------------\n"); | |
273 | report_deadlock(task, lock, NULL, ip); | |
274 | return 0; | |
275 | } | |
276 | ||
277 | /* Ugh, something corrupted the lock data structure? */ | |
278 | if (depth > 20) { | |
279 | DEBUG_OFF(); | |
280 | printk("\n===========================================\n"); | |
281 | printk( "[ BUG: infinite lock dependency detected!? |\n"); | |
282 | printk( "-------------------------------------------\n"); | |
283 | report_deadlock(task, lock, lockblk, ip); | |
284 | return 0; | |
285 | } | |
286 | ||
287 | /* Recursively check for dependencies: */ | |
288 | if (lockblk && check_deadlock(lockblk, depth+1, ti, ip)) { | |
289 | printk("\n============================================\n"); | |
290 | printk( "[ BUG: circular locking deadlock detected! ]\n"); | |
291 | printk( "--------------------------------------------\n"); | |
292 | report_deadlock(task, lock, lockblk, ip); | |
293 | return 0; | |
294 | } | |
295 | return 0; | |
296 | } | |
297 | ||
298 | /* | |
299 | * Called when a task exits, this function checks whether the | |
300 | * task is holding any locks, and reports the first one if so: | |
301 | */ | |
302 | void mutex_debug_check_no_locks_held(struct task_struct *task) | |
303 | { | |
304 | struct list_head *curr, *next; | |
305 | struct thread_info *t; | |
306 | unsigned long flags; | |
307 | struct mutex *lock; | |
308 | ||
309 | if (!debug_mutex_on) | |
310 | return; | |
311 | ||
312 | debug_spin_lock_save(&debug_mutex_lock, flags); | |
313 | list_for_each_safe(curr, next, &debug_mutex_held_locks) { | |
314 | lock = list_entry(curr, struct mutex, held_list); | |
315 | t = lock->owner; | |
316 | if (t != task->thread_info) | |
317 | continue; | |
318 | list_del_init(curr); | |
319 | DEBUG_OFF(); | |
1fb00c6c | 320 | debug_spin_unlock_restore(&debug_mutex_lock, flags); |
408894ee IM |
321 | |
322 | printk("BUG: %s/%d, lock held at task exit time!\n", | |
323 | task->comm, task->pid); | |
324 | printk_lock(lock, 1); | |
325 | if (lock->owner != task->thread_info) | |
326 | printk("exiting task is not even the owner??\n"); | |
327 | return; | |
328 | } | |
1fb00c6c | 329 | debug_spin_unlock_restore(&debug_mutex_lock, flags); |
408894ee IM |
330 | } |
331 | ||
332 | /* | |
333 | * Called when kernel memory is freed (or unmapped), or if a mutex | |
334 | * is destroyed or reinitialized - this code checks whether there is | |
335 | * any held lock in the memory range of <from> to <to>: | |
336 | */ | |
a4fc7ab1 | 337 | void mutex_debug_check_no_locks_freed(const void *from, unsigned long len) |
408894ee IM |
338 | { |
339 | struct list_head *curr, *next; | |
a4fc7ab1 | 340 | const void *to = from + len; |
408894ee IM |
341 | unsigned long flags; |
342 | struct mutex *lock; | |
343 | void *lock_addr; | |
344 | ||
345 | if (!debug_mutex_on) | |
346 | return; | |
347 | ||
348 | debug_spin_lock_save(&debug_mutex_lock, flags); | |
349 | list_for_each_safe(curr, next, &debug_mutex_held_locks) { | |
350 | lock = list_entry(curr, struct mutex, held_list); | |
351 | lock_addr = lock; | |
352 | if (lock_addr < from || lock_addr >= to) | |
353 | continue; | |
354 | list_del_init(curr); | |
355 | DEBUG_OFF(); | |
1fb00c6c | 356 | debug_spin_unlock_restore(&debug_mutex_lock, flags); |
408894ee IM |
357 | |
358 | printk("BUG: %s/%d, active lock [%p(%p-%p)] freed!\n", | |
359 | current->comm, current->pid, lock, from, to); | |
360 | dump_stack(); | |
361 | printk_lock(lock, 1); | |
362 | if (lock->owner != current_thread_info()) | |
363 | printk("freeing task is not even the owner??\n"); | |
364 | return; | |
365 | } | |
1fb00c6c | 366 | debug_spin_unlock_restore(&debug_mutex_lock, flags); |
408894ee IM |
367 | } |
368 | ||
369 | /* | |
370 | * Must be called with lock->wait_lock held. | |
371 | */ | |
372 | void debug_mutex_set_owner(struct mutex *lock, | |
373 | struct thread_info *new_owner __IP_DECL__) | |
374 | { | |
375 | lock->owner = new_owner; | |
376 | DEBUG_WARN_ON(!list_empty(&lock->held_list)); | |
377 | if (debug_mutex_on) { | |
378 | list_add_tail(&lock->held_list, &debug_mutex_held_locks); | |
379 | lock->acquire_ip = ip; | |
380 | } | |
381 | } | |
382 | ||
383 | void debug_mutex_init_waiter(struct mutex_waiter *waiter) | |
384 | { | |
a7807a32 | 385 | memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter)); |
408894ee IM |
386 | waiter->magic = waiter; |
387 | INIT_LIST_HEAD(&waiter->list); | |
388 | } | |
389 | ||
390 | void debug_mutex_wake_waiter(struct mutex *lock, struct mutex_waiter *waiter) | |
391 | { | |
392 | SMP_DEBUG_WARN_ON(!spin_is_locked(&lock->wait_lock)); | |
393 | DEBUG_WARN_ON(list_empty(&lock->wait_list)); | |
394 | DEBUG_WARN_ON(waiter->magic != waiter); | |
395 | DEBUG_WARN_ON(list_empty(&waiter->list)); | |
396 | } | |
397 | ||
398 | void debug_mutex_free_waiter(struct mutex_waiter *waiter) | |
399 | { | |
400 | DEBUG_WARN_ON(!list_empty(&waiter->list)); | |
a7807a32 | 401 | memset(waiter, MUTEX_DEBUG_FREE, sizeof(*waiter)); |
408894ee IM |
402 | } |
403 | ||
404 | void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter, | |
405 | struct thread_info *ti __IP_DECL__) | |
406 | { | |
407 | SMP_DEBUG_WARN_ON(!spin_is_locked(&lock->wait_lock)); | |
408 | check_deadlock(lock, 0, ti, ip); | |
409 | /* Mark the current thread as blocked on the lock: */ | |
410 | ti->task->blocked_on = waiter; | |
411 | waiter->lock = lock; | |
412 | } | |
413 | ||
414 | void mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter, | |
415 | struct thread_info *ti) | |
416 | { | |
417 | DEBUG_WARN_ON(list_empty(&waiter->list)); | |
418 | DEBUG_WARN_ON(waiter->task != ti->task); | |
419 | DEBUG_WARN_ON(ti->task->blocked_on != waiter); | |
420 | ti->task->blocked_on = NULL; | |
421 | ||
422 | list_del_init(&waiter->list); | |
423 | waiter->task = NULL; | |
424 | } | |
425 | ||
426 | void debug_mutex_unlock(struct mutex *lock) | |
427 | { | |
428 | DEBUG_WARN_ON(lock->magic != lock); | |
429 | DEBUG_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next); | |
430 | DEBUG_WARN_ON(lock->owner != current_thread_info()); | |
431 | if (debug_mutex_on) { | |
432 | DEBUG_WARN_ON(list_empty(&lock->held_list)); | |
433 | list_del_init(&lock->held_list); | |
434 | } | |
435 | } | |
436 | ||
437 | void debug_mutex_init(struct mutex *lock, const char *name) | |
438 | { | |
439 | /* | |
440 | * Make sure we are not reinitializing a held lock: | |
441 | */ | |
a4fc7ab1 | 442 | mutex_debug_check_no_locks_freed((void *)lock, sizeof(*lock)); |
408894ee IM |
443 | lock->owner = NULL; |
444 | INIT_LIST_HEAD(&lock->held_list); | |
445 | lock->name = name; | |
446 | lock->magic = lock; | |
447 | } | |
448 | ||
449 | /*** | |
450 | * mutex_destroy - mark a mutex unusable | |
451 | * @lock: the mutex to be destroyed | |
452 | * | |
453 | * This function marks the mutex uninitialized, and any subsequent | |
454 | * use of the mutex is forbidden. The mutex must not be locked when | |
455 | * this function is called. | |
456 | */ | |
457 | void fastcall mutex_destroy(struct mutex *lock) | |
458 | { | |
459 | DEBUG_WARN_ON(mutex_is_locked(lock)); | |
460 | lock->magic = NULL; | |
461 | } | |
462 | ||
463 | EXPORT_SYMBOL_GPL(mutex_destroy); |