/* * 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);