sem.c

Go to the documentation of this file.

#include "sem.h"
#include <cfg/debug.h>

#include <cpu/irq.h> // ASSERT_IRQ_DISABLED()

#include <kern/proc.h>
#include <kern/proc_p.h>
#include <kern/signal.h>

INLINE void sem_verify(struct Semaphore *s)
{
    (void)s;
    ASSERT(s);
    LIST_ASSERT_VALID(&s->wait_queue);
    ASSERT(s->nest_count >= 0);
    ASSERT(s->nest_count < 128);   // heuristic max
}

void sem_init(struct Semaphore *s)
{
    LIST_INIT(&s->wait_queue);
    s->owner = NULL;
    s->nest_count = 0;
}


bool sem_attempt(struct Semaphore *s)
{
    bool result = false;

    proc_forbid();
    sem_verify(s);
    if ((!s->owner) || (s->owner == current_process))
    {
        s->owner = current_process;
        s->nest_count++;
        result = true;
    }
    proc_permit();

    return result;
}


void sem_obtain(struct Semaphore *s)
{
    proc_forbid();
    sem_verify(s);

    /* Is the semaphore already locked by another process? */
    if (UNLIKELY(s->owner && (s->owner != current_process)))
    {
        /* Append calling process to the wait queue */
        ADDTAIL(&s->wait_queue, (Node *)current_process);

        /*
         * We will wake up only when the current owner calls
         * sem_release(). Then, the semaphore will already
         * be locked for us.
         */
        proc_permit();
        proc_switch();
    }
    else
    {
        ASSERT(LIST_EMPTY(&s->wait_queue));

        /* The semaphore was free: lock it */
        s->owner = current_process;
        s->nest_count++;
        proc_permit();
    }
}


void sem_release(struct Semaphore *s)
{
    Process *proc = NULL;

    proc_forbid();
    sem_verify(s);

    ASSERT(s->owner == current_process);

    /*
     * Decrement nesting count and check if the semaphore
     * has been fully unlocked.
     */
    if (--s->nest_count == 0)
    {
        /* Disown semaphore */
        s->owner = NULL;

        /* Give semaphore to the first applicant, if any */
        if (UNLIKELY((proc = (Process *)list_remHead(&s->wait_queue))))
        {
            s->nest_count = 1;
            s->owner = proc;
        }
    }
    proc_permit();

    if (proc)
        ATOMIC(proc_wakeup(proc));
}