[linux-2.6-block.git] / include / asm-ppc64 / rwsem.h

/*
 * include/asm-ppc64/rwsem.h: R/W semaphores for PPC using the stuff
 * in lib/rwsem.c.  Adapted largely from include/asm-i386/rwsem.h
 * by Paul Mackerras <paulus@samba.org>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#ifndef _PPC64_RWSEM_H
#define _PPC64_RWSEM_H

#ifdef __KERNEL__
#include <linux/list.h>
#include <linux/spinlock.h>
#include <asm/atomic.h>
#include <asm/system.h>

/*
 * the semaphore definition
 */
struct rw_semaphore {
	/* XXX this should be able to be an atomic_t  -- paulus */
	signed int		count;
#define RWSEM_UNLOCKED_VALUE		0x00000000
#define RWSEM_ACTIVE_BIAS		0x00000001
#define RWSEM_ACTIVE_MASK		0x0000ffff
#define RWSEM_WAITING_BIAS		(-0x00010000)
#define RWSEM_ACTIVE_READ_BIAS		RWSEM_ACTIVE_BIAS
#define RWSEM_ACTIVE_WRITE_BIAS		(RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
	spinlock_t		wait_lock;
	struct list_head	wait_list;
#if RWSEM_DEBUG
	int			debug;
#endif
};

/*
 * initialisation
 */
#if RWSEM_DEBUG
#define __RWSEM_DEBUG_INIT      , 0
#else
#define __RWSEM_DEBUG_INIT	/* */
#endif

#define __RWSEM_INITIALIZER(name) \
	{ RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, \
	  LIST_HEAD_INIT((name).wait_list) \
	  __RWSEM_DEBUG_INIT }

#define DECLARE_RWSEM(name)		\
	struct rw_semaphore name = __RWSEM_INITIALIZER(name)

extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_down_write_failed(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem);

static inline void init_rwsem(struct rw_semaphore *sem)
{
	sem->count = RWSEM_UNLOCKED_VALUE;
	spin_lock_init(&sem->wait_lock);
	INIT_LIST_HEAD(&sem->wait_list);
#if RWSEM_DEBUG
	sem->debug = 0;
#endif
}

/*
 * lock for reading
 */
static inline void __down_read(struct rw_semaphore *sem)
{
	if (unlikely(atomic_inc_return((atomic_t *)(&sem->count)) <= 0))
		rwsem_down_read_failed(sem);
}

static inline int __down_read_trylock(struct rw_semaphore *sem)
{
	int tmp;

	while ((tmp = sem->count) >= 0) {
		if (tmp == cmpxchg(&sem->count, tmp,
				   tmp + RWSEM_ACTIVE_READ_BIAS)) {
			return 1;
		}
	}
	return 0;
}

/*
 * lock for writing
 */
static inline void __down_write(struct rw_semaphore *sem)
{
	int tmp;

	tmp = atomic_add_return(RWSEM_ACTIVE_WRITE_BIAS,
				(atomic_t *)(&sem->count));
	if (unlikely(tmp != RWSEM_ACTIVE_WRITE_BIAS))
		rwsem_down_write_failed(sem);
}

static inline int __down_write_trylock(struct rw_semaphore *sem)
{
	int tmp;

	tmp = cmpxchg(&sem->count, RWSEM_UNLOCKED_VALUE,
		      RWSEM_ACTIVE_WRITE_BIAS);
	return tmp == RWSEM_UNLOCKED_VALUE;
}

/*
 * unlock after reading
 */
static inline void __up_read(struct rw_semaphore *sem)
{
	int tmp;

	tmp = atomic_dec_return((atomic_t *)(&sem->count));
	if (unlikely(tmp < -1 && (tmp & RWSEM_ACTIVE_MASK) == 0))
		rwsem_wake(sem);
}

/*
 * unlock after writing
 */
static inline void __up_write(struct rw_semaphore *sem)
{
	if (unlikely(atomic_sub_return(RWSEM_ACTIVE_WRITE_BIAS,
			      (atomic_t *)(&sem->count)) < 0))
		rwsem_wake(sem);
}

/*
 * implement atomic add functionality
 */
static inline void rwsem_atomic_add(int delta, struct rw_semaphore *sem)
{
	atomic_add(delta, (atomic_t *)(&sem->count));
}

/*
 * downgrade write lock to read lock
 */
static inline void __downgrade_write(struct rw_semaphore *sem)
{
	int tmp;

	tmp = atomic_add_return(-RWSEM_WAITING_BIAS, (atomic_t *)(&sem->count));
	if (tmp < 0)
		rwsem_downgrade_wake(sem);
}

/*
 * implement exchange and add functionality
 */
static inline int rwsem_atomic_update(int delta, struct rw_semaphore *sem)
{
	return atomic_add_return(delta, (atomic_t *)(&sem->count));
}

#endif /* __KERNEL__ */
#endif /* _PPC_RWSEM_XADD_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* include/asm-ppc64/rwsem.h: R/W semaphores for PPC using the stuff
	3	* in lib/rwsem.c. Adapted largely from include/asm-i386/rwsem.h
	4	* by Paul Mackerras <paulus@samba.org>.
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#ifndef _PPC64_RWSEM_H
	13	#define _PPC64_RWSEM_H
	14
	15	#ifdef __KERNEL__
	16	#include <linux/list.h>
	17	#include <linux/spinlock.h>
	18	#include <asm/atomic.h>
	19	#include <asm/system.h>
	20
	21	/*
	22	* the semaphore definition
	23	*/
	24	struct rw_semaphore {
	25	/* XXX this should be able to be an atomic_t -- paulus */
	26	signed int count;
	27	#define RWSEM_UNLOCKED_VALUE 0x00000000
	28	#define RWSEM_ACTIVE_BIAS 0x00000001
	29	#define RWSEM_ACTIVE_MASK 0x0000ffff
	30	#define RWSEM_WAITING_BIAS (-0x00010000)
	31	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
	32	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
	33	spinlock_t wait_lock;
	34	struct list_head wait_list;
	35	#if RWSEM_DEBUG
	36	int debug;
	37	#endif
	38	};
	39
	40	/*
	41	* initialisation
	42	*/
	43	#if RWSEM_DEBUG
	44	#define __RWSEM_DEBUG_INIT , 0
	45	#else
	46	#define __RWSEM_DEBUG_INIT /* */
	47	#endif
	48
	49	#define __RWSEM_INITIALIZER(name) \
	50	{ RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, \
	51	LIST_HEAD_INIT((name).wait_list) \
	52	__RWSEM_DEBUG_INIT }
	53
	54	#define DECLARE_RWSEM(name) \
	55	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
	56
	57	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
	58	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
	59	extern struct rw_semaphore rwsem_wake(struct rw_semaphore sem);
	60	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
	61
	62	static inline void init_rwsem(struct rw_semaphore *sem)
	63	{
	64	sem->count = RWSEM_UNLOCKED_VALUE;
65	spin_lock_init(&sem->wait_lock);
66	INIT_LIST_HEAD(&sem->wait_list);
67	#if RWSEM_DEBUG
68	sem->debug = 0;
69	#endif
70	}
71
72	/*
73	* lock for reading
74	*/
75	static inline void __down_read(struct rw_semaphore *sem)
76	{
77	if (unlikely(atomic_inc_return((atomic_t *)(&sem->count)) <= 0))
78	rwsem_down_read_failed(sem);
79	}
80
81	static inline int __down_read_trylock(struct rw_semaphore *sem)
82	{
83	int tmp;
84
85	while ((tmp = sem->count) >= 0) {
86	if (tmp == cmpxchg(&sem->count, tmp,
87	tmp + RWSEM_ACTIVE_READ_BIAS)) {
88	return 1;
89	}
90	}
91	return 0;
92	}
93
94	/*
95	* lock for writing
96	*/
97	static inline void __down_write(struct rw_semaphore *sem)
98	{
99	int tmp;
100
101	tmp = atomic_add_return(RWSEM_ACTIVE_WRITE_BIAS,
102	(atomic_t *)(&sem->count));
103	if (unlikely(tmp != RWSEM_ACTIVE_WRITE_BIAS))
104	rwsem_down_write_failed(sem);
105	}
106
107	static inline int __down_write_trylock(struct rw_semaphore *sem)
108	{
109	int tmp;
110
111	tmp = cmpxchg(&sem->count, RWSEM_UNLOCKED_VALUE,
112	RWSEM_ACTIVE_WRITE_BIAS);
113	return tmp == RWSEM_UNLOCKED_VALUE;
114	}
115
116	/*
117	* unlock after reading
118	*/
119	static inline void __up_read(struct rw_semaphore *sem)
120	{
121	int tmp;
122
123	tmp = atomic_dec_return((atomic_t *)(&sem->count));
124	if (unlikely(tmp < -1 && (tmp & RWSEM_ACTIVE_MASK) == 0))
125	rwsem_wake(sem);
126	}
127
128	/*
129	* unlock after writing
130	*/
131	static inline void __up_write(struct rw_semaphore *sem)
132	{
133	if (unlikely(atomic_sub_return(RWSEM_ACTIVE_WRITE_BIAS,
134	(atomic_t *)(&sem->count)) < 0))
135	rwsem_wake(sem);
136	}
137
138	/*
139	* implement atomic add functionality
140	*/
141	static inline void rwsem_atomic_add(int delta, struct rw_semaphore *sem)
142	{
143	atomic_add(delta, (atomic_t *)(&sem->count));
144	}
145
146	/*
147	* downgrade write lock to read lock
148	*/
149	static inline void __downgrade_write(struct rw_semaphore *sem)
150	{
151	int tmp;
152
153	tmp = atomic_add_return(-RWSEM_WAITING_BIAS, (atomic_t *)(&sem->count));
154	if (tmp < 0)
155	rwsem_downgrade_wake(sem);
156	}
157
158	/*
159	* implement exchange and add functionality
160	*/
161	static inline int rwsem_atomic_update(int delta, struct rw_semaphore *sem)
162	{
163	return atomic_add_return(delta, (atomic_t *)(&sem->count));
164	}
165
166	#endif /* __KERNEL__ */
167	#endif /* _PPC_RWSEM_XADD_H */