[GitHub/mt8127/android_kernel_alcatel_ttab.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>

extern int max_lock_depth; /* for sysctl */

/**
 * 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 {
	raw_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 = __RAW_SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \
	, .wait_list = PLIST_HEAD_INIT(mutexname.wait_list) \
	, .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),	\
	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
4f0e056f DY	19	extern int max_lock_depth; /* for sysctl */
4f0e056f DY	20
45f8bde0	21	/**
23f78d4a IM	22	* The rt_mutex structure
	23	*
	24	* @wait_lock: spinlock to protect the structure
	25	* @wait_list: pilist head to enqueue waiters in priority order
	26	* @owner: the mutex owner
	27	*/
	28	struct rt_mutex {
d209d74d	29	raw_spinlock_t wait_lock;
23f78d4a IM	30	struct plist_head wait_list;
	31	struct task_struct *owner;
	32	#ifdef CONFIG_DEBUG_RT_MUTEXES
	33	int save_state;
23f78d4a IM	34	const char name, file;
	35	int line;
	36	void *magic;
	37	#endif
	38	};
	39
	40	struct rt_mutex_waiter;
	41	struct hrtimer_sleeper;
	42
e7eebaf6 IM	43	#ifdef CONFIG_DEBUG_RT_MUTEXES
	44	extern int rt_mutex_debug_check_no_locks_freed(const void *from,
	45	unsigned long len);
	46	extern void rt_mutex_debug_check_no_locks_held(struct task_struct *task);
	47	#else
	48	static inline int rt_mutex_debug_check_no_locks_freed(const void *from,
	49	unsigned long len)
	50	{
	51	return 0;
	52	}
	53	# define rt_mutex_debug_check_no_locks_held(task) do { } while (0)
	54	#endif
	55
23f78d4a IM	56	#ifdef CONFIG_DEBUG_RT_MUTEXES
	57	# define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) \
	58	, .name = #mutexname, .file = __FILE__, .line = __LINE__
d5c003b4	59	# define rt_mutex_init(mutex) __rt_mutex_init(mutex, __func__)
23f78d4a IM	60	extern void rt_mutex_debug_task_free(struct task_struct *tsk);
	61	#else
	62	# define __DEBUG_RT_MUTEX_INITIALIZER(mutexname)
	63	# define rt_mutex_init(mutex) __rt_mutex_init(mutex, NULL)
e7eebaf6	64	# define rt_mutex_debug_task_free(t) do { } while (0)
23f78d4a IM	65	#endif
	66
	67	#define __RT_MUTEX_INITIALIZER(mutexname) \
d209d74d	68	{ .wait_lock = __RAW_SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \
732375c6	69	, .wait_list = PLIST_HEAD_INIT(mutexname.wait_list) \
23f78d4a IM	70	, .owner = NULL \
	71	__DEBUG_RT_MUTEX_INITIALIZER(mutexname)}
	72
	73	#define DEFINE_RT_MUTEX(mutexname) \
	74	struct rt_mutex mutexname = __RT_MUTEX_INITIALIZER(mutexname)
	75
45f8bde0	76	/**
23f78d4a IM	77	* rt_mutex_is_locked - is the mutex locked
	78	* @lock: the mutex to be queried
	79	*
	80	* Returns 1 if the mutex is locked, 0 if unlocked.
	81	*/
	82	static inline int rt_mutex_is_locked(struct rt_mutex *lock)
	83	{
	84	return lock->owner != NULL;
	85	}
	86
	87	extern void __rt_mutex_init(struct rt_mutex lock, const char name);
	88	extern void rt_mutex_destroy(struct rt_mutex *lock);
	89
	90	extern void rt_mutex_lock(struct rt_mutex *lock);
	91	extern int rt_mutex_lock_interruptible(struct rt_mutex *lock,
	92	int detect_deadlock);
	93	extern int rt_mutex_timed_lock(struct rt_mutex *lock,
	94	struct hrtimer_sleeper *timeout,
	95	int detect_deadlock);
	96
	97	extern int rt_mutex_trylock(struct rt_mutex *lock);
	98
	99	extern void rt_mutex_unlock(struct rt_mutex *lock);
	100
23f78d4a IM	101	#ifdef CONFIG_RT_MUTEXES
23f78d4a IM	102	# define INIT_RT_MUTEXES(tsk) \
732375c6	103	.pi_waiters = PLIST_HEAD_INIT(tsk.pi_waiters), \
23f78d4a IM	104	INIT_RT_MUTEX_DEBUG(tsk)
	105	#else
	106	# define INIT_RT_MUTEXES(tsk)
	107	#endif
	108
	109	#endif