4 * Debugging code for mutexes
6 * Started by Ingo Molnar:
8 * Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
10 * lock debugging, locking tree, deadlock detection started by:
12 * Copyright (C) 2004, LynuxWorks, Inc., Igor Manyilov, Bill Huey
13 * Released under the General Public License (GPL).
15 #include <linux/mutex.h>
16 #include <linux/sched.h>
17 #include <linux/delay.h>
18 #include <linux/module.h>
19 #include <linux/spinlock.h>
20 #include <linux/kallsyms.h>
21 #include <linux/interrupt.h>
23 #include <asm/mutex.h>
25 #include "mutex-debug.h"
28 * We need a global lock when we walk through the multi-process
29 * lock tree. Only used in the deadlock-debugging case.
31 DEFINE_SPINLOCK(debug_mutex_lock
);
34 * All locks held by all tasks, in a single global list:
36 LIST_HEAD(debug_mutex_held_locks
);
39 * In the debug case we carry the caller's instruction pointer into
40 * other functions, but we dont want the function argument overhead
41 * in the nondebug case - hence these macros:
43 #define __IP_DECL__ , unsigned long ip
45 #define __RET_IP__ , (unsigned long)__builtin_return_address(0)
48 * "mutex debugging enabled" flag. We turn it off when we detect
49 * the first problem because we dont want to recurse back
50 * into the tracing code when doing error printk or
53 int debug_mutex_on
= 1;
55 static void printk_task(struct task_struct
*p
)
58 printk("%16s:%5d [%p, %3d]", p
->comm
, p
->pid
, p
, p
->prio
);
63 static void printk_ti(struct thread_info
*ti
)
66 printk_task(ti
->task
);
71 static void printk_task_short(struct task_struct
*p
)
74 printk("%s/%d [%p, %3d]", p
->comm
, p
->pid
, p
, p
->prio
);
79 static void printk_lock(struct mutex
*lock
, int print_owner
)
81 printk(" [%p] {%s}\n", lock
, lock
->name
);
83 if (print_owner
&& lock
->owner
) {
84 printk(".. held by: ");
85 printk_ti(lock
->owner
);
89 printk("... acquired at: ");
90 print_symbol("%s\n", lock
->acquire_ip
);
95 * printk locks held by a task:
97 static void show_task_locks(struct task_struct
*p
)
100 case TASK_RUNNING
: printk("R"); break;
101 case TASK_INTERRUPTIBLE
: printk("S"); break;
102 case TASK_UNINTERRUPTIBLE
: printk("D"); break;
103 case TASK_STOPPED
: printk("T"); break;
104 case EXIT_ZOMBIE
: printk("Z"); break;
105 case EXIT_DEAD
: printk("X"); break;
106 default: printk("?"); break;
110 struct mutex
*lock
= p
->blocked_on
->lock
;
112 printk(" blocked on mutex:");
113 printk_lock(lock
, 1);
115 printk(" (not blocked on mutex)\n");
119 * printk all locks held in the system (if filter == NULL),
120 * or all locks belonging to a single task (if filter != NULL):
122 void show_held_locks(struct task_struct
*filter
)
124 struct list_head
*curr
, *cursor
= NULL
;
126 struct thread_info
*t
;
131 printk("------------------------------\n");
132 printk("| showing all locks held by: | (");
133 printk_task_short(filter
);
135 printk("------------------------------\n");
137 printk("---------------------------\n");
138 printk("| showing all locks held: |\n");
139 printk("---------------------------\n");
143 * Play safe and acquire the global trace lock. We
144 * cannot printk with that lock held so we iterate
148 debug_spin_lock_save(&debug_mutex_lock
, flags
);
149 list_for_each(curr
, &debug_mutex_held_locks
) {
150 if (cursor
&& curr
!= cursor
)
152 lock
= list_entry(curr
, struct mutex
, held_list
);
154 if (filter
&& (t
!= filter
->thread_info
))
158 debug_spin_lock_restore(&debug_mutex_lock
, flags
);
160 printk("\n#%03d: ", count
);
161 printk_lock(lock
, filter
? 0 : 1);
164 debug_spin_lock_restore(&debug_mutex_lock
, flags
);
168 void mutex_debug_show_all_locks(void)
170 struct task_struct
*g
, *p
;
174 printk("\nShowing all blocking locks in the system:\n");
177 * Here we try to get the tasklist_lock as hard as possible,
178 * if not successful after 2 seconds we ignore it (but keep
179 * trying). This is to enable a debug printout even if a
180 * tasklist_lock-holding task deadlocks or crashes.
183 if (!read_trylock(&tasklist_lock
)) {
185 printk("hm, tasklist_lock locked, retrying... ");
188 printk(" #%d", 10-count
);
192 printk(" ignoring it.\n");
196 printk(" locked it.\n");
198 do_each_thread(g
, p
) {
201 if (read_trylock(&tasklist_lock
))
203 } while_each_thread(g
, p
);
206 show_held_locks(NULL
);
207 printk("=============================================\n\n");
210 read_unlock(&tasklist_lock
);
213 static void report_deadlock(struct task_struct
*task
, struct mutex
*lock
,
214 struct mutex
*lockblk
, unsigned long ip
)
216 printk("\n%s/%d is trying to acquire this lock:\n",
217 current
->comm
, current
->pid
);
218 printk_lock(lock
, 1);
219 printk("... trying at: ");
220 print_symbol("%s\n", ip
);
221 show_held_locks(current
);
224 printk("but %s/%d is deadlocking current task %s/%d!\n\n",
225 task
->comm
, task
->pid
, current
->comm
, current
->pid
);
226 printk("\n%s/%d is blocked on this lock:\n",
227 task
->comm
, task
->pid
);
228 printk_lock(lockblk
, 1);
230 show_held_locks(task
);
232 printk("\n%s/%d's [blocked] stackdump:\n\n",
233 task
->comm
, task
->pid
);
234 show_stack(task
, NULL
);
237 printk("\n%s/%d's [current] stackdump:\n\n",
238 current
->comm
, current
->pid
);
240 mutex_debug_show_all_locks();
241 printk("[ turning off deadlock detection. Please report this. ]\n\n");
246 * Recursively check for mutex deadlocks:
248 static int check_deadlock(struct mutex
*lock
, int depth
,
249 struct thread_info
*ti
, unsigned long ip
)
251 struct mutex
*lockblk
;
252 struct task_struct
*task
;
263 if (task
->blocked_on
)
264 lockblk
= task
->blocked_on
->lock
;
267 if (current
== task
) {
271 printk("\n==========================================\n");
272 printk( "[ BUG: lock recursion deadlock detected! |\n");
273 printk( "------------------------------------------\n");
274 report_deadlock(task
, lock
, NULL
, ip
);
278 /* Ugh, something corrupted the lock data structure? */
281 printk("\n===========================================\n");
282 printk( "[ BUG: infinite lock dependency detected!? |\n");
283 printk( "-------------------------------------------\n");
284 report_deadlock(task
, lock
, lockblk
, ip
);
288 /* Recursively check for dependencies: */
289 if (lockblk
&& check_deadlock(lockblk
, depth
+1, ti
, ip
)) {
290 printk("\n============================================\n");
291 printk( "[ BUG: circular locking deadlock detected! ]\n");
292 printk( "--------------------------------------------\n");
293 report_deadlock(task
, lock
, lockblk
, ip
);
300 * Called when a task exits, this function checks whether the
301 * task is holding any locks, and reports the first one if so:
303 void mutex_debug_check_no_locks_held(struct task_struct
*task
)
305 struct list_head
*curr
, *next
;
306 struct thread_info
*t
;
313 debug_spin_lock_save(&debug_mutex_lock
, flags
);
314 list_for_each_safe(curr
, next
, &debug_mutex_held_locks
) {
315 lock
= list_entry(curr
, struct mutex
, held_list
);
317 if (t
!= task
->thread_info
)
321 debug_spin_lock_restore(&debug_mutex_lock
, flags
);
323 printk("BUG: %s/%d, lock held at task exit time!\n",
324 task
->comm
, task
->pid
);
325 printk_lock(lock
, 1);
326 if (lock
->owner
!= task
->thread_info
)
327 printk("exiting task is not even the owner??\n");
330 debug_spin_lock_restore(&debug_mutex_lock
, flags
);
334 * Called when kernel memory is freed (or unmapped), or if a mutex
335 * is destroyed or reinitialized - this code checks whether there is
336 * any held lock in the memory range of <from> to <to>:
338 void mutex_debug_check_no_locks_freed(const void *from
, const void *to
)
340 struct list_head
*curr
, *next
;
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
);
352 if (lock_addr
< from
|| lock_addr
>= to
)
356 debug_spin_lock_restore(&debug_mutex_lock
, flags
);
358 printk("BUG: %s/%d, active lock [%p(%p-%p)] freed!\n",
359 current
->comm
, current
->pid
, lock
, from
, to
);
361 printk_lock(lock
, 1);
362 if (lock
->owner
!= current_thread_info())
363 printk("freeing task is not even the owner??\n");
366 debug_spin_lock_restore(&debug_mutex_lock
, flags
);
370 * Must be called with lock->wait_lock held.
372 void debug_mutex_set_owner(struct mutex
*lock
,
373 struct thread_info
*new_owner __IP_DECL__
)
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
;
383 void debug_mutex_init_waiter(struct mutex_waiter
*waiter
)
385 memset(waiter
, 0x11, sizeof(*waiter
));
386 waiter
->magic
= waiter
;
387 INIT_LIST_HEAD(&waiter
->list
);
390 void debug_mutex_wake_waiter(struct mutex
*lock
, struct mutex_waiter
*waiter
)
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
));
398 void debug_mutex_free_waiter(struct mutex_waiter
*waiter
)
400 DEBUG_WARN_ON(!list_empty(&waiter
->list
));
401 memset(waiter
, 0x22, sizeof(*waiter
));
404 void debug_mutex_add_waiter(struct mutex
*lock
, struct mutex_waiter
*waiter
,
405 struct thread_info
*ti __IP_DECL__
)
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
;
414 void mutex_remove_waiter(struct mutex
*lock
, struct mutex_waiter
*waiter
,
415 struct thread_info
*ti
)
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
;
422 list_del_init(&waiter
->list
);
426 void debug_mutex_unlock(struct mutex
*lock
)
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
);
437 void debug_mutex_init(struct mutex
*lock
, const char *name
)
440 * Make sure we are not reinitializing a held lock:
442 mutex_debug_check_no_locks_freed((void *)lock
, (void *)(lock
+ 1));
444 INIT_LIST_HEAD(&lock
->held_list
);
450 * mutex_destroy - mark a mutex unusable
451 * @lock: the mutex to be destroyed
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.
457 void fastcall
mutex_destroy(struct mutex
*lock
)
459 DEBUG_WARN_ON(mutex_is_locked(lock
));
463 EXPORT_SYMBOL_GPL(mutex_destroy
);