arch/ppc/lib/locks.c

   1 /*
   2  * Locks for smp ppc
   3  *
   4  * Written by Cort Dougan (cort@cs.nmt.edu)
   5  */
   6
   7 #include <linux/sched.h>
   8 #include <linux/spinlock.h>
   9 #include <linux/module.h>
  10 #include <asm/ppc_asm.h>
  11 #include <asm/smp.h>
  12
  13 #ifdef CONFIG_DEBUG_SPINLOCK
  14
  15 #undef INIT_STUCK
  16 #define INIT_STUCK 200000000 /*0xffffffff*/
  17
  18 /*
  19  * Try to acquire a spinlock.
  20  * Only does the stwcx. if the load returned 0 - the Programming
  21  * Environments Manual suggests not doing unnecessary stcwx.'s
  22  * since they may inhibit forward progress by other CPUs in getting
  23  * a lock.
  24  */
  25 static inline unsigned long __spin_trylock(volatile unsigned long *lock)
  26 {
  27         unsigned long ret;
  28
  29         __asm__ __volatile__ ("\n\
  30 1:      lwarx   %0,0,%1\n\
  31         cmpwi   0,%0,0\n\
  32         bne     2f\n"
  33         PPC405_ERR77(0,%1)
  34 "       stwcx.  %2,0,%1\n\
  35         bne-    1b\n\
  36         isync\n\
  37 2:"
  38         : "=&r"(ret)
  39         : "r"(lock), "r"(1)
  40         : "cr0", "memory");
  41
  42         return ret;
  43 }
  44
  45 void _raw_spin_lock(spinlock_t *lock)
  46 {
  47         int cpu = smp_processor_id();
  48         unsigned int stuck = INIT_STUCK;
  49         while (__spin_trylock(&lock->lock)) {
  50                 while ((unsigned volatile long)lock->lock != 0) {
  51                         if (!--stuck) {
  52                                 printk("_spin_lock(%p) CPU#%d NIP %p"
  53                                        " holder: cpu %ld pc %08lX\n",
  54                                        lock, cpu, __builtin_return_address(0),
  55                                        lock->owner_cpu,lock->owner_pc);
  56                                 stuck = INIT_STUCK;
  57                                 /* steal the lock */
  58                                 /*xchg_u32((void *)&lock->lock,0);*/
  59                         }
  60                 }
  61         }
  62         lock->owner_pc = (unsigned long)__builtin_return_address(0);
  63         lock->owner_cpu = cpu;
  64 }
  65 EXPORT_SYMBOL(_raw_spin_lock);
  66
  67 int _raw_spin_trylock(spinlock_t *lock)
  68 {
  69         if (__spin_trylock(&lock->lock))
  70                 return 0;
  71         lock->owner_cpu = smp_processor_id();
  72         lock->owner_pc = (unsigned long)__builtin_return_address(0);
  73         return 1;
  74 }
  75 EXPORT_SYMBOL(_raw_spin_trylock);
  76
  77 void _raw_spin_unlock(spinlock_t *lp)
  78 {
  79         if ( !lp->lock )
  80                 printk("_spin_unlock(%p): no lock cpu %d curr PC %p %s/%d\n",
  81                        lp, smp_processor_id(), __builtin_return_address(0),
  82                        current->comm, current->pid);
  83         if ( lp->owner_cpu != smp_processor_id() )
  84                 printk("_spin_unlock(%p): cpu %d trying clear of cpu %d pc %lx val %lx\n",
  85                       lp, smp_processor_id(), (int)lp->owner_cpu,
  86                       lp->owner_pc,lp->lock);
  87         lp->owner_pc = lp->owner_cpu = 0;
  88         wmb();
  89         lp->lock = 0;
  90 }
  91 EXPORT_SYMBOL(_raw_spin_unlock);
  92
  93 /*
  94  * For rwlocks, zero is unlocked, -1 is write-locked,
  95  * positive is read-locked.
  96  */
  97 static __inline__ int __read_trylock(rwlock_t *rw)
  98 {
  99         signed int tmp;
 100
 101         __asm__ __volatile__(
 102 "2:     lwarx   %0,0,%1         # __read_trylock\n\
 103         addic.  %0,%0,1\n\
 104         ble-    1f\n"
 105         PPC405_ERR77(0,%1)
 106 "       stwcx.  %0,0,%1\n\
 107         bne-    2b\n\
 108         isync\n\
 109 1:"
 110         : "=&r"(tmp)
 111         : "r"(&rw->lock)
 112         : "cr0", "memory");
 113
 114         return tmp;
 115 }
 116
 117 int _raw_read_trylock(rwlock_t *rw)
 118 {
 119         return __read_trylock(rw) > 0;
 120 }
 121 EXPORT_SYMBOL(_raw_read_trylock);
 122
 123 void _raw_read_lock(rwlock_t *rw)
 124 {
 125         unsigned int stuck;
 126
 127         while (__read_trylock(rw) <= 0) {
 128                 stuck = INIT_STUCK;
 129                 while (!read_can_lock(rw)) {
 130                         if (--stuck == 0) {
 131                                 printk("_read_lock(%p) CPU#%d lock %d\n",
 132                                        rw, raw_smp_processor_id(), rw->lock);
 133                                 stuck = INIT_STUCK;
 134                         }
 135                 }
 136         }
 137 }
 138 EXPORT_SYMBOL(_raw_read_lock);
 139
 140 void _raw_read_unlock(rwlock_t *rw)
 141 {
 142         if ( rw->lock == 0 )
 143                 printk("_read_unlock(): %s/%d (nip %08lX) lock %d\n",
 144                        current->comm,current->pid,current->thread.regs->nip,
 145                       rw->lock);
 146         wmb();
 147         atomic_dec((atomic_t *) &(rw)->lock);
 148 }
 149 EXPORT_SYMBOL(_raw_read_unlock);
 150
 151 void _raw_write_lock(rwlock_t *rw)
 152 {
 153         unsigned int stuck;
 154
 155         while (cmpxchg(&rw->lock, 0, -1) != 0) {
 156                 stuck = INIT_STUCK;
 157                 while (!write_can_lock(rw)) {
 158                         if (--stuck == 0) {
 159                                 printk("write_lock(%p) CPU#%d lock %d)\n",
 160                                        rw, raw_smp_processor_id(), rw->lock);
 161                                 stuck = INIT_STUCK;
 162                         }
 163                 }
 164         }
 165         wmb();
 166 }
 167 EXPORT_SYMBOL(_raw_write_lock);
 168
 169 int _raw_write_trylock(rwlock_t *rw)
 170 {
 171         if (cmpxchg(&rw->lock, 0, -1) != 0)
 172                 return 0;
 173         wmb();
 174         return 1;
 175 }
 176 EXPORT_SYMBOL(_raw_write_trylock);
 177
 178 void _raw_write_unlock(rwlock_t *rw)
 179 {
 180         if (rw->lock >= 0)
 181                 printk("_write_lock(): %s/%d (nip %08lX) lock %d\n",
 182                       current->comm,current->pid,current->thread.regs->nip,
 183                       rw->lock);
 184         wmb();
 185         rw->lock = 0;
 186 }
 187 EXPORT_SYMBOL(_raw_write_unlock);
 188
 189 #endif