OSDev.org

Code: Select all

void wait_event(sleep_queue_t* waitqueue, uint32_t* condition)
{
    if (!waitqueue || !condition || !waitqueue->queue) // Passing bad pointers
        return;

    while (!*condition)
    {
        spin_lock(&waitqueue->lock);
        list_append_node(waitqueue->queue, &currProc->sleepNode, currProc);

        IRQ_OFF;
        spin_unlock(&waitqueue->lock);
        proc_setState(currProc, TASK_UNINTERRUPTIBLE);

        if (!*condition) // If we get woken up between releasing the lock and the process state change
           yield();

        proc_setState(currProc, TASK_RUNNING);
        IRQ_RES;
    }
}

void wakeup_queue(sleep_queue_t* waitqueue)
{
    if (!waitqueue || !waitqueue->queue)
        return;

    spin_lock(&waitqueue->lock);

    list_node_t* wakeNode = list_dequeue(waitqueue->queue);

    while (wakeNode)
    {
        process_t* wakeProc = (process_t*)wakeNode->data;
        proc_setState(wakeProc, TASK_RUNNING);
        if (!list_find(waitqueue->queue, wakeProc))
        {
            sched_queueRunnable(wakeProc);
        }


        wakeNode = list_dequeue(waitqueue->queue);
    }

    spin_unlock(&waitqueue->lock);
}

Code: Select all

wait_event:
.LFB0:
	.cfi_startproc
	cmpl	$0, (%rdi)
        [i];code inside of condition while[/i]
	jne	.L1
.L4:
	jmp	.L4

Code: Select all

void wait_event(sleep_queue_t* waitqueue, uint32_t* condition)
{
    if (!waitqueue || !condition || !waitqueue->queue) // Passing bad pointers
        return;

    while (!*condition)
    {
        spin_lock(&waitqueue->lock);
        list_append_node(waitqueue->queue, &currProc->sleepNode, currProc);

// gg - at this point currProc is in the waitqueue

        IRQ_OFF;
        spin_unlock(&waitqueue->lock);
        proc_setState(currProc, TASK_UNINTERRUPTIBLE);


// gg - let's suppose that *condition is no longer 0, we will skip the yield

        if (!*condition) // If we get woken up between releasing the lock and the process state change
           yield();

        proc_setState(currProc, TASK_RUNNING);

// gg - at this point currProc is still in the waitqueue but now running -- Is that okay ?

        IRQ_RES;
    }
}

Code: Select all

//Sleep
int msleep(uint32_t ms)
{
    static volatile uint32_t msleep_eflags;

    irq_lock(&msleep_eflags); // Wakeup function will not be called

    currProc->ticks = timer_getTicks() + ms;

    list_node_t* before = 0;
    foreach (child, timedSleepQueue)
    {
        if (((process_t*)child->data)->ticks >= currProc->ticks)
        {
            break;
        }
        before = child;
    }
    list_insert_node_after(timedSleepQueue, before, currProc, &currProc->sleepNode);
    
    proc_setState(currProc, TASK_INTERRUPTIBLE, 1);
    
    irq_unlock(&msleep_eflags);

    yield(); 

    return 0;
}

void sched_wakeTimedSleep(uint64_t ticks) // Called from timer, aka IRQs are already off
{
    if (timedSleepQueue->length == 0) // Don't bother if zero length
        return;

    if (ticks >= ((process_t*)timedSleepQueue->head->data)->ticks)
    {
        list_node_t* sleepNode = list_dequeue(timedSleepQueue);
        process_t* sleeper = sleepNode->data;

        sleeper->ticks = 0;
        proc_setState(sleeper, TASK_RUNNING, 1);
    }
}

// Wait queues

// Block until woken up, and then block again if condition is false
void wait_event(sleep_queue_t* waitqueue, volatile uint32_t* condition)
{
    static volatile uint32_t wait_lock;
    if (!waitqueue || !condition || !waitqueue->queue) // Passing bad pointers
        return;

    irq_lock(&wait_lock);
    while (!*condition)
    {
        list_append_node(waitqueue->queue, &currProc->sleepNode, currProc);

        proc_setState(currProc, TASK_UNINTERRUPTIBLE, 1);
        irq_unlock(&wait_lock);

        if (!*condition) // If we get woken up between releasing the lock and the process state change
           yield();

        // At this point, a wakeup call will have put the process back in the running state, and back on the run queue.
        irq_lock(&wait_lock);
    }
    irq_unlock(&wait_lock);
}

void wakeup_queue(sleep_queue_t* waitqueue)
{
    static volatile uint32_t wakeup_lock;
    if (!waitqueue || !waitqueue->queue)
        return;

    irq_lock(&wakeup_lock);

    list_node_t* wakeNode = list_dequeue(waitqueue->queue);

    while (wakeNode)
    {
        process_t* wakeProc = (process_t*)wakeNode->data;
        proc_setState(wakeProc, TASK_RUNNING, 1);

        wakeNode = list_dequeue(waitqueue->queue);
    }
    irq_unlock(&wakeup_lock);

}