Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * Out of line spinlock code.
3 *
4 * Copyright IBM Corp. 2004, 2006
5 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
6 */
7
8#include <linux/types.h>
9#include <linux/module.h>
10#include <linux/spinlock.h>
11#include <linux/init.h>
12#include <linux/smp.h>
13#include <asm/io.h>
14
15int spin_retry = -1;
16
17static int __init spin_retry_init(void)
18{
19 if (spin_retry < 0)
20 spin_retry = MACHINE_HAS_CAD ? 10 : 1000;
21 return 0;
22}
23early_initcall(spin_retry_init);
24
25/**
26 * spin_retry= parameter
27 */
28static int __init spin_retry_setup(char *str)
29{
30 spin_retry = simple_strtoul(str, &str, 0);
31 return 1;
32}
33__setup("spin_retry=", spin_retry_setup);
34
35static inline void _raw_compare_and_delay(unsigned int *lock, unsigned int old)
36{
37 asm(".insn rsy,0xeb0000000022,%0,0,%1" : : "d" (old), "Q" (*lock));
38}
39
40static inline int cpu_is_preempted(int cpu)
41{
42 if (test_cpu_flag_of(CIF_ENABLED_WAIT, cpu))
43 return 0;
44 if (smp_vcpu_scheduled(cpu))
45 return 0;
46 return 1;
47}
48
49void arch_spin_lock_wait(arch_spinlock_t *lp)
50{
51 unsigned int cpu = SPINLOCK_LOCKVAL;
52 unsigned int owner;
53 int count, first_diag;
54
55 first_diag = 1;
56 while (1) {
57 owner = ACCESS_ONCE(lp->lock);
58 /* Try to get the lock if it is free. */
59 if (!owner) {
60 if (_raw_compare_and_swap(&lp->lock, 0, cpu))
61 return;
62 continue;
63 }
64 /* First iteration: check if the lock owner is running. */
65 if (first_diag && cpu_is_preempted(~owner)) {
66 smp_yield_cpu(~owner);
67 first_diag = 0;
68 continue;
69 }
70 /* Loop for a while on the lock value. */
71 count = spin_retry;
72 do {
73 if (MACHINE_HAS_CAD)
74 _raw_compare_and_delay(&lp->lock, owner);
75 owner = ACCESS_ONCE(lp->lock);
76 } while (owner && count-- > 0);
77 if (!owner)
78 continue;
79 /*
80 * For multiple layers of hypervisors, e.g. z/VM + LPAR
81 * yield the CPU unconditionally. For LPAR rely on the
82 * sense running status.
83 */
84 if (!MACHINE_IS_LPAR || cpu_is_preempted(~owner)) {
85 smp_yield_cpu(~owner);
86 first_diag = 0;
87 }
88 }
89}
90EXPORT_SYMBOL(arch_spin_lock_wait);
91
92void arch_spin_lock_wait_flags(arch_spinlock_t *lp, unsigned long flags)
93{
94 unsigned int cpu = SPINLOCK_LOCKVAL;
95 unsigned int owner;
96 int count, first_diag;
97
98 local_irq_restore(flags);
99 first_diag = 1;
100 while (1) {
101 owner = ACCESS_ONCE(lp->lock);
102 /* Try to get the lock if it is free. */
103 if (!owner) {
104 local_irq_disable();
105 if (_raw_compare_and_swap(&lp->lock, 0, cpu))
106 return;
107 local_irq_restore(flags);
108 }
109 /* Check if the lock owner is running. */
110 if (first_diag && cpu_is_preempted(~owner)) {
111 smp_yield_cpu(~owner);
112 first_diag = 0;
113 continue;
114 }
115 /* Loop for a while on the lock value. */
116 count = spin_retry;
117 do {
118 if (MACHINE_HAS_CAD)
119 _raw_compare_and_delay(&lp->lock, owner);
120 owner = ACCESS_ONCE(lp->lock);
121 } while (owner && count-- > 0);
122 if (!owner)
123 continue;
124 /*
125 * For multiple layers of hypervisors, e.g. z/VM + LPAR
126 * yield the CPU unconditionally. For LPAR rely on the
127 * sense running status.
128 */
129 if (!MACHINE_IS_LPAR || cpu_is_preempted(~owner)) {
130 smp_yield_cpu(~owner);
131 first_diag = 0;
132 }
133 }
134}
135EXPORT_SYMBOL(arch_spin_lock_wait_flags);
136
137int arch_spin_trylock_retry(arch_spinlock_t *lp)
138{
139 unsigned int cpu = SPINLOCK_LOCKVAL;
140 unsigned int owner;
141 int count;
142
143 for (count = spin_retry; count > 0; count--) {
144 owner = ACCESS_ONCE(lp->lock);
145 /* Try to get the lock if it is free. */
146 if (!owner) {
147 if (_raw_compare_and_swap(&lp->lock, 0, cpu))
148 return 1;
149 } else if (MACHINE_HAS_CAD)
150 _raw_compare_and_delay(&lp->lock, owner);
151 }
152 return 0;
153}
154EXPORT_SYMBOL(arch_spin_trylock_retry);
155
156void _raw_read_lock_wait(arch_rwlock_t *rw)
157{
158 unsigned int owner, old;
159 int count = spin_retry;
160
161#ifdef CONFIG_HAVE_MARCH_Z196_FEATURES
162 __RAW_LOCK(&rw->lock, -1, __RAW_OP_ADD);
163#endif
164 owner = 0;
165 while (1) {
166 if (count-- <= 0) {
167 if (owner && cpu_is_preempted(~owner))
168 smp_yield_cpu(~owner);
169 count = spin_retry;
170 }
171 old = ACCESS_ONCE(rw->lock);
172 owner = ACCESS_ONCE(rw->owner);
173 if ((int) old < 0) {
174 if (MACHINE_HAS_CAD)
175 _raw_compare_and_delay(&rw->lock, old);
176 continue;
177 }
178 if (_raw_compare_and_swap(&rw->lock, old, old + 1))
179 return;
180 }
181}
182EXPORT_SYMBOL(_raw_read_lock_wait);
183
184int _raw_read_trylock_retry(arch_rwlock_t *rw)
185{
186 unsigned int old;
187 int count = spin_retry;
188
189 while (count-- > 0) {
190 old = ACCESS_ONCE(rw->lock);
191 if ((int) old < 0) {
192 if (MACHINE_HAS_CAD)
193 _raw_compare_and_delay(&rw->lock, old);
194 continue;
195 }
196 if (_raw_compare_and_swap(&rw->lock, old, old + 1))
197 return 1;
198 }
199 return 0;
200}
201EXPORT_SYMBOL(_raw_read_trylock_retry);
202
203#ifdef CONFIG_HAVE_MARCH_Z196_FEATURES
204
205void _raw_write_lock_wait(arch_rwlock_t *rw, unsigned int prev)
206{
207 unsigned int owner, old;
208 int count = spin_retry;
209
210 owner = 0;
211 while (1) {
212 if (count-- <= 0) {
213 if (owner && cpu_is_preempted(~owner))
214 smp_yield_cpu(~owner);
215 count = spin_retry;
216 }
217 old = ACCESS_ONCE(rw->lock);
218 owner = ACCESS_ONCE(rw->owner);
219 smp_mb();
220 if ((int) old >= 0) {
221 prev = __RAW_LOCK(&rw->lock, 0x80000000, __RAW_OP_OR);
222 old = prev;
223 }
224 if ((old & 0x7fffffff) == 0 && (int) prev >= 0)
225 break;
226 if (MACHINE_HAS_CAD)
227 _raw_compare_and_delay(&rw->lock, old);
228 }
229}
230EXPORT_SYMBOL(_raw_write_lock_wait);
231
232#else /* CONFIG_HAVE_MARCH_Z196_FEATURES */
233
234void _raw_write_lock_wait(arch_rwlock_t *rw)
235{
236 unsigned int owner, old, prev;
237 int count = spin_retry;
238
239 prev = 0x80000000;
240 owner = 0;
241 while (1) {
242 if (count-- <= 0) {
243 if (owner && cpu_is_preempted(~owner))
244 smp_yield_cpu(~owner);
245 count = spin_retry;
246 }
247 old = ACCESS_ONCE(rw->lock);
248 owner = ACCESS_ONCE(rw->owner);
249 if ((int) old >= 0 &&
250 _raw_compare_and_swap(&rw->lock, old, old | 0x80000000))
251 prev = old;
252 else
253 smp_mb();
254 if ((old & 0x7fffffff) == 0 && (int) prev >= 0)
255 break;
256 if (MACHINE_HAS_CAD)
257 _raw_compare_and_delay(&rw->lock, old);
258 }
259}
260EXPORT_SYMBOL(_raw_write_lock_wait);
261
262#endif /* CONFIG_HAVE_MARCH_Z196_FEATURES */
263
264int _raw_write_trylock_retry(arch_rwlock_t *rw)
265{
266 unsigned int old;
267 int count = spin_retry;
268
269 while (count-- > 0) {
270 old = ACCESS_ONCE(rw->lock);
271 if (old) {
272 if (MACHINE_HAS_CAD)
273 _raw_compare_and_delay(&rw->lock, old);
274 continue;
275 }
276 if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000))
277 return 1;
278 }
279 return 0;
280}
281EXPORT_SYMBOL(_raw_write_trylock_retry);
282
283void arch_lock_relax(unsigned int cpu)
284{
285 if (!cpu)
286 return;
287 if (MACHINE_IS_LPAR && !cpu_is_preempted(~cpu))
288 return;
289 smp_yield_cpu(~cpu);
290}
291EXPORT_SYMBOL(arch_lock_relax);