[deliverable/linux.git] / include / linux / spinlock_api_smp.h

#ifndef __LINUX_SPINLOCK_API_SMP_H
#define __LINUX_SPINLOCK_API_SMP_H

#ifndef __LINUX_SPINLOCK_H
# error "please don't include this file directly"
#endif

/*
 * include/linux/spinlock_api_smp.h
 *
 * spinlock API declarations on SMP (and debug)
 * (implemented in kernel/spinlock.c)
 *
 * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
 * Released under the General Public License (GPL).
 */

int in_lock_functions(unsigned long addr);

#define assert_raw_spin_locked(x)	BUG_ON(!raw_spin_is_locked(x))

void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)		__acquires(lock);
void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)
								__acquires(lock);
void __lockfunc
_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map)
								__acquires(lock);
void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)		__acquires(lock);
void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
								__acquires(lock);

unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
								__acquires(lock);
unsigned long __lockfunc
_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass)
								__acquires(lock);
int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock);
int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock);
void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)		__releases(lock);
void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)	__releases(lock);
void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)	__releases(lock);
void __lockfunc
_raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
								__releases(lock);

#ifdef CONFIG_INLINE_SPIN_LOCK
#define _raw_spin_lock(lock) __raw_spin_lock(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_LOCK_BH
#define _raw_spin_lock_bh(lock) __raw_spin_lock_bh(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_LOCK_IRQ
#define _raw_spin_lock_irq(lock) __raw_spin_lock_irq(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_LOCK_IRQSAVE
#define _raw_spin_lock_irqsave(lock) __raw_spin_lock_irqsave(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_TRYLOCK
#define _raw_spin_trylock(lock) __raw_spin_trylock(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_TRYLOCK_BH
#define _raw_spin_trylock_bh(lock) __raw_spin_trylock_bh(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_UNLOCK
#define _raw_spin_unlock(lock) __raw_spin_unlock(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_UNLOCK_BH
#define _raw_spin_unlock_bh(lock) __raw_spin_unlock_bh(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQ
#define _raw_spin_unlock_irq(lock) __raw_spin_unlock_irq(lock)
#endif

#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE
#define _raw_spin_unlock_irqrestore(lock, flags) __raw_spin_unlock_irqrestore(lock, flags)
#endif

static inline int __raw_spin_trylock(raw_spinlock_t *lock)
{
	preempt_disable();
	if (do_raw_spin_trylock(lock)) {
		spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
		return 1;
	}
	preempt_enable();
	return 0;
}

/*
 * If lockdep is enabled then we use the non-preemption spin-ops
 * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
 * not re-enabled during lock-acquire (which the preempt-spin-ops do):
 */
#if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)

static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock)
{
	unsigned long flags;

	local_irq_save(flags);
	preempt_disable();
	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	/*
	 * On lockdep we dont want the hand-coded irq-enable of
	 * do_raw_spin_lock_flags() code, because lockdep assumes
	 * that interrupts are not re-enabled during lock-acquire:
	 */
#ifdef CONFIG_LOCKDEP
	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
#else
	do_raw_spin_lock_flags(lock, &flags);
#endif
	return flags;
}

static inline void __raw_spin_lock_irq(raw_spinlock_t *lock)
{
	local_irq_disable();
	preempt_disable();
	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

static inline void __raw_spin_lock_bh(raw_spinlock_t *lock)
{
	local_bh_disable();
	preempt_disable();
	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

static inline void __raw_spin_lock(raw_spinlock_t *lock)
{
	preempt_disable();
	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

#endif /* CONFIG_PREEMPT */

static inline void __raw_spin_unlock(raw_spinlock_t *lock)
{
	spin_release(&lock->dep_map, 1, _RET_IP_);
	do_raw_spin_unlock(lock);
	preempt_enable();
}

static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,
					    unsigned long flags)
{
	spin_release(&lock->dep_map, 1, _RET_IP_);
	do_raw_spin_unlock(lock);
	local_irq_restore(flags);
	preempt_enable();
}

static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock)
{
	spin_release(&lock->dep_map, 1, _RET_IP_);
	do_raw_spin_unlock(lock);
	local_irq_enable();
	preempt_enable();
}

static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock)
{
	spin_release(&lock->dep_map, 1, _RET_IP_);
	do_raw_spin_unlock(lock);
	preempt_enable_no_resched();
	local_bh_enable_ip((unsigned long)__builtin_return_address(0));
}

static inline int __raw_spin_trylock_bh(raw_spinlock_t *lock)
{
	local_bh_disable();
	preempt_disable();
	if (do_raw_spin_trylock(lock)) {
		spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
		return 1;
	}
	preempt_enable_no_resched();
	local_bh_enable_ip((unsigned long)__builtin_return_address(0));
	return 0;
}

#include <linux/rwlock_api_smp.h>

#endif /* __LINUX_SPINLOCK_API_SMP_H */
Commit	Line	Data
	1	#ifndef __LINUX_SPINLOCK_API_SMP_H
	2	#define __LINUX_SPINLOCK_API_SMP_H
	3
	4	#ifndef __LINUX_SPINLOCK_H
	5	# error "please don't include this file directly"
	6	#endif
	7
	8	/*
	9	* include/linux/spinlock_api_smp.h
	10	*
	11	* spinlock API declarations on SMP (and debug)
	12	* (implemented in kernel/spinlock.c)
	13	*
	14	* portions Copyright 2005, Red Hat, Inc., Ingo Molnar
	15	* Released under the General Public License (GPL).
	16	*/
	17
	18	int in_lock_functions(unsigned long addr);
	19
	20	#define assert_raw_spin_locked(x) BUG_ON(!raw_spin_is_locked(x))
	21
	22	void __lockfunc _raw_spin_lock(raw_spinlock_t *lock) __acquires(lock);
	23	void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)
	24	__acquires(lock);
	25	void __lockfunc
	26	_raw_spin_lock_nest_lock(raw_spinlock_t lock, struct lockdep_map map)
	27	__acquires(lock);
	28	void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock) __acquires(lock);
	29	void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
	30	__acquires(lock);
	31
	32	unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
	33	__acquires(lock);
	34	unsigned long __lockfunc
	35	_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass)
	36	__acquires(lock);
	37	int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock);
	38	int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock);
	39	void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock) __releases(lock);
	40	void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock);
	41	void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock);
	42	void __lockfunc
	43	_raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
	44	__releases(lock);
	45
	46	#ifdef CONFIG_INLINE_SPIN_LOCK
	47	#define _raw_spin_lock(lock) __raw_spin_lock(lock)
	48	#endif
	49
	50	#ifdef CONFIG_INLINE_SPIN_LOCK_BH
	51	#define _raw_spin_lock_bh(lock) __raw_spin_lock_bh(lock)
	52	#endif
	53
	54	#ifdef CONFIG_INLINE_SPIN_LOCK_IRQ
	55	#define _raw_spin_lock_irq(lock) __raw_spin_lock_irq(lock)
	56	#endif
	57
	58	#ifdef CONFIG_INLINE_SPIN_LOCK_IRQSAVE
	59	#define _raw_spin_lock_irqsave(lock) __raw_spin_lock_irqsave(lock)
	60	#endif
	61
	62	#ifdef CONFIG_INLINE_SPIN_TRYLOCK
	63	#define _raw_spin_trylock(lock) __raw_spin_trylock(lock)
	64	#endif
	65
	66	#ifdef CONFIG_INLINE_SPIN_TRYLOCK_BH
	67	#define _raw_spin_trylock_bh(lock) __raw_spin_trylock_bh(lock)
	68	#endif
	69
	70	#ifdef CONFIG_INLINE_SPIN_UNLOCK
	71	#define _raw_spin_unlock(lock) __raw_spin_unlock(lock)
	72	#endif
	73
	74	#ifdef CONFIG_INLINE_SPIN_UNLOCK_BH
	75	#define _raw_spin_unlock_bh(lock) __raw_spin_unlock_bh(lock)
	76	#endif
	77
	78	#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQ
	79	#define _raw_spin_unlock_irq(lock) __raw_spin_unlock_irq(lock)
	80	#endif
	81
	82	#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE
	83	#define _raw_spin_unlock_irqrestore(lock, flags) __raw_spin_unlock_irqrestore(lock, flags)
	84	#endif
	85
	86	static inline int __raw_spin_trylock(raw_spinlock_t *lock)
	87	{
	88	preempt_disable();
	89	if (do_raw_spin_trylock(lock)) {
	90	spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
	91	return 1;
	92	}
	93	preempt_enable();
	94	return 0;
	95	}
	96
	97	/*
	98	* If lockdep is enabled then we use the non-preemption spin-ops
	99	* even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
	100	* not re-enabled during lock-acquire (which the preempt-spin-ops do):
	101	*/
	102	#if !defined(CONFIG_GENERIC_LOCKBREAK) \|\| defined(CONFIG_DEBUG_LOCK_ALLOC)
	103
	104	static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock)
	105	{
	106	unsigned long flags;
	107
	108	local_irq_save(flags);
	109	preempt_disable();
	110	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	111	/*
	112	* On lockdep we dont want the hand-coded irq-enable of
	113	* do_raw_spin_lock_flags() code, because lockdep assumes
	114	* that interrupts are not re-enabled during lock-acquire:
	115	*/
	116	#ifdef CONFIG_LOCKDEP
	117	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
	118	#else
	119	do_raw_spin_lock_flags(lock, &flags);
	120	#endif
	121	return flags;
	122	}
	123
	124	static inline void __raw_spin_lock_irq(raw_spinlock_t *lock)
	125	{
	126	local_irq_disable();
	127	preempt_disable();
	128	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	129	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
	130	}
	131
	132	static inline void __raw_spin_lock_bh(raw_spinlock_t *lock)
	133	{
	134	local_bh_disable();
	135	preempt_disable();
	136	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	137	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
	138	}
	139
	140	static inline void __raw_spin_lock(raw_spinlock_t *lock)
	141	{
	142	preempt_disable();
	143	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	144	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
	145	}
	146
	147	#endif /* CONFIG_PREEMPT */
	148
	149	static inline void __raw_spin_unlock(raw_spinlock_t *lock)
	150	{
	151	spin_release(&lock->dep_map, 1, _RET_IP_);
	152	do_raw_spin_unlock(lock);
	153	preempt_enable();
	154	}
	155
	156	static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,
	157	unsigned long flags)
	158	{
	159	spin_release(&lock->dep_map, 1, _RET_IP_);
	160	do_raw_spin_unlock(lock);
	161	local_irq_restore(flags);
	162	preempt_enable();
	163	}
	164
	165	static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock)
	166	{
	167	spin_release(&lock->dep_map, 1, _RET_IP_);
	168	do_raw_spin_unlock(lock);
	169	local_irq_enable();
	170	preempt_enable();
	171	}
	172
	173	static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock)
	174	{
	175	spin_release(&lock->dep_map, 1, _RET_IP_);
	176	do_raw_spin_unlock(lock);
	177	preempt_enable_no_resched();
	178	local_bh_enable_ip((unsigned long)__builtin_return_address(0));
	179	}
	180
	181	static inline int __raw_spin_trylock_bh(raw_spinlock_t *lock)
	182	{
	183	local_bh_disable();
	184	preempt_disable();
	185	if (do_raw_spin_trylock(lock)) {
	186	spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
	187	return 1;
	188	}
	189	preempt_enable_no_resched();
	190	local_bh_enable_ip((unsigned long)__builtin_return_address(0));
	191	return 0;
	192	}
	193
	194	#include <linux/rwlock_api_smp.h>
	195
	196	#endif /* __LINUX_SPINLOCK_API_SMP_H */