WebSVN – Kolibri OS – Blame – /drivers/include/linux/rwsem.h

Rev	Author	Line No.	Line
5272	serge	1	/* rwsem.h: R/W semaphores, public interface
		2	*
		3	* Written by David Howells (dhowells@redhat.com).
		4	* Derived from asm-i386/semaphore.h
		5	*/
		6
		7	#ifndef _LINUX_RWSEM_H
		8	#define _LINUX_RWSEM_H
		9
		10	#include
		11
		12	#include
		13	#include
		14	#include
		15	#include
		16	#include
		17	#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
		18	#include
		19	#endif
		20
		21	struct rw_semaphore;
		22
		23	#ifdef CONFIG_RWSEM_GENERIC_SPINLOCK
		24	#include /* use a generic implementation */
		25	#else
		26	/* All arch specific implementations share the same struct */
		27	struct rw_semaphore {
5345	serge	28	struct list_head wait_list;
5272	serge	29	long count;
		30	raw_spinlock_t wait_lock;
		31	#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
		32	struct optimistic_spin_queue osq; /* spinner MCS lock */
		33	/*
		34	* Write owner. Used as a speculative check to see
		35	* if the owner is running on the cpu.
		36	*/
		37	struct task_struct *owner;
		38	#endif
		39	#ifdef CONFIG_DEBUG_LOCK_ALLOC
		40	struct lockdep_map dep_map;
		41	#endif
		42	};
		43
		44	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
		45	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
		46	extern struct rw_semaphore rwsem_wake(struct rw_semaphore );
		47	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
		48
		49	/* Include the arch specific part */
		50	#include
		51
		52	/* In all implementations count != 0 means locked */
		53	static inline int rwsem_is_locked(struct rw_semaphore *sem)
		54	{
		55	return sem->count != 0;
		56	}
		57
		58	#endif
		59
		60	/* Common initializer macros and functions */
		61
		62	#ifdef CONFIG_DEBUG_LOCK_ALLOC
		63	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
		64	#else
		65	# define __RWSEM_DEP_MAP_INIT(lockname)
		66	#endif
		67
		68	#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
		69	#define __RWSEM_OPT_INIT(lockname) , .osq = OSQ_LOCK_UNLOCKED, .owner = NULL
		70	#else
		71	#define __RWSEM_OPT_INIT(lockname)
		72	#endif
		73
		74	#define __RWSEM_INITIALIZER(name) \
		75	{ .count = RWSEM_UNLOCKED_VALUE, \
		76	.wait_list = LIST_HEAD_INIT((name).wait_list), \
		77	.wait_lock = __RAW_SPIN_LOCK_UNLOCKED(name.wait_lock) \
		78	__RWSEM_OPT_INIT(name) \
		79	__RWSEM_DEP_MAP_INIT(name) }
		80
		81	#define DECLARE_RWSEM(name) \
		82	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
		83
		84	extern void __init_rwsem(struct rw_semaphore sem, const char name,
		85	struct lock_class_key *key);
		86
		87	#define init_rwsem(sem) \
		88	do { \
		89	static struct lock_class_key __key; \
		90	\
		91	__init_rwsem((sem), #sem, &__key); \
		92	} while (0)
		93
		94	/*
		95	* This is the same regardless of which rwsem implementation that is being used.
		96	* It is just a heuristic meant to be called by somebody alreadying holding the
		97	* rwsem to see if somebody from an incompatible type is wanting access to the
		98	* lock.
		99	*/
		100	static inline int rwsem_is_contended(struct rw_semaphore *sem)
		101	{
		102	return !list_empty(&sem->wait_list);
		103	}
		104
		105	/*
		106	* lock for reading
		107	*/
		108	extern void down_read(struct rw_semaphore *sem);
		109
		110	/*
		111	* trylock for reading -- returns 1 if successful, 0 if contention
		112	*/
		113	extern int down_read_trylock(struct rw_semaphore *sem);
		114
		115	/*
		116	* lock for writing
		117	*/
		118	extern void down_write(struct rw_semaphore *sem);
		119
		120	/*
		121	* trylock for writing -- returns 1 if successful, 0 if contention
		122	*/
		123	extern int down_write_trylock(struct rw_semaphore *sem);
		124
		125	/*
		126	* release a read lock
		127	*/
		128	extern void up_read(struct rw_semaphore *sem);
		129
		130	/*
		131	* release a write lock
		132	*/
		133	extern void up_write(struct rw_semaphore *sem);
		134
		135	/*
		136	* downgrade write lock to read lock
		137	*/
		138	extern void downgrade_write(struct rw_semaphore *sem);
		139
		140	#ifdef CONFIG_DEBUG_LOCK_ALLOC
		141	/*
		142	* nested locking. NOTE: rwsems are not allowed to recurse
		143	* (which occurs if the same task tries to acquire the same
		144	* lock instance multiple times), but multiple locks of the
		145	* same lock class might be taken, if the order of the locks
		146	* is always the same. This ordering rule can be expressed
		147	* to lockdep via the _nested() APIs, but enumerating the
		148	* subclasses that are used. (If the nesting relationship is
		149	* static then another method for expressing nested locking is
		150	* the explicit definition of lock class keys and the use of
		151	* lockdep_set_class() at lock initialization time.
		152	* See Documentation/locking/lockdep-design.txt for more details.)
		153	*/
		154	extern void down_read_nested(struct rw_semaphore *sem, int subclass);
		155	extern void down_write_nested(struct rw_semaphore *sem, int subclass);
		156	extern void _down_write_nest_lock(struct rw_semaphore sem, struct lockdep_map nest_lock);
		157
		158	# define down_write_nest_lock(sem, nest_lock) \
		159	do { \
		160	typecheck(struct lockdep_map *, &(nest_lock)->dep_map); \
		161	_down_write_nest_lock(sem, &(nest_lock)->dep_map); \
		162	} while (0);
		163
		164	/*
		165	* Take/release a lock when not the owner will release it.
		166	*
		167	* [ This API should be avoided as much as possible - the
		168	* proper abstraction for this case is completions. ]
		169	*/
		170	extern void down_read_non_owner(struct rw_semaphore *sem);
		171	extern void up_read_non_owner(struct rw_semaphore *sem);
		172	#else
		173	# define down_read_nested(sem, subclass) down_read(sem)
		174	# define down_write_nest_lock(sem, nest_lock) down_write(sem)
		175	# define down_write_nested(sem, subclass) down_write(sem)
		176	# define down_read_non_owner(sem) down_read(sem)
		177	# define up_read_non_owner(sem) up_read(sem)
		178	#endif
		179
		180	#endif /* _LINUX_RWSEM_H */

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/rwsem.h – Rev 5588