Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Out of line spinlock code.
4 *
5 * Copyright IBM Corp. 2004, 2006
6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
7 */
8
9#include <linux/types.h>
10#include <linux/export.h>
11#include <linux/spinlock.h>
12#include <linux/jiffies.h>
13#include <linux/init.h>
14#include <linux/smp.h>
15#include <linux/percpu.h>
16#include <linux/io.h>
17#include <asm/alternative.h>
18#include <asm/asm.h>
19
20int spin_retry = -1;
21
22static int __init spin_retry_init(void)
23{
24 if (spin_retry < 0)
25 spin_retry = 1000;
26 return 0;
27}
28early_initcall(spin_retry_init);
29
30/*
31 * spin_retry= parameter
32 */
33static int __init spin_retry_setup(char *str)
34{
35 spin_retry = simple_strtoul(str, &str, 0);
36 return 1;
37}
38__setup("spin_retry=", spin_retry_setup);
39
40struct spin_wait {
41 struct spin_wait *next, *prev;
42 int node_id;
43} __aligned(32);
44
45static DEFINE_PER_CPU_ALIGNED(struct spin_wait, spin_wait[4]);
46
47#define _Q_LOCK_CPU_OFFSET 0
48#define _Q_LOCK_STEAL_OFFSET 16
49#define _Q_TAIL_IDX_OFFSET 18
50#define _Q_TAIL_CPU_OFFSET 20
51
52#define _Q_LOCK_CPU_MASK 0x0000ffff
53#define _Q_LOCK_STEAL_ADD 0x00010000
54#define _Q_LOCK_STEAL_MASK 0x00030000
55#define _Q_TAIL_IDX_MASK 0x000c0000
56#define _Q_TAIL_CPU_MASK 0xfff00000
57
58#define _Q_LOCK_MASK (_Q_LOCK_CPU_MASK | _Q_LOCK_STEAL_MASK)
59#define _Q_TAIL_MASK (_Q_TAIL_IDX_MASK | _Q_TAIL_CPU_MASK)
60
61void arch_spin_lock_setup(int cpu)
62{
63 struct spin_wait *node;
64 int ix;
65
66 node = per_cpu_ptr(&spin_wait[0], cpu);
67 for (ix = 0; ix < 4; ix++, node++) {
68 memset(node, 0, sizeof(*node));
69 node->node_id = ((cpu + 1) << _Q_TAIL_CPU_OFFSET) +
70 (ix << _Q_TAIL_IDX_OFFSET);
71 }
72}
73
74static inline int arch_load_niai4(int *lock)
75{
76 int owner;
77
78 asm_inline volatile(
79 ALTERNATIVE("nop", ".insn rre,0xb2fa0000,4,0", ALT_FACILITY(49)) /* NIAI 4 */
80 " l %[owner],%[lock]\n"
81 : [owner] "=d" (owner) : [lock] "R" (*lock) : "memory");
82 return owner;
83}
84
85#ifdef __HAVE_ASM_FLAG_OUTPUTS__
86
87static inline int arch_try_cmpxchg_niai8(int *lock, int old, int new)
88{
89 int cc;
90
91 asm_inline volatile(
92 ALTERNATIVE("nop", ".insn rre,0xb2fa0000,8,0", ALT_FACILITY(49)) /* NIAI 8 */
93 " cs %[old],%[new],%[lock]\n"
94 : [old] "+d" (old), [lock] "+Q" (*lock), "=@cc" (cc)
95 : [new] "d" (new)
96 : "memory");
97 return cc == 0;
98}
99
100#else /* __HAVE_ASM_FLAG_OUTPUTS__ */
101
102static inline int arch_try_cmpxchg_niai8(int *lock, int old, int new)
103{
104 int expected = old;
105
106 asm_inline volatile(
107 ALTERNATIVE("nop", ".insn rre,0xb2fa0000,8,0", ALT_FACILITY(49)) /* NIAI 8 */
108 " cs %[old],%[new],%[lock]\n"
109 : [old] "+d" (old), [lock] "+Q" (*lock)
110 : [new] "d" (new)
111 : "cc", "memory");
112 return expected == old;
113}
114
115#endif /* __HAVE_ASM_FLAG_OUTPUTS__ */
116
117static inline struct spin_wait *arch_spin_decode_tail(int lock)
118{
119 int ix, cpu;
120
121 ix = (lock & _Q_TAIL_IDX_MASK) >> _Q_TAIL_IDX_OFFSET;
122 cpu = (lock & _Q_TAIL_CPU_MASK) >> _Q_TAIL_CPU_OFFSET;
123 return per_cpu_ptr(&spin_wait[ix], cpu - 1);
124}
125
126static inline int arch_spin_yield_target(int lock, struct spin_wait *node)
127{
128 if (lock & _Q_LOCK_CPU_MASK)
129 return lock & _Q_LOCK_CPU_MASK;
130 if (node == NULL || node->prev == NULL)
131 return 0; /* 0 -> no target cpu */
132 while (node->prev)
133 node = node->prev;
134 return node->node_id >> _Q_TAIL_CPU_OFFSET;
135}
136
137static inline void arch_spin_lock_queued(arch_spinlock_t *lp)
138{
139 struct spin_wait *node, *next;
140 int lockval, ix, node_id, tail_id, old, new, owner, count;
141
142 ix = get_lowcore()->spinlock_index++;
143 barrier();
144 lockval = SPINLOCK_LOCKVAL; /* cpu + 1 */
145 node = this_cpu_ptr(&spin_wait[ix]);
146 node->prev = node->next = NULL;
147 node_id = node->node_id;
148
149 /* Enqueue the node for this CPU in the spinlock wait queue */
150 old = READ_ONCE(lp->lock);
151 while (1) {
152 if ((old & _Q_LOCK_CPU_MASK) == 0 &&
153 (old & _Q_LOCK_STEAL_MASK) != _Q_LOCK_STEAL_MASK) {
154 /*
155 * The lock is free but there may be waiters.
156 * With no waiters simply take the lock, if there
157 * are waiters try to steal the lock. The lock may
158 * be stolen three times before the next queued
159 * waiter will get the lock.
160 */
161 new = (old ? (old + _Q_LOCK_STEAL_ADD) : 0) | lockval;
162 if (arch_try_cmpxchg(&lp->lock, &old, new))
163 /* Got the lock */
164 goto out;
165 /* lock passing in progress */
166 continue;
167 }
168 /* Make the node of this CPU the new tail. */
169 new = node_id | (old & _Q_LOCK_MASK);
170 if (arch_try_cmpxchg(&lp->lock, &old, new))
171 break;
172 }
173 /* Set the 'next' pointer of the tail node in the queue */
174 tail_id = old & _Q_TAIL_MASK;
175 if (tail_id != 0) {
176 node->prev = arch_spin_decode_tail(tail_id);
177 WRITE_ONCE(node->prev->next, node);
178 }
179
180 /* Pass the virtual CPU to the lock holder if it is not running */
181 owner = arch_spin_yield_target(old, node);
182 if (owner && arch_vcpu_is_preempted(owner - 1))
183 smp_yield_cpu(owner - 1);
184
185 /* Spin on the CPU local node->prev pointer */
186 if (tail_id != 0) {
187 count = spin_retry;
188 while (READ_ONCE(node->prev) != NULL) {
189 if (count-- >= 0)
190 continue;
191 count = spin_retry;
192 /* Query running state of lock holder again. */
193 owner = arch_spin_yield_target(old, node);
194 if (owner && arch_vcpu_is_preempted(owner - 1))
195 smp_yield_cpu(owner - 1);
196 }
197 }
198
199 /* Spin on the lock value in the spinlock_t */
200 count = spin_retry;
201 while (1) {
202 old = READ_ONCE(lp->lock);
203 owner = old & _Q_LOCK_CPU_MASK;
204 if (!owner) {
205 tail_id = old & _Q_TAIL_MASK;
206 new = ((tail_id != node_id) ? tail_id : 0) | lockval;
207 if (arch_try_cmpxchg(&lp->lock, &old, new))
208 /* Got the lock */
209 break;
210 continue;
211 }
212 if (count-- >= 0)
213 continue;
214 count = spin_retry;
215 if (!MACHINE_IS_LPAR || arch_vcpu_is_preempted(owner - 1))
216 smp_yield_cpu(owner - 1);
217 }
218
219 /* Pass lock_spin job to next CPU in the queue */
220 if (node_id && tail_id != node_id) {
221 /* Wait until the next CPU has set up the 'next' pointer */
222 while ((next = READ_ONCE(node->next)) == NULL)
223 ;
224 next->prev = NULL;
225 }
226
227 out:
228 get_lowcore()->spinlock_index--;
229}
230
231static inline void arch_spin_lock_classic(arch_spinlock_t *lp)
232{
233 int lockval, old, new, owner, count;
234
235 lockval = SPINLOCK_LOCKVAL; /* cpu + 1 */
236
237 /* Pass the virtual CPU to the lock holder if it is not running */
238 owner = arch_spin_yield_target(READ_ONCE(lp->lock), NULL);
239 if (owner && arch_vcpu_is_preempted(owner - 1))
240 smp_yield_cpu(owner - 1);
241
242 count = spin_retry;
243 while (1) {
244 old = arch_load_niai4(&lp->lock);
245 owner = old & _Q_LOCK_CPU_MASK;
246 /* Try to get the lock if it is free. */
247 if (!owner) {
248 new = (old & _Q_TAIL_MASK) | lockval;
249 if (arch_try_cmpxchg_niai8(&lp->lock, old, new)) {
250 /* Got the lock */
251 return;
252 }
253 continue;
254 }
255 if (count-- >= 0)
256 continue;
257 count = spin_retry;
258 if (!MACHINE_IS_LPAR || arch_vcpu_is_preempted(owner - 1))
259 smp_yield_cpu(owner - 1);
260 }
261}
262
263void arch_spin_lock_wait(arch_spinlock_t *lp)
264{
265 if (test_cpu_flag(CIF_DEDICATED_CPU))
266 arch_spin_lock_queued(lp);
267 else
268 arch_spin_lock_classic(lp);
269}
270EXPORT_SYMBOL(arch_spin_lock_wait);
271
272int arch_spin_trylock_retry(arch_spinlock_t *lp)
273{
274 int cpu = SPINLOCK_LOCKVAL;
275 int owner, count;
276
277 for (count = spin_retry; count > 0; count--) {
278 owner = READ_ONCE(lp->lock);
279 /* Try to get the lock if it is free. */
280 if (!owner) {
281 if (arch_try_cmpxchg(&lp->lock, &owner, cpu))
282 return 1;
283 }
284 }
285 return 0;
286}
287EXPORT_SYMBOL(arch_spin_trylock_retry);
288
289void arch_read_lock_wait(arch_rwlock_t *rw)
290{
291 if (unlikely(in_interrupt())) {
292 while (READ_ONCE(rw->cnts) & 0x10000)
293 barrier();
294 return;
295 }
296
297 /* Remove this reader again to allow recursive read locking */
298 __atomic_add_const(-1, &rw->cnts);
299 /* Put the reader into the wait queue */
300 arch_spin_lock(&rw->wait);
301 /* Now add this reader to the count value again */
302 __atomic_add_const(1, &rw->cnts);
303 /* Loop until the writer is done */
304 while (READ_ONCE(rw->cnts) & 0x10000)
305 barrier();
306 arch_spin_unlock(&rw->wait);
307}
308EXPORT_SYMBOL(arch_read_lock_wait);
309
310void arch_write_lock_wait(arch_rwlock_t *rw)
311{
312 int old;
313
314 /* Add this CPU to the write waiters */
315 __atomic_add(0x20000, &rw->cnts);
316
317 /* Put the writer into the wait queue */
318 arch_spin_lock(&rw->wait);
319
320 while (1) {
321 old = READ_ONCE(rw->cnts);
322 if ((old & 0x1ffff) == 0 &&
323 arch_try_cmpxchg(&rw->cnts, &old, old | 0x10000))
324 /* Got the lock */
325 break;
326 barrier();
327 }
328
329 arch_spin_unlock(&rw->wait);
330}
331EXPORT_SYMBOL(arch_write_lock_wait);
332
333void arch_spin_relax(arch_spinlock_t *lp)
334{
335 int cpu;
336
337 cpu = READ_ONCE(lp->lock) & _Q_LOCK_CPU_MASK;
338 if (!cpu)
339 return;
340 if (MACHINE_IS_LPAR && !arch_vcpu_is_preempted(cpu - 1))
341 return;
342 smp_yield_cpu(cpu - 1);
343}
344EXPORT_SYMBOL(arch_spin_relax);
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
40void arch_spin_lock_wait(arch_spinlock_t *lp)
41{
42 unsigned int cpu = SPINLOCK_LOCKVAL;
43 unsigned int owner;
44 int count, first_diag;
45
46 first_diag = 1;
47 while (1) {
48 owner = ACCESS_ONCE(lp->lock);
49 /* Try to get the lock if it is free. */
50 if (!owner) {
51 if (_raw_compare_and_swap(&lp->lock, 0, cpu))
52 return;
53 continue;
54 }
55 /* First iteration: check if the lock owner is running. */
56 if (first_diag && arch_vcpu_is_preempted(~owner)) {
57 smp_yield_cpu(~owner);
58 first_diag = 0;
59 continue;
60 }
61 /* Loop for a while on the lock value. */
62 count = spin_retry;
63 do {
64 if (MACHINE_HAS_CAD)
65 _raw_compare_and_delay(&lp->lock, owner);
66 owner = ACCESS_ONCE(lp->lock);
67 } while (owner && count-- > 0);
68 if (!owner)
69 continue;
70 /*
71 * For multiple layers of hypervisors, e.g. z/VM + LPAR
72 * yield the CPU unconditionally. For LPAR rely on the
73 * sense running status.
74 */
75 if (!MACHINE_IS_LPAR || arch_vcpu_is_preempted(~owner)) {
76 smp_yield_cpu(~owner);
77 first_diag = 0;
78 }
79 }
80}
81EXPORT_SYMBOL(arch_spin_lock_wait);
82
83void arch_spin_lock_wait_flags(arch_spinlock_t *lp, unsigned long flags)
84{
85 unsigned int cpu = SPINLOCK_LOCKVAL;
86 unsigned int owner;
87 int count, first_diag;
88
89 local_irq_restore(flags);
90 first_diag = 1;
91 while (1) {
92 owner = ACCESS_ONCE(lp->lock);
93 /* Try to get the lock if it is free. */
94 if (!owner) {
95 local_irq_disable();
96 if (_raw_compare_and_swap(&lp->lock, 0, cpu))
97 return;
98 local_irq_restore(flags);
99 continue;
100 }
101 /* Check if the lock owner is running. */
102 if (first_diag && arch_vcpu_is_preempted(~owner)) {
103 smp_yield_cpu(~owner);
104 first_diag = 0;
105 continue;
106 }
107 /* Loop for a while on the lock value. */
108 count = spin_retry;
109 do {
110 if (MACHINE_HAS_CAD)
111 _raw_compare_and_delay(&lp->lock, owner);
112 owner = ACCESS_ONCE(lp->lock);
113 } while (owner && count-- > 0);
114 if (!owner)
115 continue;
116 /*
117 * For multiple layers of hypervisors, e.g. z/VM + LPAR
118 * yield the CPU unconditionally. For LPAR rely on the
119 * sense running status.
120 */
121 if (!MACHINE_IS_LPAR || arch_vcpu_is_preempted(~owner)) {
122 smp_yield_cpu(~owner);
123 first_diag = 0;
124 }
125 }
126}
127EXPORT_SYMBOL(arch_spin_lock_wait_flags);
128
129int arch_spin_trylock_retry(arch_spinlock_t *lp)
130{
131 unsigned int cpu = SPINLOCK_LOCKVAL;
132 unsigned int owner;
133 int count;
134
135 for (count = spin_retry; count > 0; count--) {
136 owner = ACCESS_ONCE(lp->lock);
137 /* Try to get the lock if it is free. */
138 if (!owner) {
139 if (_raw_compare_and_swap(&lp->lock, 0, cpu))
140 return 1;
141 } else if (MACHINE_HAS_CAD)
142 _raw_compare_and_delay(&lp->lock, owner);
143 }
144 return 0;
145}
146EXPORT_SYMBOL(arch_spin_trylock_retry);
147
148void _raw_read_lock_wait(arch_rwlock_t *rw)
149{
150 unsigned int owner, old;
151 int count = spin_retry;
152
153#ifdef CONFIG_HAVE_MARCH_Z196_FEATURES
154 __RAW_LOCK(&rw->lock, -1, __RAW_OP_ADD);
155#endif
156 owner = 0;
157 while (1) {
158 if (count-- <= 0) {
159 if (owner && arch_vcpu_is_preempted(~owner))
160 smp_yield_cpu(~owner);
161 count = spin_retry;
162 }
163 old = ACCESS_ONCE(rw->lock);
164 owner = ACCESS_ONCE(rw->owner);
165 if ((int) old < 0) {
166 if (MACHINE_HAS_CAD)
167 _raw_compare_and_delay(&rw->lock, old);
168 continue;
169 }
170 if (_raw_compare_and_swap(&rw->lock, old, old + 1))
171 return;
172 }
173}
174EXPORT_SYMBOL(_raw_read_lock_wait);
175
176int _raw_read_trylock_retry(arch_rwlock_t *rw)
177{
178 unsigned int old;
179 int count = spin_retry;
180
181 while (count-- > 0) {
182 old = ACCESS_ONCE(rw->lock);
183 if ((int) old < 0) {
184 if (MACHINE_HAS_CAD)
185 _raw_compare_and_delay(&rw->lock, old);
186 continue;
187 }
188 if (_raw_compare_and_swap(&rw->lock, old, old + 1))
189 return 1;
190 }
191 return 0;
192}
193EXPORT_SYMBOL(_raw_read_trylock_retry);
194
195#ifdef CONFIG_HAVE_MARCH_Z196_FEATURES
196
197void _raw_write_lock_wait(arch_rwlock_t *rw, unsigned int prev)
198{
199 unsigned int owner, old;
200 int count = spin_retry;
201
202 owner = 0;
203 while (1) {
204 if (count-- <= 0) {
205 if (owner && arch_vcpu_is_preempted(~owner))
206 smp_yield_cpu(~owner);
207 count = spin_retry;
208 }
209 old = ACCESS_ONCE(rw->lock);
210 owner = ACCESS_ONCE(rw->owner);
211 smp_mb();
212 if ((int) old >= 0) {
213 prev = __RAW_LOCK(&rw->lock, 0x80000000, __RAW_OP_OR);
214 old = prev;
215 }
216 if ((old & 0x7fffffff) == 0 && (int) prev >= 0)
217 break;
218 if (MACHINE_HAS_CAD)
219 _raw_compare_and_delay(&rw->lock, old);
220 }
221}
222EXPORT_SYMBOL(_raw_write_lock_wait);
223
224#else /* CONFIG_HAVE_MARCH_Z196_FEATURES */
225
226void _raw_write_lock_wait(arch_rwlock_t *rw)
227{
228 unsigned int owner, old, prev;
229 int count = spin_retry;
230
231 prev = 0x80000000;
232 owner = 0;
233 while (1) {
234 if (count-- <= 0) {
235 if (owner && arch_vcpu_is_preempted(~owner))
236 smp_yield_cpu(~owner);
237 count = spin_retry;
238 }
239 old = ACCESS_ONCE(rw->lock);
240 owner = ACCESS_ONCE(rw->owner);
241 if ((int) old >= 0 &&
242 _raw_compare_and_swap(&rw->lock, old, old | 0x80000000))
243 prev = old;
244 else
245 smp_mb();
246 if ((old & 0x7fffffff) == 0 && (int) prev >= 0)
247 break;
248 if (MACHINE_HAS_CAD)
249 _raw_compare_and_delay(&rw->lock, old);
250 }
251}
252EXPORT_SYMBOL(_raw_write_lock_wait);
253
254#endif /* CONFIG_HAVE_MARCH_Z196_FEATURES */
255
256int _raw_write_trylock_retry(arch_rwlock_t *rw)
257{
258 unsigned int old;
259 int count = spin_retry;
260
261 while (count-- > 0) {
262 old = ACCESS_ONCE(rw->lock);
263 if (old) {
264 if (MACHINE_HAS_CAD)
265 _raw_compare_and_delay(&rw->lock, old);
266 continue;
267 }
268 if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000))
269 return 1;
270 }
271 return 0;
272}
273EXPORT_SYMBOL(_raw_write_trylock_retry);
274
275void arch_lock_relax(unsigned int cpu)
276{
277 if (!cpu)
278 return;
279 if (MACHINE_IS_LPAR && !arch_vcpu_is_preempted(~cpu))
280 return;
281 smp_yield_cpu(~cpu);
282}
283EXPORT_SYMBOL(arch_lock_relax);