1 files changed, 0 insertions, 149 deletions
diff --git a/arch/mn10300/kernel/semaphore.c b/arch/mn10300/kernel/semaphore.c
deleted file mode 100644
index 9153c4039fd2..000000000000
--- a/arch/mn10300/kernel/semaphore.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/* MN10300 Semaphore implementation
- *
- * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
- * Written by David Howells (dhowells@redhat.com)
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public Licence
- * as published by the Free Software Foundation; either version
- * 2 of the Licence, or (at your option) any later version.
- */
-#include <linux/sched.h>
-#include <linux/module.h>
-#include <asm/semaphore.h>
-struct sem_waiter {
-        struct list_head        list;
-        struct task_struct      *task;
-};
-#if SEMAPHORE_DEBUG
-void semtrace(struct semaphore *sem, const char *str)
-{
-        if (sem->debug)
-                printk(KERN_DEBUG "[%d] %s({%d,%d})\n",
-                       current->pid,
-                       str,
-                       atomic_read(&sem->count),
-                       list_empty(&sem->wait_list) ? 0 : 1);
-}
-#else
-#define semtrace(SEM, STR) do { } while (0)
-#endif
-/*
- * wait for a token to be granted from a semaphore
- * - entered with lock held and interrupts disabled
- */
-void __down(struct semaphore *sem, unsigned long flags)
-{
-        struct task_struct *tsk = current;
-        struct sem_waiter waiter;
-        semtrace(sem, "Entering __down");
-        /* set up my own style of waitqueue */
-        waiter.task = tsk;
-        get_task_struct(tsk);
-        list_add_tail(&waiter.list, &sem->wait_list);
-        /* we don't need to touch the semaphore struct anymore */
-        spin_unlock_irqrestore(&sem->wait_lock, flags);
-        /* wait to be given the semaphore */
-        set_task_state(tsk, TASK_UNINTERRUPTIBLE);
-        for (;;) {
-                if (!waiter.task)
-                        break;
-                schedule();
-                set_task_state(tsk, TASK_UNINTERRUPTIBLE);
-        }
-        tsk->state = TASK_RUNNING;
-        semtrace(sem, "Leaving __down");
-}
-EXPORT_SYMBOL(__down);
-/*
- * interruptibly wait for a token to be granted from a semaphore
- * - entered with lock held and interrupts disabled
- */
-int __down_interruptible(struct semaphore *sem, unsigned long flags)
-{
-        struct task_struct *tsk = current;
-        struct sem_waiter waiter;
-        int ret;
-        semtrace(sem, "Entering __down_interruptible");
-        /* set up my own style of waitqueue */
-        waiter.task = tsk;
-        get_task_struct(tsk);
-        list_add_tail(&waiter.list, &sem->wait_list);
-        /* we don't need to touch the semaphore struct anymore */
-        set_task_state(tsk, TASK_INTERRUPTIBLE);
-        spin_unlock_irqrestore(&sem->wait_lock, flags);
-        /* wait to be given the semaphore */
-        ret = 0;
-        for (;;) {
-                if (!waiter.task)
-                        break;
-                if (unlikely(signal_pending(current)))
-                        goto interrupted;
-                schedule();
-                set_task_state(tsk, TASK_INTERRUPTIBLE);
-        }
- out:
-        tsk->state = TASK_RUNNING;
-        semtrace(sem, "Leaving __down_interruptible");
-        return ret;
- interrupted:
-        spin_lock_irqsave(&sem->wait_lock, flags);
-        list_del(&waiter.list);
-        spin_unlock_irqrestore(&sem->wait_lock, flags);
-        ret = 0;
-        if (!waiter.task) {
-                put_task_struct(current);
-                ret = -EINTR;
-        }
-        goto out;
-}
-EXPORT_SYMBOL(__down_interruptible);
-/*
- * release a single token back to a semaphore
- * - entered with lock held and interrupts disabled
- */
-void __up(struct semaphore *sem)
-{
-        struct task_struct *tsk;
-        struct sem_waiter *waiter;
-        semtrace(sem, "Entering __up");
-        /* grant the token to the process at the front of the queue */
-        waiter = list_entry(sem->wait_list.next, struct sem_waiter, list);
-        /* We must be careful not to touch 'waiter' after we set ->task = NULL.
-         * It is an allocated on the waiter's stack and may become invalid at
-         * any time after that point (due to a wakeup from another source).
-         */
-        list_del_init(&waiter->list);
-        tsk = waiter->task;
-        smp_mb();
-        waiter->task = NULL;
-        wake_up_process(tsk);
-        put_task_struct(tsk);
-        semtrace(sem, "Leaving __up");
-}
-EXPORT_SYMBOL(__up);

diff --git a/arch/mn10300/kernel/semaphore.c b/arch/mn10300/kernel/semaphore.c deleted file mode 100644 index 9153c4039fd2..000000000000 --- a/arch/mn10300/kernel/semaphore.c +++ /dev/null
@@ -1,149 +0,0 @@
1	/* MN10300 Semaphore implementation
2	*
3	* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4	* Written by David Howells (dhowells@redhat.com)
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public Licence
8	* as published by the Free Software Foundation; either version
9	* 2 of the Licence, or (at your option) any later version.
10	*/
11	#include <linux/sched.h>
12	#include <linux/module.h>
13	#include <asm/semaphore.h>
14
15	struct sem_waiter {
16	struct list_head list;
17	struct task_struct *task;
18	};
19
20	#if SEMAPHORE_DEBUG
21	void semtrace(struct semaphore sem, const char str)
22	{
23	if (sem->debug)
24	printk(KERN_DEBUG "[%d] %s({%d,%d})\n",
25	current->pid,
26	str,
27	atomic_read(&sem->count),
28	list_empty(&sem->wait_list) ? 0 : 1);
29	}
30	#else
31	#define semtrace(SEM, STR) do { } while (0)
32	#endif
33
34	/*
35	* wait for a token to be granted from a semaphore
36	* - entered with lock held and interrupts disabled
37	*/
38	void __down(struct semaphore *sem, unsigned long flags)
39	{
40	struct task_struct *tsk = current;
41	struct sem_waiter waiter;
42
43	semtrace(sem, "Entering __down");
44
45	/* set up my own style of waitqueue */
46	waiter.task = tsk;
47	get_task_struct(tsk);
48
49	list_add_tail(&waiter.list, &sem->wait_list);
50
51	/* we don't need to touch the semaphore struct anymore */
52	spin_unlock_irqrestore(&sem->wait_lock, flags);
53
54	/* wait to be given the semaphore */
55	set_task_state(tsk, TASK_UNINTERRUPTIBLE);
56
57	for (;;) {
58	if (!waiter.task)
59	break;
60	schedule();
61	set_task_state(tsk, TASK_UNINTERRUPTIBLE);
62	}
63
64	tsk->state = TASK_RUNNING;
65	semtrace(sem, "Leaving __down");
66	}
67	EXPORT_SYMBOL(__down);
68
69	/*
70	* interruptibly wait for a token to be granted from a semaphore
71	* - entered with lock held and interrupts disabled
72	*/
73	int __down_interruptible(struct semaphore *sem, unsigned long flags)
74	{
75	struct task_struct *tsk = current;
76	struct sem_waiter waiter;
77	int ret;
78
79	semtrace(sem, "Entering __down_interruptible");
80
81	/* set up my own style of waitqueue */
82	waiter.task = tsk;
83	get_task_struct(tsk);
84
85	list_add_tail(&waiter.list, &sem->wait_list);
86
87	/* we don't need to touch the semaphore struct anymore */
88	set_task_state(tsk, TASK_INTERRUPTIBLE);
89
90	spin_unlock_irqrestore(&sem->wait_lock, flags);
91
92	/* wait to be given the semaphore */
93	ret = 0;
94	for (;;) {
95	if (!waiter.task)
96	break;
97	if (unlikely(signal_pending(current)))
98	goto interrupted;
99	schedule();
100	set_task_state(tsk, TASK_INTERRUPTIBLE);
101	}
102
103	out:
104	tsk->state = TASK_RUNNING;
105	semtrace(sem, "Leaving __down_interruptible");
106	return ret;
107
108	interrupted:
109	spin_lock_irqsave(&sem->wait_lock, flags);
110	list_del(&waiter.list);
111	spin_unlock_irqrestore(&sem->wait_lock, flags);
112
113	ret = 0;
114	if (!waiter.task) {
115	put_task_struct(current);
116	ret = -EINTR;
117	}
118	goto out;
119	}
120	EXPORT_SYMBOL(__down_interruptible);
121
122	/*
123	* release a single token back to a semaphore
124	* - entered with lock held and interrupts disabled
125	*/
126	void __up(struct semaphore *sem)
127	{
128	struct task_struct *tsk;
129	struct sem_waiter *waiter;
130
131	semtrace(sem, "Entering __up");
132
133	/* grant the token to the process at the front of the queue */
134	waiter = list_entry(sem->wait_list.next, struct sem_waiter, list);
135
136	/* We must be careful not to touch 'waiter' after we set ->task = NULL.
137	* It is an allocated on the waiter's stack and may become invalid at
138	* any time after that point (due to a wakeup from another source).
139	*/
140	list_del_init(&waiter->list);
141	tsk = waiter->task;
142	smp_mb();
143	waiter->task = NULL;
144	wake_up_process(tsk);
145	put_task_struct(tsk);
146
147	semtrace(sem, "Leaving __up");
148	}
149	EXPORT_SYMBOL(__up);