/* * kernel/mutex-debug.c * * Debugging code for mutexes * * Started by Ingo Molnar: * * Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> * * lock debugging, locking tree, deadlock detection started by: * * Copyright (C) 2004, LynuxWorks, Inc., Igor Manyilov, Bill Huey * Released under the General Public License (GPL). */ #include <linux/mutex.h> #include <linux/sched.h> #include <linux/delay.h> #include <linux/module.h> #include <linux/spinlock.h> #include <linux/kallsyms.h> #include <linux/interrupt.h> #include "mutex-debug.h" /* * We need a global lock when we walk through the multi-process * lock tree. Only used in the deadlock-debugging case. */ DEFINE_SPINLOCK(debug_mutex_lock); /* * All locks held by all tasks, in a single global list: */ LIST_HEAD(debug_mutex_held_locks); /* * In the debug case we carry the caller's instruction pointer into * other functions, but we dont want the function argument overhead * in the nondebug case - hence these macros: */ #define __IP_DECL__ , unsigned long ip #define __IP__ , ip #define __RET_IP__ , (unsigned long)__builtin_return_address(0) /* * "mutex debugging enabled" flag. We turn it off when we detect * the first problem because we dont want to recurse back * into the tracing code when doing error printk or * executing a BUG(): */ int debug_mutex_on = 1; static void printk_task(struct task_struct *p) { if (p) printk("%16s:%5d [%p, %3d]", p->comm, p->pid, p, p->prio); else printk("<none>"); } static void printk_ti(struct thread_info *ti) { if (ti) printk_task(ti->task); else printk("<none>"); } static void printk_task_short(struct task_struct *p) { if (p) printk("%s/%d [%p, %3d]", p->comm, p->pid, p, p->prio); else printk("<none>"); } static void printk_lock(struct mutex *lock, int print_owner) { printk(" [%p] {%s}\n", lock, lock->name); if (print_owner && lock->owner) { printk(".. held by: "); printk_ti(lock->owner); printk("\n"); } if (lock->owner) { printk("... acquired at: "); print_symbol("%s\n", lock->acquire_ip); } } /* * printk locks held by a task: */ static void show_task_locks(struct task_struct *p) { switch (p->state) { case TASK_RUNNING: printk("R"); break; case TASK_INTERRUPTIBLE: printk("S"); break; case TASK_UNINTERRUPTIBLE: printk("D"); break; case TASK_STOPPED: printk("T"); break; case EXIT_ZOMBIE: printk("Z"); break; case EXIT_DEAD: printk("X"); break; default: printk("?"); break; } printk_task(p); if (p->blocked_on) { struct mutex *lock = p->blocked_on->lock; printk(" blocked on mutex:"); printk_lock(lock, 1); } else printk(" (not blocked on mutex)\n"); } /* * printk all locks held in the system (if filter == NULL), * or all locks belonging to a single task (if filter != NULL): */ void show_held_locks(struct task_struct *filter) { struct list_head *curr, *cursor = NULL; struct mutex *lock; struct thread_info *t; unsigned long flags; int count = 0; if (filter) { printk("------------------------------\n"); printk("| showing all locks held by: | ("); printk_task_short(filter); printk("):\n"); printk("------------------------------\n"); } else { printk("---------------------------\n"); printk("| showing all locks held: |\n"); printk("---------------------------\n"); } /* * Play safe and acquire the global trace lock. We * cannot printk with that lock held so we iterate * very carefully: */ next: debug_spin_lock_save(&debug_mutex_lock, flags); list_for_each(curr, &debug_mutex_held_locks) { if (cursor && curr != cursor) continue; lock = list_entry(curr, struct mutex, held_list); t = lock->owner; if (filter && (t != filter->thread_info)) continue; count++; cursor = curr->next; debug_spin_lock_restore(&debug_mutex_lock, flags); printk("\n#%03d: ", count); printk_lock(lock, filter ? 0 : 1); goto next; } debug_spin_lock_restore(&debug_mutex_lock, flags); printk("\n"); } void mutex_debug_show_all_locks(void) { struct task_struct *g, *p; int count = 10; int unlock = 1; printk("\nShowing all blocking locks in the system:\n"); /* * Here we try to get the tasklist_lock as hard as possible, * if not successful after 2 seconds we ignore it (but keep * trying). This is to enable a debug printout even if a * tasklist_lock-holding task deadlocks or crashes. */ retry: if (!read_trylock(&tasklist_lock)) { if (count == 10) printk("hm, tasklist_lock locked, retrying... "); if (count) { count--; printk(" #%d", 10-count); mdelay(200); goto retry; } printk(" ignoring it.\n"); unlock = 0; } if (count != 10) printk(" locked it.\n"); do_each_thread(g, p) { show_task_locks(p); if (!unlock) if (read_trylock(&tasklist_lock)) unlock = 1; } while_each_thread(g, p); printk("\n"); show_held_locks(NULL); printk("=============================================\n\n"); if (unlock) read_unlock(&tasklist_lock); } static void report_deadlock(struct task_struct *task, struct mutex *lock, struct mutex *lockblk, unsigned long ip) { printk("\n%s/%d is trying to acquire this lock:\n", current->comm, current->pid); printk_lock(lock, 1); printk("... trying at: "); print_symbol("%s\n", ip); show_held_locks(current); if (lockblk) { printk("but %s/%d is deadlocking current task %s/%d!\n\n", task->comm, task->pid, current->comm, current->pid); printk("\n%s/%d is blocked on this lock:\n", task->comm, task->pid); printk_lock(lockblk, 1); show_held_locks(task); printk("\n%s/%d's [blocked] stackdump:\n\n", task->comm, task->pid); show_stack(task, NULL); } printk("\n%s/%d's [current] stackdump:\n\n", current->comm, current->pid); dump_stack(); mutex_debug_show_all_locks(); printk("[ turning off deadlock detection. Please report this. ]\n\n"); local_irq_disable(); } /* * Recursively check for mutex deadlocks: */ static int check_deadlock(struct mutex *lock, int depth, struct thread_info *ti, unsigned long ip) { struct mutex *lockblk; struct task_struct *task; if (!debug_mutex_on) return 0; ti = lock->owner; if (!ti) return 0; task = ti->task; lockblk = NULL; if (task->blocked_on) lockblk = task->blocked_on->lock; /* Self-deadlock: */ if (current == task) { DEBUG_OFF(); if (depth) return 1; printk("\n==========================================\n"); printk( "[ BUG: lock recursion deadlock detected! |\n"); printk( "------------------------------------------\n"); report_deadlock(task, lock, NULL, ip); return 0; } /* Ugh, something corrupted the lock data structure? */ if (depth > 20) { DEBUG_OFF(); printk("\n===========================================\n"); printk( "[ BUG: infinite lock dependency detected!? |\n"); printk( "-------------------------------------------\n"); report_deadlock(task, lock, lockblk, ip); return 0; } /* Recursively check for dependencies: */ if (lockblk && check_deadlock(lockblk, depth+1, ti, ip)) { printk("\n============================================\n"); printk( "[ BUG: circular locking deadlock detected! ]\n"); printk( "--------------------------------------------\n"); report_deadlock(task, lock, lockblk, ip); return 0; } return 0; } /* * Called when a task exits, this function checks whether the * task is holding any locks, and reports the first one if so: */ void mutex_debug_check_no_locks_held(struct task_struct *task) { struct list_head *curr, *next; struct thread_info *t; unsigned long flags; struct mutex *lock; if (!debug_mutex_on) return; debug_spin_lock_save(&debug_mutex_lock, flags); list_for_each_safe(curr, next, &debug_mutex_held_locks) { lock = list_entry(curr, struct mutex, held_list); t = lock->owner; if (t != task->thread_info) continue; list_del_init(curr); DEBUG_OFF(); debug_spin_lock_restore(&debug_mutex_lock, flags); printk("BUG: %s/%d, lock held at task exit time!\n", task->comm, task->pid); printk_lock(lock, 1); if (lock->owner != task->thread_info) printk("exiting task is not even the owner??\n"); return; } debug_spin_lock_restore(&debug_mutex_lock, flags); } /* * Called when kernel memory is freed (or unmapped), or if a mutex * is destroyed or reinitialized - this code checks whether there is * any held lock in the memory range of <from> to <to>: */ void mutex_debug_check_no_locks_freed(const void *from, unsigned long len) { struct list_head *curr, *next; const void *to = from + len; unsigned long flags; struct mutex *lock; void *lock_addr; if (!debug_mutex_on) return; debug_spin_lock_save(&debug_mutex_lock, flags); list_for_each_safe(curr, next, &debug_mutex_held_locks) { lock = list_entry(curr, struct mutex, held_list); lock_addr = lock; if (lock_addr < from || lock_addr >= to) continue; list_del_init(curr); DEBUG_OFF(); debug_spin_lock_restore(&debug_mutex_lock, flags); printk("BUG: %s/%d, active lock [%p(%p-%p)] freed!\n", current->comm, current->pid, lock, from, to); dump_stack(); printk_lock(lock, 1); if (lock->owner != current_thread_info()) printk("freeing task is not even the owner??\n"); return; } debug_spin_lock_restore(&debug_mutex_lock, flags); } /* * Must be called with lock->wait_lock held. */ void debug_mutex_set_owner(struct mutex *lock, struct thread_info *new_owner __IP_DECL__) { lock->owner = new_owner; DEBUG_WARN_ON(!list_empty(&lock->held_list)); if (debug_mutex_on) { list_add_tail(&lock->held_list, &debug_mutex_held_locks); lock->acquire_ip = ip; } } void debug_mutex_init_waiter(struct mutex_waiter *waiter) { memset(waiter, 0x11, sizeof(*waiter)); waiter->magic = waiter; INIT_LIST_HEAD(&waiter->list); } void debug_mutex_wake_waiter(struct mutex *lock, struct mutex_waiter *waiter) { SMP_DEBUG_WARN_ON(!spin_is_locked(&lock->wait_lock)); DEBUG_WARN_ON(list_empty(&lock->wait_list)); DEBUG_WARN_ON(waiter->magic != waiter); DEBUG_WARN_ON(list_empty(&waiter->list)); } void debug_mutex_free_waiter(struct mutex_waiter *waiter) { DEBUG_WARN_ON(!list_empty(&waiter->list)); memset(waiter, 0x22, sizeof(*waiter)); } void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter, struct thread_info *ti __IP_DECL__) { SMP_DEBUG_WARN_ON(!spin_is_locked(&lock->wait_lock)); check_deadlock(lock, 0, ti, ip); /* Mark the current thread as blocked on the lock: */ ti->task->blocked_on = waiter; waiter->lock = lock; } void mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter, struct thread_info *ti) { DEBUG_WARN_ON(list_empty(&waiter->list)); DEBUG_WARN_ON(waiter->task != ti->task); DEBUG_WARN_ON(ti->task->blocked_on != waiter); ti->task->blocked_on = NULL; list_del_init(&waiter->list); waiter->task = NULL; } void debug_mutex_unlock(struct mutex *lock) { DEBUG_WARN_ON(lock->magic != lock); DEBUG_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next); DEBUG_WARN_ON(lock->owner != current_thread_info()); if (debug_mutex_on) { DEBUG_WARN_ON(list_empty(&lock->held_list)); list_del_init(&lock->held_list); } } void debug_mutex_init(struct mutex *lock, const char *name) { /* * Make sure we are not reinitializing a held lock: */ mutex_debug_check_no_locks_freed((void *)lock, sizeof(*lock)); lock->owner = NULL; INIT_LIST_HEAD(&lock->held_list); lock->name = name; lock->magic = lock; } /*** * mutex_destroy - mark a mutex unusable * @lock: the mutex to be destroyed * * This function marks the mutex uninitialized, and any subsequent * use of the mutex is forbidden. The mutex must not be locked when * this function is called. */ void fastcall mutex_destroy(struct mutex *lock) { DEBUG_WARN_ON(mutex_is_locked(lock)); lock->magic = NULL; } EXPORT_SYMBOL_GPL(mutex_destroy);