[mirror_ubuntu-bionic-kernel.git] / include / asm-s390 / rwsem.h

#ifndef _S390_RWSEM_H
#define _S390_RWSEM_H

/*
 *  include/asm-s390/rwsem.h
 *
 *  S390 version
 *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
 *
 *  Based on asm-alpha/semaphore.h and asm-i386/rwsem.h
 */

/*
 *
 * The MSW of the count is the negated number of active writers and waiting
 * lockers, and the LSW is the total number of active locks
 *
 * The lock count is initialized to 0 (no active and no waiting lockers).
 *
 * When a writer subtracts WRITE_BIAS, it'll get 0xffff0001 for the case of an
 * uncontended lock. This can be determined because XADD returns the old value.
 * Readers increment by 1 and see a positive value when uncontended, negative
 * if there are writers (and maybe) readers waiting (in which case it goes to
 * sleep).
 *
 * The value of WAITING_BIAS supports up to 32766 waiting processes. This can
 * be extended to 65534 by manually checking the whole MSW rather than relying
 * on the S flag.
 *
 * The value of ACTIVE_BIAS supports up to 65535 active processes.
 *
 * This should be totally fair - if anything is waiting, a process that wants a
 * lock will go to the back of the queue. When the currently active lock is
 * released, if there's a writer at the front of the queue, then that and only
 * that will be woken up; if there's a bunch of consequtive readers at the
 * front, then they'll all be woken up, but no other readers will be.
 */

#ifndef _LINUX_RWSEM_H
#error "please don't include asm/rwsem.h directly, use linux/rwsem.h instead"
#endif

#ifdef __KERNEL__

#include <linux/list.h>
#include <linux/spinlock.h>

struct rwsem_waiter;

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

/*
 * the semaphore definition
 */
struct rw_semaphore {
	signed long		count;
	spinlock_t		wait_lock;
	struct list_head	wait_list;
};

#ifndef __s390x__
#define RWSEM_UNLOCKED_VALUE	0x00000000
#define RWSEM_ACTIVE_BIAS	0x00000001
#define RWSEM_ACTIVE_MASK	0x0000ffff
#define RWSEM_WAITING_BIAS	(-0x00010000)
#else /* __s390x__ */
#define RWSEM_UNLOCKED_VALUE	0x0000000000000000L
#define RWSEM_ACTIVE_BIAS	0x0000000000000001L
#define RWSEM_ACTIVE_MASK	0x00000000ffffffffL
#define RWSEM_WAITING_BIAS	(-0x0000000100000000L)
#endif /* __s390x__ */
#define RWSEM_ACTIVE_READ_BIAS	RWSEM_ACTIVE_BIAS
#define RWSEM_ACTIVE_WRITE_BIAS	(RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)

/*
 * initialisation
 */
#define __RWSEM_INITIALIZER(name) \
{ RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) }

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

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);
}

/*
 * lock for reading
 */
static inline void __down_read(struct rw_semaphore *sem)
{
	signed long old, new;

	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   ahi  %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   aghi %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count),
		  "i" (RWSEM_ACTIVE_READ_BIAS) : "cc", "memory" );
	if (old < 0)
		rwsem_down_read_failed(sem);
}

/*
 * trylock for reading -- returns 1 if successful, 0 if contention
 */
static inline int __down_read_trylock(struct rw_semaphore *sem)
{
	signed long old, new;

	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: ltr  %1,%0\n"
		"   jm   1f\n"
		"   ahi  %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b\n"
		"1:"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: ltgr %1,%0\n"
		"   jm   1f\n"
		"   aghi %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b\n"
		"1:"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count),
		  "i" (RWSEM_ACTIVE_READ_BIAS) : "cc", "memory" );
	return old >= 0 ? 1 : 0;
}

/*
 * lock for writing
 */
static inline void __down_write(struct rw_semaphore *sem)
{
	signed long old, new, tmp;

	tmp = RWSEM_ACTIVE_WRITE_BIAS;
	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   a    %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   ag   %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count), "m" (tmp)
		: "cc", "memory" );
	if (old != 0)
		rwsem_down_write_failed(sem);
}

/*
 * trylock for writing -- returns 1 if successful, 0 if contention
 */
static inline int __down_write_trylock(struct rw_semaphore *sem)
{
	signed long old;

	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%2)\n"
		"0: ltr  %0,%0\n"
		"   jnz  1f\n"
		"   cs   %0,%4,0(%2)\n"
		"   jl   0b\n"
#else /* __s390x__ */
		"   lg   %0,0(%2)\n"
		"0: ltgr %0,%0\n"
		"   jnz  1f\n"
		"   csg  %0,%4,0(%2)\n"
		"   jl   0b\n"
#endif /* __s390x__ */
		"1:"
                : "=&d" (old), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count),
		  "d" (RWSEM_ACTIVE_WRITE_BIAS) : "cc", "memory" );
	return (old == RWSEM_UNLOCKED_VALUE) ? 1 : 0;
}

/*
 * unlock after reading
 */
static inline void __up_read(struct rw_semaphore *sem)
{
	signed long old, new;

	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   ahi  %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   aghi %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count),
		  "i" (-RWSEM_ACTIVE_READ_BIAS)
		: "cc", "memory" );
	if (new < 0)
		if ((new & RWSEM_ACTIVE_MASK) == 0)
			rwsem_wake(sem);
}

/*
 * unlock after writing
 */
static inline void __up_write(struct rw_semaphore *sem)
{
	signed long old, new, tmp;

	tmp = -RWSEM_ACTIVE_WRITE_BIAS;
	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   a    %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   ag   %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count), "m" (tmp)
		: "cc", "memory" );
	if (new < 0)
		if ((new & RWSEM_ACTIVE_MASK) == 0)
			rwsem_wake(sem);
}

/*
 * downgrade write lock to read lock
 */
static inline void __downgrade_write(struct rw_semaphore *sem)
{
	signed long old, new, tmp;

	tmp = -RWSEM_WAITING_BIAS;
	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   a    %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   ag   %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count), "m" (tmp)
		: "cc", "memory" );
	if (new > 1)
		rwsem_downgrade_wake(sem);
}

/*
 * implement atomic add functionality
 */
static inline void rwsem_atomic_add(long delta, struct rw_semaphore *sem)
{
	signed long old, new;

	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   ar   %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   agr  %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count), "d" (delta)
		: "cc", "memory" );
}

/*
 * implement exchange and add functionality
 */
static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem)
{
	signed long old, new;

	__asm__ __volatile__(
#ifndef __s390x__
		"   l    %0,0(%3)\n"
		"0: lr   %1,%0\n"
		"   ar   %1,%5\n"
		"   cs   %0,%1,0(%3)\n"
		"   jl   0b"
#else /* __s390x__ */
		"   lg   %0,0(%3)\n"
		"0: lgr  %1,%0\n"
		"   agr  %1,%5\n"
		"   csg  %0,%1,0(%3)\n"
		"   jl   0b"
#endif /* __s390x__ */
                : "=&d" (old), "=&d" (new), "=m" (sem->count)
		: "a" (&sem->count), "m" (sem->count), "d" (delta)
		: "cc", "memory" );
	return new;
}

#endif /* __KERNEL__ */
#endif /* _S390_RWSEM_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _S390_RWSEM_H
	2	#define _S390_RWSEM_H
	3
	4	/*
	5	* include/asm-s390/rwsem.h
	6	*
	7	* S390 version
	8	* Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
	9	* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
	10	*
	11	* Based on asm-alpha/semaphore.h and asm-i386/rwsem.h
	12	*/
	13
	14	/*
	15	*
	16	* The MSW of the count is the negated number of active writers and waiting
	17	* lockers, and the LSW is the total number of active locks
	18	*
	19	* The lock count is initialized to 0 (no active and no waiting lockers).
	20	*
	21	* When a writer subtracts WRITE_BIAS, it'll get 0xffff0001 for the case of an
	22	* uncontended lock. This can be determined because XADD returns the old value.
	23	* Readers increment by 1 and see a positive value when uncontended, negative
	24	* if there are writers (and maybe) readers waiting (in which case it goes to
	25	* sleep).
	26	*
	27	* The value of WAITING_BIAS supports up to 32766 waiting processes. This can
	28	* be extended to 65534 by manually checking the whole MSW rather than relying
	29	* on the S flag.
	30	*
	31	* The value of ACTIVE_BIAS supports up to 65535 active processes.
	32	*
	33	* This should be totally fair - if anything is waiting, a process that wants a
	34	* lock will go to the back of the queue. When the currently active lock is
	35	* released, if there's a writer at the front of the queue, then that and only
	36	* that will be woken up; if there's a bunch of consequtive readers at the
	37	* front, then they'll all be woken up, but no other readers will be.
	38	*/
	39
	40	#ifndef _LINUX_RWSEM_H
	41	#error "please don't include asm/rwsem.h directly, use linux/rwsem.h instead"
	42	#endif
	43
	44	#ifdef __KERNEL__
	45
	46	#include <linux/list.h>
	47	#include <linux/spinlock.h>
	48
	49	struct rwsem_waiter;
	50
	51	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore );
	52	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore );
	53	extern struct rw_semaphore rwsem_wake(struct rw_semaphore );
	54	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore );
	55	extern struct rw_semaphore rwsem_downgrade_write(struct rw_semaphore );
	56
	57	/*
	58	* the semaphore definition
	59	*/
	60	struct rw_semaphore {
	61	signed long count;
	62	spinlock_t wait_lock;
	63	struct list_head wait_list;
	64	};
65
66	#ifndef __s390x__
67	#define RWSEM_UNLOCKED_VALUE 0x00000000
68	#define RWSEM_ACTIVE_BIAS 0x00000001
69	#define RWSEM_ACTIVE_MASK 0x0000ffff
70	#define RWSEM_WAITING_BIAS (-0x00010000)
71	#else /* __s390x__ */
72	#define RWSEM_UNLOCKED_VALUE 0x0000000000000000L
73	#define RWSEM_ACTIVE_BIAS 0x0000000000000001L
74	#define RWSEM_ACTIVE_MASK 0x00000000ffffffffL
75	#define RWSEM_WAITING_BIAS (-0x0000000100000000L)
76	#endif /* __s390x__ */
77	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
78	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
79
80	/*
81	* initialisation
82	*/
83	#define __RWSEM_INITIALIZER(name) \
84	{ RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) }
85
86	#define DECLARE_RWSEM(name) \
87	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
88
89	static inline void init_rwsem(struct rw_semaphore *sem)
90	{
91	sem->count = RWSEM_UNLOCKED_VALUE;
92	spin_lock_init(&sem->wait_lock);
93	INIT_LIST_HEAD(&sem->wait_list);
94	}
95
96	/*
97	* lock for reading
98	*/
99	static inline void __down_read(struct rw_semaphore *sem)
100	{
101	signed long old, new;
102
103	__asm__ __volatile__(
104	#ifndef __s390x__
105	" l %0,0(%3)\n"
106	"0: lr %1,%0\n"
107	" ahi %1,%5\n"
108	" cs %0,%1,0(%3)\n"
109	" jl 0b"
110	#else /* __s390x__ */
111	" lg %0,0(%3)\n"
112	"0: lgr %1,%0\n"
113	" aghi %1,%5\n"
114	" csg %0,%1,0(%3)\n"
115	" jl 0b"
116	#endif /* __s390x__ */
117	: "=&d" (old), "=&d" (new), "=m" (sem->count)
118	: "a" (&sem->count), "m" (sem->count),
119	"i" (RWSEM_ACTIVE_READ_BIAS) : "cc", "memory" );
120	if (old < 0)
121	rwsem_down_read_failed(sem);
122	}
123
124	/*
125	* trylock for reading -- returns 1 if successful, 0 if contention
126	*/
127	static inline int __down_read_trylock(struct rw_semaphore *sem)
128	{
129	signed long old, new;
130
131	__asm__ __volatile__(
132	#ifndef __s390x__
133	" l %0,0(%3)\n"
134	"0: ltr %1,%0\n"
135	" jm 1f\n"
136	" ahi %1,%5\n"
137	" cs %0,%1,0(%3)\n"
138	" jl 0b\n"
139	"1:"
140	#else /* __s390x__ */
141	" lg %0,0(%3)\n"
142	"0: ltgr %1,%0\n"
143	" jm 1f\n"
144	" aghi %1,%5\n"
145	" csg %0,%1,0(%3)\n"
146	" jl 0b\n"
147	"1:"
148	#endif /* __s390x__ */
149	: "=&d" (old), "=&d" (new), "=m" (sem->count)
150	: "a" (&sem->count), "m" (sem->count),
151	"i" (RWSEM_ACTIVE_READ_BIAS) : "cc", "memory" );
152	return old >= 0 ? 1 : 0;
153	}
154
155	/*
156	* lock for writing
157	*/
158	static inline void __down_write(struct rw_semaphore *sem)
159	{
160	signed long old, new, tmp;
161
162	tmp = RWSEM_ACTIVE_WRITE_BIAS;
163	__asm__ __volatile__(
164	#ifndef __s390x__
165	" l %0,0(%3)\n"
166	"0: lr %1,%0\n"
167	" a %1,%5\n"
168	" cs %0,%1,0(%3)\n"
169	" jl 0b"
170	#else /* __s390x__ */
171	" lg %0,0(%3)\n"
172	"0: lgr %1,%0\n"
173	" ag %1,%5\n"
174	" csg %0,%1,0(%3)\n"
175	" jl 0b"
176	#endif /* __s390x__ */
177	: "=&d" (old), "=&d" (new), "=m" (sem->count)
178	: "a" (&sem->count), "m" (sem->count), "m" (tmp)
179	: "cc", "memory" );
180	if (old != 0)
181	rwsem_down_write_failed(sem);
182	}
183
184	/*
185	* trylock for writing -- returns 1 if successful, 0 if contention
186	*/
187	static inline int __down_write_trylock(struct rw_semaphore *sem)
188	{
189	signed long old;
190
191	__asm__ __volatile__(
192	#ifndef __s390x__
193	" l %0,0(%2)\n"
194	"0: ltr %0,%0\n"
195	" jnz 1f\n"
196	" cs %0,%4,0(%2)\n"
197	" jl 0b\n"
198	#else /* __s390x__ */
199	" lg %0,0(%2)\n"
200	"0: ltgr %0,%0\n"
201	" jnz 1f\n"
202	" csg %0,%4,0(%2)\n"
203	" jl 0b\n"
204	#endif /* __s390x__ */
205	"1:"
206	: "=&d" (old), "=m" (sem->count)
207	: "a" (&sem->count), "m" (sem->count),
208	"d" (RWSEM_ACTIVE_WRITE_BIAS) : "cc", "memory" );
209	return (old == RWSEM_UNLOCKED_VALUE) ? 1 : 0;
210	}
211
212	/*
213	* unlock after reading
214	*/
215	static inline void __up_read(struct rw_semaphore *sem)
216	{
217	signed long old, new;
218
219	__asm__ __volatile__(
220	#ifndef __s390x__
221	" l %0,0(%3)\n"
222	"0: lr %1,%0\n"
223	" ahi %1,%5\n"
224	" cs %0,%1,0(%3)\n"
225	" jl 0b"
226	#else /* __s390x__ */
227	" lg %0,0(%3)\n"
228	"0: lgr %1,%0\n"
229	" aghi %1,%5\n"
230	" csg %0,%1,0(%3)\n"
231	" jl 0b"
232	#endif /* __s390x__ */
233	: "=&d" (old), "=&d" (new), "=m" (sem->count)
234	: "a" (&sem->count), "m" (sem->count),
235	"i" (-RWSEM_ACTIVE_READ_BIAS)
236	: "cc", "memory" );
237	if (new < 0)
238	if ((new & RWSEM_ACTIVE_MASK) == 0)
239	rwsem_wake(sem);
240	}
241
242	/*
243	* unlock after writing
244	*/
245	static inline void __up_write(struct rw_semaphore *sem)
246	{
247	signed long old, new, tmp;
248
249	tmp = -RWSEM_ACTIVE_WRITE_BIAS;
250	__asm__ __volatile__(
251	#ifndef __s390x__
252	" l %0,0(%3)\n"
253	"0: lr %1,%0\n"
254	" a %1,%5\n"
255	" cs %0,%1,0(%3)\n"
256	" jl 0b"
257	#else /* __s390x__ */
258	" lg %0,0(%3)\n"
259	"0: lgr %1,%0\n"
260	" ag %1,%5\n"
261	" csg %0,%1,0(%3)\n"
262	" jl 0b"
263	#endif /* __s390x__ */
264	: "=&d" (old), "=&d" (new), "=m" (sem->count)
265	: "a" (&sem->count), "m" (sem->count), "m" (tmp)
266	: "cc", "memory" );
267	if (new < 0)
268	if ((new & RWSEM_ACTIVE_MASK) == 0)
269	rwsem_wake(sem);
270	}
271
272	/*
273	* downgrade write lock to read lock
274	*/
275	static inline void __downgrade_write(struct rw_semaphore *sem)
276	{
277	signed long old, new, tmp;
278
279	tmp = -RWSEM_WAITING_BIAS;
280	__asm__ __volatile__(
281	#ifndef __s390x__
282	" l %0,0(%3)\n"
283	"0: lr %1,%0\n"
284	" a %1,%5\n"
285	" cs %0,%1,0(%3)\n"
286	" jl 0b"
287	#else /* __s390x__ */
288	" lg %0,0(%3)\n"
289	"0: lgr %1,%0\n"
290	" ag %1,%5\n"
291	" csg %0,%1,0(%3)\n"
292	" jl 0b"
293	#endif /* __s390x__ */
294	: "=&d" (old), "=&d" (new), "=m" (sem->count)
295	: "a" (&sem->count), "m" (sem->count), "m" (tmp)
296	: "cc", "memory" );
297	if (new > 1)
298	rwsem_downgrade_wake(sem);
299	}
300
301	/*
302	* implement atomic add functionality
303	*/
304	static inline void rwsem_atomic_add(long delta, struct rw_semaphore *sem)
305	{
306	signed long old, new;
307
308	__asm__ __volatile__(
309	#ifndef __s390x__
310	" l %0,0(%3)\n"
311	"0: lr %1,%0\n"
312	" ar %1,%5\n"
313	" cs %0,%1,0(%3)\n"
314	" jl 0b"
315	#else /* __s390x__ */
316	" lg %0,0(%3)\n"
317	"0: lgr %1,%0\n"
318	" agr %1,%5\n"
319	" csg %0,%1,0(%3)\n"
320	" jl 0b"
321	#endif /* __s390x__ */
322	: "=&d" (old), "=&d" (new), "=m" (sem->count)
323	: "a" (&sem->count), "m" (sem->count), "d" (delta)
324	: "cc", "memory" );
325	}
326
327	/*
328	* implement exchange and add functionality
329	*/
330	static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem)
331	{
332	signed long old, new;
333
334	__asm__ __volatile__(
335	#ifndef __s390x__
336	" l %0,0(%3)\n"
337	"0: lr %1,%0\n"
338	" ar %1,%5\n"
339	" cs %0,%1,0(%3)\n"
340	" jl 0b"
341	#else /* __s390x__ */
342	" lg %0,0(%3)\n"
343	"0: lgr %1,%0\n"
344	" agr %1,%5\n"
345	" csg %0,%1,0(%3)\n"
346	" jl 0b"
347	#endif /* __s390x__ */
348	: "=&d" (old), "=&d" (new), "=m" (sem->count)
349	: "a" (&sem->count), "m" (sem->count), "d" (delta)
350	: "cc", "memory" );
351	return new;
352	}
353
354	#endif /* __KERNEL__ */
355	#endif /* _S390_RWSEM_H */