tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1#ifndef __ASM_SPINLOCK_H
2#define __ASM_SPINLOCK_H
3
4#include <asm/barrier.h>
5#include <asm/ldcw.h>
6#include <asm/processor.h>
7#include <asm/spinlock_types.h>
8
9static inline int arch_spin_is_locked(arch_spinlock_t *x)
10{
11 volatile unsigned int *a = __ldcw_align(x);
12 return *a == 0;
13}
14
15#define arch_spin_lock(lock) arch_spin_lock_flags(lock, 0)
16#define arch_spin_unlock_wait(x) \
17 do { cpu_relax(); } while (arch_spin_is_locked(x))
18
19static inline void arch_spin_lock_flags(arch_spinlock_t *x,
20 unsigned long flags)
21{
22 volatile unsigned int *a;
23
24 mb();
25 a = __ldcw_align(x);
26 while (__ldcw(a) == 0)
27 while (*a == 0)
28 if (flags & PSW_SM_I) {
29 local_irq_enable();
30 cpu_relax();
31 local_irq_disable();
32 } else
33 cpu_relax();
34 mb();
35}
36
37static inline void arch_spin_unlock(arch_spinlock_t *x)
38{
39 volatile unsigned int *a;
40 mb();
41 a = __ldcw_align(x);
42 *a = 1;
43 mb();
44}
45
46static inline int arch_spin_trylock(arch_spinlock_t *x)
47{
48 volatile unsigned int *a;
49 int ret;
50
51 mb();
52 a = __ldcw_align(x);
53 ret = __ldcw(a) != 0;
54 mb();
55
56 return ret;
57}
58
59/*
60 * Read-write spinlocks, allowing multiple readers but only one writer.
61 * Linux rwlocks are unfair to writers; they can be starved for an indefinite
62 * time by readers. With care, they can also be taken in interrupt context.
63 *
64 * In the PA-RISC implementation, we have a spinlock and a counter.
65 * Readers use the lock to serialise their access to the counter (which
66 * records how many readers currently hold the lock).
67 * Writers hold the spinlock, preventing any readers or other writers from
68 * grabbing the rwlock.
69 */
70
71/* Note that we have to ensure interrupts are disabled in case we're
72 * interrupted by some other code that wants to grab the same read lock */
73static __inline__ void arch_read_lock(arch_rwlock_t *rw)
74{
75 unsigned long flags;
76 local_irq_save(flags);
77 arch_spin_lock_flags(&rw->lock, flags);
78 rw->counter++;
79 arch_spin_unlock(&rw->lock);
80 local_irq_restore(flags);
81}
82
83/* Note that we have to ensure interrupts are disabled in case we're
84 * interrupted by some other code that wants to grab the same read lock */
85static __inline__ void arch_read_unlock(arch_rwlock_t *rw)
86{
87 unsigned long flags;
88 local_irq_save(flags);
89 arch_spin_lock_flags(&rw->lock, flags);
90 rw->counter--;
91 arch_spin_unlock(&rw->lock);
92 local_irq_restore(flags);
93}
94
95/* Note that we have to ensure interrupts are disabled in case we're
96 * interrupted by some other code that wants to grab the same read lock */
97static __inline__ int arch_read_trylock(arch_rwlock_t *rw)
98{
99 unsigned long flags;
100 retry:
101 local_irq_save(flags);
102 if (arch_spin_trylock(&rw->lock)) {
103 rw->counter++;
104 arch_spin_unlock(&rw->lock);
105 local_irq_restore(flags);
106 return 1;
107 }
108
109 local_irq_restore(flags);
110 /* If write-locked, we fail to acquire the lock */
111 if (rw->counter < 0)
112 return 0;
113
114 /* Wait until we have a realistic chance at the lock */
115 while (arch_spin_is_locked(&rw->lock) && rw->counter >= 0)
116 cpu_relax();
117
118 goto retry;
119}
120
121/* Note that we have to ensure interrupts are disabled in case we're
122 * interrupted by some other code that wants to read_trylock() this lock */
123static __inline__ void arch_write_lock(arch_rwlock_t *rw)
124{
125 unsigned long flags;
126retry:
127 local_irq_save(flags);
128 arch_spin_lock_flags(&rw->lock, flags);
129
130 if (rw->counter != 0) {
131 arch_spin_unlock(&rw->lock);
132 local_irq_restore(flags);
133
134 while (rw->counter != 0)
135 cpu_relax();
136
137 goto retry;
138 }
139
140 rw->counter = -1; /* mark as write-locked */
141 mb();
142 local_irq_restore(flags);
143}
144
145static __inline__ void arch_write_unlock(arch_rwlock_t *rw)
146{
147 rw->counter = 0;
148 arch_spin_unlock(&rw->lock);
149}
150
151/* Note that we have to ensure interrupts are disabled in case we're
152 * interrupted by some other code that wants to read_trylock() this lock */
153static __inline__ int arch_write_trylock(arch_rwlock_t *rw)
154{
155 unsigned long flags;
156 int result = 0;
157
158 local_irq_save(flags);
159 if (arch_spin_trylock(&rw->lock)) {
160 if (rw->counter == 0) {
161 rw->counter = -1;
162 result = 1;
163 } else {
164 /* Read-locked. Oh well. */
165 arch_spin_unlock(&rw->lock);
166 }
167 }
168 local_irq_restore(flags);
169
170 return result;
171}
172
173/*
174 * read_can_lock - would read_trylock() succeed?
175 * @lock: the rwlock in question.
176 */
177static __inline__ int arch_read_can_lock(arch_rwlock_t *rw)
178{
179 return rw->counter >= 0;
180}
181
182/*
183 * write_can_lock - would write_trylock() succeed?
184 * @lock: the rwlock in question.
185 */
186static __inline__ int arch_write_can_lock(arch_rwlock_t *rw)
187{
188 return !rw->counter;
189}
190
191#define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
192#define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
193
194#define arch_spin_relax(lock) cpu_relax()
195#define arch_read_relax(lock) cpu_relax()
196#define arch_write_relax(lock) cpu_relax()
197
198#endif /* __ASM_SPINLOCK_H */