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