[mirror_ubuntu-bionic-kernel.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 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
ef12f109 TG	53	/*
	54	* Define the various rw_lock methods. Note we define these
	55	* regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
	56	* methods are defined as nops in the case they are not required.
	57	*/
9c1721aa TG	58	#define read_trylock(lock) __cond_lock(lock, _raw_read_trylock(lock))
9c1721aa TG	59	#define write_trylock(lock) __cond_lock(lock, _raw_write_trylock(lock))
ef12f109	60
9c1721aa TG	61	#define write_lock(lock) _raw_write_lock(lock)
9c1721aa TG	62	#define read_lock(lock) _raw_read_lock(lock)
ef12f109 TG	63
	64	#if defined(CONFIG_SMP) \|\| defined(CONFIG_DEBUG_SPINLOCK)
	65
	66	#define read_lock_irqsave(lock, flags) \
	67	do { \
	68	typecheck(unsigned long, flags); \
9c1721aa	69	flags = _raw_read_lock_irqsave(lock); \
ef12f109 TG	70	} while (0)
	71	#define write_lock_irqsave(lock, flags) \
	72	do { \
	73	typecheck(unsigned long, flags); \
9c1721aa	74	flags = _raw_write_lock_irqsave(lock); \
ef12f109 TG	75	} while (0)
	76
	77	#else
	78
	79	#define read_lock_irqsave(lock, flags) \
	80	do { \
	81	typecheck(unsigned long, flags); \
9c1721aa	82	_raw_read_lock_irqsave(lock, flags); \
ef12f109 TG	83	} while (0)
	84	#define write_lock_irqsave(lock, flags) \
	85	do { \
	86	typecheck(unsigned long, flags); \
9c1721aa	87	_raw_write_lock_irqsave(lock, flags); \
ef12f109 TG	88	} while (0)
	89
	90	#endif
	91
9c1721aa TG	92	#define read_lock_irq(lock) _raw_read_lock_irq(lock)
	93	#define read_lock_bh(lock) _raw_read_lock_bh(lock)
	94	#define write_lock_irq(lock) _raw_write_lock_irq(lock)
	95	#define write_lock_bh(lock) _raw_write_lock_bh(lock)
	96	#define read_unlock(lock) _raw_read_unlock(lock)
	97	#define write_unlock(lock) _raw_write_unlock(lock)
	98	#define read_unlock_irq(lock) _raw_read_unlock_irq(lock)
	99	#define write_unlock_irq(lock) _raw_write_unlock_irq(lock)
	100
	101	#define read_unlock_irqrestore(lock, flags) \
	102	do { \
	103	typecheck(unsigned long, flags); \
	104	_raw_read_unlock_irqrestore(lock, flags); \
ef12f109	105	} while (0)
9c1721aa	106	#define read_unlock_bh(lock) _raw_read_unlock_bh(lock)
ef12f109 TG	107
	108	#define write_unlock_irqrestore(lock, flags) \
	109	do { \
	110	typecheck(unsigned long, flags); \
9c1721aa	111	_raw_write_unlock_irqrestore(lock, flags); \
ef12f109	112	} while (0)
9c1721aa	113	#define write_unlock_bh(lock) _raw_write_unlock_bh(lock)
ef12f109 TG	114
	115	#define write_trylock_irqsave(lock, flags) \
	116	({ \
	117	local_irq_save(flags); \
	118	write_trylock(lock) ? \
	119	1 : ({ local_irq_restore(flags); 0; }); \
	120	})
	121
	122	#endif /* __LINUX_RWLOCK_H */