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

#ifndef __LINUX_RWLOCK_H
#define __LINUX_RWLOCK_H

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

/*
 * rwlock related methods
 *
 * split out from spinlock.h
 *
 * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
 * Released under the General Public License (GPL).
 */

#ifdef CONFIG_DEBUG_SPINLOCK
  extern void __rwlock_init(rwlock_t *lock, const char *name,
			    struct lock_class_key *key);
# define rwlock_init(lock)					\
do {								\
	static struct lock_class_key __key;			\
								\
	__rwlock_init((lock), #lock, &__key);			\
} while (0)
#else
# define rwlock_init(lock)					\
	do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0)
#endif

#ifdef CONFIG_DEBUG_SPINLOCK
 extern void do_raw_read_lock(rwlock_t *lock) __acquires(lock);
#define do_raw_read_lock_flags(lock, flags) do_raw_read_lock(lock)
 extern int do_raw_read_trylock(rwlock_t *lock);
 extern void do_raw_read_unlock(rwlock_t *lock) __releases(lock);
 extern void do_raw_write_lock(rwlock_t *lock) __acquires(lock);
#define do_raw_write_lock_flags(lock, flags) do_raw_write_lock(lock)
 extern int do_raw_write_trylock(rwlock_t *lock);
 extern void do_raw_write_unlock(rwlock_t *lock) __releases(lock);
#else
# define do_raw_read_lock(rwlock)	do {__acquire(lock); arch_read_lock(&(rwlock)->raw_lock); } while (0)
# define do_raw_read_lock_flags(lock, flags) \
		do {__acquire(lock); arch_read_lock_flags(&(lock)->raw_lock, *(flags)); } while (0)
# define do_raw_read_trylock(rwlock)	arch_read_trylock(&(rwlock)->raw_lock)
# define do_raw_read_unlock(rwlock)	do {arch_read_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
# define do_raw_write_lock(rwlock)	do {__acquire(lock); arch_write_lock(&(rwlock)->raw_lock); } while (0)
# define do_raw_write_lock_flags(lock, flags) \
		do {__acquire(lock); arch_write_lock_flags(&(lock)->raw_lock, *(flags)); } while (0)
# define do_raw_write_trylock(rwlock)	arch_write_trylock(&(rwlock)->raw_lock)
# define do_raw_write_unlock(rwlock)	do {arch_write_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
#endif

#define read_can_lock(rwlock)		arch_read_can_lock(&(rwlock)->raw_lock)
#define write_can_lock(rwlock)		arch_write_can_lock(&(rwlock)->raw_lock)

/*
 * Define the various rw_lock methods.  Note we define these
 * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
 * methods are defined as nops in the case they are not required.
 */
#define read_trylock(lock)	__cond_lock(lock, _raw_read_trylock(lock))
#define write_trylock(lock)	__cond_lock(lock, _raw_write_trylock(lock))

#define write_lock(lock)	_raw_write_lock(lock)
#define read_lock(lock)		_raw_read_lock(lock)

#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)

#define read_lock_irqsave(lock, flags)			\
	do {						\
		typecheck(unsigned long, flags);	\
		flags = _raw_read_lock_irqsave(lock);	\
	} while (0)
#define write_lock_irqsave(lock, flags)			\
	do {						\
		typecheck(unsigned long, flags);	\
		flags = _raw_write_lock_irqsave(lock);	\
	} while (0)

#else

#define read_lock_irqsave(lock, flags)			\
	do {						\
		typecheck(unsigned long, flags);	\
		_raw_read_lock_irqsave(lock, flags);	\
	} while (0)
#define write_lock_irqsave(lock, flags)			\
	do {						\
		typecheck(unsigned long, flags);	\
		_raw_write_lock_irqsave(lock, flags);	\
	} while (0)

#endif

#define read_lock_irq(lock)		_raw_read_lock_irq(lock)
#define read_lock_bh(lock)		_raw_read_lock_bh(lock)
#define write_lock_irq(lock)		_raw_write_lock_irq(lock)
#define write_lock_bh(lock)		_raw_write_lock_bh(lock)
#define read_unlock(lock)		_raw_read_unlock(lock)
#define write_unlock(lock)		_raw_write_unlock(lock)
#define read_unlock_irq(lock)		_raw_read_unlock_irq(lock)
#define write_unlock_irq(lock)		_raw_write_unlock_irq(lock)

#define read_unlock_irqrestore(lock, flags)			\
	do {							\
		typecheck(unsigned long, flags);		\
		_raw_read_unlock_irqrestore(lock, flags);	\
	} while (0)
#define read_unlock_bh(lock)		_raw_read_unlock_bh(lock)

#define write_unlock_irqrestore(lock, flags)		\
	do {						\
		typecheck(unsigned long, flags);	\
		_raw_write_unlock_irqrestore(lock, flags);	\
	} while (0)
#define write_unlock_bh(lock)		_raw_write_unlock_bh(lock)

#define write_trylock_irqsave(lock, flags) \
({ \
	local_irq_save(flags); \
	write_trylock(lock) ? \
	1 : ({ local_irq_restore(flags); 0; }); \
})

#endif /* __LINUX_RWLOCK_H */
Commit	Line	Data
ef12f109 TG	1	#ifndef __LINUX_RWLOCK_H
	2	#define __LINUX_RWLOCK_H
	3
	4	#ifndef __LINUX_SPINLOCK_H
	5	# error "please don't include this file directly"
	6	#endif
	7
	8	/*
	9	* rwlock related methods
	10	*
	11	* split out from spinlock.h
	12	*
	13	* portions Copyright 2005, Red Hat, Inc., Ingo Molnar
	14	* Released under the General Public License (GPL).
	15	*/
	16
	17	#ifdef CONFIG_DEBUG_SPINLOCK
	18	extern void __rwlock_init(rwlock_t lock, const char name,
	19	struct lock_class_key *key);
	20	# define rwlock_init(lock) \
	21	do { \
	22	static struct lock_class_key __key; \
	23	\
	24	__rwlock_init((lock), #lock, &__key); \
	25	} while (0)
	26	#else
	27	# define rwlock_init(lock) \
	28	do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0)
	29	#endif
	30
	31	#ifdef CONFIG_DEBUG_SPINLOCK
b97c4bc1	32	extern void do_raw_read_lock(rwlock_t *lock) __acquires(lock);
9828ea9d TG	33	#define do_raw_read_lock_flags(lock, flags) do_raw_read_lock(lock)
9828ea9d TG	34	extern int do_raw_read_trylock(rwlock_t *lock);
b97c4bc1 LB	35	extern void do_raw_read_unlock(rwlock_t *lock) __releases(lock);
b97c4bc1 LB	36	extern void do_raw_write_lock(rwlock_t *lock) __acquires(lock);
9828ea9d TG	37	#define do_raw_write_lock_flags(lock, flags) do_raw_write_lock(lock)
9828ea9d TG	38	extern int do_raw_write_trylock(rwlock_t *lock);
b97c4bc1	39	extern void do_raw_write_unlock(rwlock_t *lock) __releases(lock);
ef12f109	40	#else
b97c4bc1	41	# define do_raw_read_lock(rwlock) do {__acquire(lock); arch_read_lock(&(rwlock)->raw_lock); } while (0)
9828ea9d	42	# define do_raw_read_lock_flags(lock, flags) \
b97c4bc1	43	do {__acquire(lock); arch_read_lock_flags(&(lock)->raw_lock, *(flags)); } while (0)
9828ea9d	44	# define do_raw_read_trylock(rwlock) arch_read_trylock(&(rwlock)->raw_lock)
b97c4bc1 LB	45	# define do_raw_read_unlock(rwlock) do {arch_read_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
b97c4bc1 LB	46	# define do_raw_write_lock(rwlock) do {__acquire(lock); arch_write_lock(&(rwlock)->raw_lock); } while (0)
9828ea9d	47	# define do_raw_write_lock_flags(lock, flags) \
b97c4bc1	48	do {__acquire(lock); arch_write_lock_flags(&(lock)->raw_lock, *(flags)); } while (0)
9828ea9d	49	# define do_raw_write_trylock(rwlock) arch_write_trylock(&(rwlock)->raw_lock)
b97c4bc1	50	# define do_raw_write_unlock(rwlock) do {arch_write_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
ef12f109 TG	51	#endif
ef12f109 TG	52
e5931943 TG	53	#define read_can_lock(rwlock) arch_read_can_lock(&(rwlock)->raw_lock)
e5931943 TG	54	#define write_can_lock(rwlock) arch_write_can_lock(&(rwlock)->raw_lock)
ef12f109 TG	55
	56	/*
	57	* Define the various rw_lock methods. Note we define these
	58	* regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
	59	* methods are defined as nops in the case they are not required.
	60	*/
9c1721aa TG	61	#define read_trylock(lock) __cond_lock(lock, _raw_read_trylock(lock))
9c1721aa TG	62	#define write_trylock(lock) __cond_lock(lock, _raw_write_trylock(lock))
ef12f109	63
9c1721aa TG	64	#define write_lock(lock) _raw_write_lock(lock)
9c1721aa TG	65	#define read_lock(lock) _raw_read_lock(lock)
ef12f109 TG	66
	67	#if defined(CONFIG_SMP) \|\| defined(CONFIG_DEBUG_SPINLOCK)
	68
	69	#define read_lock_irqsave(lock, flags) \
	70	do { \
	71	typecheck(unsigned long, flags); \
9c1721aa	72	flags = _raw_read_lock_irqsave(lock); \
ef12f109 TG	73	} while (0)
	74	#define write_lock_irqsave(lock, flags) \
	75	do { \
	76	typecheck(unsigned long, flags); \
9c1721aa	77	flags = _raw_write_lock_irqsave(lock); \
ef12f109 TG	78	} while (0)
	79
	80	#else
	81
	82	#define read_lock_irqsave(lock, flags) \
	83	do { \
	84	typecheck(unsigned long, flags); \
9c1721aa	85	_raw_read_lock_irqsave(lock, flags); \
ef12f109 TG	86	} while (0)
	87	#define write_lock_irqsave(lock, flags) \
	88	do { \
	89	typecheck(unsigned long, flags); \
9c1721aa	90	_raw_write_lock_irqsave(lock, flags); \
ef12f109 TG	91	} while (0)
	92
	93	#endif
	94
9c1721aa TG	95	#define read_lock_irq(lock) _raw_read_lock_irq(lock)
	96	#define read_lock_bh(lock) _raw_read_lock_bh(lock)
	97	#define write_lock_irq(lock) _raw_write_lock_irq(lock)
	98	#define write_lock_bh(lock) _raw_write_lock_bh(lock)
	99	#define read_unlock(lock) _raw_read_unlock(lock)
	100	#define write_unlock(lock) _raw_write_unlock(lock)
	101	#define read_unlock_irq(lock) _raw_read_unlock_irq(lock)
	102	#define write_unlock_irq(lock) _raw_write_unlock_irq(lock)
	103
	104	#define read_unlock_irqrestore(lock, flags) \
	105	do { \
	106	typecheck(unsigned long, flags); \
	107	_raw_read_unlock_irqrestore(lock, flags); \
ef12f109	108	} while (0)
9c1721aa	109	#define read_unlock_bh(lock) _raw_read_unlock_bh(lock)
ef12f109 TG	110
	111	#define write_unlock_irqrestore(lock, flags) \
	112	do { \
	113	typecheck(unsigned long, flags); \
9c1721aa	114	_raw_write_unlock_irqrestore(lock, flags); \
ef12f109	115	} while (0)
9c1721aa	116	#define write_unlock_bh(lock) _raw_write_unlock_bh(lock)
ef12f109 TG	117
	118	#define write_trylock_irqsave(lock, flags) \
	119	({ \
	120	local_irq_save(flags); \
	121	write_trylock(lock) ? \
	122	1 : ({ local_irq_restore(flags); 0; }); \
	123	})
	124
	125	#endif /* __LINUX_RWLOCK_H */