Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

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 000000000000..694163d696d8
--- /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