signal.c

Go to the documentation of this file.

#include "signal.h"

#include "cfg/cfg_timer.h"
#include <cfg/debug.h>
#include <cfg/depend.h>

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


#if CONFIG_KERN_SIGNALS

// Check config dependencies
CONFIG_DEPEND(CONFIG_KERN_SIGNALS, CONFIG_KERN);

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

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

    return result;
}


sigmask_t sig_wait(sigmask_t sigs)
{
    sigmask_t result;

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

    /*
     * This is subtle: there's a race condition where a concurrent process
     * or an interrupt may call sig_send()/sig_post() 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.
     */
    IRQ_DISABLE;

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

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

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

    IRQ_ENABLE;
    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

INLINE void __sig_signal(Process *proc, sigmask_t sigs, bool wakeup)
{
    cpu_flags_t flags;

    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)
    {
        ASSERT(proc != current_process);

        proc->sig_wait = 0;
        if (wakeup)
            proc_wakeup(proc);
        else
            SCHED_ENQUEUE_HEAD(proc);
    }
    IRQ_RESTORE(flags);
}

void sig_send(Process *proc, sigmask_t sigs)
{
    ASSERT_USER_CONTEXT();
    IRQ_ASSERT_ENABLED();
    ASSERT(proc_preemptAllowed());

    __sig_signal(proc, sigs, true);
}

void sig_post(Process *proc, sigmask_t sigs)
{
    __sig_signal(proc, sigs, false);
}

#endif /* CONFIG_KERN_SIGNALS */