[GitHub/mt8127/android_kernel_alcatel_ttab.git] / kernel / mutex-debug.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);
Commit	Line	Data
408894ee IM	1	/*
	2	* kernel/mutex-debug.c
	3	*
	4	* Debugging code for mutexes
	5	*
	6	* Started by Ingo Molnar:
	7	*
	8	* Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
	9	*
	10	* lock debugging, locking tree, deadlock detection started by:
	11	*
	12	* Copyright (C) 2004, LynuxWorks, Inc., Igor Manyilov, Bill Huey
	13	* Released under the General Public License (GPL).
	14	*/
	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>
	22
408894ee IM	23	#include "mutex-debug.h"
	24
	25	/*
	26	* We need a global lock when we walk through the multi-process
	27	* lock tree. Only used in the deadlock-debugging case.
	28	*/
	29	DEFINE_SPINLOCK(debug_mutex_lock);
	30
	31	/*
	32	* All locks held by all tasks, in a single global list:
	33	*/
	34	LIST_HEAD(debug_mutex_held_locks);
	35
	36	/*
	37	* In the debug case we carry the caller's instruction pointer into
	38	* other functions, but we dont want the function argument overhead
	39	* in the nondebug case - hence these macros:
	40	*/
	41	#define __IP_DECL__ , unsigned long ip
	42	#define __IP__ , ip
	43	#define __RET_IP__ , (unsigned long)__builtin_return_address(0)
	44
	45	/*
	46	* "mutex debugging enabled" flag. We turn it off when we detect
	47	* the first problem because we dont want to recurse back
	48	* into the tracing code when doing error printk or
	49	* executing a BUG():
	50	*/
	51	int debug_mutex_on = 1;
	52
	53	static void printk_task(struct task_struct *p)
	54	{
	55	if (p)
	56	printk("%16s:%5d [%p, %3d]", p->comm, p->pid, p, p->prio);
	57	else
	58	printk("<none>");
	59	}
	60
	61	static void printk_ti(struct thread_info *ti)
	62	{
	63	if (ti)
	64	printk_task(ti->task);
	65	else
	66	printk("<none>");
	67	}
	68
	69	static void printk_task_short(struct task_struct *p)
	70	{
	71	if (p)
	72	printk("%s/%d [%p, %3d]", p->comm, p->pid, p, p->prio);
	73	else
	74	printk("<none>");
	75	}
	76
	77	static void printk_lock(struct mutex *lock, int print_owner)
	78	{
	79	printk(" [%p] {%s}\n", lock, lock->name);
	80
	81	if (print_owner && lock->owner) {
	82	printk(".. held by: ");
	83	printk_ti(lock->owner);
	84	printk("\n");
	85	}
	86	if (lock->owner) {
87	printk("... acquired at: ");
88	print_symbol("%s\n", lock->acquire_ip);
89	}
90	}
91
92	/*
93	* printk locks held by a task:
94	*/
95	static void show_task_locks(struct task_struct *p)
96	{
97	switch (p->state) {
98	case TASK_RUNNING: printk("R"); break;
99	case TASK_INTERRUPTIBLE: printk("S"); break;
100	case TASK_UNINTERRUPTIBLE: printk("D"); break;
101	case TASK_STOPPED: printk("T"); break;
102	case EXIT_ZOMBIE: printk("Z"); break;
103	case EXIT_DEAD: printk("X"); break;
104	default: printk("?"); break;
105	}
106	printk_task(p);
107	if (p->blocked_on) {
108	struct mutex *lock = p->blocked_on->lock;
109
110	printk(" blocked on mutex:");
111	printk_lock(lock, 1);
112	} else
113	printk(" (not blocked on mutex)\n");
114	}
115
116	/*
117	* printk all locks held in the system (if filter == NULL),
118	* or all locks belonging to a single task (if filter != NULL):
119	*/
120	void show_held_locks(struct task_struct *filter)
121	{
122	struct list_head curr, cursor = NULL;
123	struct mutex *lock;
124	struct thread_info *t;
125	unsigned long flags;
126	int count = 0;
127
128	if (filter) {
129	printk("------------------------------\n");
130	printk("\| showing all locks held by: \| (");
131	printk_task_short(filter);
132	printk("):\n");
133	printk("------------------------------\n");
134	} else {
135	printk("---------------------------\n");
136	printk("\| showing all locks held: \|\n");
137	printk("---------------------------\n");
138	}
139
140	/*
141	* Play safe and acquire the global trace lock. We
142	* cannot printk with that lock held so we iterate
143	* very carefully:
144	*/
145	next:
146	debug_spin_lock_save(&debug_mutex_lock, flags);
147	list_for_each(curr, &debug_mutex_held_locks) {
148	if (cursor && curr != cursor)
149	continue;
150	lock = list_entry(curr, struct mutex, held_list);
151	t = lock->owner;
152	if (filter && (t != filter->thread_info))
153	continue;
154	count++;
155	cursor = curr->next;
1fb00c6c	156	debug_spin_unlock_restore(&debug_mutex_lock, flags);
408894ee IM	157
	158	printk("\n#%03d: ", count);
	159	printk_lock(lock, filter ? 0 : 1);
	160	goto next;
	161	}
1fb00c6c	162	debug_spin_unlock_restore(&debug_mutex_lock, flags);
408894ee IM	163	printk("\n");
	164	}
	165
	166	void mutex_debug_show_all_locks(void)
	167	{
	168	struct task_struct g, p;
	169	int count = 10;
	170	int unlock = 1;
	171
	172	printk("\nShowing all blocking locks in the system:\n");
	173
	174	/*
	175	* Here we try to get the tasklist_lock as hard as possible,
	176	* if not successful after 2 seconds we ignore it (but keep
	177	* trying). This is to enable a debug printout even if a
	178	* tasklist_lock-holding task deadlocks or crashes.
	179	*/
	180	retry:
	181	if (!read_trylock(&tasklist_lock)) {
	182	if (count == 10)
	183	printk("hm, tasklist_lock locked, retrying... ");
	184	if (count) {
	185	count--;
	186	printk(" #%d", 10-count);
	187	mdelay(200);
	188	goto retry;
	189	}
	190	printk(" ignoring it.\n");
	191	unlock = 0;
	192	}
	193	if (count != 10)
	194	printk(" locked it.\n");
	195
	196	do_each_thread(g, p) {
	197	show_task_locks(p);
	198	if (!unlock)
	199	if (read_trylock(&tasklist_lock))
	200	unlock = 1;
	201	} while_each_thread(g, p);
	202
	203	printk("\n");
	204	show_held_locks(NULL);
	205	printk("=============================================\n\n");
	206
	207	if (unlock)
	208	read_unlock(&tasklist_lock);
	209	}
	210
	211	static void report_deadlock(struct task_struct task, struct mutex lock,
	212	struct mutex *lockblk, unsigned long ip)
	213	{
	214	printk("\n%s/%d is trying to acquire this lock:\n",
	215	current->comm, current->pid);
	216	printk_lock(lock, 1);
	217	printk("... trying at: ");
	218	print_symbol("%s\n", ip);
	219	show_held_locks(current);
	220
	221	if (lockblk) {
	222	printk("but %s/%d is deadlocking current task %s/%d!\n\n",
	223	task->comm, task->pid, current->comm, current->pid);
	224	printk("\n%s/%d is blocked on this lock:\n",
	225	task->comm, task->pid);
	226	printk_lock(lockblk, 1);
227
228	show_held_locks(task);
229
230	printk("\n%s/%d's [blocked] stackdump:\n\n",
231	task->comm, task->pid);
232	show_stack(task, NULL);
233	}
234
235	printk("\n%s/%d's [current] stackdump:\n\n",
236	current->comm, current->pid);
237	dump_stack();
238	mutex_debug_show_all_locks();
239	printk("[ turning off deadlock detection. Please report this. ]\n\n");
240	local_irq_disable();
241	}
242
243	/*
244	* Recursively check for mutex deadlocks:
245	*/
246	static int check_deadlock(struct mutex *lock, int depth,
247	struct thread_info *ti, unsigned long ip)
248	{
249	struct mutex *lockblk;
250	struct task_struct *task;
251
252	if (!debug_mutex_on)
253	return 0;
254
255	ti = lock->owner;
256	if (!ti)
257	return 0;
258
259	task = ti->task;
260	lockblk = NULL;
261	if (task->blocked_on)
262	lockblk = task->blocked_on->lock;
263
264	/* Self-deadlock: */
265	if (current == task) {
266	DEBUG_OFF();
267	if (depth)
268	return 1;
269	printk("\n==========================================\n");
270	printk( "[ BUG: lock recursion deadlock detected! \|\n");
271	printk( "------------------------------------------\n");
272	report_deadlock(task, lock, NULL, ip);
273	return 0;
274	}
275
276	/* Ugh, something corrupted the lock data structure? */
277	if (depth > 20) {
278	DEBUG_OFF();
279	printk("\n===========================================\n");
280	printk( "[ BUG: infinite lock dependency detected!? \|\n");
281	printk( "-------------------------------------------\n");
282	report_deadlock(task, lock, lockblk, ip);
283	return 0;
284	}
285
286	/* Recursively check for dependencies: */
287	if (lockblk && check_deadlock(lockblk, depth+1, ti, ip)) {
288	printk("\n============================================\n");
289	printk( "[ BUG: circular locking deadlock detected! ]\n");
290	printk( "--------------------------------------------\n");
291	report_deadlock(task, lock, lockblk, ip);
292	return 0;
293	}
294	return 0;
295	}
296
297	/*
298	* Called when a task exits, this function checks whether the
299	* task is holding any locks, and reports the first one if so:
300	*/
301	void mutex_debug_check_no_locks_held(struct task_struct *task)
302	{
303	struct list_head curr, next;
304	struct thread_info *t;
305	unsigned long flags;
306	struct mutex *lock;
307
308	if (!debug_mutex_on)
309	return;
310
311	debug_spin_lock_save(&debug_mutex_lock, flags);
312	list_for_each_safe(curr, next, &debug_mutex_held_locks) {
313	lock = list_entry(curr, struct mutex, held_list);
314	t = lock->owner;
315	if (t != task->thread_info)
316	continue;
317	list_del_init(curr);
318	DEBUG_OFF();
1fb00c6c	319	debug_spin_unlock_restore(&debug_mutex_lock, flags);
408894ee IM	320
	321	printk("BUG: %s/%d, lock held at task exit time!\n",
	322	task->comm, task->pid);
	323	printk_lock(lock, 1);
	324	if (lock->owner != task->thread_info)
	325	printk("exiting task is not even the owner??\n");
	326	return;
	327	}
1fb00c6c	328	debug_spin_unlock_restore(&debug_mutex_lock, flags);
408894ee IM	329	}
	330
	331	/*
	332	* Called when kernel memory is freed (or unmapped), or if a mutex
	333	* is destroyed or reinitialized - this code checks whether there is
	334	* any held lock in the memory range of <from> to <to>:
	335	*/
a4fc7ab1	336	void mutex_debug_check_no_locks_freed(const void *from, unsigned long len)
408894ee IM	337	{
408894ee IM	338	struct list_head curr, next;
a4fc7ab1	339	const void *to = from + len;
408894ee IM	340	unsigned long flags;
	341	struct mutex *lock;
	342	void *lock_addr;
	343
	344	if (!debug_mutex_on)
	345	return;
	346
	347	debug_spin_lock_save(&debug_mutex_lock, flags);
	348	list_for_each_safe(curr, next, &debug_mutex_held_locks) {
	349	lock = list_entry(curr, struct mutex, held_list);
	350	lock_addr = lock;
	351	if (lock_addr < from \|\| lock_addr >= to)
	352	continue;
	353	list_del_init(curr);
	354	DEBUG_OFF();
1fb00c6c	355	debug_spin_unlock_restore(&debug_mutex_lock, flags);
408894ee IM	356
	357	printk("BUG: %s/%d, active lock [%p(%p-%p)] freed!\n",
	358	current->comm, current->pid, lock, from, to);
	359	dump_stack();
	360	printk_lock(lock, 1);
	361	if (lock->owner != current_thread_info())
	362	printk("freeing task is not even the owner??\n");
	363	return;
	364	}
1fb00c6c	365	debug_spin_unlock_restore(&debug_mutex_lock, flags);
408894ee IM	366	}
	367
	368	/*
	369	* Must be called with lock->wait_lock held.
	370	*/
	371	void debug_mutex_set_owner(struct mutex *lock,
	372	struct thread_info *new_owner __IP_DECL__)
	373	{
	374	lock->owner = new_owner;
	375	DEBUG_WARN_ON(!list_empty(&lock->held_list));
	376	if (debug_mutex_on) {
	377	list_add_tail(&lock->held_list, &debug_mutex_held_locks);
	378	lock->acquire_ip = ip;
	379	}
	380	}
	381
	382	void debug_mutex_init_waiter(struct mutex_waiter *waiter)
	383	{
	384	memset(waiter, 0x11, sizeof(*waiter));
	385	waiter->magic = waiter;
	386	INIT_LIST_HEAD(&waiter->list);
	387	}
	388
	389	void debug_mutex_wake_waiter(struct mutex lock, struct mutex_waiter waiter)
	390	{
	391	SMP_DEBUG_WARN_ON(!spin_is_locked(&lock->wait_lock));
	392	DEBUG_WARN_ON(list_empty(&lock->wait_list));
	393	DEBUG_WARN_ON(waiter->magic != waiter);
	394	DEBUG_WARN_ON(list_empty(&waiter->list));
	395	}
	396
	397	void debug_mutex_free_waiter(struct mutex_waiter *waiter)
	398	{
	399	DEBUG_WARN_ON(!list_empty(&waiter->list));
	400	memset(waiter, 0x22, sizeof(*waiter));
	401	}
	402
	403	void debug_mutex_add_waiter(struct mutex lock, struct mutex_waiter waiter,
	404	struct thread_info *ti __IP_DECL__)
	405	{
	406	SMP_DEBUG_WARN_ON(!spin_is_locked(&lock->wait_lock));
	407	check_deadlock(lock, 0, ti, ip);
	408	/* Mark the current thread as blocked on the lock: */
	409	ti->task->blocked_on = waiter;
	410	waiter->lock = lock;
	411	}
	412
	413	void mutex_remove_waiter(struct mutex lock, struct mutex_waiter waiter,
	414	struct thread_info *ti)
	415	{
	416	DEBUG_WARN_ON(list_empty(&waiter->list));
	417	DEBUG_WARN_ON(waiter->task != ti->task);
	418	DEBUG_WARN_ON(ti->task->blocked_on != waiter);
	419	ti->task->blocked_on = NULL;
	420
	421	list_del_init(&waiter->list);
	422	waiter->task = NULL;
	423	}
	424
	425	void debug_mutex_unlock(struct mutex *lock)
	426	{
	427	DEBUG_WARN_ON(lock->magic != lock);
	428	DEBUG_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next);
	429	DEBUG_WARN_ON(lock->owner != current_thread_info());
430	if (debug_mutex_on) {
431	DEBUG_WARN_ON(list_empty(&lock->held_list));
432	list_del_init(&lock->held_list);
433	}
434	}
435
436	void debug_mutex_init(struct mutex lock, const char name)
437	{
438	/*
439	* Make sure we are not reinitializing a held lock:
440	*/
a4fc7ab1	441	mutex_debug_check_no_locks_freed((void )lock, sizeof(lock));
408894ee IM	442	lock->owner = NULL;
	443	INIT_LIST_HEAD(&lock->held_list);
	444	lock->name = name;
	445	lock->magic = lock;
	446	}
	447
	448	/***
	449	* mutex_destroy - mark a mutex unusable
	450	* @lock: the mutex to be destroyed
	451	*
	452	* This function marks the mutex uninitialized, and any subsequent
	453	* use of the mutex is forbidden. The mutex must not be locked when
	454	* this function is called.
	455	*/
	456	void fastcall mutex_destroy(struct mutex *lock)
	457	{
	458	DEBUG_WARN_ON(mutex_is_locked(lock));
	459	lock->magic = NULL;
	460	}
	461
	462	EXPORT_SYMBOL_GPL(mutex_destroy);