[PATCH] lockdep: remove mutex deadlock checking code
With the lock validator we detect mutex deadlocks (and more), the mutex deadlock checking code is both redundant and slower. So remove it. Signed-off-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Ingo Molnar
Linus Torvalds
parent
36596243da
commit
fb7e42413a
2 changed files with 0 additions and 324 deletions
|
|
@ -51,321 +51,6 @@ LIST_HEAD(debug_mutex_held_locks);
|
||||||
*/
|
*/
|
||||||
int debug_mutex_on = 1;
|
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_unlock_restore(&debug_mutex_lock, flags);
|
|
||||||
|
|
||||||
printk("\n#%03d: ", count);
|
|
||||||
printk_lock(lock, filter ? 0 : 1);
|
|
||||||
goto next;
|
|
||||||
}
|
|
||||||
debug_spin_unlock_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_unlock_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_unlock_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_unlock_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_unlock_restore(&debug_mutex_lock, flags);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Must be called with lock->wait_lock held.
|
* Must be called with lock->wait_lock held.
|
||||||
*/
|
*/
|
||||||
|
|
@ -405,7 +90,6 @@ void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,
|
||||||
struct thread_info *ti __IP_DECL__)
|
struct thread_info *ti __IP_DECL__)
|
||||||
{
|
{
|
||||||
SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));
|
SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));
|
||||||
check_deadlock(lock, 0, ti, ip);
|
|
||||||
/* Mark the current thread as blocked on the lock: */
|
/* Mark the current thread as blocked on the lock: */
|
||||||
ti->task->blocked_on = waiter;
|
ti->task->blocked_on = waiter;
|
||||||
waiter->lock = lock;
|
waiter->lock = lock;
|
||||||
|
|
|
||||||
|
|
@ -115,14 +115,6 @@ config DEBUG_PREEMPT
|
||||||
if kernel code uses it in a preemption-unsafe way. Also, the kernel
|
if kernel code uses it in a preemption-unsafe way. Also, the kernel
|
||||||
will detect preemption count underflows.
|
will detect preemption count underflows.
|
||||||
|
|
||||||
config DEBUG_MUTEXES
|
|
||||||
bool "Mutex debugging, deadlock detection"
|
|
||||||
default n
|
|
||||||
depends on DEBUG_KERNEL
|
|
||||||
help
|
|
||||||
This allows mutex semantics violations and mutex related deadlocks
|
|
||||||
(lockups) to be detected and reported automatically.
|
|
||||||
|
|
||||||
config DEBUG_RT_MUTEXES
|
config DEBUG_RT_MUTEXES
|
||||||
bool "RT Mutex debugging, deadlock detection"
|
bool "RT Mutex debugging, deadlock detection"
|
||||||
depends on DEBUG_KERNEL && RT_MUTEXES
|
depends on DEBUG_KERNEL && RT_MUTEXES
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue