Subversion Repositories HelenOS

Rev

Rev 1965 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1965 Rev 1968
1
/*
1
/*
2
 * Copyright (C) 2001-2004 Jakub Jermar
2
 * Copyright (C) 2001-2004 Jakub Jermar
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/**
29
/**
30
 * @file    waitq.c
30
 * @file    waitq.c
31
 * @brief   Wait queue.
31
 * @brief   Wait queue.
32
 *
32
 *
33
 * Wait queue is the basic synchronization primitive upon which all
33
 * Wait queue is the basic synchronization primitive upon which all
34
 * other synchronization primitives build.
34
 * other synchronization primitives build.
35
 *
35
 *
36
 * It allows threads to wait for an event in first-come, first-served
36
 * It allows threads to wait for an event in first-come, first-served
37
 * fashion. Conditional operation as well as timeouts and interruptions
37
 * fashion. Conditional operation as well as timeouts and interruptions
38
 * are supported.
38
 * are supported.
39
 */
39
 */
40
 
40
 
41
#include <synch/waitq.h>
41
#include <synch/waitq.h>
42
#include <synch/synch.h>
42
#include <synch/synch.h>
43
#include <synch/spinlock.h>
43
#include <synch/spinlock.h>
44
#include <proc/thread.h>
44
#include <proc/thread.h>
45
#include <proc/scheduler.h>
45
#include <proc/scheduler.h>
46
#include <arch/asm.h>
46
#include <arch/asm.h>
47
#include <arch/types.h>
47
#include <arch/types.h>
48
#include <typedefs.h>
48
#include <typedefs.h>
49
#include <time/timeout.h>
49
#include <time/timeout.h>
50
#include <arch.h>
50
#include <arch.h>
51
#include <context.h>
51
#include <context.h>
52
#include <adt/list.h>
52
#include <adt/list.h>
53
 
53
 
54
static void waitq_timeouted_sleep(void *data);
54
static void waitq_timeouted_sleep(void *data);
55
 
55
 
56
/** Initialize wait queue
56
/** Initialize wait queue
57
 *
57
 *
58
 * Initialize wait queue.
58
 * Initialize wait queue.
59
 *
59
 *
60
 * @param wq Pointer to wait queue to be initialized.
60
 * @param wq Pointer to wait queue to be initialized.
61
 */
61
 */
62
void waitq_initialize(waitq_t *wq)
62
void waitq_initialize(waitq_t *wq)
63
{
63
{
64
    spinlock_initialize(&wq->lock, "waitq_lock");
64
    spinlock_initialize(&wq->lock, "waitq_lock");
65
    list_initialize(&wq->head);
65
    list_initialize(&wq->head);
66
    wq->missed_wakeups = 0;
66
    wq->missed_wakeups = 0;
67
}
67
}
68
 
68
 
69
/** Handle timeout during waitq_sleep_timeout() call
69
/** Handle timeout during waitq_sleep_timeout() call
70
 *
70
 *
71
 * This routine is called when waitq_sleep_timeout() timeouts.
71
 * This routine is called when waitq_sleep_timeout() timeouts.
72
 * Interrupts are disabled.
72
 * Interrupts are disabled.
73
 *
73
 *
74
 * It is supposed to try to remove 'its' thread from the wait queue;
74
 * It is supposed to try to remove 'its' thread from the wait queue;
75
 * it can eventually fail to achieve this goal when these two events
75
 * it can eventually fail to achieve this goal when these two events
76
 * overlap. In that case it behaves just as though there was no
76
 * overlap. In that case it behaves just as though there was no
77
 * timeout at all.
77
 * timeout at all.
78
 *
78
 *
79
 * @param data Pointer to the thread that called waitq_sleep_timeout().
79
 * @param data Pointer to the thread that called waitq_sleep_timeout().
80
 */
80
 */
81
void waitq_timeouted_sleep(void *data)
81
void waitq_timeouted_sleep(void *data)
82
{
82
{
83
    thread_t *t = (thread_t *) data;
83
    thread_t *t = (thread_t *) data;
84
    waitq_t *wq;
84
    waitq_t *wq;
85
    bool do_wakeup = false;
85
    bool do_wakeup = false;
86
 
86
 
87
    spinlock_lock(&threads_lock);
87
    spinlock_lock(&threads_lock);
88
    if (!thread_exists(t))
88
    if (!thread_exists(t))
89
        goto out;
89
        goto out;
90
 
90
 
91
grab_locks:
91
grab_locks:
92
    spinlock_lock(&t->lock);
92
    spinlock_lock(&t->lock);
93
    if ((wq = t->sleep_queue)) {        /* assignment */
93
    if ((wq = t->sleep_queue)) {        /* assignment */
94
        if (!spinlock_trylock(&wq->lock)) {
94
        if (!spinlock_trylock(&wq->lock)) {
95
            spinlock_unlock(&t->lock);
95
            spinlock_unlock(&t->lock);
96
            goto grab_locks;    /* avoid deadlock */
96
            goto grab_locks;    /* avoid deadlock */
97
        }
97
        }
98
 
98
 
99
        list_remove(&t->wq_link);
99
        list_remove(&t->wq_link);
100
        t->saved_context = t->sleep_timeout_context;
100
        t->saved_context = t->sleep_timeout_context;
101
        do_wakeup = true;
101
        do_wakeup = true;
102
        t->sleep_queue = NULL;
102
        t->sleep_queue = NULL;
103
        spinlock_unlock(&wq->lock);
103
        spinlock_unlock(&wq->lock);
104
    }
104
    }
105
   
105
   
106
    t->timeout_pending = false;
106
    t->timeout_pending = false;
107
    spinlock_unlock(&t->lock);
107
    spinlock_unlock(&t->lock);
108
   
108
   
109
    if (do_wakeup)
109
    if (do_wakeup)
110
        thread_ready(t);
110
        thread_ready(t);
111
 
111
 
112
out:
112
out:
113
    spinlock_unlock(&threads_lock);
113
    spinlock_unlock(&threads_lock);
114
}
114
}
115
 
115
 
116
/** Interrupt sleeping thread.
116
/** Interrupt sleeping thread.
117
 *
117
 *
118
 * This routine attempts to interrupt a thread from its sleep in a waitqueue.
118
 * This routine attempts to interrupt a thread from its sleep in a waitqueue.
119
 * If the thread is not found sleeping, no action is taken.
119
 * If the thread is not found sleeping, no action is taken.
120
 *
120
 *
121
 * @param t Thread to be interrupted.
121
 * @param t Thread to be interrupted.
122
 */
122
 */
123
void waitq_interrupt_sleep(thread_t *t)
123
void waitq_interrupt_sleep(thread_t *t)
124
{
124
{
125
    waitq_t *wq;
125
    waitq_t *wq;
126
    bool do_wakeup = false;
126
    bool do_wakeup = false;
127
    ipl_t ipl;
127
    ipl_t ipl;
128
 
128
 
129
    ipl = interrupts_disable();
129
    ipl = interrupts_disable();
130
    spinlock_lock(&threads_lock);
130
    spinlock_lock(&threads_lock);
131
    if (!thread_exists(t))
131
    if (!thread_exists(t))
132
        goto out;
132
        goto out;
133
 
133
 
134
grab_locks:
134
grab_locks:
135
    spinlock_lock(&t->lock);
135
    spinlock_lock(&t->lock);
136
    if ((wq = t->sleep_queue)) {        /* assignment */
136
    if ((wq = t->sleep_queue)) {        /* assignment */
137
        if (!(t->sleep_interruptible)) {
137
        if (!(t->sleep_interruptible)) {
138
            /*
138
            /*
139
             * The sleep cannot be interrupted.
139
             * The sleep cannot be interrupted.
140
             */
140
             */
141
            spinlock_unlock(&t->lock);
141
            spinlock_unlock(&t->lock);
142
            goto out;
142
            goto out;
143
        }
143
        }
144
           
144
           
145
        if (!spinlock_trylock(&wq->lock)) {
145
        if (!spinlock_trylock(&wq->lock)) {
146
            spinlock_unlock(&t->lock);
146
            spinlock_unlock(&t->lock);
147
            goto grab_locks;    /* avoid deadlock */
147
            goto grab_locks;    /* avoid deadlock */
148
        }
148
        }
149
 
149
 
150
        if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
150
        if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
151
            t->timeout_pending = false;
151
            t->timeout_pending = false;
152
 
152
 
153
        list_remove(&t->wq_link);
153
        list_remove(&t->wq_link);
154
        t->saved_context = t->sleep_interruption_context;
154
        t->saved_context = t->sleep_interruption_context;
155
        do_wakeup = true;
155
        do_wakeup = true;
156
        t->sleep_queue = NULL;
156
        t->sleep_queue = NULL;
157
        spinlock_unlock(&wq->lock);
157
        spinlock_unlock(&wq->lock);
158
    }
158
    }
159
    spinlock_unlock(&t->lock);
159
    spinlock_unlock(&t->lock);
160
 
160
 
161
    if (do_wakeup)
161
    if (do_wakeup)
162
        thread_ready(t);
162
        thread_ready(t);
163
 
163
 
164
out:
164
out:
165
    spinlock_unlock(&threads_lock);
165
    spinlock_unlock(&threads_lock);
166
    interrupts_restore(ipl);
166
    interrupts_restore(ipl);
167
}
167
}
168
 
168
 
169
/** Sleep until either wakeup, timeout or interruption occurs
169
/** Sleep until either wakeup, timeout or interruption occurs
170
 *
170
 *
171
 * This is a sleep implementation which allows itself to time out or to be
171
 * This is a sleep implementation which allows itself to time out or to be
172
 * interrupted from the sleep, restoring a failover context.
172
 * interrupted from the sleep, restoring a failover context.
173
 *
173
 *
174
 * Sleepers are organised in a FIFO fashion in a structure called wait queue.
174
 * Sleepers are organised in a FIFO fashion in a structure called wait queue.
175
 *
175
 *
176
 * This function is really basic in that other functions as waitq_sleep()
176
 * This function is really basic in that other functions as waitq_sleep()
177
 * and all the *_timeout() functions use it.
177
 * and all the *_timeout() functions use it.
178
 *
178
 *
179
 * @param wq Pointer to wait queue.
179
 * @param wq Pointer to wait queue.
180
 * @param usec Timeout in microseconds.
180
 * @param usec Timeout in microseconds.
181
 * @param flags Specify mode of the sleep.
181
 * @param flags Specify mode of the sleep.
182
 *
182
 *
183
 * The sleep can be interrupted only if the
183
 * The sleep can be interrupted only if the
184
 * SYNCH_FLAGS_INTERRUPTIBLE bit is specified in flags.
184
 * SYNCH_FLAGS_INTERRUPTIBLE bit is specified in flags.
185
 
185
 
186
 * If usec is greater than zero, regardless of the value of the
186
 * If usec is greater than zero, regardless of the value of the
187
 * SYNCH_FLAGS_NON_BLOCKING bit in flags, the call will not return until either timeout,
187
 * SYNCH_FLAGS_NON_BLOCKING bit in flags, the call will not return until either timeout,
188
 * interruption or wakeup comes.
188
 * interruption or wakeup comes.
189
 *
189
 *
190
 * If usec is zero and the SYNCH_FLAGS_NON_BLOCKING bit is not set in flags, the call
190
 * If usec is zero and the SYNCH_FLAGS_NON_BLOCKING bit is not set in flags, the call
191
 * will not return until wakeup or interruption comes.
191
 * will not return until wakeup or interruption comes.
192
 *
192
 *
193
 * If usec is zero and the SYNCH_FLAGS_NON_BLOCKING bit is set in flags, the call will
193
 * If usec is zero and the SYNCH_FLAGS_NON_BLOCKING bit is set in flags, the call will
194
 * immediately return, reporting either success or failure.
194
 * immediately return, reporting either success or failure.
195
 *
195
 *
196
 * @return  Returns one of: ESYNCH_WOULD_BLOCK, ESYNCH_TIMEOUT, ESYNCH_INTERRUPTED,
196
 * @return  Returns one of: ESYNCH_WOULD_BLOCK, ESYNCH_TIMEOUT, ESYNCH_INTERRUPTED,
197
 *          ESYNCH_OK_ATOMIC, ESYNCH_OK_BLOCKED.
197
 *          ESYNCH_OK_ATOMIC, ESYNCH_OK_BLOCKED.
198
 *
198
 *
199
 * @li ESYNCH_WOULD_BLOCK means that the sleep failed because at the time
199
 * @li ESYNCH_WOULD_BLOCK means that the sleep failed because at the time
200
 * of the call there was no pending wakeup.
200
 * of the call there was no pending wakeup.
201
 *
201
 *
202
 * @li ESYNCH_TIMEOUT means that the sleep timed out.
202
 * @li ESYNCH_TIMEOUT means that the sleep timed out.
203
 *
203
 *
204
 * @li ESYNCH_INTERRUPTED means that somebody interrupted the sleeping thread.
204
 * @li ESYNCH_INTERRUPTED means that somebody interrupted the sleeping thread.
205
 *
205
 *
206
 * @li ESYNCH_OK_ATOMIC means that the sleep succeeded and that there was
206
 * @li ESYNCH_OK_ATOMIC means that the sleep succeeded and that there was
207
 * a pending wakeup at the time of the call. The caller was not put
207
 * a pending wakeup at the time of the call. The caller was not put
208
 * asleep at all.
208
 * asleep at all.
209
 *
209
 *
210
 * @li ESYNCH_OK_BLOCKED means that the sleep succeeded; the full sleep was
210
 * @li ESYNCH_OK_BLOCKED means that the sleep succeeded; the full sleep was
211
 * attempted.
211
 * attempted.
212
 */
212
 */
213
int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int flags)
213
int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int flags)
214
{
214
{
215
    ipl_t ipl;
215
    ipl_t ipl;
216
    int rc;
216
    int rc;
217
   
217
   
218
    ipl = waitq_sleep_prepare(wq);
218
    ipl = waitq_sleep_prepare(wq);
219
    rc = waitq_sleep_timeout_unsafe(wq, usec, flags);
219
    rc = waitq_sleep_timeout_unsafe(wq, usec, flags);
220
    waitq_sleep_finish(wq, rc, ipl);
220
    waitq_sleep_finish(wq, rc, ipl);
221
    return rc;
221
    return rc;
222
}
222
}
223
 
223
 
224
/** Prepare to sleep in a waitq.
224
/** Prepare to sleep in a waitq.
225
 *
225
 *
226
 * This function will return holding the lock of the wait queue
226
 * This function will return holding the lock of the wait queue
227
 * and interrupts disabled.
227
 * and interrupts disabled.
228
 *
228
 *
229
 * @param wq Wait queue.
229
 * @param wq Wait queue.
230
 *
230
 *
231
 * @return Interrupt level as it existed on entry to this function.
231
 * @return Interrupt level as it existed on entry to this function.
232
 */
232
 */
233
ipl_t waitq_sleep_prepare(waitq_t *wq)
233
ipl_t waitq_sleep_prepare(waitq_t *wq)
234
{
234
{
235
    ipl_t ipl;
235
    ipl_t ipl;
236
   
236
   
237
restart:
237
restart:
238
    ipl = interrupts_disable();
238
    ipl = interrupts_disable();
239
 
239
 
240
    if (THREAD) {   /* needed during system initiailzation */
240
    if (THREAD) {   /* needed during system initiailzation */
241
        /*
241
        /*
242
         * Busy waiting for a delayed timeout.
242
         * Busy waiting for a delayed timeout.
243
         * This is an important fix for the race condition between
243
         * This is an important fix for the race condition between
244
         * a delayed timeout and a next call to waitq_sleep_timeout().
244
         * a delayed timeout and a next call to waitq_sleep_timeout().
245
         * Simply, the thread is not allowed to go to sleep if
245
         * Simply, the thread is not allowed to go to sleep if
246
         * there are timeouts in progress.
246
         * there are timeouts in progress.
247
         */
247
         */
248
        spinlock_lock(&THREAD->lock);
248
        spinlock_lock(&THREAD->lock);
249
        if (THREAD->timeout_pending) {
249
        if (THREAD->timeout_pending) {
250
            spinlock_unlock(&THREAD->lock);
250
            spinlock_unlock(&THREAD->lock);
251
            interrupts_restore(ipl);
251
            interrupts_restore(ipl);
252
            goto restart;
252
            goto restart;
253
        }
253
        }
254
        spinlock_unlock(&THREAD->lock);
254
        spinlock_unlock(&THREAD->lock);
255
    }
255
    }
256
                                                   
256
                                                   
257
    spinlock_lock(&wq->lock);
257
    spinlock_lock(&wq->lock);
258
    return ipl;
258
    return ipl;
259
}
259
}
260
 
260
 
261
/** Finish waiting in a wait queue.
261
/** Finish waiting in a wait queue.
262
 *
262
 *
263
 * This function restores interrupts to the state that existed prior
263
 * This function restores interrupts to the state that existed prior
264
 * to the call to waitq_sleep_prepare(). If necessary, the wait queue
264
 * to the call to waitq_sleep_prepare(). If necessary, the wait queue
265
 * lock is released.
265
 * lock is released.
266
 *
266
 *
267
 * @param wq Wait queue.
267
 * @param wq Wait queue.
268
 * @param rc Return code of waitq_sleep_timeout_unsafe().
268
 * @param rc Return code of waitq_sleep_timeout_unsafe().
269
 * @param ipl Interrupt level returned by waitq_sleep_prepare().
269
 * @param ipl Interrupt level returned by waitq_sleep_prepare().
270
 */
270
 */
271
void waitq_sleep_finish(waitq_t *wq, int rc, ipl_t ipl)
271
void waitq_sleep_finish(waitq_t *wq, int rc, ipl_t ipl)
272
{
272
{
273
    switch (rc) {
273
    switch (rc) {
274
    case ESYNCH_WOULD_BLOCK:
274
    case ESYNCH_WOULD_BLOCK:
275
    case ESYNCH_OK_ATOMIC:
275
    case ESYNCH_OK_ATOMIC:
276
        spinlock_unlock(&wq->lock);
276
        spinlock_unlock(&wq->lock);
277
        break;
277
        break;
278
    default:
278
    default:
279
        break;
279
        break;
280
    }
280
    }
281
    interrupts_restore(ipl);
281
    interrupts_restore(ipl);
282
}
282
}
283
 
283
 
284
/** Internal implementation of waitq_sleep_timeout().
284
/** Internal implementation of waitq_sleep_timeout().
285
 *
285
 *
286
 * This function implements logic of sleeping in a wait queue.
286
 * This function implements logic of sleeping in a wait queue.
287
 * This call must be preceeded by a call to waitq_sleep_prepare()
287
 * This call must be preceeded by a call to waitq_sleep_prepare()
288
 * and followed by a call to waitq_slee_finish().
288
 * and followed by a call to waitq_slee_finish().
289
 *
289
 *
290
 * @param wq See waitq_sleep_timeout().
290
 * @param wq See waitq_sleep_timeout().
291
 * @param usec See waitq_sleep_timeout().
291
 * @param usec See waitq_sleep_timeout().
292
 * @param flags See waitq_sleep_timeout().
292
 * @param flags See waitq_sleep_timeout().
293
 *
293
 *
294
 * @return See waitq_sleep_timeout().
294
 * @return See waitq_sleep_timeout().
295
 */
295
 */
296
int waitq_sleep_timeout_unsafe(waitq_t *wq, __u32 usec, int flags)
296
int waitq_sleep_timeout_unsafe(waitq_t *wq, __u32 usec, int flags)
297
{
297
{
298
    /* checks whether to go to sleep at all */
298
    /* checks whether to go to sleep at all */
299
    if (wq->missed_wakeups) {
299
    if (wq->missed_wakeups) {
300
        wq->missed_wakeups--;
300
        wq->missed_wakeups--;
301
        return ESYNCH_OK_ATOMIC;
301
        return ESYNCH_OK_ATOMIC;
302
    }
302
    }
303
    else {
303
    else {
304
        if ((flags & SYNCH_FLAGS_NON_BLOCKING) && (usec == 0)) {
304
        if ((flags & SYNCH_FLAGS_NON_BLOCKING) && (usec == 0)) {
305
            /* return immediatelly instead of going to sleep */
305
            /* return immediatelly instead of going to sleep */
306
            return ESYNCH_WOULD_BLOCK;
306
            return ESYNCH_WOULD_BLOCK;
307
        }
307
        }
308
    }
308
    }
309
   
309
   
310
    /*
310
    /*
311
     * Now we are firmly decided to go to sleep.
311
     * Now we are firmly decided to go to sleep.
312
     */
312
     */
313
    spinlock_lock(&THREAD->lock);
313
    spinlock_lock(&THREAD->lock);
314
 
314
 
315
    if (flags & SYNCH_FLAGS_INTERRUPTIBLE) {
315
    if (flags & SYNCH_FLAGS_INTERRUPTIBLE) {
316
 
316
 
317
        /*
317
        /*
318
         * If the thread was already interrupted,
318
         * If the thread was already interrupted,
319
         * don't go to sleep at all.
319
         * don't go to sleep at all.
320
         */
320
         */
321
        if (THREAD->interrupted) {
321
        if (THREAD->interrupted) {
322
            spinlock_unlock(&THREAD->lock);
322
            spinlock_unlock(&THREAD->lock);
323
            spinlock_unlock(&wq->lock);
323
            spinlock_unlock(&wq->lock);
324
            return ESYNCH_INTERRUPTED;
324
            return ESYNCH_INTERRUPTED;
325
        }
325
        }
326
 
326
 
327
        /*
327
        /*
328
         * Set context that will be restored if the sleep
328
         * Set context that will be restored if the sleep
329
         * of this thread is ever interrupted.
329
         * of this thread is ever interrupted.
330
         */
330
         */
331
        THREAD->sleep_interruptible = true;
331
        THREAD->sleep_interruptible = true;
332
        if (!context_save(&THREAD->sleep_interruption_context)) {
332
        if (!context_save(&THREAD->sleep_interruption_context)) {
333
            /* Short emulation of scheduler() return code. */
333
            /* Short emulation of scheduler() return code. */
334
            spinlock_unlock(&THREAD->lock);
334
            spinlock_unlock(&THREAD->lock);
335
            return ESYNCH_INTERRUPTED;
335
            return ESYNCH_INTERRUPTED;
336
        }
336
        }
337
 
337
 
338
    } else {
338
    } else {
339
        THREAD->sleep_interruptible = false;
339
        THREAD->sleep_interruptible = false;
340
    }
340
    }
341
 
341
 
342
    if (usec) {
342
    if (usec) {
343
        /* We use the timeout variant. */
343
        /* We use the timeout variant. */
344
        if (!context_save(&THREAD->sleep_timeout_context)) {
344
        if (!context_save(&THREAD->sleep_timeout_context)) {
345
            /* Short emulation of scheduler() return code. */
345
            /* Short emulation of scheduler() return code. */
346
            spinlock_unlock(&THREAD->lock);
346
            spinlock_unlock(&THREAD->lock);
347
            return ESYNCH_TIMEOUT;
347
            return ESYNCH_TIMEOUT;
348
        }
348
        }
349
        THREAD->timeout_pending = true;
349
        THREAD->timeout_pending = true;
350
        timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_timeouted_sleep, THREAD);
350
        timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_timeouted_sleep, THREAD);
351
    }
351
    }
352
 
352
 
353
    list_append(&THREAD->wq_link, &wq->head);
353
    list_append(&THREAD->wq_link, &wq->head);
354
 
354
 
355
    /*
355
    /*
356
     * Suspend execution.
356
     * Suspend execution.
357
     */
357
     */
358
    THREAD->state = Sleeping;
358
    THREAD->state = Sleeping;
359
    THREAD->sleep_queue = wq;
359
    THREAD->sleep_queue = wq;
360
 
360
 
361
    spinlock_unlock(&THREAD->lock);
361
    spinlock_unlock(&THREAD->lock);
362
 
362
 
363
    scheduler();    /* wq->lock is released in scheduler_separated_stack() */
363
    scheduler();    /* wq->lock is released in scheduler_separated_stack() */
364
   
364
   
365
    return ESYNCH_OK_BLOCKED;
365
    return ESYNCH_OK_BLOCKED;
366
}
366
}
367
 
367
 
368
 
368
 
369
/** Wake up first thread sleeping in a wait queue
369
/** Wake up first thread sleeping in a wait queue
370
 *
370
 *
371
 * Wake up first thread sleeping in a wait queue.
371
 * Wake up first thread sleeping in a wait queue.
372
 * This is the SMP- and IRQ-safe wrapper meant for
372
 * This is the SMP- and IRQ-safe wrapper meant for
373
 * general use.
373
 * general use.
374
 *
374
 *
375
 * Besides its 'normal' wakeup operation, it attempts
375
 * Besides its 'normal' wakeup operation, it attempts
376
 * to unregister possible timeout.
376
 * to unregister possible timeout.
377
 *
377
 *
378
 * @param wq Pointer to wait queue.
378
 * @param wq Pointer to wait queue.
379
 * @param all If this is non-zero, all sleeping threads
379
 * @param all If this is non-zero, all sleeping threads
380
 *        will be woken up and missed count will be zeroed.
380
 *        will be woken up and missed count will be zeroed.
381
 */
381
 */
382
void waitq_wakeup(waitq_t *wq, bool all)
382
void waitq_wakeup(waitq_t *wq, bool all)
383
{
383
{
384
    ipl_t ipl;
384
    ipl_t ipl;
385
 
385
 
386
    ipl = interrupts_disable();
386
    ipl = interrupts_disable();
387
    spinlock_lock(&wq->lock);
387
    spinlock_lock(&wq->lock);
388
 
388
 
389
    _waitq_wakeup_unsafe(wq, all);
389
    _waitq_wakeup_unsafe(wq, all);
390
 
390
 
391
    spinlock_unlock(&wq->lock);
391
    spinlock_unlock(&wq->lock);
392
    interrupts_restore(ipl);   
392
    interrupts_restore(ipl);   
393
}
393
}
394
 
394
 
395
/** Internal SMP- and IRQ-unsafe version of waitq_wakeup()
395
/** Internal SMP- and IRQ-unsafe version of waitq_wakeup()
396
 *
396
 *
397
 * This is the internal SMP- and IRQ-unsafe version
397
 * This is the internal SMP- and IRQ-unsafe version
398
 * of waitq_wakeup(). It assumes wq->lock is already
398
 * of waitq_wakeup(). It assumes wq->lock is already
399
 * locked and interrupts are already disabled.
399
 * locked and interrupts are already disabled.
400
 *
400
 *
401
 * @param wq Pointer to wait queue.
401
 * @param wq Pointer to wait queue.
402
 * @param all If this is non-zero, all sleeping threads
402
 * @param all If this is non-zero, all sleeping threads
403
 *        will be woken up and missed count will be zeroed.
403
 *        will be woken up and missed count will be zeroed.
404
 */
404
 */
405
void _waitq_wakeup_unsafe(waitq_t *wq, bool all)
405
void _waitq_wakeup_unsafe(waitq_t *wq, bool all)
406
{
406
{
407
    thread_t *t;
407
    thread_t *t;
408
 
408
 
409
loop:  
409
loop:  
410
    if (list_empty(&wq->head)) {
410
    if (list_empty(&wq->head)) {
411
        wq->missed_wakeups++;
411
        wq->missed_wakeups++;
412
        if (all)
412
        if (all)
413
            wq->missed_wakeups = 0;
413
            wq->missed_wakeups = 0;
414
        return;
414
        return;
415
    }
415
    }
416
 
416
 
417
    t = list_get_instance(wq->head.next, thread_t, wq_link);
417
    t = list_get_instance(wq->head.next, thread_t, wq_link);
418
   
418
   
419
    /*
419
    /*
420
     * Lock the thread prior to removing it from the wq.
420
     * Lock the thread prior to removing it from the wq.
421
     * This is not necessary because of mutual exclusion
421
     * This is not necessary because of mutual exclusion
422
     * (the link belongs to the wait queue), but because
422
     * (the link belongs to the wait queue), but because
423
     * of synchronization with waitq_timeouted_sleep()
423
     * of synchronization with waitq_timeouted_sleep()
424
     * and waitq_interrupt_sleep().
424
     * and waitq_interrupt_sleep().
425
     *
425
     *
426
     * In order for these two functions to work, the following
426
     * In order for these two functions to work, the following
427
     * invariant must hold:
427
     * invariant must hold:
428
     *
428
     *
429
     * t->sleep_queue != NULL <=> t sleeps in a wait queue
429
     * t->sleep_queue != NULL <=> t sleeps in a wait queue
430
     *
430
     *
431
     * For an observer who locks the thread, the invariant
431
     * For an observer who locks the thread, the invariant
432
     * holds only when the lock is held prior to removing
432
     * holds only when the lock is held prior to removing
433
     * it from the wait queue.
433
     * it from the wait queue.
434
     */
434
     */
435
    spinlock_lock(&t->lock);
435
    spinlock_lock(&t->lock);
436
    list_remove(&t->wq_link);
436
    list_remove(&t->wq_link);
437
   
437
   
438
    if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
438
    if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
439
        t->timeout_pending = false;
439
        t->timeout_pending = false;
440
    t->sleep_queue = NULL;
440
    t->sleep_queue = NULL;
441
    spinlock_unlock(&t->lock);
441
    spinlock_unlock(&t->lock);
442
 
442
 
443
    thread_ready(t);
443
    thread_ready(t);
444
 
444
 
445
    if (all)
445
    if (all)
446
        goto loop;
446
        goto loop;
447
}
447
}
448
 
448