Subversion Repositories HelenOS

Rev

Rev 2109 | Rev 2310 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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