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, 102 insertions, 0 deletions

diff --git a/arch/parisc/kernel/semaphore.c b/arch/parisc/kernel/semaphore.c
new file mode 100644
index 000000000000..ee806bcc3726
--- /dev/null
+++ b/arch/parisc/kernel/semaphore.c
@@ -0,0 +1,102 @@
+/*
+ * Semaphore implementation Copyright (c) 2001 Matthew Wilcox, Hewlett-Packard
+ */
+
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+
+/*
+ * Semaphores are complex as we wish to avoid using two variables.
+ * `count' has multiple roles, depending on its value.  If it is positive
+ * or zero, there are no waiters.  The functions here will never be
+ * called; see <asm/semaphore.h>
+ *
+ * When count is -1 it indicates there is at least one task waiting
+ * for the semaphore.
+ *
+ * When count is less than that, there are '- count - 1' wakeups
+ * pending.  ie if it has value -3, there are 2 wakeups pending.
+ *
+ * Note that these functions are only called when there is contention
+ * on the lock, and as such all this is the "non-critical" part of the
+ * whole semaphore business. The critical part is the inline stuff in
+ * <asm/semaphore.h> where we want to avoid any extra jumps and calls.
+ */
+void __up(struct semaphore *sem)
+{
+        sem->count--;
+        wake_up(&sem->wait);
+}
+
+#define wakers(count) (-1 - count)
+
+#define DOWN_HEAD                                                       \
+        int ret = 0;                                                    \
+        DECLARE_WAITQUEUE(wait, current);                               \
+                                                                        \
+        /* Note that someone is waiting */                              \
+        if (sem->count == 0)                                            \
+                sem->count = -1;                                        \
+                                                                        \
+        /* protected by the sentry still -- use unlocked version */     \
+        wait.flags = WQ_FLAG_EXCLUSIVE;                                 \
+        __add_wait_queue_tail(&sem->wait, &wait);                       \
+ lost_race:                                                             \
+        spin_unlock_irq(&sem->sentry);                                  \
+
+#define DOWN_TAIL                                                       \
+        spin_lock_irq(&sem->sentry);                                    \
+        if (wakers(sem->count) == 0 && ret == 0)                        \
+                goto lost_race; /* Someone stole our wakeup */          \
+        __remove_wait_queue(&sem->wait, &wait);                         \
+        current->state = TASK_RUNNING;                                  \
+        if (!waitqueue_active(&sem->wait) && (sem->count < 0))          \
+                sem->count = wakers(sem->count);
+
+#define UPDATE_COUNT                                                    \
+        sem->count += (sem->count < 0) ? 1 : - 1;
+        
+
+void __sched __down(struct semaphore * sem)
+{
+        DOWN_HEAD
+
+        for(;;) {
+                set_task_state(current, TASK_UNINTERRUPTIBLE);
+                /* we can _read_ this without the sentry */
+                if (sem->count != -1)
+                        break;
+                schedule();
+        }
+
+        DOWN_TAIL
+        UPDATE_COUNT
+}
+
+int __sched __down_interruptible(struct semaphore * sem)
+{
+        DOWN_HEAD
+
+        for(;;) {
+                set_task_state(current, TASK_INTERRUPTIBLE);
+                /* we can _read_ this without the sentry */
+                if (sem->count != -1)
+                        break;
+
+                if (signal_pending(current)) {
+                        ret = -EINTR;
+                        break;
+                }
+                schedule();
+        }
+
+        DOWN_TAIL
+
+        if (!ret) {
+                UPDATE_COUNT
+        }
+
+        return ret;
+}