[mirror_ubuntu-artful-kernel.git] / kernel / locking / 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/delay.h>
#include <linux/export.h>
#include <linux/poison.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/kallsyms.h>
#include <linux/interrupt.h>
#include <linux/debug_locks.h>

#include "mutex-debug.h"

/*
 * Must be called with lock->wait_lock held.
 */
void debug_mutex_lock_common(struct mutex *lock, struct mutex_waiter *waiter)
{
	memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter));
	waiter->magic = waiter;
	INIT_LIST_HEAD(&waiter->list);
}

void debug_mutex_wake_waiter(struct mutex *lock, struct mutex_waiter *waiter)
{
	SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));
	DEBUG_LOCKS_WARN_ON(list_empty(&lock->wait_list));
	DEBUG_LOCKS_WARN_ON(waiter->magic != waiter);
	DEBUG_LOCKS_WARN_ON(list_empty(&waiter->list));
}

void debug_mutex_free_waiter(struct mutex_waiter *waiter)
{
	DEBUG_LOCKS_WARN_ON(!list_empty(&waiter->list));
	memset(waiter, MUTEX_DEBUG_FREE, sizeof(*waiter));
}

void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,
			    struct thread_info *ti)
{
	SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));

	/* Mark the current thread as blocked on the lock: */
	ti->task->blocked_on = waiter;
}

void mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter,
			 struct thread_info *ti)
{
	DEBUG_LOCKS_WARN_ON(list_empty(&waiter->list));
	DEBUG_LOCKS_WARN_ON(waiter->task != ti->task);
	DEBUG_LOCKS_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)
{
	if (likely(debug_locks)) {
		DEBUG_LOCKS_WARN_ON(lock->magic != lock);

		if (!lock->owner)
			DEBUG_LOCKS_WARN_ON(!lock->owner);
		else
			DEBUG_LOCKS_WARN_ON(lock->owner != current);

		DEBUG_LOCKS_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next);
		mutex_clear_owner(lock);
	}

	/*
	 * __mutex_slowpath_needs_to_unlock() is explicitly 0 for debug
	 * mutexes so that we can do it here after we've verified state.
	 */
	atomic_set(&lock->count, 1);
}

void debug_mutex_init(struct mutex *lock, const char *name,
		      struct lock_class_key *key)
{
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	/*
	 * Make sure we are not reinitializing a held lock:
	 */
	debug_check_no_locks_freed((void *)lock, sizeof(*lock));
	lockdep_init_map(&lock->dep_map, name, key, 0);
#endif
	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 mutex_destroy(struct mutex *lock)
{
	DEBUG_LOCKS_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>
408894ee	16	#include <linux/delay.h>
9984de1a	17	#include <linux/export.h>
a7807a32	18	#include <linux/poison.h>
d43c36dc	19	#include <linux/sched.h>
408894ee IM	20	#include <linux/spinlock.h>
	21	#include <linux/kallsyms.h>
	22	#include <linux/interrupt.h>
9a11b49a	23	#include <linux/debug_locks.h>
408894ee	24
408894ee IM	25	#include "mutex-debug.h"
408894ee IM	26
408894ee IM	27	/*
	28	* Must be called with lock->wait_lock held.
	29	*/
9a11b49a	30	void debug_mutex_lock_common(struct mutex lock, struct mutex_waiter waiter)
408894ee	31	{
a7807a32	32	memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter));
408894ee IM	33	waiter->magic = waiter;
	34	INIT_LIST_HEAD(&waiter->list);
	35	}
	36
	37	void debug_mutex_wake_waiter(struct mutex lock, struct mutex_waiter waiter)
	38	{
9e7f4d45 IM	39	SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));
	40	DEBUG_LOCKS_WARN_ON(list_empty(&lock->wait_list));
	41	DEBUG_LOCKS_WARN_ON(waiter->magic != waiter);
	42	DEBUG_LOCKS_WARN_ON(list_empty(&waiter->list));
408894ee IM	43	}
	44
	45	void debug_mutex_free_waiter(struct mutex_waiter *waiter)
	46	{
9e7f4d45	47	DEBUG_LOCKS_WARN_ON(!list_empty(&waiter->list));
a7807a32	48	memset(waiter, MUTEX_DEBUG_FREE, sizeof(*waiter));
408894ee IM	49	}
	50
	51	void debug_mutex_add_waiter(struct mutex lock, struct mutex_waiter waiter,
9a11b49a	52	struct thread_info *ti)
408894ee	53	{
9e7f4d45	54	SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));
9a11b49a	55
408894ee IM	56	/* Mark the current thread as blocked on the lock: */
408894ee IM	57	ti->task->blocked_on = waiter;
408894ee IM	58	}
	59
	60	void mutex_remove_waiter(struct mutex lock, struct mutex_waiter waiter,
	61	struct thread_info *ti)
	62	{
9e7f4d45 IM	63	DEBUG_LOCKS_WARN_ON(list_empty(&waiter->list));
	64	DEBUG_LOCKS_WARN_ON(waiter->task != ti->task);
	65	DEBUG_LOCKS_WARN_ON(ti->task->blocked_on != waiter);
408894ee IM	66	ti->task->blocked_on = NULL;
	67
	68	list_del_init(&waiter->list);
	69	waiter->task = NULL;
	70	}
	71
	72	void debug_mutex_unlock(struct mutex *lock)
	73	{
a227960f PZ	74	if (likely(debug_locks)) {
a227960f PZ	75	DEBUG_LOCKS_WARN_ON(lock->magic != lock);
2ee91f19	76
a227960f PZ	77	if (!lock->owner)
	78	DEBUG_LOCKS_WARN_ON(!lock->owner);
	79	else
	80	DEBUG_LOCKS_WARN_ON(lock->owner != current);
91f30a17	81
a227960f PZ	82	DEBUG_LOCKS_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next);
	83	mutex_clear_owner(lock);
	84	}
6f008e72 PZ	85
	86	/*
	87	* __mutex_slowpath_needs_to_unlock() is explicitly 0 for debug
	88	* mutexes so that we can do it here after we've verified state.
	89	*/
	90	atomic_set(&lock->count, 1);
408894ee IM	91	}
408894ee IM	92
ef5d4707 IM	93	void debug_mutex_init(struct mutex lock, const char name,
ef5d4707 IM	94	struct lock_class_key *key)
408894ee	95	{
ef5d4707	96	#ifdef CONFIG_DEBUG_LOCK_ALLOC
408894ee IM	97	/*
	98	* Make sure we are not reinitializing a held lock:
	99	*/
9a11b49a	100	debug_check_no_locks_freed((void )lock, sizeof(lock));
4dfbb9d8	101	lockdep_init_map(&lock->dep_map, name, key, 0);
ef5d4707	102	#endif
408894ee IM	103	lock->magic = lock;
	104	}
	105
	106	/***
	107	* mutex_destroy - mark a mutex unusable
	108	* @lock: the mutex to be destroyed
	109	*
	110	* This function marks the mutex uninitialized, and any subsequent
	111	* use of the mutex is forbidden. The mutex must not be locked when
	112	* this function is called.
	113	*/
7ad5b3a5	114	void mutex_destroy(struct mutex *lock)
408894ee	115	{
9e7f4d45	116	DEBUG_LOCKS_WARN_ON(mutex_is_locked(lock));
408894ee IM	117	lock->magic = NULL;
	118	}
	119
	120	EXPORT_SYMBOL_GPL(mutex_destroy);