1 files changed, 0 insertions, 102 deletions
diff --git a/arch/parisc/kernel/semaphore.c b/arch/parisc/kernel/semaphore.c
deleted file mode 100644
index ee806bcc3726..000000000000
--- a/arch/parisc/kernel/semaphore.c
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * 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;
-}

diff --git a/arch/parisc/kernel/semaphore.c b/arch/parisc/kernel/semaphore.c deleted file mode 100644 index ee806bcc3726..000000000000 --- a/arch/parisc/kernel/semaphore.c +++ /dev/null
@@ -1,102 +0,0 @@
1	/*
2	* Semaphore implementation Copyright (c) 2001 Matthew Wilcox, Hewlett-Packard
3	*/
4
5	#include <linux/sched.h>
6	#include <linux/spinlock.h>
7	#include <linux/errno.h>
8	#include <linux/init.h>
9
10	/*
11	* Semaphores are complex as we wish to avoid using two variables.
12	* `count' has multiple roles, depending on its value. If it is positive
13	* or zero, there are no waiters. The functions here will never be
14	* called; see <asm/semaphore.h>
15	*
16	* When count is -1 it indicates there is at least one task waiting
17	* for the semaphore.
18	*
19	* When count is less than that, there are '- count - 1' wakeups
20	* pending. ie if it has value -3, there are 2 wakeups pending.
21	*
22	* Note that these functions are only called when there is contention
23	* on the lock, and as such all this is the "non-critical" part of the
24	* whole semaphore business. The critical part is the inline stuff in
25	* <asm/semaphore.h> where we want to avoid any extra jumps and calls.
26	*/
27	void __up(struct semaphore *sem)
28	{
29	sem->count--;
30	wake_up(&sem->wait);
31	}
32
33	#define wakers(count) (-1 - count)
34
35	#define DOWN_HEAD \
36	int ret = 0; \
37	DECLARE_WAITQUEUE(wait, current); \
38	\
39	/* Note that someone is waiting */ \
40	if (sem->count == 0) \
41	sem->count = -1; \
42	\
43	/* protected by the sentry still -- use unlocked version */ \
44	wait.flags = WQ_FLAG_EXCLUSIVE; \
45	__add_wait_queue_tail(&sem->wait, &wait); \
46	lost_race: \
47	spin_unlock_irq(&sem->sentry); \
48
49	#define DOWN_TAIL \
50	spin_lock_irq(&sem->sentry); \
51	if (wakers(sem->count) == 0 && ret == 0) \
52	goto lost_race; /* Someone stole our wakeup */ \
53	__remove_wait_queue(&sem->wait, &wait); \
54	current->state = TASK_RUNNING; \
55	if (!waitqueue_active(&sem->wait) && (sem->count < 0)) \
56	sem->count = wakers(sem->count);
57
58	#define UPDATE_COUNT \
59	sem->count += (sem->count < 0) ? 1 : - 1;
60
61
62	void __sched __down(struct semaphore * sem)
63	{
64	DOWN_HEAD
65
66	for(;;) {
67	set_task_state(current, TASK_UNINTERRUPTIBLE);
68	/* we can _read_ this without the sentry */
69	if (sem->count != -1)
70	break;
71	schedule();
72	}
73
74	DOWN_TAIL
75	UPDATE_COUNT
76	}
77
78	int __sched __down_interruptible(struct semaphore * sem)
79	{
80	DOWN_HEAD
81
82	for(;;) {
83	set_task_state(current, TASK_INTERRUPTIBLE);
84	/* we can _read_ this without the sentry */
85	if (sem->count != -1)
86	break;
87
88	if (signal_pending(current)) {
89	ret = -EINTR;
90	break;
91	}
92	schedule();
93	}
94
95	DOWN_TAIL
96
97	if (!ret) {
98	UPDATE_COUNT
99	}
100
101	return ret;
102	}