mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Ingo Molnar](/assets/img/avatar_default.png)
It seems ppc64 wants to lock mutexes in early bootup code, with interrupts disabled, and they expect interrupts to stay disabled, else they crash. Work around this bug by making mutex debugging variants save/restore irq flags. Signed-off-by: Ingo Molnar <mingo@elte.hu> Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org> Cc: Paul Mackerras <paulus@samba.org> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
462 lines
12 KiB
C
462 lines
12 KiB
C
/*
|
|
* 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_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.
|
|
*/
|
|
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);
|