[net-next-2.6.git] / include / linux / rtmutex.h

/*
 * RT Mutexes: blocking mutual exclusion locks with PI support
 *
 * started by Ingo Molnar and Thomas Gleixner:
 *
 *  Copyright (C) 2004-2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
 *  Copyright (C) 2006, Timesys Corp., Thomas Gleixner <tglx@timesys.com>
 *
 * This file contains the public data structure and API definitions.
 */

#ifndef __LINUX_RT_MUTEX_H
#define __LINUX_RT_MUTEX_H

#include <linux/linkage.h>
#include <linux/plist.h>
#include <linux/spinlock_types.h>

/**
 * The rt_mutex structure
 *
 * @wait_lock:	spinlock to protect the structure
 * @wait_list:	pilist head to enqueue waiters in priority order
 * @owner:	the mutex owner
 */
struct rt_mutex {
	spinlock_t		wait_lock;
	struct plist_head	wait_list;
	struct task_struct	*owner;
#ifdef CONFIG_DEBUG_RT_MUTEXES
	int			save_state;
	const char 		*name, *file;
	int			line;
	void			*magic;
#endif
};

struct rt_mutex_waiter;
struct hrtimer_sleeper;

#ifdef CONFIG_DEBUG_RT_MUTEXES
 extern int rt_mutex_debug_check_no_locks_freed(const void *from,
						unsigned long len);
 extern void rt_mutex_debug_check_no_locks_held(struct task_struct *task);
#else
 static inline int rt_mutex_debug_check_no_locks_freed(const void *from,
						       unsigned long len)
 {
	return 0;
 }
# define rt_mutex_debug_check_no_locks_held(task)	do { } while (0)
#endif

#ifdef CONFIG_DEBUG_RT_MUTEXES
# define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) \
	, .name = #mutexname, .file = __FILE__, .line = __LINE__
# define rt_mutex_init(mutex)			__rt_mutex_init(mutex, __func__)
 extern void rt_mutex_debug_task_free(struct task_struct *tsk);
#else
# define __DEBUG_RT_MUTEX_INITIALIZER(mutexname)
# define rt_mutex_init(mutex)			__rt_mutex_init(mutex, NULL)
# define rt_mutex_debug_task_free(t)			do { } while (0)
#endif

#define __RT_MUTEX_INITIALIZER(mutexname) \
	{ .wait_lock = __SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \
	, .wait_list = PLIST_HEAD_INIT(mutexname.wait_list, mutexname.wait_lock) \
	, .owner = NULL \
	__DEBUG_RT_MUTEX_INITIALIZER(mutexname)}

#define DEFINE_RT_MUTEX(mutexname) \
	struct rt_mutex mutexname = __RT_MUTEX_INITIALIZER(mutexname)

/**
 * rt_mutex_is_locked - is the mutex locked
 * @lock: the mutex to be queried
 *
 * Returns 1 if the mutex is locked, 0 if unlocked.
 */
static inline int rt_mutex_is_locked(struct rt_mutex *lock)
{
	return lock->owner != NULL;
}

extern void __rt_mutex_init(struct rt_mutex *lock, const char *name);
extern void rt_mutex_destroy(struct rt_mutex *lock);

extern void rt_mutex_lock(struct rt_mutex *lock);
extern int rt_mutex_lock_interruptible(struct rt_mutex *lock,
						int detect_deadlock);
extern int rt_mutex_timed_lock(struct rt_mutex *lock,
					struct hrtimer_sleeper *timeout,
					int detect_deadlock);

extern int rt_mutex_trylock(struct rt_mutex *lock);

extern void rt_mutex_unlock(struct rt_mutex *lock);

#ifdef CONFIG_RT_MUTEXES
# define INIT_RT_MUTEXES(tsk)						\
	.pi_waiters	= PLIST_HEAD_INIT(tsk.pi_waiters, tsk.pi_lock),	\
	INIT_RT_MUTEX_DEBUG(tsk)
#else
# define INIT_RT_MUTEXES(tsk)
#endif

#endif
Commit	Line	Data
23f78d4a IM	1	/*
	2	* RT Mutexes: blocking mutual exclusion locks with PI support
	3	*
	4	* started by Ingo Molnar and Thomas Gleixner:
	5	*
	6	* Copyright (C) 2004-2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
	7	* Copyright (C) 2006, Timesys Corp., Thomas Gleixner <tglx@timesys.com>
	8	*
	9	* This file contains the public data structure and API definitions.
	10	*/
	11
	12	#ifndef __LINUX_RT_MUTEX_H
	13	#define __LINUX_RT_MUTEX_H
	14
	15	#include <linux/linkage.h>
	16	#include <linux/plist.h>
	17	#include <linux/spinlock_types.h>
	18
45f8bde0	19	/**
23f78d4a IM	20	* The rt_mutex structure
	21	*
	22	* @wait_lock: spinlock to protect the structure
	23	* @wait_list: pilist head to enqueue waiters in priority order
	24	* @owner: the mutex owner
	25	*/
	26	struct rt_mutex {
	27	spinlock_t wait_lock;
	28	struct plist_head wait_list;
	29	struct task_struct *owner;
	30	#ifdef CONFIG_DEBUG_RT_MUTEXES
	31	int save_state;
23f78d4a IM	32	const char name, file;
	33	int line;
	34	void *magic;
	35	#endif
	36	};
	37
	38	struct rt_mutex_waiter;
	39	struct hrtimer_sleeper;
	40
e7eebaf6 IM	41	#ifdef CONFIG_DEBUG_RT_MUTEXES
	42	extern int rt_mutex_debug_check_no_locks_freed(const void *from,
	43	unsigned long len);
	44	extern void rt_mutex_debug_check_no_locks_held(struct task_struct *task);
	45	#else
	46	static inline int rt_mutex_debug_check_no_locks_freed(const void *from,
	47	unsigned long len)
	48	{
	49	return 0;
	50	}
	51	# define rt_mutex_debug_check_no_locks_held(task) do { } while (0)
	52	#endif
	53
23f78d4a IM	54	#ifdef CONFIG_DEBUG_RT_MUTEXES
	55	# define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) \
	56	, .name = #mutexname, .file = __FILE__, .line = __LINE__
d5c003b4	57	# define rt_mutex_init(mutex) __rt_mutex_init(mutex, __func__)
23f78d4a IM	58	extern void rt_mutex_debug_task_free(struct task_struct *tsk);
	59	#else
	60	# define __DEBUG_RT_MUTEX_INITIALIZER(mutexname)
	61	# define rt_mutex_init(mutex) __rt_mutex_init(mutex, NULL)
e7eebaf6	62	# define rt_mutex_debug_task_free(t) do { } while (0)
23f78d4a IM	63	#endif
	64
	65	#define __RT_MUTEX_INITIALIZER(mutexname) \
6cfd76a2	66	{ .wait_lock = __SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \
23f78d4a IM	67	, .wait_list = PLIST_HEAD_INIT(mutexname.wait_list, mutexname.wait_lock) \
	68	, .owner = NULL \
	69	__DEBUG_RT_MUTEX_INITIALIZER(mutexname)}
	70
	71	#define DEFINE_RT_MUTEX(mutexname) \
	72	struct rt_mutex mutexname = __RT_MUTEX_INITIALIZER(mutexname)
	73
45f8bde0	74	/**
23f78d4a IM	75	* rt_mutex_is_locked - is the mutex locked
	76	* @lock: the mutex to be queried
	77	*
	78	* Returns 1 if the mutex is locked, 0 if unlocked.
	79	*/
	80	static inline int rt_mutex_is_locked(struct rt_mutex *lock)
	81	{
	82	return lock->owner != NULL;
	83	}
	84
	85	extern void __rt_mutex_init(struct rt_mutex lock, const char name);
	86	extern void rt_mutex_destroy(struct rt_mutex *lock);
	87
	88	extern void rt_mutex_lock(struct rt_mutex *lock);
	89	extern int rt_mutex_lock_interruptible(struct rt_mutex *lock,
	90	int detect_deadlock);
	91	extern int rt_mutex_timed_lock(struct rt_mutex *lock,
	92	struct hrtimer_sleeper *timeout,
	93	int detect_deadlock);
	94
	95	extern int rt_mutex_trylock(struct rt_mutex *lock);
	96
	97	extern void rt_mutex_unlock(struct rt_mutex *lock);
	98
23f78d4a IM	99	#ifdef CONFIG_RT_MUTEXES
	100	# define INIT_RT_MUTEXES(tsk) \
	101	.pi_waiters = PLIST_HEAD_INIT(tsk.pi_waiters, tsk.pi_lock), \
	102	INIT_RT_MUTEX_DEBUG(tsk)
	103	#else
	104	# define INIT_RT_MUTEXES(tsk)
	105	#endif
	106
	107	#endif