leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

locking: Further name space cleanups

Browse Source 
The name space hierarchy for the internal lock functions is now a bit
backwards. raw_spin* functions map to _spin* which use __spin*, while
we would like to have _raw_spin* and __raw_spin*.

_raw_spin* is already used by lock debugging, so rename those funtions
to do_raw_spin* to free up the _raw_spin* name space.

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>
This commit is contained in:
Thomas Gleixner 2009-12-03 20:55:53 +01:00
parent 5f6384c5fb
commit 9828ea9d75
8 changed files with 81 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
include/linux/rwlock.h
View File

@ -29,25 +29,25 @@ do { \
#endif #endif
#ifdef CONFIG_DEBUG_SPINLOCK #ifdef CONFIG_DEBUG_SPINLOCK
extern void _raw_read_lock(rwlock_t *lock); extern void do_raw_read_lock(rwlock_t *lock);
#define _raw_read_lock_flags(lock, flags) _raw_read_lock(lock) #define do_raw_read_lock_flags(lock, flags) do_raw_read_lock(lock)
extern int _raw_read_trylock(rwlock_t *lock); extern int do_raw_read_trylock(rwlock_t *lock);
extern void _raw_read_unlock(rwlock_t *lock); extern void do_raw_read_unlock(rwlock_t *lock);
extern void _raw_write_lock(rwlock_t *lock); extern void do_raw_write_lock(rwlock_t *lock);
#define _raw_write_lock_flags(lock, flags) _raw_write_lock(lock) #define do_raw_write_lock_flags(lock, flags) do_raw_write_lock(lock)
extern int _raw_write_trylock(rwlock_t *lock); extern int do_raw_write_trylock(rwlock_t *lock);
extern void _raw_write_unlock(rwlock_t *lock); extern void do_raw_write_unlock(rwlock_t *lock);
#else #else
# define _raw_read_lock(rwlock) arch_read_lock(&(rwlock)->raw_lock) # define do_raw_read_lock(rwlock) arch_read_lock(&(rwlock)->raw_lock)
# define _raw_read_lock_flags(lock, flags) \ # define do_raw_read_lock_flags(lock, flags) \
arch_read_lock_flags(&(lock)->raw_lock, *(flags)) arch_read_lock_flags(&(lock)->raw_lock, *(flags))
# define _raw_read_trylock(rwlock) arch_read_trylock(&(rwlock)->raw_lock) # define do_raw_read_trylock(rwlock) arch_read_trylock(&(rwlock)->raw_lock)
# define _raw_read_unlock(rwlock) arch_read_unlock(&(rwlock)->raw_lock) # define do_raw_read_unlock(rwlock) arch_read_unlock(&(rwlock)->raw_lock)
# define _raw_write_lock(rwlock) arch_write_lock(&(rwlock)->raw_lock) # define do_raw_write_lock(rwlock) arch_write_lock(&(rwlock)->raw_lock)
# define _raw_write_lock_flags(lock, flags) \ # define do_raw_write_lock_flags(lock, flags) \
arch_write_lock_flags(&(lock)->raw_lock, *(flags)) arch_write_lock_flags(&(lock)->raw_lock, *(flags))
# define _raw_write_trylock(rwlock) arch_write_trylock(&(rwlock)->raw_lock) # define do_raw_write_trylock(rwlock) arch_write_trylock(&(rwlock)->raw_lock)
# define _raw_write_unlock(rwlock) arch_write_unlock(&(rwlock)->raw_lock) # define do_raw_write_unlock(rwlock) arch_write_unlock(&(rwlock)->raw_lock)
#endif #endif
#define read_can_lock(rwlock) arch_read_can_lock(&(rwlock)->raw_lock) #define read_can_lock(rwlock) arch_read_can_lock(&(rwlock)->raw_lock)

40
include/linux/rwlock_api_smp.h
View File

@ -113,7 +113,7 @@ void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
static inline int __read_trylock(rwlock_t *lock) static inline int __read_trylock(rwlock_t *lock)
{ {
preempt_disable(); preempt_disable();
if (_raw_read_trylock(lock)) { if (do_raw_read_trylock(lock)) {
rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_); rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
return 1; return 1;
} }
@ -124,7 +124,7 @@ static inline int __read_trylock(rwlock_t *lock)
static inline int __write_trylock(rwlock_t *lock) static inline int __write_trylock(rwlock_t *lock)
{ {
preempt_disable(); preempt_disable();
if (_raw_write_trylock(lock)) { if (do_raw_write_trylock(lock)) {
rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_); rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
return 1; return 1;
} }
@ -143,7 +143,7 @@ static inline void __read_lock(rwlock_t *lock)
{ {
preempt_disable(); preempt_disable();
rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock); LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
} }
static inline unsigned long __read_lock_irqsave(rwlock_t *lock) static inline unsigned long __read_lock_irqsave(rwlock_t *lock)
@ -153,8 +153,8 @@ static inline unsigned long __read_lock_irqsave(rwlock_t *lock)
local_irq_save(flags); local_irq_save(flags);
preempt_disable(); preempt_disable();
rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED_FLAGS(lock, _raw_read_trylock, _raw_read_lock, LOCK_CONTENDED_FLAGS(lock, do_raw_read_trylock, do_raw_read_lock,
_raw_read_lock_flags, &flags); do_raw_read_lock_flags, &flags);
return flags; return flags;
} }
@ -163,7 +163,7 @@ static inline void __read_lock_irq(rwlock_t *lock)
local_irq_disable(); local_irq_disable();
preempt_disable(); preempt_disable();
rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock); LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
} }
static inline void __read_lock_bh(rwlock_t *lock) static inline void __read_lock_bh(rwlock_t *lock)
@ -171,7 +171,7 @@ static inline void __read_lock_bh(rwlock_t *lock)
local_bh_disable(); local_bh_disable();
preempt_disable(); preempt_disable();
rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock); LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
} }
static inline unsigned long __write_lock_irqsave(rwlock_t *lock) static inline unsigned long __write_lock_irqsave(rwlock_t *lock)
@ -181,8 +181,8 @@ static inline unsigned long __write_lock_irqsave(rwlock_t *lock)
local_irq_save(flags); local_irq_save(flags);
preempt_disable(); preempt_disable();
rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED_FLAGS(lock, _raw_write_trylock, _raw_write_lock, LOCK_CONTENDED_FLAGS(lock, do_raw_write_trylock, do_raw_write_lock,
_raw_write_lock_flags, &flags); do_raw_write_lock_flags, &flags);
return flags; return flags;
} }
@ -191,7 +191,7 @@ static inline void __write_lock_irq(rwlock_t *lock)
local_irq_disable(); local_irq_disable();
preempt_disable(); preempt_disable();
rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock); LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
} }
static inline void __write_lock_bh(rwlock_t *lock) static inline void __write_lock_bh(rwlock_t *lock)
@ -199,14 +199,14 @@ static inline void __write_lock_bh(rwlock_t *lock)
local_bh_disable(); local_bh_disable();
preempt_disable(); preempt_disable();
rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock); LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
} }
static inline void __write_lock(rwlock_t *lock) static inline void __write_lock(rwlock_t *lock)
{ {
preempt_disable(); preempt_disable();
rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock); LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
} }
#endif /* CONFIG_PREEMPT */ #endif /* CONFIG_PREEMPT */
@ -214,21 +214,21 @@ static inline void __write_lock(rwlock_t *lock)
static inline void __write_unlock(rwlock_t *lock) static inline void __write_unlock(rwlock_t *lock)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_write_unlock(lock); do_raw_write_unlock(lock);
preempt_enable(); preempt_enable();
} }
static inline void __read_unlock(rwlock_t *lock) static inline void __read_unlock(rwlock_t *lock)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_read_unlock(lock); do_raw_read_unlock(lock);
preempt_enable(); preempt_enable();
} }
static inline void __read_unlock_irqrestore(rwlock_t *lock, unsigned long flags) static inline void __read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_read_unlock(lock); do_raw_read_unlock(lock);
local_irq_restore(flags); local_irq_restore(flags);
preempt_enable(); preempt_enable();
} }
@ -236,7 +236,7 @@ static inline void __read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
static inline void __read_unlock_irq(rwlock_t *lock) static inline void __read_unlock_irq(rwlock_t *lock)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_read_unlock(lock); do_raw_read_unlock(lock);
local_irq_enable(); local_irq_enable();
preempt_enable(); preempt_enable();
} }
@ -244,7 +244,7 @@ static inline void __read_unlock_irq(rwlock_t *lock)
static inline void __read_unlock_bh(rwlock_t *lock) static inline void __read_unlock_bh(rwlock_t *lock)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_read_unlock(lock); do_raw_read_unlock(lock);
preempt_enable_no_resched(); preempt_enable_no_resched();
local_bh_enable_ip((unsigned long)__builtin_return_address(0)); local_bh_enable_ip((unsigned long)__builtin_return_address(0));
} }
@ -253,7 +253,7 @@ static inline void __write_unlock_irqrestore(rwlock_t *lock,
unsigned long flags) unsigned long flags)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_write_unlock(lock); do_raw_write_unlock(lock);
local_irq_restore(flags); local_irq_restore(flags);
preempt_enable(); preempt_enable();
} }
@ -261,7 +261,7 @@ static inline void __write_unlock_irqrestore(rwlock_t *lock,
static inline void __write_unlock_irq(rwlock_t *lock) static inline void __write_unlock_irq(rwlock_t *lock)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_write_unlock(lock); do_raw_write_unlock(lock);
local_irq_enable(); local_irq_enable();
preempt_enable(); preempt_enable();
} }
@ -269,7 +269,7 @@ static inline void __write_unlock_irq(rwlock_t *lock)
static inline void __write_unlock_bh(rwlock_t *lock) static inline void __write_unlock_bh(rwlock_t *lock)
{ {
rwlock_release(&lock->dep_map, 1, _RET_IP_); rwlock_release(&lock->dep_map, 1, _RET_IP_);
_raw_write_unlock(lock); do_raw_write_unlock(lock);
preempt_enable_no_resched(); preempt_enable_no_resched();
local_bh_enable_ip((unsigned long)__builtin_return_address(0)); local_bh_enable_ip((unsigned long)__builtin_return_address(0));
} }

16
include/linux/spinlock.h
View File

@ -128,28 +128,28 @@ static inline void smp_mb__after_lock(void) { smp_mb(); }
#define raw_spin_unlock_wait(lock) arch_spin_unlock_wait(&(lock)->raw_lock) #define raw_spin_unlock_wait(lock) arch_spin_unlock_wait(&(lock)->raw_lock)
#ifdef CONFIG_DEBUG_SPINLOCK #ifdef CONFIG_DEBUG_SPINLOCK
extern void _raw_spin_lock(raw_spinlock_t *lock); extern void do_raw_spin_lock(raw_spinlock_t *lock);
#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock) #define do_raw_spin_lock_flags(lock, flags) do_raw_spin_lock(lock)
extern int _raw_spin_trylock(raw_spinlock_t *lock); extern int do_raw_spin_trylock(raw_spinlock_t *lock);
extern void _raw_spin_unlock(raw_spinlock_t *lock); extern void do_raw_spin_unlock(raw_spinlock_t *lock);
#else #else
static inline void _raw_spin_lock(raw_spinlock_t *lock) static inline void do_raw_spin_lock(raw_spinlock_t *lock)
{ {
arch_spin_lock(&lock->raw_lock); arch_spin_lock(&lock->raw_lock);
} }
static inline void static inline void
_raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long *flags) do_raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long *flags)
{ {
arch_spin_lock_flags(&lock->raw_lock, *flags); arch_spin_lock_flags(&lock->raw_lock, *flags);
} }
static inline int _raw_spin_trylock(raw_spinlock_t *lock) static inline int do_raw_spin_trylock(raw_spinlock_t *lock)
{ {
return arch_spin_trylock(&(lock)->raw_lock); return arch_spin_trylock(&(lock)->raw_lock);
} }
static inline void _raw_spin_unlock(raw_spinlock_t *lock) static inline void do_raw_spin_unlock(raw_spinlock_t *lock)
{ {
arch_spin_unlock(&lock->raw_lock); arch_spin_unlock(&lock->raw_lock);
} }

24
include/linux/spinlock_api_smp.h
View File

@ -85,7 +85,7 @@ _spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
static inline int __spin_trylock(raw_spinlock_t *lock) static inline int __spin_trylock(raw_spinlock_t *lock)
{ {
preempt_disable(); preempt_disable();
if (_raw_spin_trylock(lock)) { if (do_raw_spin_trylock(lock)) {
spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
return 1; return 1;
} }
@ -109,13 +109,13 @@ static inline unsigned long __spin_lock_irqsave(raw_spinlock_t *lock)
spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
/* /*
* On lockdep we dont want the hand-coded irq-enable of * On lockdep we dont want the hand-coded irq-enable of
* _raw_spin_lock_flags() code, because lockdep assumes * do_raw_spin_lock_flags() code, because lockdep assumes
* that interrupts are not re-enabled during lock-acquire: * that interrupts are not re-enabled during lock-acquire:
*/ */
#ifdef CONFIG_LOCKDEP #ifdef CONFIG_LOCKDEP
LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
#else #else
_raw_spin_lock_flags(lock, &flags); do_raw_spin_lock_flags(lock, &flags);
#endif #endif
return flags; return flags;
} }
@ -125,7 +125,7 @@ static inline void __spin_lock_irq(raw_spinlock_t *lock)
local_irq_disable(); local_irq_disable();
preempt_disable(); preempt_disable();
spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
} }
static inline void __spin_lock_bh(raw_spinlock_t *lock) static inline void __spin_lock_bh(raw_spinlock_t *lock)
@ -133,14 +133,14 @@ static inline void __spin_lock_bh(raw_spinlock_t *lock)
local_bh_disable(); local_bh_disable();
preempt_disable(); preempt_disable();
spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
} }
static inline void __spin_lock(raw_spinlock_t *lock) static inline void __spin_lock(raw_spinlock_t *lock)
{ {
preempt_disable(); preempt_disable();
spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
} }
#endif /* CONFIG_PREEMPT */ #endif /* CONFIG_PREEMPT */
@ -148,7 +148,7 @@ static inline void __spin_lock(raw_spinlock_t *lock)
static inline void __spin_unlock(raw_spinlock_t *lock) static inline void __spin_unlock(raw_spinlock_t *lock)
{ {
spin_release(&lock->dep_map, 1, _RET_IP_); spin_release(&lock->dep_map, 1, _RET_IP_);
_raw_spin_unlock(lock); do_raw_spin_unlock(lock);
preempt_enable(); preempt_enable();
} }
@ -156,7 +156,7 @@ static inline void __spin_unlock_irqrestore(raw_spinlock_t *lock,
unsigned long flags) unsigned long flags)
{ {
spin_release(&lock->dep_map, 1, _RET_IP_); spin_release(&lock->dep_map, 1, _RET_IP_);
_raw_spin_unlock(lock); do_raw_spin_unlock(lock);
local_irq_restore(flags); local_irq_restore(flags);
preempt_enable(); preempt_enable();
} }
@ -164,7 +164,7 @@ static inline void __spin_unlock_irqrestore(raw_spinlock_t *lock,
static inline void __spin_unlock_irq(raw_spinlock_t *lock) static inline void __spin_unlock_irq(raw_spinlock_t *lock)
{ {
spin_release(&lock->dep_map, 1, _RET_IP_); spin_release(&lock->dep_map, 1, _RET_IP_);
_raw_spin_unlock(lock); do_raw_spin_unlock(lock);
local_irq_enable(); local_irq_enable();
preempt_enable(); preempt_enable();
} }
@ -172,7 +172,7 @@ static inline void __spin_unlock_irq(raw_spinlock_t *lock)
static inline void __spin_unlock_bh(raw_spinlock_t *lock) static inline void __spin_unlock_bh(raw_spinlock_t *lock)
{ {
spin_release(&lock->dep_map, 1, _RET_IP_); spin_release(&lock->dep_map, 1, _RET_IP_);
_raw_spin_unlock(lock); do_raw_spin_unlock(lock);
preempt_enable_no_resched(); preempt_enable_no_resched();
local_bh_enable_ip((unsigned long)__builtin_return_address(0)); local_bh_enable_ip((unsigned long)__builtin_return_address(0));
} }
@ -181,7 +181,7 @@ static inline int __spin_trylock_bh(raw_spinlock_t *lock)
{ {
local_bh_disable(); local_bh_disable();
preempt_disable(); preempt_disable();
if (_raw_spin_trylock(lock)) { if (do_raw_spin_trylock(lock)) {
spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
return 1; return 1;
} }

2
kernel/sched.c
View File

@ -6684,7 +6684,7 @@ SYSCALL_DEFINE0(sched_yield)
*/ */
__release(rq->lock); __release(rq->lock);
spin_release(&rq->lock.dep_map, 1, _THIS_IP_); spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
_raw_spin_unlock(&rq->lock); do_raw_spin_unlock(&rq->lock);
preempt_enable_no_resched(); preempt_enable_no_resched();
schedule(); schedule();

12
kernel/spinlock.c
View File

@ -48,7 +48,7 @@ void __lockfunc __##op##_lock(locktype##_t *lock) \
{ \ { \
for (;;) { \ for (;;) { \
preempt_disable(); \ preempt_disable(); \
if (likely(_raw_##op##_trylock(lock))) \ if (likely(do_raw_##op##_trylock(lock))) \
break; \ break; \
preempt_enable(); \ preempt_enable(); \
\ \
@ -67,7 +67,7 @@ unsigned long __lockfunc __##op##_lock_irqsave(locktype##_t *lock) \
for (;;) { \ for (;;) { \
preempt_disable(); \ preempt_disable(); \
local_irq_save(flags); \ local_irq_save(flags); \
if (likely(_raw_##op##_trylock(lock))) \ if (likely(do_raw_##op##_trylock(lock))) \
break; \ break; \
local_irq_restore(flags); \ local_irq_restore(flags); \
preempt_enable(); \ preempt_enable(); \
@ -345,7 +345,7 @@ void __lockfunc _spin_lock_nested(raw_spinlock_t *lock, int subclass)
{ {
preempt_disable(); preempt_disable();
spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_); spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
} }
EXPORT_SYMBOL(_spin_lock_nested); EXPORT_SYMBOL(_spin_lock_nested);
@ -357,8 +357,8 @@ unsigned long __lockfunc _spin_lock_irqsave_nested(raw_spinlock_t *lock,
local_irq_save(flags); local_irq_save(flags);
preempt_disable(); preempt_disable();
spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_); spin_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
LOCK_CONTENDED_FLAGS(lock, _raw_spin_trylock, _raw_spin_lock, LOCK_CONTENDED_FLAGS(lock, do_raw_spin_trylock, do_raw_spin_lock,
_raw_spin_lock_flags, &flags); do_raw_spin_lock_flags, &flags);
return flags; return flags;
} }
EXPORT_SYMBOL(_spin_lock_irqsave_nested); EXPORT_SYMBOL(_spin_lock_irqsave_nested);
@ -368,7 +368,7 @@ void __lockfunc _spin_lock_nest_lock(raw_spinlock_t *lock,
{ {
preempt_disable(); preempt_disable();
spin_acquire_nest(&lock->dep_map, 0, 0, nest_lock, _RET_IP_); spin_acquire_nest(&lock->dep_map, 0, 0, nest_lock, _RET_IP_);
LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
} }
EXPORT_SYMBOL(_spin_lock_nest_lock); EXPORT_SYMBOL(_spin_lock_nest_lock);

18
lib/kernel_lock.c
View File

@ -36,12 +36,12 @@ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);
* If it successfully gets the lock, it should increment * If it successfully gets the lock, it should increment
* the preemption count like any spinlock does. * the preemption count like any spinlock does.
* *
* (This works on UP too - _raw_spin_trylock will never * (This works on UP too - do_raw_spin_trylock will never
* return false in that case) * return false in that case)
*/ */
int __lockfunc __reacquire_kernel_lock(void) int __lockfunc __reacquire_kernel_lock(void)
{ {
while (!_raw_spin_trylock(&kernel_flag)) { while (!do_raw_spin_trylock(&kernel_flag)) {
if (need_resched()) if (need_resched())
return -EAGAIN; return -EAGAIN;
cpu_relax(); cpu_relax();
@ -52,27 +52,27 @@ int __lockfunc __reacquire_kernel_lock(void)
void __lockfunc __release_kernel_lock(void) void __lockfunc __release_kernel_lock(void)
{ {
_raw_spin_unlock(&kernel_flag); do_raw_spin_unlock(&kernel_flag);
preempt_enable_no_resched(); preempt_enable_no_resched();
} }
/* /*
* These are the BKL spinlocks - we try to be polite about preemption. * These are the BKL spinlocks - we try to be polite about preemption.
* If SMP is not on (ie UP preemption), this all goes away because the * If SMP is not on (ie UP preemption), this all goes away because the
* _raw_spin_trylock() will always succeed. * do_raw_spin_trylock() will always succeed.
*/ */
#ifdef CONFIG_PREEMPT #ifdef CONFIG_PREEMPT
static inline void __lock_kernel(void) static inline void __lock_kernel(void)
{ {
preempt_disable(); preempt_disable();
if (unlikely(!_raw_spin_trylock(&kernel_flag))) { if (unlikely(!do_raw_spin_trylock(&kernel_flag))) {
/* /*
* If preemption was disabled even before this * If preemption was disabled even before this
* was called, there's nothing we can be polite * was called, there's nothing we can be polite
* about - just spin. * about - just spin.
*/ */
if (preempt_count() > 1) { if (preempt_count() > 1) {
_raw_spin_lock(&kernel_flag); do_raw_spin_lock(&kernel_flag);
return; return;
} }
@ -85,7 +85,7 @@ static inline void __lock_kernel(void)
while (spin_is_locked(&kernel_flag)) while (spin_is_locked(&kernel_flag))
cpu_relax(); cpu_relax();
preempt_disable(); preempt_disable();
} while (!_raw_spin_trylock(&kernel_flag)); } while (!do_raw_spin_trylock(&kernel_flag));
} }
} }
@ -96,7 +96,7 @@ static inline void __lock_kernel(void)
*/ */
static inline void __lock_kernel(void) static inline void __lock_kernel(void)
{ {
_raw_spin_lock(&kernel_flag); do_raw_spin_lock(&kernel_flag);
} }
#endif #endif
@ -106,7 +106,7 @@ static inline void __unlock_kernel(void)
* the BKL is not covered by lockdep, so we open-code the * the BKL is not covered by lockdep, so we open-code the
* unlocking sequence (and thus avoid the dep-chain ops): * unlocking sequence (and thus avoid the dep-chain ops):
*/ */
_raw_spin_unlock(&kernel_flag); do_raw_spin_unlock(&kernel_flag);
preempt_enable(); preempt_enable();
} }

18
lib/spinlock_debug.c
View File

@ -125,7 +125,7 @@ static void __spin_lock_debug(raw_spinlock_t *lock)
} }
} }
void _raw_spin_lock(raw_spinlock_t *lock) void do_raw_spin_lock(raw_spinlock_t *lock)
{ {
debug_spin_lock_before(lock); debug_spin_lock_before(lock);
if (unlikely(!arch_spin_trylock(&lock->raw_lock))) if (unlikely(!arch_spin_trylock(&lock->raw_lock)))
@ -133,7 +133,7 @@ void _raw_spin_lock(raw_spinlock_t *lock)
debug_spin_lock_after(lock); debug_spin_lock_after(lock);
} }
int _raw_spin_trylock(raw_spinlock_t *lock) int do_raw_spin_trylock(raw_spinlock_t *lock)
{ {
int ret = arch_spin_trylock(&lock->raw_lock); int ret = arch_spin_trylock(&lock->raw_lock);
@ -148,7 +148,7 @@ int _raw_spin_trylock(raw_spinlock_t *lock)
return ret; return ret;
} }
void _raw_spin_unlock(raw_spinlock_t *lock) void do_raw_spin_unlock(raw_spinlock_t *lock)
{ {
debug_spin_unlock(lock); debug_spin_unlock(lock);
arch_spin_unlock(&lock->raw_lock); arch_spin_unlock(&lock->raw_lock);
@ -193,13 +193,13 @@ static void __read_lock_debug(rwlock_t *lock)
} }
#endif #endif
void _raw_read_lock(rwlock_t *lock) void do_raw_read_lock(rwlock_t *lock)
{ {
RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic"); RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
arch_read_lock(&lock->raw_lock); arch_read_lock(&lock->raw_lock);
} }
int _raw_read_trylock(rwlock_t *lock) int do_raw_read_trylock(rwlock_t *lock)
{ {
int ret = arch_read_trylock(&lock->raw_lock); int ret = arch_read_trylock(&lock->raw_lock);
@ -212,7 +212,7 @@ int _raw_read_trylock(rwlock_t *lock)
return ret; return ret;
} }
void _raw_read_unlock(rwlock_t *lock) void do_raw_read_unlock(rwlock_t *lock)
{ {
RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic"); RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
arch_read_unlock(&lock->raw_lock); arch_read_unlock(&lock->raw_lock);
@ -268,14 +268,14 @@ static void __write_lock_debug(rwlock_t *lock)
} }
#endif #endif
void _raw_write_lock(rwlock_t *lock) void do_raw_write_lock(rwlock_t *lock)
{ {
debug_write_lock_before(lock); debug_write_lock_before(lock);
arch_write_lock(&lock->raw_lock); arch_write_lock(&lock->raw_lock);
debug_write_lock_after(lock); debug_write_lock_after(lock);
} }
int _raw_write_trylock(rwlock_t *lock) int do_raw_write_trylock(rwlock_t *lock)
{ {
int ret = arch_write_trylock(&lock->raw_lock); int ret = arch_write_trylock(&lock->raw_lock);
@ -290,7 +290,7 @@ int _raw_write_trylock(rwlock_t *lock)
return ret; return ret;
} }
void _raw_write_unlock(rwlock_t *lock) void do_raw_write_unlock(rwlock_t *lock)
{ {
debug_write_unlock(lock); debug_write_unlock(lock);
arch_write_unlock(&lock->raw_lock); arch_write_unlock(&lock->raw_lock);