4 files changed, 56 insertions, 56 deletions

diff --git a/include/linux/rwlock.h b/include/linux/rwlock.h
index 5725b034defe..bd799bc6d086 100644
--- a/include/linux/rwlock.h
+++ b/include/linux/rwlock.h
@@ -29,25 +29,25 @@ do {								\
 #endif
 
 #ifdef CONFIG_DEBUG_SPINLOCK
- extern void _raw_read_lock(rwlock_t *lock);
-#define _raw_read_lock_flags(lock, flags) _raw_read_lock(lock)
- extern int _raw_read_trylock(rwlock_t *lock);
- extern void _raw_read_unlock(rwlock_t *lock);
- extern void _raw_write_lock(rwlock_t *lock);
-#define _raw_write_lock_flags(lock, flags) _raw_write_lock(lock)
- extern int _raw_write_trylock(rwlock_t *lock);
- extern void _raw_write_unlock(rwlock_t *lock);
+ extern void do_raw_read_lock(rwlock_t *lock);
+#define do_raw_read_lock_flags(lock, flags) do_raw_read_lock(lock)
+ extern int do_raw_read_trylock(rwlock_t *lock);
+ extern void do_raw_read_unlock(rwlock_t *lock);
+ extern void do_raw_write_lock(rwlock_t *lock);
+#define do_raw_write_lock_flags(lock, flags) do_raw_write_lock(lock)
+ extern int do_raw_write_trylock(rwlock_t *lock);
+ extern void do_raw_write_unlock(rwlock_t *lock);
 #else
-# define _raw_read_lock(rwlock)         arch_read_lock(&(rwlock)->raw_lock)
-# define _raw_read_lock_flags(lock, flags) \
+# define do_raw_read_lock(rwlock)               arch_read_lock(&(rwlock)->raw_lock)
+# define do_raw_read_lock_flags(lock, flags) \
                 arch_read_lock_flags(&(lock)->raw_lock, *(flags))
-# define _raw_read_trylock(rwlock)      arch_read_trylock(&(rwlock)->raw_lock)
-# define _raw_read_unlock(rwlock)       arch_read_unlock(&(rwlock)->raw_lock)
-# define _raw_write_lock(rwlock)        arch_write_lock(&(rwlock)->raw_lock)
-# define _raw_write_lock_flags(lock, flags) \
+# define do_raw_read_trylock(rwlock)    arch_read_trylock(&(rwlock)->raw_lock)
+# define do_raw_read_unlock(rwlock)     arch_read_unlock(&(rwlock)->raw_lock)
+# define do_raw_write_lock(rwlock)      arch_write_lock(&(rwlock)->raw_lock)
+# define do_raw_write_lock_flags(lock, flags) \
                 arch_write_lock_flags(&(lock)->raw_lock, *(flags))
-# define _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_trylock(rwlock)   arch_write_trylock(&(rwlock)->raw_lock)
+# define do_raw_write_unlock(rwlock)    arch_write_unlock(&(rwlock)->raw_lock)
 #endif
 
 #define read_can_lock(rwlock)           arch_read_can_lock(&(rwlock)->raw_lock)
diff --git a/include/linux/rwlock_api_smp.h b/include/linux/rwlock_api_smp.h
index 090f876f828d..b3ba5ae6a8c4 100644
--- a/include/linux/rwlock_api_smp.h
+++ b/include/linux/rwlock_api_smp.h
@@ -113,7 +113,7 @@ void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 static inline int __read_trylock(rwlock_t *lock)
 {
         preempt_disable();
-        if (_raw_read_trylock(lock)) {
+        if (do_raw_read_trylock(lock)) {
                 rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
                 return 1;
         }
@@ -124,7 +124,7 @@ static inline int __read_trylock(rwlock_t *lock)
 static inline int __write_trylock(rwlock_t *lock)
 {
         preempt_disable();
-        if (_raw_write_trylock(lock)) {
+        if (do_raw_write_trylock(lock)) {
                 rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
                 return 1;
         }
@@ -143,7 +143,7 @@ static inline void __read_lock(rwlock_t *lock)
 {
         preempt_disable();
         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)
@@ -153,8 +153,8 @@ static inline unsigned long __read_lock_irqsave(rwlock_t *lock)
         local_irq_save(flags);
         preempt_disable();
         rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED_FLAGS(lock, _raw_read_trylock, _raw_read_lock,
-                             _raw_read_lock_flags, &flags);
+        LOCK_CONTENDED_FLAGS(lock, do_raw_read_trylock, do_raw_read_lock,
+                             do_raw_read_lock_flags, &flags);
         return flags;
 }
 
@@ -163,7 +163,7 @@ static inline void __read_lock_irq(rwlock_t *lock)
         local_irq_disable();
         preempt_disable();
         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)
@@ -171,7 +171,7 @@ static inline void __read_lock_bh(rwlock_t *lock)
         local_bh_disable();
         preempt_disable();
         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)
@@ -181,8 +181,8 @@ static inline unsigned long __write_lock_irqsave(rwlock_t *lock)
         local_irq_save(flags);
         preempt_disable();
         rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED_FLAGS(lock, _raw_write_trylock, _raw_write_lock,
-                             _raw_write_lock_flags, &flags);
+        LOCK_CONTENDED_FLAGS(lock, do_raw_write_trylock, do_raw_write_lock,
+                             do_raw_write_lock_flags, &flags);
         return flags;
 }
 
@@ -191,7 +191,7 @@ static inline void __write_lock_irq(rwlock_t *lock)
         local_irq_disable();
         preempt_disable();
         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)
@@ -199,14 +199,14 @@ static inline void __write_lock_bh(rwlock_t *lock)
         local_bh_disable();
         preempt_disable();
         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)
 {
         preempt_disable();
         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 */
@@ -214,21 +214,21 @@ static inline void __write_lock(rwlock_t *lock)
 static inline void __write_unlock(rwlock_t *lock)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
+        do_raw_write_unlock(lock);
         preempt_enable();
 }
 
 static inline void __read_unlock(rwlock_t *lock)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
+        do_raw_read_unlock(lock);
         preempt_enable();
 }
 
 static inline void __read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
+        do_raw_read_unlock(lock);
         local_irq_restore(flags);
         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)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
+        do_raw_read_unlock(lock);
         local_irq_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)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
+        do_raw_read_unlock(lock);
         preempt_enable_no_resched();
         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)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
+        do_raw_write_unlock(lock);
         local_irq_restore(flags);
         preempt_enable();
 }
@@ -261,7 +261,7 @@ static inline void __write_unlock_irqrestore(rwlock_t *lock,
 static inline void __write_unlock_irq(rwlock_t *lock)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
+        do_raw_write_unlock(lock);
         local_irq_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)
 {
         rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
+        do_raw_write_unlock(lock);
         preempt_enable_no_resched();
         local_bh_enable_ip((unsigned long)__builtin_return_address(0));
 }
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index ef5a55d96b9b..0cbc58acf689 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -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)
 
 #ifdef CONFIG_DEBUG_SPINLOCK
- extern void _raw_spin_lock(raw_spinlock_t *lock);
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
- extern int _raw_spin_trylock(raw_spinlock_t *lock);
- extern void _raw_spin_unlock(raw_spinlock_t *lock);
+ extern void do_raw_spin_lock(raw_spinlock_t *lock);
+#define do_raw_spin_lock_flags(lock, flags) do_raw_spin_lock(lock)
+ extern int do_raw_spin_trylock(raw_spinlock_t *lock);
+ extern void do_raw_spin_unlock(raw_spinlock_t *lock);
 #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);
 }
 
 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);
 }
 
-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);
 }
 
-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);
 }
diff --git a/include/linux/spinlock_api_smp.h b/include/linux/spinlock_api_smp.h
index eabe5068d138..1be1fc57fc4b 100644
--- a/include/linux/spinlock_api_smp.h
+++ b/include/linux/spinlock_api_smp.h
@@ -85,7 +85,7 @@ _spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
 static inline int __spin_trylock(raw_spinlock_t *lock)
 {
         preempt_disable();
-        if (_raw_spin_trylock(lock)) {
+        if (do_raw_spin_trylock(lock)) {
                 spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
                 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_);
         /*
          * 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:
          */
 #ifdef CONFIG_LOCKDEP
-        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+        LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
 #else
-        _raw_spin_lock_flags(lock, &flags);
+        do_raw_spin_lock_flags(lock, &flags);
 #endif
         return flags;
 }
@@ -125,7 +125,7 @@ static inline void __spin_lock_irq(raw_spinlock_t *lock)
         local_irq_disable();
         preempt_disable();
         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)
@@ -133,14 +133,14 @@ static inline void __spin_lock_bh(raw_spinlock_t *lock)
         local_bh_disable();
         preempt_disable();
         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)
 {
         preempt_disable();
         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 */
@@ -148,7 +148,7 @@ static inline void __spin_lock(raw_spinlock_t *lock)
 static inline void __spin_unlock(raw_spinlock_t *lock)
 {
         spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
+        do_raw_spin_unlock(lock);
         preempt_enable();
 }
 
@@ -156,7 +156,7 @@ static inline void __spin_unlock_irqrestore(raw_spinlock_t *lock,
                                             unsigned long flags)
 {
         spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
+        do_raw_spin_unlock(lock);
         local_irq_restore(flags);
         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)
 {
         spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
+        do_raw_spin_unlock(lock);
         local_irq_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)
 {
         spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
+        do_raw_spin_unlock(lock);
         preempt_enable_no_resched();
         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();
         preempt_disable();
-        if (_raw_spin_trylock(lock)) {
+        if (do_raw_spin_trylock(lock)) {
                 spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
                 return 1;
         }