This source file includes following definitions.
- spin_retry_init
- spin_retry_setup
- arch_spin_lock_setup
- arch_load_niai4
- arch_cmpxchg_niai8
- arch_spin_decode_tail
- arch_spin_yield_target
- arch_spin_lock_queued
- arch_spin_lock_classic
- arch_spin_lock_wait
- arch_spin_trylock_retry
- arch_read_lock_wait
- arch_write_lock_wait
- arch_spin_relax
1
2
3
4
5
6
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 <asm/alternative.h>
17 #include <asm/io.h>
18
19 int spin_retry = -1;
20
21 static int __init spin_retry_init(void)
22 {
23 if (spin_retry < 0)
24 spin_retry = 1000;
25 return 0;
26 }
27 early_initcall(spin_retry_init);
28
29
30
31
32 static int __init spin_retry_setup(char *str)
33 {
34 spin_retry = simple_strtoul(str, &str, 0);
35 return 1;
36 }
37 __setup("spin_retry=", spin_retry_setup);
38
39 struct spin_wait {
40 struct spin_wait *next, *prev;
41 int node_id;
42 } __aligned(32);
43
44 static DEFINE_PER_CPU_ALIGNED(struct spin_wait, spin_wait[4]);
45
46 #define _Q_LOCK_CPU_OFFSET 0
47 #define _Q_LOCK_STEAL_OFFSET 16
48 #define _Q_TAIL_IDX_OFFSET 18
49 #define _Q_TAIL_CPU_OFFSET 20
50
51 #define _Q_LOCK_CPU_MASK 0x0000ffff
52 #define _Q_LOCK_STEAL_ADD 0x00010000
53 #define _Q_LOCK_STEAL_MASK 0x00030000
54 #define _Q_TAIL_IDX_MASK 0x000c0000
55 #define _Q_TAIL_CPU_MASK 0xfff00000
56
57 #define _Q_LOCK_MASK (_Q_LOCK_CPU_MASK | _Q_LOCK_STEAL_MASK)
58 #define _Q_TAIL_MASK (_Q_TAIL_IDX_MASK | _Q_TAIL_CPU_MASK)
59
60 void arch_spin_lock_setup(int cpu)
61 {
62 struct spin_wait *node;
63 int ix;
64
65 node = per_cpu_ptr(&spin_wait[0], cpu);
66 for (ix = 0; ix < 4; ix++, node++) {
67 memset(node, 0, sizeof(*node));
68 node->node_id = ((cpu + 1) << _Q_TAIL_CPU_OFFSET) +
69 (ix << _Q_TAIL_IDX_OFFSET);
70 }
71 }
72
73 static inline int arch_load_niai4(int *lock)
74 {
75 int owner;
76
77 asm volatile(
78 ALTERNATIVE("", ".long 0xb2fa0040", 49)
79 " l %0,%1\n"
80 : "=d" (owner) : "Q" (*lock) : "memory");
81 return owner;
82 }
83
84 static inline int arch_cmpxchg_niai8(int *lock, int old, int new)
85 {
86 int expected = old;
87
88 asm volatile(
89 ALTERNATIVE("", ".long 0xb2fa0080", 49)
90 " cs %0,%3,%1\n"
91 : "=d" (old), "=Q" (*lock)
92 : "0" (old), "d" (new), "Q" (*lock)
93 : "cc", "memory");
94 return expected == old;
95 }
96
97 static inline struct spin_wait *arch_spin_decode_tail(int lock)
98 {
99 int ix, cpu;
100
101 ix = (lock & _Q_TAIL_IDX_MASK) >> _Q_TAIL_IDX_OFFSET;
102 cpu = (lock & _Q_TAIL_CPU_MASK) >> _Q_TAIL_CPU_OFFSET;
103 return per_cpu_ptr(&spin_wait[ix], cpu - 1);
104 }
105
106 static inline int arch_spin_yield_target(int lock, struct spin_wait *node)
107 {
108 if (lock & _Q_LOCK_CPU_MASK)
109 return lock & _Q_LOCK_CPU_MASK;
110 if (node == NULL || node->prev == NULL)
111 return 0;
112 while (node->prev)
113 node = node->prev;
114 return node->node_id >> _Q_TAIL_CPU_OFFSET;
115 }
116
117 static inline void arch_spin_lock_queued(arch_spinlock_t *lp)
118 {
119 struct spin_wait *node, *next;
120 int lockval, ix, node_id, tail_id, old, new, owner, count;
121
122 ix = S390_lowcore.spinlock_index++;
123 barrier();
124 lockval = SPINLOCK_LOCKVAL;
125 node = this_cpu_ptr(&spin_wait[ix]);
126 node->prev = node->next = NULL;
127 node_id = node->node_id;
128
129
130 while (1) {
131 old = READ_ONCE(lp->lock);
132 if ((old & _Q_LOCK_CPU_MASK) == 0 &&
133 (old & _Q_LOCK_STEAL_MASK) != _Q_LOCK_STEAL_MASK) {
134
135
136
137
138
139
140
141 new = (old ? (old + _Q_LOCK_STEAL_ADD) : 0) | lockval;
142 if (__atomic_cmpxchg_bool(&lp->lock, old, new))
143
144 goto out;
145
146 continue;
147 }
148
149 new = node_id | (old & _Q_LOCK_MASK);
150 if (__atomic_cmpxchg_bool(&lp->lock, old, new))
151 break;
152 }
153
154 tail_id = old & _Q_TAIL_MASK;
155 if (tail_id != 0) {
156 node->prev = arch_spin_decode_tail(tail_id);
157 WRITE_ONCE(node->prev->next, node);
158 }
159
160
161 owner = arch_spin_yield_target(old, node);
162 if (owner && arch_vcpu_is_preempted(owner - 1))
163 smp_yield_cpu(owner - 1);
164
165
166 if (tail_id != 0) {
167 count = spin_retry;
168 while (READ_ONCE(node->prev) != NULL) {
169 if (count-- >= 0)
170 continue;
171 count = spin_retry;
172
173 owner = arch_spin_yield_target(old, node);
174 if (owner && arch_vcpu_is_preempted(owner - 1))
175 smp_yield_cpu(owner - 1);
176 }
177 }
178
179
180 count = spin_retry;
181 while (1) {
182 old = READ_ONCE(lp->lock);
183 owner = old & _Q_LOCK_CPU_MASK;
184 if (!owner) {
185 tail_id = old & _Q_TAIL_MASK;
186 new = ((tail_id != node_id) ? tail_id : 0) | lockval;
187 if (__atomic_cmpxchg_bool(&lp->lock, old, new))
188
189 break;
190 continue;
191 }
192 if (count-- >= 0)
193 continue;
194 count = spin_retry;
195 if (!MACHINE_IS_LPAR || arch_vcpu_is_preempted(owner - 1))
196 smp_yield_cpu(owner - 1);
197 }
198
199
200 if (node_id && tail_id != node_id) {
201
202 while ((next = READ_ONCE(node->next)) == NULL)
203 ;
204 next->prev = NULL;
205 }
206
207 out:
208 S390_lowcore.spinlock_index--;
209 }
210
211 static inline void arch_spin_lock_classic(arch_spinlock_t *lp)
212 {
213 int lockval, old, new, owner, count;
214
215 lockval = SPINLOCK_LOCKVAL;
216
217
218 owner = arch_spin_yield_target(READ_ONCE(lp->lock), NULL);
219 if (owner && arch_vcpu_is_preempted(owner - 1))
220 smp_yield_cpu(owner - 1);
221
222 count = spin_retry;
223 while (1) {
224 old = arch_load_niai4(&lp->lock);
225 owner = old & _Q_LOCK_CPU_MASK;
226
227 if (!owner) {
228 new = (old & _Q_TAIL_MASK) | lockval;
229 if (arch_cmpxchg_niai8(&lp->lock, old, new)) {
230
231 return;
232 }
233 continue;
234 }
235 if (count-- >= 0)
236 continue;
237 count = spin_retry;
238 if (!MACHINE_IS_LPAR || arch_vcpu_is_preempted(owner - 1))
239 smp_yield_cpu(owner - 1);
240 }
241 }
242
243 void arch_spin_lock_wait(arch_spinlock_t *lp)
244 {
245
246 if (test_cpu_flag(CIF_DEDICATED_CPU))
247 arch_spin_lock_queued(lp);
248 else
249 arch_spin_lock_classic(lp);
250 }
251 EXPORT_SYMBOL(arch_spin_lock_wait);
252
253 int arch_spin_trylock_retry(arch_spinlock_t *lp)
254 {
255 int cpu = SPINLOCK_LOCKVAL;
256 int owner, count;
257
258 for (count = spin_retry; count > 0; count--) {
259 owner = READ_ONCE(lp->lock);
260
261 if (!owner) {
262 if (__atomic_cmpxchg_bool(&lp->lock, 0, cpu))
263 return 1;
264 }
265 }
266 return 0;
267 }
268 EXPORT_SYMBOL(arch_spin_trylock_retry);
269
270 void arch_read_lock_wait(arch_rwlock_t *rw)
271 {
272 if (unlikely(in_interrupt())) {
273 while (READ_ONCE(rw->cnts) & 0x10000)
274 barrier();
275 return;
276 }
277
278
279 __atomic_add_const(-1, &rw->cnts);
280
281 arch_spin_lock(&rw->wait);
282
283 __atomic_add_const(1, &rw->cnts);
284
285 while (READ_ONCE(rw->cnts) & 0x10000)
286 barrier();
287 arch_spin_unlock(&rw->wait);
288 }
289 EXPORT_SYMBOL(arch_read_lock_wait);
290
291 void arch_write_lock_wait(arch_rwlock_t *rw)
292 {
293 int old;
294
295
296 __atomic_add(0x20000, &rw->cnts);
297
298
299 arch_spin_lock(&rw->wait);
300
301 while (1) {
302 old = READ_ONCE(rw->cnts);
303 if ((old & 0x1ffff) == 0 &&
304 __atomic_cmpxchg_bool(&rw->cnts, old, old | 0x10000))
305
306 break;
307 barrier();
308 }
309
310 arch_spin_unlock(&rw->wait);
311 }
312 EXPORT_SYMBOL(arch_write_lock_wait);
313
314 void arch_spin_relax(arch_spinlock_t *lp)
315 {
316 int cpu;
317
318 cpu = READ_ONCE(lp->lock) & _Q_LOCK_CPU_MASK;
319 if (!cpu)
320 return;
321 if (MACHINE_IS_LPAR && !arch_vcpu_is_preempted(cpu - 1))
322 return;
323 smp_yield_cpu(cpu - 1);
324 }
325 EXPORT_SYMBOL(arch_spin_relax);