event.h

Go to the documentation of this file.

#ifndef KERN_EVENT_H
#define KERN_EVENT_H

#include "cfg/cfg_proc.h"
#include "cfg/cfg_signal.h"
#include "cfg/cfg_timer.h"
#include <cfg/compiler.h>

#include <cpu/power.h> /* cpu_relax() */

#if CONFIG_KERN && CONFIG_KERN_SIGNALS
#include <kern/signal.h>
/* Forward decl */
struct Process;
#endif

typedef struct Event
{
    void (*action)(struct Event *);
    union
    {
#if CONFIG_KERN && CONFIG_KERN_SIGNALS
        struct
        {
            struct Process *sig_proc;  /* Process to be signalled */
            sigbit_t        sig_bit;   /* Signal to send */
            Signal          sig;       /* Local signal structure (used by generic event) */
        } Sig;
#endif
        struct
        {
            Hook  func;         /* Pointer to softint hook */
            void *user_data;    /* Data to be passed back to user hook */
        } Int;

        struct
        {
            bool completed;             /* Generic event completion */
        } Gen;
    } Ev;
} Event;

void event_hook_ignore(Event *event);
void event_hook_signal(Event *event);
void event_hook_softint(Event *event);
void event_hook_generic(Event *event);
void event_hook_generic_signal(Event *event);

#define event_initNone(e) \
    ((e)->action = event_hook_ignore)

INLINE Event event_createNone(void)
{
    Event e;
    e.action = event_hook_ignore;
    return e;
}

#define event_initSoftint(e,f,u) \
    ((e)->action = event_hook_softint,(e)->Ev.Int.func = (f), (e)->Ev.Int.user_data = (u))

INLINE Event event_createSoftint(Hook func, void *user_data)
{
    Event e;
    e.action = event_hook_softint;
    e.Ev.Int.func = func;
    e.Ev.Int.user_data = user_data;
    return e;
}

#if CONFIG_KERN && CONFIG_KERN_SIGNALS

#define event_initSignal(e,p,s) \
    ((e)->action = event_hook_signal,(e)->Ev.Sig.sig_proc = (p), (e)->Ev.Sig.sig_bit = (s))

INLINE Event event_createSignal(struct Process *proc, sigbit_t bit)
{
    Event e;
    e.action = event_hook_signal;
    e.Ev.Sig.sig_proc = proc;
    e.Ev.Sig.sig_bit = bit;
    return e;
}

#define EVENT_GENERIC_SIGNAL    SIG_SYSTEM6

#define event_initGeneric(e)                    \
    ((e)->action = event_hook_generic_signal,       \
        (e)->Ev.Sig.sig_proc = proc_current(),      \
        (e)->Ev.Sig.sig_bit = EVENT_GENERIC_SIGNAL, \
        (e)->Ev.Sig.sig.wait = 0, (e)->Ev.Sig.sig.recv = 0)
#else
#define event_initGeneric(e) \
    ((e)->action = event_hook_generic, (e)->Ev.Gen.completed = false)
#endif

INLINE Event event_createGeneric(void)
{
    Event e;
    event_initGeneric(&e);
    return e;
}

INLINE void event_wait(Event *e)
{
#if CONFIG_KERN_SIGNALS
    e->Ev.Sig.sig_proc = proc_current();
    sig_waitSignal(&e->Ev.Sig.sig, EVENT_GENERIC_SIGNAL);
#else
    while (ACCESS_SAFE(e->Ev.Gen.completed) == false)
        cpu_relax();
    e->Ev.Gen.completed = false;
    MEMORY_BARRIER;
#endif
}

int event_select(Event **evs, int n, ticks_t timeout);

bool event_waitTimeout(Event *e, ticks_t timeout);

INLINE void event_do(struct Event *e)
{
    e->action(e);
}

#endif /* KERN_EVENT_H */