summaryrefslogtreecommitdiffstats
path: root/arch/mips/kernel/semaphore.c
blob: 1f47bd929e7842ba05a2ba4c47c9482865368a6b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
/*
 *  Generic semaphore code. Buyer beware. Do your own
 * specific changes in <asm/semaphore-helper.h>
 */

#include <linux/sched.h>
#include <asm/semaphore-helper.h>

/*
 * Semaphores are implemented using a two-way counter:
 * The "count" variable is decremented for each process
 * that tries to sleep, while the "waking" variable is
 * incremented when the "up()" code goes to wake up waiting
 * processes.
 *
 * Notably, the inline "up()" and "down()" functions can
 * efficiently test if they need to do any extra work (up
 * needs to do something only if count was negative before
 * the increment operation.
 *
 * waking_non_zero() (from asm/semaphore.h) must execute
 * atomically.
 *
 * When __up() is called, the count was negative before
 * incrementing it, and we need to wake up somebody.
 *
 * This routine adds one to the count of processes that need to
 * wake up and exit.  ALL waiting processes actually wake up but
 * only the one that gets to the "waking" field first will gate
 * through and acquire the semaphore.  The others will go back
 * to sleep.
 *
 * 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)
{
	wake_one_more(sem);
	wake_up(&sem->wait);
}

/*
 * Perform the "down" function.  Return zero for semaphore acquired,
 * return negative for signalled out of the function.
 *
 * If called from __down, the return is ignored and the wait loop is
 * not interruptible.  This means that a task waiting on a semaphore
 * using "down()" cannot be killed until someone does an "up()" on
 * the semaphore.
 *
 * If called from __down_interruptible, the return value gets checked
 * upon return.  If the return value is negative then the task continues
 * with the negative value in the return register (it can be tested by
 * the caller).
 *
 * Either form may be used in conjunction with "up()".
 *
 */

#define DOWN_VAR				\
	struct task_struct *tsk = current;	\
	wait_queue_t wait;			\
	init_waitqueue_entry(&wait, tsk);

#define DOWN_HEAD(task_state)						\
									\
									\
	tsk->state = (task_state);					\
	add_wait_queue(&sem->wait, &wait);				\
									\
	/*								\
	 * Ok, we're set up.  sem->count is known to be less than zero	\
	 * so we must wait.						\
	 *								\
	 * We can let go the lock for purposes of waiting.		\
	 * We re-acquire it after awaking so as to protect		\
	 * all semaphore operations.					\
	 *								\
	 * If "up()" is called before we call waking_non_zero() then	\
	 * we will catch it right away.  If it is called later then	\
	 * we will have to go through a wakeup cycle to catch it.	\
	 *								\
	 * Multiple waiters contend for the semaphore lock to see	\
	 * who gets to gate through and who has to wait some more.	\
	 */								\
	for (;;) {

#define DOWN_TAIL(task_state)			\
		tsk->state = (task_state);	\
	}					\
	tsk->state = TASK_RUNNING;		\
	remove_wait_queue(&sem->wait, &wait);

void __down(struct semaphore * sem)
{
	DOWN_VAR
	DOWN_HEAD(TASK_UNINTERRUPTIBLE)
	if (waking_non_zero(sem))
		break;
	schedule();
	DOWN_TAIL(TASK_UNINTERRUPTIBLE)
}

int __down_interruptible(struct semaphore * sem)
{
	int ret = 0;
	DOWN_VAR
	DOWN_HEAD(TASK_INTERRUPTIBLE)

	ret = waking_non_zero_interruptible(sem, tsk);
	if (ret)
	{
		if (ret == 1)
			/* ret != 0 only if we get interrupted -arca */
			ret = 0;
		break;
	}
	schedule();
	DOWN_TAIL(TASK_INTERRUPTIBLE)
	return ret;
}

int __down_trylock(struct semaphore * sem)
{
	return waking_non_zero_trylock(sem);
}

/*
 * RW Semaphores
 */
void
__down_read(struct rw_semaphore *sem, int count)
{
	DOWN_VAR;

 retry_down:
	if (count < 0) {
		/* Wait for the lock to become unbiased.  Readers
		   are non-exclusive.  */
		
		/* This takes care of granting the lock.  */
		up_read(sem);

		add_wait_queue(&sem->wait, &wait);
		while (atomic_read(&sem->count) < 0) {
			set_task_state(tsk, TASK_UNINTERRUPTIBLE);
			if (atomic_read(&sem->count) >= 0)
				break;
			schedule();
		}

		remove_wait_queue(&sem->wait, &wait);
		tsk->state = TASK_RUNNING;

		mb();
		count = atomic_dec_return(&sem->count);
		if (count <= 0)
			goto retry_down;
	} else {
		add_wait_queue(&sem->wait, &wait);

		while (1) {
			if (test_and_clear_bit(0, &sem->granted))
				break;
			set_task_state(tsk, TASK_UNINTERRUPTIBLE);
			if ((sem->granted & 1) == 0)
				schedule();
		}

		remove_wait_queue(&sem->wait, &wait);
		tsk->state = TASK_RUNNING;
	}
}

void
__down_write(struct rw_semaphore *sem, int count)
{
	DOWN_VAR;

 retry_down:
	if (count + RW_LOCK_BIAS < 0) {
		up_write(sem);

		add_wait_queue_exclusive(&sem->wait, &wait);
	
		while (atomic_read(&sem->count) < 0) {
			set_task_state(tsk, (TASK_UNINTERRUPTIBLE
					     | TASK_EXCLUSIVE));
			if (atomic_read(&sem->count) >= RW_LOCK_BIAS)
				break;
			schedule();
		}

		remove_wait_queue(&sem->wait, &wait);
		tsk->state = TASK_RUNNING;

		mb();
		count = atomic_sub_return(RW_LOCK_BIAS, &sem->count);
		if (count != 0)
			goto retry_down;
	} else {
		/* Put ourselves at the end of the list.  */
		add_wait_queue_exclusive(&sem->write_bias_wait, &wait);

		while (1) {
			if (test_and_clear_bit(1, &sem->granted))
				break;
			set_task_state(tsk, (TASK_UNINTERRUPTIBLE
					     | TASK_EXCLUSIVE));
			if ((sem->granted & 2) == 0)
				schedule();
		}

		remove_wait_queue(&sem->write_bias_wait, &wait);
		tsk->state = TASK_RUNNING;

		/* If the lock is currently unbiased, awaken the sleepers.
		   FIXME: This wakes up the readers early in a bit of a
		   stampede -> bad!  */
		if (atomic_read(&sem->count) >= 0)
			wake_up(&sem->wait);
	}
}

void
__rwsem_wake(struct rw_semaphore *sem, unsigned long readers)
{
	if (readers) {
		if (test_and_set_bit(0, &sem->granted))
			BUG();
		wake_up(&sem->wait);
	} else {
		if (test_and_set_bit(1, &sem->granted))
			BUG();
		wake_up(&sem->write_bias_wait);
	}
}