Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit b7b40ade58e621851896aa261452df99d4e9d99b

Authored by Thomas Gleixner
1 parent 3ea6b3d0e6
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

locking: Reorder functions in spinlock.c 

Separate spin_lock and rw_lock functions. Preempt-RT needs to exclude
the rw_lock functions from being compiled. The reordering allows to do
that with a single #ifdef.

No functional change.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Acked-by: Ingo Molnar <mingo@elte.hu>

Showing 1 changed file with 123 additions and 123 deletions Side-by-side Diff

... ... @@ -113,41 +113,6 @@
113 113  
114 114 #endif
115 115  
116   -#ifdef CONFIG_DEBUG_LOCK_ALLOC
117   -
118   -void __lockfunc _spin_lock_nested(spinlock_t *lock, int subclass)
119   -{
120   - preempt_disable();
121   - spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
122   - LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
123   -}
124   -EXPORT_SYMBOL(_spin_lock_nested);
125   -
126   -unsigned long __lockfunc _spin_lock_irqsave_nested(spinlock_t *lock,
127   - int subclass)
128   -{
129   - unsigned long flags;
130   -
131   - local_irq_save(flags);
132   - preempt_disable();
133   - spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
134   - LOCK_CONTENDED_FLAGS(lock, _raw_spin_trylock, _raw_spin_lock,
135   - _raw_spin_lock_flags, &flags);
136   - return flags;
137   -}
138   -EXPORT_SYMBOL(_spin_lock_irqsave_nested);
139   -
140   -void __lockfunc _spin_lock_nest_lock(spinlock_t *lock,
141   - struct lockdep_map *nest_lock)
142   -{
143   - preempt_disable();
144   - spin_acquire_nest(&lock->dep_map, 0, 0, nest_lock, _RET_IP_);
145   - LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
146   -}
147   -EXPORT_SYMBOL(_spin_lock_nest_lock);
148   -
149   -#endif
150   -
151 116 #ifndef CONFIG_INLINE_SPIN_TRYLOCK
152 117 int __lockfunc _spin_trylock(spinlock_t *lock)
153 118 {
154 119  
155 120  
156 121  
157 122  
158 123  
159 124  
... ... @@ -156,30 +121,22 @@
156 121 EXPORT_SYMBOL(_spin_trylock);
157 122 #endif
158 123  
159   -#ifndef CONFIG_INLINE_READ_TRYLOCK
160   -int __lockfunc _read_trylock(rwlock_t *lock)
  124 +#ifndef CONFIG_INLINE_SPIN_TRYLOCK_BH
  125 +int __lockfunc _spin_trylock_bh(spinlock_t *lock)
161 126 {
162   - return __read_trylock(lock);
  127 + return __spin_trylock_bh(lock);
163 128 }
164   -EXPORT_SYMBOL(_read_trylock);
  129 +EXPORT_SYMBOL(_spin_trylock_bh);
165 130 #endif
166 131  
167   -#ifndef CONFIG_INLINE_WRITE_TRYLOCK
168   -int __lockfunc _write_trylock(rwlock_t *lock)
  132 +#ifndef CONFIG_INLINE_SPIN_LOCK
  133 +void __lockfunc _spin_lock(spinlock_t *lock)
169 134 {
170   - return __write_trylock(lock);
  135 + __spin_lock(lock);
171 136 }
172   -EXPORT_SYMBOL(_write_trylock);
  137 +EXPORT_SYMBOL(_spin_lock);
173 138 #endif
174 139  
175   -#ifndef CONFIG_INLINE_READ_LOCK
176   -void __lockfunc _read_lock(rwlock_t *lock)
177   -{
178   - __read_lock(lock);
179   -}
180   -EXPORT_SYMBOL(_read_lock);
181   -#endif
182   -
183 140 #ifndef CONFIG_INLINE_SPIN_LOCK_IRQSAVE
184 141 unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)
185 142 {
186 143  
187 144  
188 145  
189 146  
190 147  
191 148  
192 149  
193 150  
194 151  
195 152  
196 153  
197 154  
198 155  
199 156  
200 157  
201 158  
202 159  
203 160  
204 161  
205 162  
206 163  
207 164  
208 165  
209 166  
210 167  
211 168  
212 169  
... ... @@ -204,86 +161,78 @@
204 161 EXPORT_SYMBOL(_spin_lock_bh);
205 162 #endif
206 163  
207   -#ifndef CONFIG_INLINE_READ_LOCK_IRQSAVE
208   -unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)
  164 +#ifndef CONFIG_INLINE_SPIN_UNLOCK
  165 +void __lockfunc _spin_unlock(spinlock_t *lock)
209 166 {
210   - return __read_lock_irqsave(lock);
  167 + __spin_unlock(lock);
211 168 }
212   -EXPORT_SYMBOL(_read_lock_irqsave);
  169 +EXPORT_SYMBOL(_spin_unlock);
213 170 #endif
214 171  
215   -#ifndef CONFIG_INLINE_READ_LOCK_IRQ
216   -void __lockfunc _read_lock_irq(rwlock_t *lock)
  172 +#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE
  173 +void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
217 174 {
218   - __read_lock_irq(lock);
  175 + __spin_unlock_irqrestore(lock, flags);
219 176 }
220   -EXPORT_SYMBOL(_read_lock_irq);
  177 +EXPORT_SYMBOL(_spin_unlock_irqrestore);
221 178 #endif
222 179  
223   -#ifndef CONFIG_INLINE_READ_LOCK_BH
224   -void __lockfunc _read_lock_bh(rwlock_t *lock)
  180 +#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQ
  181 +void __lockfunc _spin_unlock_irq(spinlock_t *lock)
225 182 {
226   - __read_lock_bh(lock);
  183 + __spin_unlock_irq(lock);
227 184 }
228   -EXPORT_SYMBOL(_read_lock_bh);
  185 +EXPORT_SYMBOL(_spin_unlock_irq);
229 186 #endif
230 187  
231   -#ifndef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
232   -unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)
  188 +#ifndef CONFIG_INLINE_SPIN_UNLOCK_BH
  189 +void __lockfunc _spin_unlock_bh(spinlock_t *lock)
233 190 {
234   - return __write_lock_irqsave(lock);
  191 + __spin_unlock_bh(lock);
235 192 }
236   -EXPORT_SYMBOL(_write_lock_irqsave);
  193 +EXPORT_SYMBOL(_spin_unlock_bh);
237 194 #endif
238 195  
239   -#ifndef CONFIG_INLINE_WRITE_LOCK_IRQ
240   -void __lockfunc _write_lock_irq(rwlock_t *lock)
  196 +#ifndef CONFIG_INLINE_READ_TRYLOCK
  197 +int __lockfunc _read_trylock(rwlock_t *lock)
241 198 {
242   - __write_lock_irq(lock);
  199 + return __read_trylock(lock);
243 200 }
244   -EXPORT_SYMBOL(_write_lock_irq);
  201 +EXPORT_SYMBOL(_read_trylock);
245 202 #endif
246 203  
247   -#ifndef CONFIG_INLINE_WRITE_LOCK_BH
248   -void __lockfunc _write_lock_bh(rwlock_t *lock)
  204 +#ifndef CONFIG_INLINE_READ_LOCK
  205 +void __lockfunc _read_lock(rwlock_t *lock)
249 206 {
250   - __write_lock_bh(lock);
  207 + __read_lock(lock);
251 208 }
252   -EXPORT_SYMBOL(_write_lock_bh);
  209 +EXPORT_SYMBOL(_read_lock);
253 210 #endif
254 211  
255   -#ifndef CONFIG_INLINE_SPIN_LOCK
256   -void __lockfunc _spin_lock(spinlock_t *lock)
  212 +#ifndef CONFIG_INLINE_READ_LOCK_IRQSAVE
  213 +unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)
257 214 {
258   - __spin_lock(lock);
  215 + return __read_lock_irqsave(lock);
259 216 }
260   -EXPORT_SYMBOL(_spin_lock);
  217 +EXPORT_SYMBOL(_read_lock_irqsave);
261 218 #endif
262 219  
263   -#ifndef CONFIG_INLINE_WRITE_LOCK
264   -void __lockfunc _write_lock(rwlock_t *lock)
  220 +#ifndef CONFIG_INLINE_READ_LOCK_IRQ
  221 +void __lockfunc _read_lock_irq(rwlock_t *lock)
265 222 {
266   - __write_lock(lock);
  223 + __read_lock_irq(lock);
267 224 }
268   -EXPORT_SYMBOL(_write_lock);
  225 +EXPORT_SYMBOL(_read_lock_irq);
269 226 #endif
270 227  
271   -#ifndef CONFIG_INLINE_SPIN_UNLOCK
272   -void __lockfunc _spin_unlock(spinlock_t *lock)
  228 +#ifndef CONFIG_INLINE_READ_LOCK_BH
  229 +void __lockfunc _read_lock_bh(rwlock_t *lock)
273 230 {
274   - __spin_unlock(lock);
  231 + __read_lock_bh(lock);
275 232 }
276   -EXPORT_SYMBOL(_spin_unlock);
  233 +EXPORT_SYMBOL(_read_lock_bh);
277 234 #endif
278 235  
279   -#ifndef CONFIG_INLINE_WRITE_UNLOCK
280   -void __lockfunc _write_unlock(rwlock_t *lock)
281   -{
282   - __write_unlock(lock);
283   -}
284   -EXPORT_SYMBOL(_write_unlock);
285   -#endif
286   -
287 236 #ifndef CONFIG_INLINE_READ_UNLOCK
288 237 void __lockfunc _read_unlock(rwlock_t *lock)
289 238 {
... ... @@ -292,30 +241,6 @@
292 241 EXPORT_SYMBOL(_read_unlock);
293 242 #endif
294 243  
295   -#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE
296   -void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
297   -{
298   - __spin_unlock_irqrestore(lock, flags);
299   -}
300   -EXPORT_SYMBOL(_spin_unlock_irqrestore);
301   -#endif
302   -
303   -#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQ
304   -void __lockfunc _spin_unlock_irq(spinlock_t *lock)
305   -{
306   - __spin_unlock_irq(lock);
307   -}
308   -EXPORT_SYMBOL(_spin_unlock_irq);
309   -#endif
310   -
311   -#ifndef CONFIG_INLINE_SPIN_UNLOCK_BH
312   -void __lockfunc _spin_unlock_bh(spinlock_t *lock)
313   -{
314   - __spin_unlock_bh(lock);
315   -}
316   -EXPORT_SYMBOL(_spin_unlock_bh);
317   -#endif
318   -
319 244 #ifndef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
320 245 void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
321 246 {
... ... @@ -340,6 +265,54 @@
340 265 EXPORT_SYMBOL(_read_unlock_bh);
341 266 #endif
342 267  
  268 +#ifndef CONFIG_INLINE_WRITE_TRYLOCK
  269 +int __lockfunc _write_trylock(rwlock_t *lock)
  270 +{
  271 + return __write_trylock(lock);
  272 +}
  273 +EXPORT_SYMBOL(_write_trylock);
  274 +#endif
  275 +
  276 +#ifndef CONFIG_INLINE_WRITE_LOCK
  277 +void __lockfunc _write_lock(rwlock_t *lock)
  278 +{
  279 + __write_lock(lock);
  280 +}
  281 +EXPORT_SYMBOL(_write_lock);
  282 +#endif
  283 +
  284 +#ifndef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
  285 +unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)
  286 +{
  287 + return __write_lock_irqsave(lock);
  288 +}
  289 +EXPORT_SYMBOL(_write_lock_irqsave);
  290 +#endif
  291 +
  292 +#ifndef CONFIG_INLINE_WRITE_LOCK_IRQ
  293 +void __lockfunc _write_lock_irq(rwlock_t *lock)
  294 +{
  295 + __write_lock_irq(lock);
  296 +}
  297 +EXPORT_SYMBOL(_write_lock_irq);
  298 +#endif
  299 +
  300 +#ifndef CONFIG_INLINE_WRITE_LOCK_BH
  301 +void __lockfunc _write_lock_bh(rwlock_t *lock)
  302 +{
  303 + __write_lock_bh(lock);
  304 +}
  305 +EXPORT_SYMBOL(_write_lock_bh);
  306 +#endif
  307 +
  308 +#ifndef CONFIG_INLINE_WRITE_UNLOCK
  309 +void __lockfunc _write_unlock(rwlock_t *lock)
  310 +{
  311 + __write_unlock(lock);
  312 +}
  313 +EXPORT_SYMBOL(_write_unlock);
  314 +#endif
  315 +
343 316 #ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
344 317 void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
345 318 {
346 319  
347 320  
... ... @@ -364,12 +337,39 @@
364 337 EXPORT_SYMBOL(_write_unlock_bh);
365 338 #endif
366 339  
367   -#ifndef CONFIG_INLINE_SPIN_TRYLOCK_BH
368   -int __lockfunc _spin_trylock_bh(spinlock_t *lock)
  340 +#ifdef CONFIG_DEBUG_LOCK_ALLOC
  341 +
  342 +void __lockfunc _spin_lock_nested(spinlock_t *lock, int subclass)
369 343 {
370   - return __spin_trylock_bh(lock);
  344 + preempt_disable();
  345 + spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
  346 + LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
371 347 }
372   -EXPORT_SYMBOL(_spin_trylock_bh);
  348 +EXPORT_SYMBOL(_spin_lock_nested);
  349 +
  350 +unsigned long __lockfunc _spin_lock_irqsave_nested(spinlock_t *lock,
  351 + int subclass)
  352 +{
  353 + unsigned long flags;
  354 +
  355 + local_irq_save(flags);
  356 + preempt_disable();
  357 + spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
  358 + LOCK_CONTENDED_FLAGS(lock, _raw_spin_trylock, _raw_spin_lock,
  359 + _raw_spin_lock_flags, &flags);
  360 + return flags;
  361 +}
  362 +EXPORT_SYMBOL(_spin_lock_irqsave_nested);
  363 +
  364 +void __lockfunc _spin_lock_nest_lock(spinlock_t *lock,
  365 + struct lockdep_map *nest_lock)
  366 +{
  367 + preempt_disable();
  368 + spin_acquire_nest(&lock->dep_map, 0, 0, nest_lock, _RET_IP_);
  369 + LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
  370 +}
  371 +EXPORT_SYMBOL(_spin_lock_nest_lock);
  372 +
373 373 #endif
374 374  
375 375 notrace int in_lock_functions(unsigned long addr)