waitq.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <core/panic.h>
#include <core/arch.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/signal.h>
#include <sys/waitq.h>

static void sleep_on(struct waitq *waitq, state_t state)
{
    if (!waitq)
        panic("sleeping in a blackhole?");
 
    curthread->waitq = waitq;
    list_append(&waitq->threads, &curthread->run_link);
    curthread->state = state;
    arch_sleep();
    curthread->state = RUNNABLE;
}

int waitq_sleep(struct waitq *waitq)
{
    if (signal_interrupts(curthread))
        return -ERESTARTSYS;
 
    sleep_on(waitq, ISLEEP);
 
    return signal_interrupts(curthread) ? -ERESTARTSYS : 0;
}

void waitq_sleep_unint(struct waitq *waitq)
{
    sleep_on(waitq, USLEEP);
}
 
/*
 * select() and poll() wait for any of several files. For each file, the
 * thread registers the wait queue that the file's readers (or writers)
 * sleep on (poll_register()), then sleeps on its own queue,
 * `thread->poll_wait`. A wakeup of any registered queue also wakes that
 * thread, which then looks at its files again. A file that can't say
 * which queue it uses registers NULL, which every wakeup matches.
 *
 * Registrations are kept in a small hash table, keyed by the queue, so
 * that a wakeup finds its pollers without looking at every thread.
 */
MALLOC_DEFINE(M_POLL_REG, "poll-reg", "a queue a thread polls");

struct poll_reg {
    struct waitq *queue;
    struct thread *thread;
    struct poll_reg *next;          /* the next one in its hash chain */
    struct poll_reg *thread_next;   /* the thread's next registration */
};
 
#define POLL_HASH   64
 
static struct poll_reg *poll_hash[POLL_HASH];
static int poll_regs;

static struct poll_reg **poll_chain(struct waitq *queue)
{
    return &poll_hash[((uintptr_t) queue >> 4) % POLL_HASH];
}

int poll_register(struct waitq *queue)
{
    struct thread *thread = curthread;
 
    for (struct poll_reg *r = thread->poll_regs; r; r = r->thread_next)
        if (r->queue == queue)
            return 0;
 
    struct poll_reg *r = kmalloc(sizeof(*r), &M_POLL_REG, 0);
 
    if (!r)
        return -ENOMEM;
 
    struct poll_reg **chain = poll_chain(queue);
 
    r->queue = queue;
    r->thread = thread;
    r->next = *chain;
    *chain = r;
    r->thread_next = thread->poll_regs;
    thread->poll_regs = r;
    poll_regs++;
 
    return 0;
}

void poll_unregister(struct thread *thread)
{
    while (thread->poll_regs) {
        struct poll_reg *r = thread->poll_regs;
        struct poll_reg **p = poll_chain(r->queue);
 
        while (*p != r)
            p = &(*p)->next;
 
        *p = r->next;
        thread->poll_regs = r->thread_next;
        poll_regs--;
        kfree(r);
    }
}

static void poll_wake(struct waitq *waitq)
{
    for (struct poll_reg *r = *poll_chain(waitq); r; r = r->next)
        if (r->queue == waitq)
            waitq_wakeup_nopoll(&r->thread->poll_wait);
 
    for (struct poll_reg *r = *poll_chain(NULL); r; r = r->next)
        if (!r->queue)
            waitq_wakeup_nopoll(&r->thread->poll_wait);
}

void waitq_wakeup(struct waitq *waitq)
{
    if (!waitq)
        return;
 
    if (poll_regs)
        poll_wake(waitq);
 
    waitq_wakeup_nopoll(waitq);
}

void waitq_wakeup_nopoll(struct waitq *waitq)
{
    struct list_node *node;
 
    if (!waitq)
        return;
 
    while ((node = list_pop(&waitq->threads))) {
        struct thread *thread = list_entry(node, struct thread, run_link);
        thread->waitq = NULL;
        sched_thread_wake(thread);
    }
}

void thread_wakeup(struct thread *thread)
{
    if (!thread->waitq)
        return;
 
    list_remove(&thread->run_link);
    thread->waitq = NULL;
    sched_thread_wake(thread);
}