diff options
Diffstat (limited to 'arch/ppc/lib/locks.c')
| -rw-r--r-- | arch/ppc/lib/locks.c | 190 |
1 files changed, 190 insertions, 0 deletions
diff --git a/arch/ppc/lib/locks.c b/arch/ppc/lib/locks.c new file mode 100644 index 0000000..694163d --- /dev/null +++ b/arch/ppc/lib/locks.c @@ -0,0 +1,190 @@ +/* + * Locks for smp ppc + * + * Written by Cort Dougan (cort@cs.nmt.edu) + */ + +#include <linux/config.h> +#include <linux/sched.h> +#include <linux/spinlock.h> +#include <linux/module.h> +#include <asm/ppc_asm.h> +#include <asm/smp.h> + +#ifdef CONFIG_DEBUG_SPINLOCK + +#undef INIT_STUCK +#define INIT_STUCK 200000000 /*0xffffffff*/ + +/* + * Try to acquire a spinlock. + * Only does the stwcx. if the load returned 0 - the Programming + * Environments Manual suggests not doing unnecessary stcwx.'s + * since they may inhibit forward progress by other CPUs in getting + * a lock. + */ +static inline unsigned long __spin_trylock(volatile unsigned long *lock) +{ + unsigned long ret; + + __asm__ __volatile__ ("\n\ +1: lwarx %0,0,%1\n\ + cmpwi 0,%0,0\n\ + bne 2f\n" + PPC405_ERR77(0,%1) +" stwcx. %2,0,%1\n\ + bne- 1b\n\ + isync\n\ +2:" + : "=&r"(ret) + : "r"(lock), "r"(1) + : "cr0", "memory"); + + return ret; +} + +void _raw_spin_lock(spinlock_t *lock) +{ + int cpu = smp_processor_id(); + unsigned int stuck = INIT_STUCK; + while (__spin_trylock(&lock->lock)) { + while ((unsigned volatile long)lock->lock != 0) { + if (!--stuck) { + printk("_spin_lock(%p) CPU#%d NIP %p" + " holder: cpu %ld pc %08lX\n", + lock, cpu, __builtin_return_address(0), + lock->owner_cpu,lock->owner_pc); + stuck = INIT_STUCK; + /* steal the lock */ + /*xchg_u32((void *)&lock->lock,0);*/ + } + } + } + lock->owner_pc = (unsigned long)__builtin_return_address(0); + lock->owner_cpu = cpu; +} +EXPORT_SYMBOL(_raw_spin_lock); + +int _raw_spin_trylock(spinlock_t *lock) +{ + if (__spin_trylock(&lock->lock)) + return 0; + lock->owner_cpu = smp_processor_id(); + lock->owner_pc = (unsigned long)__builtin_return_address(0); + return 1; +} +EXPORT_SYMBOL(_raw_spin_trylock); + +void _raw_spin_unlock(spinlock_t *lp) +{ + if ( !lp->lock ) + printk("_spin_unlock(%p): no lock cpu %d curr PC %p %s/%d\n", + lp, smp_processor_id(), __builtin_return_address(0), + current->comm, current->pid); + if ( lp->owner_cpu != smp_processor_id() ) + printk("_spin_unlock(%p): cpu %d trying clear of cpu %d pc %lx val %lx\n", + lp, smp_processor_id(), (int)lp->owner_cpu, + lp->owner_pc,lp->lock); + lp->owner_pc = lp->owner_cpu = 0; + wmb(); + lp->lock = 0; +} +EXPORT_SYMBOL(_raw_spin_unlock); + +/* + * For rwlocks, zero is unlocked, -1 is write-locked, + * positive is read-locked. + */ +static __inline__ int __read_trylock(rwlock_t *rw) +{ + signed int tmp; + + __asm__ __volatile__( +"2: lwarx %0,0,%1 # __read_trylock\n\ + addic. %0,%0,1\n\ + ble- 1f\n" + PPC405_ERR77(0,%1) +" stwcx. %0,0,%1\n\ + bne- 2b\n\ + isync\n\ +1:" + : "=&r"(tmp) + : "r"(&rw->lock) + : "cr0", "memory"); + + return tmp; +} + +int _raw_read_trylock(rwlock_t *rw) +{ + return __read_trylock(rw) > 0; +} +EXPORT_SYMBOL(_raw_read_trylock); + +void _raw_read_lock(rwlock_t *rw) +{ + unsigned int stuck; + + while (__read_trylock(rw) <= 0) { + stuck = INIT_STUCK; + while (!read_can_lock(rw)) { + if (--stuck == 0) { + printk("_read_lock(%p) CPU#%d lock %d\n", + rw, _smp_processor_id(), rw->lock); + stuck = INIT_STUCK; + } + } + } +} +EXPORT_SYMBOL(_raw_read_lock); + +void _raw_read_unlock(rwlock_t *rw) +{ + if ( rw->lock == 0 ) + printk("_read_unlock(): %s/%d (nip %08lX) lock %d\n", + current->comm,current->pid,current->thread.regs->nip, + rw->lock); + wmb(); + atomic_dec((atomic_t *) &(rw)->lock); +} +EXPORT_SYMBOL(_raw_read_unlock); + +void _raw_write_lock(rwlock_t *rw) +{ + unsigned int stuck; + + while (cmpxchg(&rw->lock, 0, -1) != 0) { + stuck = INIT_STUCK; + while (!write_can_lock(rw)) { + if (--stuck == 0) { + printk("write_lock(%p) CPU#%d lock %d)\n", + rw, _smp_processor_id(), rw->lock); + stuck = INIT_STUCK; + } + } + } + wmb(); +} +EXPORT_SYMBOL(_raw_write_lock); + +int _raw_write_trylock(rwlock_t *rw) +{ + if (cmpxchg(&rw->lock, 0, -1) != 0) + return 0; + wmb(); + return 1; +} +EXPORT_SYMBOL(_raw_write_trylock); + +void _raw_write_unlock(rwlock_t *rw) +{ + if (rw->lock >= 0) + printk("_write_lock(): %s/%d (nip %08lX) lock %d\n", + current->comm,current->pid,current->thread.regs->nip, + rw->lock); + wmb(); + rw->lock = 0; +} +EXPORT_SYMBOL(_raw_write_unlock); + +#endif |