[linux-block.git] / include / linux / rwlock_api_smp.h

#ifndef __LINUX_RWLOCK_API_SMP_H
#define __LINUX_RWLOCK_API_SMP_H

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

/*
 * include/linux/rwlock_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).
 */

void __lockfunc _raw_read_lock(rwlock_t *lock)		__acquires(lock);
void __lockfunc _raw_write_lock(rwlock_t *lock)		__acquires(lock);
void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass)	__acquires(lock);
void __lockfunc _raw_read_lock_bh(rwlock_t *lock)	__acquires(lock);
void __lockfunc _raw_write_lock_bh(rwlock_t *lock)	__acquires(lock);
void __lockfunc _raw_read_lock_irq(rwlock_t *lock)	__acquires(lock);
void __lockfunc _raw_write_lock_irq(rwlock_t *lock)	__acquires(lock);
unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
							__acquires(lock);
unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
							__acquires(lock);
int __lockfunc _raw_read_trylock(rwlock_t *lock);
int __lockfunc _raw_write_trylock(rwlock_t *lock);
void __lockfunc _raw_read_unlock(rwlock_t *lock)	__releases(lock);
void __lockfunc _raw_write_unlock(rwlock_t *lock)	__releases(lock);
void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)	__releases(lock);
void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)	__releases(lock);
void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)	__releases(lock);
void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)	__releases(lock);
void __lockfunc
_raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
							__releases(lock);
void __lockfunc
_raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
							__releases(lock);

#ifdef CONFIG_INLINE_READ_LOCK
#define _raw_read_lock(lock) __raw_read_lock(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_LOCK
#define _raw_write_lock(lock) __raw_write_lock(lock)
#endif

#ifdef CONFIG_INLINE_READ_LOCK_BH
#define _raw_read_lock_bh(lock) __raw_read_lock_bh(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_LOCK_BH
#define _raw_write_lock_bh(lock) __raw_write_lock_bh(lock)
#endif

#ifdef CONFIG_INLINE_READ_LOCK_IRQ
#define _raw_read_lock_irq(lock) __raw_read_lock_irq(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_LOCK_IRQ
#define _raw_write_lock_irq(lock) __raw_write_lock_irq(lock)
#endif

#ifdef CONFIG_INLINE_READ_LOCK_IRQSAVE
#define _raw_read_lock_irqsave(lock) __raw_read_lock_irqsave(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
#define _raw_write_lock_irqsave(lock) __raw_write_lock_irqsave(lock)
#endif

#ifdef CONFIG_INLINE_READ_TRYLOCK
#define _raw_read_trylock(lock) __raw_read_trylock(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_TRYLOCK
#define _raw_write_trylock(lock) __raw_write_trylock(lock)
#endif

#ifdef CONFIG_INLINE_READ_UNLOCK
#define _raw_read_unlock(lock) __raw_read_unlock(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_UNLOCK
#define _raw_write_unlock(lock) __raw_write_unlock(lock)
#endif

#ifdef CONFIG_INLINE_READ_UNLOCK_BH
#define _raw_read_unlock_bh(lock) __raw_read_unlock_bh(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_UNLOCK_BH
#define _raw_write_unlock_bh(lock) __raw_write_unlock_bh(lock)
#endif

#ifdef CONFIG_INLINE_READ_UNLOCK_IRQ
#define _raw_read_unlock_irq(lock) __raw_read_unlock_irq(lock)
#endif

#ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQ
#define _raw_write_unlock_irq(lock) __raw_write_unlock_irq(lock)
#endif

#ifdef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
#define _raw_read_unlock_irqrestore(lock, flags) \
	__raw_read_unlock_irqrestore(lock, flags)
#endif

#ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
#define _raw_write_unlock_irqrestore(lock, flags) \
	__raw_write_unlock_irqrestore(lock, flags)
#endif

static inline int __raw_read_trylock(rwlock_t *lock)
{
	preempt_disable();
	if (do_raw_read_trylock(lock)) {
		rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
		return 1;
	}
	preempt_enable();
	return 0;
}

static inline int __raw_write_trylock(rwlock_t *lock)
{
	preempt_disable();
	if (do_raw_write_trylock(lock)) {
		rwlock_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 void __raw_read_lock(rwlock_t *lock)
{
	preempt_disable();
	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
}

static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
{
	unsigned long flags;

	local_irq_save(flags);
	preempt_disable();
	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
	return flags;
}

static inline void __raw_read_lock_irq(rwlock_t *lock)
{
	local_irq_disable();
	preempt_disable();
	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
}

static inline void __raw_read_lock_bh(rwlock_t *lock)
{
	__local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
}

static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
{
	unsigned long flags;

	local_irq_save(flags);
	preempt_disable();
	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
	return flags;
}

static inline void __raw_write_lock_irq(rwlock_t *lock)
{
	local_irq_disable();
	preempt_disable();
	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
}

static inline void __raw_write_lock_bh(rwlock_t *lock)
{
	__local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
}

static inline void __raw_write_lock(rwlock_t *lock)
{
	preempt_disable();
	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
}

static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass)
{
	preempt_disable();
	rwlock_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
}

#endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */

static inline void __raw_write_unlock(rwlock_t *lock)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_write_unlock(lock);
	preempt_enable();
}

static inline void __raw_read_unlock(rwlock_t *lock)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_read_unlock(lock);
	preempt_enable();
}

static inline void
__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_read_unlock(lock);
	local_irq_restore(flags);
	preempt_enable();
}

static inline void __raw_read_unlock_irq(rwlock_t *lock)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_read_unlock(lock);
	local_irq_enable();
	preempt_enable();
}

static inline void __raw_read_unlock_bh(rwlock_t *lock)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_read_unlock(lock);
	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
}

static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,
					     unsigned long flags)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_write_unlock(lock);
	local_irq_restore(flags);
	preempt_enable();
}

static inline void __raw_write_unlock_irq(rwlock_t *lock)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_write_unlock(lock);
	local_irq_enable();
	preempt_enable();
}

static inline void __raw_write_unlock_bh(rwlock_t *lock)
{
	rwlock_release(&lock->dep_map, _RET_IP_);
	do_raw_write_unlock(lock);
	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
}

#endif /* __LINUX_RWLOCK_API_SMP_H */
Commit	Line	Data
6b6b4792 TG	1	#ifndef __LINUX_RWLOCK_API_SMP_H
	2	#define __LINUX_RWLOCK_API_SMP_H
	3
	4	#ifndef __LINUX_SPINLOCK_API_SMP_H
	5	# error "please don't include this file directly"
	6	#endif
	7
	8	/*
	9	* include/linux/rwlock_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
9c1721aa TG	18	void __lockfunc _raw_read_lock(rwlock_t *lock) __acquires(lock);
9c1721aa TG	19	void __lockfunc _raw_write_lock(rwlock_t *lock) __acquires(lock);
4a57d6bb	20	void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass) __acquires(lock);
9c1721aa TG	21	void __lockfunc _raw_read_lock_bh(rwlock_t *lock) __acquires(lock);
	22	void __lockfunc _raw_write_lock_bh(rwlock_t *lock) __acquires(lock);
	23	void __lockfunc _raw_read_lock_irq(rwlock_t *lock) __acquires(lock);
	24	void __lockfunc _raw_write_lock_irq(rwlock_t *lock) __acquires(lock);
	25	unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
6b6b4792	26	__acquires(lock);
9c1721aa	27	unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
6b6b4792	28	__acquires(lock);
9c1721aa TG	29	int __lockfunc _raw_read_trylock(rwlock_t *lock);
	30	int __lockfunc _raw_write_trylock(rwlock_t *lock);
	31	void __lockfunc _raw_read_unlock(rwlock_t *lock) __releases(lock);
	32	void __lockfunc _raw_write_unlock(rwlock_t *lock) __releases(lock);
	33	void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases(lock);
	34	void __lockfunc _raw_write_unlock_bh(rwlock_t *lock) __releases(lock);
	35	void __lockfunc _raw_read_unlock_irq(rwlock_t *lock) __releases(lock);
	36	void __lockfunc _raw_write_unlock_irq(rwlock_t *lock) __releases(lock);
	37	void __lockfunc
	38	_raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
6b6b4792	39	__releases(lock);
9c1721aa TG	40	void __lockfunc
9c1721aa TG	41	_raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
6b6b4792 TG	42	__releases(lock);
	43
	44	#ifdef CONFIG_INLINE_READ_LOCK
9c1721aa	45	#define _raw_read_lock(lock) __raw_read_lock(lock)
6b6b4792 TG	46	#endif
	47
	48	#ifdef CONFIG_INLINE_WRITE_LOCK
9c1721aa	49	#define _raw_write_lock(lock) __raw_write_lock(lock)
6b6b4792 TG	50	#endif
	51
	52	#ifdef CONFIG_INLINE_READ_LOCK_BH
9c1721aa	53	#define _raw_read_lock_bh(lock) __raw_read_lock_bh(lock)
6b6b4792 TG	54	#endif
	55
	56	#ifdef CONFIG_INLINE_WRITE_LOCK_BH
9c1721aa	57	#define _raw_write_lock_bh(lock) __raw_write_lock_bh(lock)
6b6b4792 TG	58	#endif
	59
	60	#ifdef CONFIG_INLINE_READ_LOCK_IRQ
9c1721aa	61	#define _raw_read_lock_irq(lock) __raw_read_lock_irq(lock)
6b6b4792 TG	62	#endif
	63
	64	#ifdef CONFIG_INLINE_WRITE_LOCK_IRQ
9c1721aa	65	#define _raw_write_lock_irq(lock) __raw_write_lock_irq(lock)
6b6b4792 TG	66	#endif
	67
	68	#ifdef CONFIG_INLINE_READ_LOCK_IRQSAVE
9c1721aa	69	#define _raw_read_lock_irqsave(lock) __raw_read_lock_irqsave(lock)
6b6b4792 TG	70	#endif
	71
	72	#ifdef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
9c1721aa	73	#define _raw_write_lock_irqsave(lock) __raw_write_lock_irqsave(lock)
6b6b4792 TG	74	#endif
	75
	76	#ifdef CONFIG_INLINE_READ_TRYLOCK
9c1721aa	77	#define _raw_read_trylock(lock) __raw_read_trylock(lock)
6b6b4792 TG	78	#endif
	79
	80	#ifdef CONFIG_INLINE_WRITE_TRYLOCK
9c1721aa	81	#define _raw_write_trylock(lock) __raw_write_trylock(lock)
6b6b4792 TG	82	#endif
	83
	84	#ifdef CONFIG_INLINE_READ_UNLOCK
9c1721aa	85	#define _raw_read_unlock(lock) __raw_read_unlock(lock)
6b6b4792 TG	86	#endif
	87
	88	#ifdef CONFIG_INLINE_WRITE_UNLOCK
9c1721aa	89	#define _raw_write_unlock(lock) __raw_write_unlock(lock)
6b6b4792 TG	90	#endif
	91
	92	#ifdef CONFIG_INLINE_READ_UNLOCK_BH
9c1721aa	93	#define _raw_read_unlock_bh(lock) __raw_read_unlock_bh(lock)
6b6b4792 TG	94	#endif
	95
	96	#ifdef CONFIG_INLINE_WRITE_UNLOCK_BH
9c1721aa	97	#define _raw_write_unlock_bh(lock) __raw_write_unlock_bh(lock)
6b6b4792 TG	98	#endif
	99
	100	#ifdef CONFIG_INLINE_READ_UNLOCK_IRQ
9c1721aa	101	#define _raw_read_unlock_irq(lock) __raw_read_unlock_irq(lock)
6b6b4792 TG	102	#endif
	103
	104	#ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQ
9c1721aa	105	#define _raw_write_unlock_irq(lock) __raw_write_unlock_irq(lock)
6b6b4792 TG	106	#endif
	107
	108	#ifdef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
9c1721aa TG	109	#define _raw_read_unlock_irqrestore(lock, flags) \
9c1721aa TG	110	__raw_read_unlock_irqrestore(lock, flags)
6b6b4792 TG	111	#endif
	112
	113	#ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
9c1721aa TG	114	#define _raw_write_unlock_irqrestore(lock, flags) \
9c1721aa TG	115	__raw_write_unlock_irqrestore(lock, flags)
6b6b4792 TG	116	#endif
6b6b4792 TG	117
9c1721aa	118	static inline int __raw_read_trylock(rwlock_t *lock)
6b6b4792 TG	119	{
6b6b4792 TG	120	preempt_disable();
9828ea9d	121	if (do_raw_read_trylock(lock)) {
6b6b4792 TG	122	rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
	123	return 1;
	124	}
	125	preempt_enable();
	126	return 0;
	127	}
	128
9c1721aa	129	static inline int __raw_write_trylock(rwlock_t *lock)
6b6b4792 TG	130	{
6b6b4792 TG	131	preempt_disable();
9828ea9d	132	if (do_raw_write_trylock(lock)) {
6b6b4792 TG	133	rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
	134	return 1;
	135	}
	136	preempt_enable();
	137	return 0;
	138	}
	139
	140	/*
	141	* If lockdep is enabled then we use the non-preemption spin-ops
	142	* even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
	143	* not re-enabled during lock-acquire (which the preempt-spin-ops do):
	144	*/
	145	#if !defined(CONFIG_GENERIC_LOCKBREAK) \|\| defined(CONFIG_DEBUG_LOCK_ALLOC)
	146
9c1721aa	147	static inline void __raw_read_lock(rwlock_t *lock)
6b6b4792 TG	148	{
	149	preempt_disable();
	150	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
9828ea9d	151	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
6b6b4792 TG	152	}
6b6b4792 TG	153
9c1721aa	154	static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
6b6b4792 TG	155	{
	156	unsigned long flags;
	157
	158	local_irq_save(flags);
	159	preempt_disable();
	160	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
f98a3dcc	161	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
6b6b4792 TG	162	return flags;
	163	}
	164
9c1721aa	165	static inline void __raw_read_lock_irq(rwlock_t *lock)
6b6b4792 TG	166	{
	167	local_irq_disable();
	168	preempt_disable();
	169	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
9828ea9d	170	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
6b6b4792 TG	171	}
6b6b4792 TG	172
9c1721aa	173	static inline void __raw_read_lock_bh(rwlock_t *lock)
6b6b4792	174	{
9ea4c380	175	__local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
6b6b4792	176	rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
9828ea9d	177	LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
6b6b4792 TG	178	}
6b6b4792 TG	179
9c1721aa	180	static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
6b6b4792 TG	181	{
	182	unsigned long flags;
	183
	184	local_irq_save(flags);
	185	preempt_disable();
	186	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
f98a3dcc	187	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
6b6b4792 TG	188	return flags;
	189	}
	190
9c1721aa	191	static inline void __raw_write_lock_irq(rwlock_t *lock)
6b6b4792 TG	192	{
	193	local_irq_disable();
	194	preempt_disable();
	195	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
9828ea9d	196	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
6b6b4792 TG	197	}
6b6b4792 TG	198
9c1721aa	199	static inline void __raw_write_lock_bh(rwlock_t *lock)
6b6b4792	200	{
9ea4c380	201	__local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
6b6b4792	202	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
9828ea9d	203	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
6b6b4792 TG	204	}
6b6b4792 TG	205
9c1721aa	206	static inline void __raw_write_lock(rwlock_t *lock)
6b6b4792 TG	207	{
	208	preempt_disable();
	209	rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
9828ea9d	210	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
6b6b4792 TG	211	}
6b6b4792 TG	212
4a57d6bb MK	213	static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass)
	214	{
	215	preempt_disable();
	216	rwlock_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
	217	LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
	218	}
	219
f791dd25	220	#endif /* !CONFIG_GENERIC_LOCKBREAK \|\| CONFIG_DEBUG_LOCK_ALLOC */
6b6b4792	221
9c1721aa	222	static inline void __raw_write_unlock(rwlock_t *lock)
6b6b4792	223	{
5facae4f	224	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	225	do_raw_write_unlock(lock);
6b6b4792 TG	226	preempt_enable();
	227	}
	228
9c1721aa	229	static inline void __raw_read_unlock(rwlock_t *lock)
6b6b4792	230	{
5facae4f	231	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	232	do_raw_read_unlock(lock);
6b6b4792 TG	233	preempt_enable();
	234	}
	235
9c1721aa TG	236	static inline void
9c1721aa TG	237	__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
6b6b4792	238	{
5facae4f	239	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	240	do_raw_read_unlock(lock);
6b6b4792 TG	241	local_irq_restore(flags);
	242	preempt_enable();
	243	}
	244
9c1721aa	245	static inline void __raw_read_unlock_irq(rwlock_t *lock)
6b6b4792	246	{
5facae4f	247	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	248	do_raw_read_unlock(lock);
6b6b4792 TG	249	local_irq_enable();
	250	preempt_enable();
	251	}
	252
9c1721aa	253	static inline void __raw_read_unlock_bh(rwlock_t *lock)
6b6b4792	254	{
5facae4f	255	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	256	do_raw_read_unlock(lock);
9ea4c380	257	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
6b6b4792 TG	258	}
6b6b4792 TG	259
9c1721aa	260	static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,
6b6b4792 TG	261	unsigned long flags)
6b6b4792 TG	262	{
5facae4f	263	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	264	do_raw_write_unlock(lock);
6b6b4792 TG	265	local_irq_restore(flags);
	266	preempt_enable();
	267	}
	268
9c1721aa	269	static inline void __raw_write_unlock_irq(rwlock_t *lock)
6b6b4792	270	{
5facae4f	271	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	272	do_raw_write_unlock(lock);
6b6b4792 TG	273	local_irq_enable();
	274	preempt_enable();
	275	}
	276
9c1721aa	277	static inline void __raw_write_unlock_bh(rwlock_t *lock)
6b6b4792	278	{
5facae4f	279	rwlock_release(&lock->dep_map, _RET_IP_);
9828ea9d	280	do_raw_write_unlock(lock);
9ea4c380	281	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
6b6b4792 TG	282	}
	283
	284	#endif /* __LINUX_RWLOCK_API_SMP_H */