signal.c

Go to the documentation of this file.

#include "signal.h"

#include <cfg/cfg_timer.h>
#include <cfg/debug.h>
#include <cpu/irq.h>
#include <kern/proc.h>
#include <kern/proc_p.h>


#if CONFIG_KERN_SIGNALS

sigmask_t sig_check(sigmask_t sigs)
{
    sigmask_t result;
    cpu_flags_t flags;

    IRQ_SAVE_DISABLE(flags);
    result = CurrentProcess->sig_recv & sigs;
    CurrentProcess->sig_recv &= ~sigs;
    IRQ_RESTORE(flags);

    return result;
}


sigmask_t sig_wait(sigmask_t sigs)
{
    sigmask_t result;
    cpu_flags_t flags;

    /* Sleeping with IRQs disabled or preemption forbidden is illegal */
    IRQ_ASSERT_ENABLED();
    ASSERT(proc_allowed());

    /*
     * This is subtle: there's a race condition where a concurrent
     * process or an interrupt may call sig_signal() to set a bit in
     * Process.sig_recv just after we have checked for it, but before
     * we've set Process.sig_wait to let them know we want to be awaken.
     *
     * In this case, we'd deadlock with the signal bit already set
     * and the process never being reinserted into the ready list.
     */
    // FIXME: just use IRQ_DISABLE() here
    IRQ_SAVE_DISABLE(flags);

    /* Loop until we get at least one of the signals */
    while (!(result = CurrentProcess->sig_recv & sigs))
    {
        /*
         * Tell "them" that we want to be awaken when any of these
         * signals arrives.
         */
        CurrentProcess->sig_wait = sigs;

        /*
         * Go to sleep and proc_switch() to another process.
         *
         * We re-enable IRQs because proc_switch() does not
         * guarantee to save and restore the interrupt mask.
         */
        IRQ_RESTORE(flags);
        proc_switch();
        IRQ_SAVE_DISABLE(flags);

        /*
         * When we come back here, the wait mask must have been
         * cleared by someone through sig_signal(), and at least
         * one of the signals we were expecting must have been
         * delivered to us.
         */
        ASSERT(!CurrentProcess->sig_wait);
        ASSERT(CurrentProcess->sig_recv & sigs);
    }

    /* Signals found: clear them and return */
    CurrentProcess->sig_recv &= ~sigs;

    IRQ_RESTORE(flags);
    return result;
}

#if CONFIG_TIMER_EVENTS

#include <drv/timer.h>
sigmask_t sig_waitTimeout(sigmask_t sigs, ticks_t timeout)
{
    Timer t;
    sigmask_t res;
    cpu_flags_t flags;

    ASSERT(!sig_check(SIG_TIMEOUT));
    ASSERT(!(sigs & SIG_TIMEOUT));
    /* IRQ are needed to run timer */
    ASSERT(IRQ_ENABLED());

    timer_set_event_signal(&t, proc_current(), SIG_TIMEOUT);
    timer_setDelay(&t, timeout);
    timer_add(&t);
    res = sig_wait(SIG_TIMEOUT | sigs);

    IRQ_SAVE_DISABLE(flags);
    /* Remove timer if sigs occur before timer signal */
    if (!(res & SIG_TIMEOUT) && !sig_check(SIG_TIMEOUT))
        timer_abort(&t);
    IRQ_RESTORE(flags);
    return res;
}

#endif // CONFIG_TIMER_EVENTS


void sig_signal(Process *proc, sigmask_t sigs)
{
    cpu_flags_t flags;

    /* See comment in sig_wait() for why this protection is necessary */
    IRQ_SAVE_DISABLE(flags);

    /* Set the signals */
    proc->sig_recv |= sigs;

    /* Check if process needs to be awoken */
    if (proc->sig_recv & proc->sig_wait)
    {
        /* Wake up process and enqueue in ready list */
        proc->sig_wait = 0;
        SCHED_ENQUEUE(proc);
    }

    IRQ_RESTORE(flags);
}

#endif /* CONFIG_KERN_SIGNALS */