4 files changed, 85 insertions, 83 deletions

diff --git a/lib/debugobjects.c b/lib/debugobjects.c
index eae56fddfa3b..a9a8996d286a 100644
--- a/lib/debugobjects.c
+++ b/lib/debugobjects.c
@@ -26,14 +26,14 @@
 
 struct debug_bucket {
         struct hlist_head       list;
-        spinlock_t              lock;
+        raw_spinlock_t          lock;
 };
 
 static struct debug_bucket      obj_hash[ODEBUG_HASH_SIZE];
 
 static struct debug_obj         obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
 
-static DEFINE_SPINLOCK(pool_lock);
+static DEFINE_RAW_SPINLOCK(pool_lock);
 
 static HLIST_HEAD(obj_pool);
 
@@ -96,10 +96,10 @@ static int fill_pool(void)
                 if (!new)
                         return obj_pool_free;
 
-                spin_lock_irqsave(&pool_lock, flags);
+                raw_spin_lock_irqsave(&pool_lock, flags);
                 hlist_add_head(&new->node, &obj_pool);
                 obj_pool_free++;
-                spin_unlock_irqrestore(&pool_lock, flags);
+                raw_spin_unlock_irqrestore(&pool_lock, flags);
         }
         return obj_pool_free;
 }
@@ -133,7 +133,7 @@ alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
 {
         struct debug_obj *obj = NULL;
 
-        spin_lock(&pool_lock);
+        raw_spin_lock(&pool_lock);
         if (obj_pool.first) {
                 obj         = hlist_entry(obj_pool.first, typeof(*obj), node);
 
@@ -152,7 +152,7 @@ alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
                 if (obj_pool_free < obj_pool_min_free)
                         obj_pool_min_free = obj_pool_free;
         }
-        spin_unlock(&pool_lock);
+        raw_spin_unlock(&pool_lock);
 
         return obj;
 }
@@ -165,7 +165,7 @@ static void free_obj_work(struct work_struct *work)
         struct debug_obj *obj;
         unsigned long flags;
 
-        spin_lock_irqsave(&pool_lock, flags);
+        raw_spin_lock_irqsave(&pool_lock, flags);
         while (obj_pool_free > ODEBUG_POOL_SIZE) {
                 obj = hlist_entry(obj_pool.first, typeof(*obj), node);
                 hlist_del(&obj->node);
@@ -174,11 +174,11 @@ static void free_obj_work(struct work_struct *work)
                  * We release pool_lock across kmem_cache_free() to
                  * avoid contention on pool_lock.
                  */
-                spin_unlock_irqrestore(&pool_lock, flags);
+                raw_spin_unlock_irqrestore(&pool_lock, flags);
                 kmem_cache_free(obj_cache, obj);
-                spin_lock_irqsave(&pool_lock, flags);
+                raw_spin_lock_irqsave(&pool_lock, flags);
         }
-        spin_unlock_irqrestore(&pool_lock, flags);
+        raw_spin_unlock_irqrestore(&pool_lock, flags);
 }
 
 /*
@@ -190,7 +190,7 @@ static void free_object(struct debug_obj *obj)
         unsigned long flags;
         int sched = 0;
 
-        spin_lock_irqsave(&pool_lock, flags);
+        raw_spin_lock_irqsave(&pool_lock, flags);
         /*
          * schedule work when the pool is filled and the cache is
          * initialized:
@@ -200,7 +200,7 @@ static void free_object(struct debug_obj *obj)
         hlist_add_head(&obj->node, &obj_pool);
         obj_pool_free++;
         obj_pool_used--;
-        spin_unlock_irqrestore(&pool_lock, flags);
+        raw_spin_unlock_irqrestore(&pool_lock, flags);
         if (sched)
                 schedule_work(&debug_obj_work);
 }
@@ -221,9 +221,9 @@ static void debug_objects_oom(void)
         printk(KERN_WARNING "ODEBUG: Out of memory. ODEBUG disabled\n");
 
         for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
-                spin_lock_irqsave(&db->lock, flags);
+                raw_spin_lock_irqsave(&db->lock, flags);
                 hlist_move_list(&db->list, &freelist);
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
 
                 /* Now free them */
                 hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
@@ -303,14 +303,14 @@ __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
 
         db = get_bucket((unsigned long) addr);
 
-        spin_lock_irqsave(&db->lock, flags);
+        raw_spin_lock_irqsave(&db->lock, flags);
 
         obj = lookup_object(addr, db);
         if (!obj) {
                 obj = alloc_object(addr, db, descr);
                 if (!obj) {
                         debug_objects_enabled = 0;
-                        spin_unlock_irqrestore(&db->lock, flags);
+                        raw_spin_unlock_irqrestore(&db->lock, flags);
                         debug_objects_oom();
                         return;
                 }
@@ -327,7 +327,7 @@ __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
         case ODEBUG_STATE_ACTIVE:
                 debug_print_object(obj, "init");
                 state = obj->state;
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
                 debug_object_fixup(descr->fixup_init, addr, state);
                 return;
 
@@ -338,7 +338,7 @@ __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
                 break;
         }
 
-        spin_unlock_irqrestore(&db->lock, flags);
+        raw_spin_unlock_irqrestore(&db->lock, flags);
 }
 
 /**
@@ -385,7 +385,7 @@ void debug_object_activate(void *addr, struct debug_obj_descr *descr)
 
         db = get_bucket((unsigned long) addr);
 
-        spin_lock_irqsave(&db->lock, flags);
+        raw_spin_lock_irqsave(&db->lock, flags);
 
         obj = lookup_object(addr, db);
         if (obj) {
@@ -398,7 +398,7 @@ void debug_object_activate(void *addr, struct debug_obj_descr *descr)
                 case ODEBUG_STATE_ACTIVE:
                         debug_print_object(obj, "activate");
                         state = obj->state;
-                        spin_unlock_irqrestore(&db->lock, flags);
+                        raw_spin_unlock_irqrestore(&db->lock, flags);
                         debug_object_fixup(descr->fixup_activate, addr, state);
                         return;
 
@@ -408,11 +408,11 @@ void debug_object_activate(void *addr, struct debug_obj_descr *descr)
                 default:
                         break;
                 }
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
                 return;
         }
 
-        spin_unlock_irqrestore(&db->lock, flags);
+        raw_spin_unlock_irqrestore(&db->lock, flags);
         /*
          * This happens when a static object is activated. We
          * let the type specific code decide whether this is
@@ -438,7 +438,7 @@ void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
 
         db = get_bucket((unsigned long) addr);
 
-        spin_lock_irqsave(&db->lock, flags);
+        raw_spin_lock_irqsave(&db->lock, flags);
 
         obj = lookup_object(addr, db);
         if (obj) {
@@ -463,7 +463,7 @@ void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
                 debug_print_object(&o, "deactivate");
         }
 
-        spin_unlock_irqrestore(&db->lock, flags);
+        raw_spin_unlock_irqrestore(&db->lock, flags);
 }
 
 /**
@@ -483,7 +483,7 @@ void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
 
         db = get_bucket((unsigned long) addr);
 
-        spin_lock_irqsave(&db->lock, flags);
+        raw_spin_lock_irqsave(&db->lock, flags);
 
         obj = lookup_object(addr, db);
         if (!obj)
@@ -498,7 +498,7 @@ void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
         case ODEBUG_STATE_ACTIVE:
                 debug_print_object(obj, "destroy");
                 state = obj->state;
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
                 debug_object_fixup(descr->fixup_destroy, addr, state);
                 return;
 
@@ -509,7 +509,7 @@ void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
                 break;
         }
 out_unlock:
-        spin_unlock_irqrestore(&db->lock, flags);
+        raw_spin_unlock_irqrestore(&db->lock, flags);
 }
 
 /**
@@ -529,7 +529,7 @@ void debug_object_free(void *addr, struct debug_obj_descr *descr)
 
         db = get_bucket((unsigned long) addr);
 
-        spin_lock_irqsave(&db->lock, flags);
+        raw_spin_lock_irqsave(&db->lock, flags);
 
         obj = lookup_object(addr, db);
         if (!obj)
@@ -539,17 +539,17 @@ void debug_object_free(void *addr, struct debug_obj_descr *descr)
         case ODEBUG_STATE_ACTIVE:
                 debug_print_object(obj, "free");
                 state = obj->state;
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
                 debug_object_fixup(descr->fixup_free, addr, state);
                 return;
         default:
                 hlist_del(&obj->node);
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
                 free_object(obj);
                 return;
         }
 out_unlock:
-        spin_unlock_irqrestore(&db->lock, flags);
+        raw_spin_unlock_irqrestore(&db->lock, flags);
 }
 
 #ifdef CONFIG_DEBUG_OBJECTS_FREE
@@ -575,7 +575,7 @@ static void __debug_check_no_obj_freed(const void *address, unsigned long size)
 
 repeat:
                 cnt = 0;
-                spin_lock_irqsave(&db->lock, flags);
+                raw_spin_lock_irqsave(&db->lock, flags);
                 hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
                         cnt++;
                         oaddr = (unsigned long) obj->object;
@@ -587,7 +587,7 @@ repeat:
                                 debug_print_object(obj, "free");
                                 descr = obj->descr;
                                 state = obj->state;
-                                spin_unlock_irqrestore(&db->lock, flags);
+                                raw_spin_unlock_irqrestore(&db->lock, flags);
                                 debug_object_fixup(descr->fixup_free,
                                                    (void *) oaddr, state);
                                 goto repeat;
@@ -597,7 +597,7 @@ repeat:
                                 break;
                         }
                 }
-                spin_unlock_irqrestore(&db->lock, flags);
+                raw_spin_unlock_irqrestore(&db->lock, flags);
 
                 /* Now free them */
                 hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
@@ -783,7 +783,7 @@ check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
 
         db = get_bucket((unsigned long) addr);
 
-        spin_lock_irqsave(&db->lock, flags);
+        raw_spin_lock_irqsave(&db->lock, flags);
 
         obj = lookup_object(addr, db);
         if (!obj && state != ODEBUG_STATE_NONE) {
@@ -807,7 +807,7 @@ check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
         }
         res = 0;
 out:
-        spin_unlock_irqrestore(&db->lock, flags);
+        raw_spin_unlock_irqrestore(&db->lock, flags);
         if (res)
                 debug_objects_enabled = 0;
         return res;
@@ -907,7 +907,7 @@ void __init debug_objects_early_init(void)
         int i;
 
         for (i = 0; i < ODEBUG_HASH_SIZE; i++)
-                spin_lock_init(&obj_hash[i].lock);
+                raw_spin_lock_init(&obj_hash[i].lock);
 
         for (i = 0; i < ODEBUG_POOL_SIZE; i++)
                 hlist_add_head(&obj_static_pool[i].node, &obj_pool);
diff --git a/lib/kernel_lock.c b/lib/kernel_lock.c
index 5526b46aba94..b135d04aa48a 100644
--- a/lib/kernel_lock.c
+++ b/lib/kernel_lock.c
@@ -23,7 +23,7 @@
  *
  * Don't use in new code.
  */
-static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);
+static  __cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK(kernel_flag);
 
 
 /*
@@ -36,12 +36,12 @@ static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);
  * If it successfully gets the lock, it should increment
  * 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)
  */
 int __lockfunc __reacquire_kernel_lock(void)
 {
-        while (!_raw_spin_trylock(&kernel_flag)) {
+        while (!do_raw_spin_trylock(&kernel_flag)) {
                 if (need_resched())
                         return -EAGAIN;
                 cpu_relax();
@@ -52,27 +52,27 @@ int __lockfunc __reacquire_kernel_lock(void)
 
 void __lockfunc __release_kernel_lock(void)
 {
-        _raw_spin_unlock(&kernel_flag);
+        do_raw_spin_unlock(&kernel_flag);
         preempt_enable_no_resched();
 }
 
 /*
  * 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
- * _raw_spin_trylock() will always succeed.
+ * do_raw_spin_trylock() will always succeed.
  */
 #ifdef CONFIG_PREEMPT
 static inline void __lock_kernel(void)
 {
         preempt_disable();
-        if (unlikely(!_raw_spin_trylock(&kernel_flag))) {
+        if (unlikely(!do_raw_spin_trylock(&kernel_flag))) {
                 /*
                  * If preemption was disabled even before this
                  * was called, there's nothing we can be polite
                  * about - just spin.
                  */
                 if (preempt_count() > 1) {
-                        _raw_spin_lock(&kernel_flag);
+                        do_raw_spin_lock(&kernel_flag);
                         return;
                 }
 
@@ -82,10 +82,10 @@ static inline void __lock_kernel(void)
                  */
                 do {
                         preempt_enable();
-                        while (spin_is_locked(&kernel_flag))
+                        while (raw_spin_is_locked(&kernel_flag))
                                 cpu_relax();
                         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)
 {
-        _raw_spin_lock(&kernel_flag);
+        do_raw_spin_lock(&kernel_flag);
 }
 #endif
 
@@ -106,7 +106,7 @@ static inline void __unlock_kernel(void)
          * the BKL is not covered by lockdep, so we open-code the
          * unlocking sequence (and thus avoid the dep-chain ops):
          */
-        _raw_spin_unlock(&kernel_flag);
+        do_raw_spin_unlock(&kernel_flag);
         preempt_enable();
 }
 
diff --git a/lib/plist.c b/lib/plist.c
index d6c64a824e1d..1471988d9190 100644
--- a/lib/plist.c
+++ b/lib/plist.c
@@ -54,9 +54,11 @@ static void plist_check_list(struct list_head *top)
 
 static void plist_check_head(struct plist_head *head)
 {
-        WARN_ON(!head->lock);
-        if (head->lock)
-                WARN_ON_SMP(!spin_is_locked(head->lock));
+        WARN_ON(!head->rawlock && !head->spinlock);
+        if (head->rawlock)
+                WARN_ON_SMP(!raw_spin_is_locked(head->rawlock));
+        if (head->spinlock)
+                WARN_ON_SMP(!spin_is_locked(head->spinlock));
         plist_check_list(&head->prio_list);
         plist_check_list(&head->node_list);
 }
diff --git a/lib/spinlock_debug.c b/lib/spinlock_debug.c
index 9c4b0256490b..4755b98b6dfb 100644
--- a/lib/spinlock_debug.c
+++ b/lib/spinlock_debug.c
@@ -13,8 +13,8 @@
 #include <linux/delay.h>
 #include <linux/module.h>
 
-void __spin_lock_init(spinlock_t *lock, const char *name,
-                      struct lock_class_key *key)
+void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name,
+                          struct lock_class_key *key)
 {
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
         /*
@@ -23,13 +23,13 @@ void __spin_lock_init(spinlock_t *lock, const char *name,
         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
         lockdep_init_map(&lock->dep_map, name, key, 0);
 #endif
-        lock->raw_lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        lock->raw_lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
         lock->magic = SPINLOCK_MAGIC;
         lock->owner = SPINLOCK_OWNER_INIT;
         lock->owner_cpu = -1;
 }
 
-EXPORT_SYMBOL(__spin_lock_init);
+EXPORT_SYMBOL(__raw_spin_lock_init);
 
 void __rwlock_init(rwlock_t *lock, const char *name,
                    struct lock_class_key *key)
@@ -41,7 +41,7 @@ void __rwlock_init(rwlock_t *lock, const char *name,
         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
         lockdep_init_map(&lock->dep_map, name, key, 0);
 #endif
-        lock->raw_lock = (raw_rwlock_t) __RAW_RW_LOCK_UNLOCKED;
+        lock->raw_lock = (arch_rwlock_t) __ARCH_RW_LOCK_UNLOCKED;
         lock->magic = RWLOCK_MAGIC;
         lock->owner = SPINLOCK_OWNER_INIT;
         lock->owner_cpu = -1;
@@ -49,7 +49,7 @@ void __rwlock_init(rwlock_t *lock, const char *name,
 
 EXPORT_SYMBOL(__rwlock_init);
 
-static void spin_bug(spinlock_t *lock, const char *msg)
+static void spin_bug(raw_spinlock_t *lock, const char *msg)
 {
         struct task_struct *owner = NULL;
 
@@ -73,7 +73,7 @@ static void spin_bug(spinlock_t *lock, const char *msg)
 #define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg)
 
 static inline void
-debug_spin_lock_before(spinlock_t *lock)
+debug_spin_lock_before(raw_spinlock_t *lock)
 {
         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
         SPIN_BUG_ON(lock->owner == current, lock, "recursion");
@@ -81,16 +81,16 @@ debug_spin_lock_before(spinlock_t *lock)
                                                         lock, "cpu recursion");
 }
 
-static inline void debug_spin_lock_after(spinlock_t *lock)
+static inline void debug_spin_lock_after(raw_spinlock_t *lock)
 {
         lock->owner_cpu = raw_smp_processor_id();
         lock->owner = current;
 }
 
-static inline void debug_spin_unlock(spinlock_t *lock)
+static inline void debug_spin_unlock(raw_spinlock_t *lock)
 {
         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
-        SPIN_BUG_ON(!spin_is_locked(lock), lock, "already unlocked");
+        SPIN_BUG_ON(!raw_spin_is_locked(lock), lock, "already unlocked");
         SPIN_BUG_ON(lock->owner != current, lock, "wrong owner");
         SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
                                                         lock, "wrong CPU");
@@ -98,7 +98,7 @@ static inline void debug_spin_unlock(spinlock_t *lock)
         lock->owner_cpu = -1;
 }
 
-static void __spin_lock_debug(spinlock_t *lock)
+static void __spin_lock_debug(raw_spinlock_t *lock)
 {
         u64 i;
         u64 loops = loops_per_jiffy * HZ;
@@ -106,7 +106,7 @@ static void __spin_lock_debug(spinlock_t *lock)
 
         for (;;) {
                 for (i = 0; i < loops; i++) {
-                        if (__raw_spin_trylock(&lock->raw_lock))
+                        if (arch_spin_trylock(&lock->raw_lock))
                                 return;
                         __delay(1);
                 }
@@ -125,17 +125,17 @@ static void __spin_lock_debug(spinlock_t *lock)
         }
 }
 
-void _raw_spin_lock(spinlock_t *lock)
+void do_raw_spin_lock(raw_spinlock_t *lock)
 {
         debug_spin_lock_before(lock);
-        if (unlikely(!__raw_spin_trylock(&lock->raw_lock)))
+        if (unlikely(!arch_spin_trylock(&lock->raw_lock)))
                 __spin_lock_debug(lock);
         debug_spin_lock_after(lock);
 }
 
-int _raw_spin_trylock(spinlock_t *lock)
+int do_raw_spin_trylock(raw_spinlock_t *lock)
 {
-        int ret = __raw_spin_trylock(&lock->raw_lock);
+        int ret = arch_spin_trylock(&lock->raw_lock);
 
         if (ret)
                 debug_spin_lock_after(lock);
@@ -148,10 +148,10 @@ int _raw_spin_trylock(spinlock_t *lock)
         return ret;
 }
 
-void _raw_spin_unlock(spinlock_t *lock)
+void do_raw_spin_unlock(raw_spinlock_t *lock)
 {
         debug_spin_unlock(lock);
-        __raw_spin_unlock(&lock->raw_lock);
+        arch_spin_unlock(&lock->raw_lock);
 }
 
 static void rwlock_bug(rwlock_t *lock, const char *msg)
@@ -176,7 +176,7 @@ static void __read_lock_debug(rwlock_t *lock)
 
         for (;;) {
                 for (i = 0; i < loops; i++) {
-                        if (__raw_read_trylock(&lock->raw_lock))
+                        if (arch_read_trylock(&lock->raw_lock))
                                 return;
                         __delay(1);
                 }
@@ -193,15 +193,15 @@ static void __read_lock_debug(rwlock_t *lock)
 }
 #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");
-        __raw_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 = __raw_read_trylock(&lock->raw_lock);
+        int ret = arch_read_trylock(&lock->raw_lock);
 
 #ifndef CONFIG_SMP
         /*
@@ -212,10 +212,10 @@ int _raw_read_trylock(rwlock_t *lock)
         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");
-        __raw_read_unlock(&lock->raw_lock);
+        arch_read_unlock(&lock->raw_lock);
 }
 
 static inline void debug_write_lock_before(rwlock_t *lock)
@@ -251,7 +251,7 @@ static void __write_lock_debug(rwlock_t *lock)
 
         for (;;) {
                 for (i = 0; i < loops; i++) {
-                        if (__raw_write_trylock(&lock->raw_lock))
+                        if (arch_write_trylock(&lock->raw_lock))
                                 return;
                         __delay(1);
                 }
@@ -268,16 +268,16 @@ static void __write_lock_debug(rwlock_t *lock)
 }
 #endif
 
-void _raw_write_lock(rwlock_t *lock)
+void do_raw_write_lock(rwlock_t *lock)
 {
         debug_write_lock_before(lock);
-        __raw_write_lock(&lock->raw_lock);
+        arch_write_lock(&lock->raw_lock);
         debug_write_lock_after(lock);
 }
 
-int _raw_write_trylock(rwlock_t *lock)
+int do_raw_write_trylock(rwlock_t *lock)
 {
-        int ret = __raw_write_trylock(&lock->raw_lock);
+        int ret = arch_write_trylock(&lock->raw_lock);
 
         if (ret)
                 debug_write_lock_after(lock);
@@ -290,8 +290,8 @@ int _raw_write_trylock(rwlock_t *lock)
         return ret;
 }
 
-void _raw_write_unlock(rwlock_t *lock)
+void do_raw_write_unlock(rwlock_t *lock)
 {
         debug_write_unlock(lock);
-        __raw_write_unlock(&lock->raw_lock);
+        arch_write_unlock(&lock->raw_lock);
 }