[SPARC64]: Make debugging spinlocks usable again.

When the spinlock routines were moved out of line into
kernel/spinlock.c this made it so that the debugging
spinlocks record lock acquisition program counts in the
kernel/spinlock.c functions not in their callers.
This makes the debugging info kind of useless.

So record the correct caller's program counter and
now this feature is useful once more.

Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/arch/sparc64/kernel/sparc64_ksyms.c b/arch/sparc64/kernel/sparc64_ksyms.c
index 9202d925a9ce6961816b5920f5cd9e5bc8758c58..0764b93307845e98e3b7bca2aa8d5e771ff422c2 100644 (file)
--- a/arch/sparc64/kernel/sparc64_ksyms.c
+++ b/arch/sparc64/kernel/sparc64_ksyms.c
@@ -99,17 +99,6 @@ extern int __ashrdi3(int, int);
 extern void dump_thread(struct pt_regs *, struct user *);
 extern int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs);
 
-#if defined(CONFIG_SMP) && defined(CONFIG_DEBUG_SPINLOCK)
-extern void _do_spin_lock (spinlock_t *lock, char *str);
-extern void _do_spin_unlock (spinlock_t *lock);
-extern int _spin_trylock (spinlock_t *lock);
-extern void _do_read_lock(rwlock_t *rw, char *str);
-extern void _do_read_unlock(rwlock_t *rw, char *str);
-extern void _do_write_lock(rwlock_t *rw, char *str);
-extern void _do_write_unlock(rwlock_t *rw);
-extern int _do_write_trylock(rwlock_t *rw, char *str);
-#endif
-
 extern unsigned long phys_base;
 extern unsigned long pfn_base;
 
@@ -152,18 +141,6 @@ EXPORT_SYMBOL(_mcount);
 EXPORT_SYMBOL(cpu_online_map);
 EXPORT_SYMBOL(phys_cpu_present_map);
 
-/* Spinlock debugging library, optional. */
-#ifdef CONFIG_DEBUG_SPINLOCK
-EXPORT_SYMBOL(_do_spin_lock);
-EXPORT_SYMBOL(_do_spin_unlock);
-EXPORT_SYMBOL(_spin_trylock);
-EXPORT_SYMBOL(_do_read_lock);
-EXPORT_SYMBOL(_do_read_unlock);
-EXPORT_SYMBOL(_do_write_lock);
-EXPORT_SYMBOL(_do_write_unlock);
-EXPORT_SYMBOL(_do_write_trylock);
-#endif
-
 EXPORT_SYMBOL(smp_call_function);
 #endif /* CONFIG_SMP */
 

diff --git a/arch/sparc64/lib/debuglocks.c b/arch/sparc64/lib/debuglocks.c
index f03344cf784e1785efbef5e0b195d89a568549b3..7f6ccc4114c50befc33c32e1a48ee63a32f99287 100644 (file)
--- a/arch/sparc64/lib/debuglocks.c
+++ b/arch/sparc64/lib/debuglocks.c
@@ -12,8 +12,6 @@
 
 #ifdef CONFIG_SMP
 
-#define GET_CALLER(PC) __asm__ __volatile__("mov %%i7, %0" : "=r" (PC))
-
 static inline void show (char *str, spinlock_t *lock, unsigned long caller)
 {
        int cpu = smp_processor_id();
@@ -51,14 +49,13 @@ static inline void show_write (char *str, rwlock_t *lock, unsigned long caller)
 #undef INIT_STUCK
 #define INIT_STUCK 100000000
 
-void _do_spin_lock(spinlock_t *lock, char *str)
+void _do_spin_lock(spinlock_t *lock, char *str, unsigned long caller)
 {
-       unsigned long caller, val;
+       unsigned long val;
        int stuck = INIT_STUCK;
        int cpu = get_cpu();
        int shown = 0;
 
-       GET_CALLER(caller);
 again:
        __asm__ __volatile__("ldstub [%1], %0"
                             : "=r" (val)
@@ -84,12 +81,11 @@ again:
        put_cpu();
 }
 
-int _do_spin_trylock(spinlock_t *lock)
+int _do_spin_trylock(spinlock_t *lock, unsigned long caller)
 {
-       unsigned long val, caller;
+       unsigned long val;
        int cpu = get_cpu();
 
-       GET_CALLER(caller);
        __asm__ __volatile__("ldstub [%1], %0"
                             : "=r" (val)
                             : "r" (&(lock->lock))
@@ -118,14 +114,13 @@ void _do_spin_unlock(spinlock_t *lock)
 
 /* Keep INIT_STUCK the same... */
 
-void _do_read_lock (rwlock_t *rw, char *str)
+void _do_read_lock(rwlock_t *rw, char *str, unsigned long caller)
 {
-       unsigned long caller, val;
+       unsigned long val;
        int stuck = INIT_STUCK;
        int cpu = get_cpu();
        int shown = 0;
 
-       GET_CALLER(caller);
 wlock_again:
        /* Wait for any writer to go away.  */
        while (((long)(rw->lock)) < 0) {
@@ -157,15 +152,13 @@ wlock_again:
        put_cpu();
 }
 
-void _do_read_unlock (rwlock_t *rw, char *str)
+void _do_read_unlock(rwlock_t *rw, char *str, unsigned long caller)
 {
-       unsigned long caller, val;
+       unsigned long val;
        int stuck = INIT_STUCK;
        int cpu = get_cpu();
        int shown = 0;
 
-       GET_CALLER(caller);
-
        /* Drop our identity _first_. */
        rw->reader_pc[cpu] = 0;
        current->thread.smp_lock_count--;
@@ -193,14 +186,13 @@ runlock_again:
        put_cpu();
 }
 
-void _do_write_lock (rwlock_t *rw, char *str)
+void _do_write_lock(rwlock_t *rw, char *str, unsigned long caller)
 {
-       unsigned long caller, val;
+       unsigned long val;
        int stuck = INIT_STUCK;
        int cpu = get_cpu();
        int shown = 0;
 
-       GET_CALLER(caller);
 wlock_again:
        /* Spin while there is another writer. */
        while (((long)rw->lock) < 0) {
@@ -278,14 +270,12 @@ wlock_again:
        put_cpu();
 }
 
-void _do_write_unlock(rwlock_t *rw)
+void _do_write_unlock(rwlock_t *rw, unsigned long caller)
 {
-       unsigned long caller, val;
+       unsigned long val;
        int stuck = INIT_STUCK;
        int shown = 0;
 
-       GET_CALLER(caller);
-
        /* Drop our identity _first_ */
        rw->writer_pc = 0;
        rw->writer_cpu = NO_PROC_ID;
@@ -313,13 +303,11 @@ wlock_again:
        }
 }
 
-int _do_write_trylock (rwlock_t *rw, char *str)
+int _do_write_trylock(rwlock_t *rw, char *str, unsigned long caller)
 {
-       unsigned long caller, val;
+       unsigned long val;
        int cpu = get_cpu();
 
-       GET_CALLER(caller);
-
        /* Try to acuire the write bit.  */
        __asm__ __volatile__(
 "      mov     1, %%g3\n"

diff --git a/include/asm-sparc64/spinlock.h b/include/asm-sparc64/spinlock.h
index 9cb93a5c2b4feac61ab2245c9ca17cb74997ded0..d265bf6570fe421bc9f85f0915cd4897dc19d0c5 100644 (file)
--- a/include/asm-sparc64/spinlock.h
+++ b/include/asm-sparc64/spinlock.h
@@ -132,12 +132,15 @@ do { \
        membar("#LoadLoad"); \
 } while((__lock)->lock)
 
-extern void _do_spin_lock (spinlock_t *lock, char *str);
-extern void _do_spin_unlock (spinlock_t *lock);
-extern int _do_spin_trylock (spinlock_t *lock);
-
-#define _raw_spin_trylock(lp)  _do_spin_trylock(lp)
-#define _raw_spin_lock(lock)   _do_spin_lock(lock, "spin_lock")
+extern void _do_spin_lock(spinlock_t *lock, char *str, unsigned long caller);
+extern void _do_spin_unlock(spinlock_t *lock);
+extern int _do_spin_trylock(spinlock_t *lock, unsigned long caller);
+
+#define _raw_spin_trylock(lp)  \
+       _do_spin_trylock(lp, (unsigned long) __builtin_return_address(0))
+#define _raw_spin_lock(lock)   \
+       _do_spin_lock(lock, "spin_lock", \
+                     (unsigned long) __builtin_return_address(0))
 #define _raw_spin_unlock(lock) _do_spin_unlock(lock)
 #define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
 
@@ -279,37 +282,41 @@ typedef struct {
 #define RW_LOCK_UNLOCKED       (rwlock_t) { 0, 0, 0xff, { } }
 #define rwlock_init(lp) do { *(lp) = RW_LOCK_UNLOCKED; } while(0)
 
-extern void _do_read_lock(rwlock_t *rw, char *str);
-extern void _do_read_unlock(rwlock_t *rw, char *str);
-extern void _do_write_lock(rwlock_t *rw, char *str);
-extern void _do_write_unlock(rwlock_t *rw);
-extern int _do_write_trylock(rwlock_t *rw, char *str);
+extern void _do_read_lock(rwlock_t *rw, char *str, unsigned long caller);
+extern void _do_read_unlock(rwlock_t *rw, char *str, unsigned long caller);
+extern void _do_write_lock(rwlock_t *rw, char *str, unsigned long caller);
+extern void _do_write_unlock(rwlock_t *rw, unsigned long caller);
+extern int _do_write_trylock(rwlock_t *rw, char *str, unsigned long caller);
 
 #define _raw_read_lock(lock) \
 do {   unsigned long flags; \
        local_irq_save(flags); \
-       _do_read_lock(lock, "read_lock"); \
+       _do_read_lock(lock, "read_lock", \
+                     (unsigned long) __builtin_return_address(0)); \
        local_irq_restore(flags); \
 } while(0)
 
 #define _raw_read_unlock(lock) \
 do {   unsigned long flags; \
        local_irq_save(flags); \
-       _do_read_unlock(lock, "read_unlock"); \
+       _do_read_unlock(lock, "read_unlock", \
+                     (unsigned long) __builtin_return_address(0)); \
        local_irq_restore(flags); \
 } while(0)
 
 #define _raw_write_lock(lock) \
 do {   unsigned long flags; \
        local_irq_save(flags); \
-       _do_write_lock(lock, "write_lock"); \
+       _do_write_lock(lock, "write_lock", \
+                     (unsigned long) __builtin_return_address(0)); \
        local_irq_restore(flags); \
 } while(0)
 
 #define _raw_write_unlock(lock) \
 do {   unsigned long flags; \
        local_irq_save(flags); \
-       _do_write_unlock(lock); \
+       _do_write_unlock(lock, \
+                     (unsigned long) __builtin_return_address(0)); \
        local_irq_restore(flags); \
 } while(0)
 
@@ -317,7 +324,8 @@ do {        unsigned long flags; \
 ({     unsigned long flags; \
        int val; \
        local_irq_save(flags); \
-       val = _do_write_trylock(lock, "write_trylock"); \
+       val = _do_write_trylock(lock, "write_trylock", \
+                               (unsigned long) __builtin_return_address(0)); \
        local_irq_restore(flags); \
        val; \
 })