Return to event.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib

Annotation of embedaddon/bird2/lib/event.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     BIRD Library -- Event Processing
        !             3:  *
        !             4:  *     (c) 1999 Martin Mares <mj@ucw.cz>
        !             5:  *
        !             6:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !             7:  */
        !             8: 
        !             9: /**
        !            10:  * DOC: Events
        !            11:  *
        !            12:  * Events are there to keep track of deferred execution.
        !            13:  * Since BIRD is single-threaded, it requires long lasting tasks to be split to smaller
        !            14:  * parts, so that no module can monopolize the CPU. To split such a task, just create
        !            15:  * an &event resource, point it to the function you want to have called and call ev_schedule()
        !            16:  * to ask the core to run the event when nothing more important requires attention.
        !            17:  *
        !            18:  * You can also define your own event lists (the &event_list structure), enqueue your
        !            19:  * events in them and explicitly ask to run them.
        !            20:  */
        !            21: 
        !            22: #include "nest/bird.h"
        !            23: #include "lib/event.h"
        !            24: 
        !            25: event_list global_event_list;
        !            26: 
        !            27: inline void
        !            28: ev_postpone(event *e)
        !            29: {
        !            30:   if (ev_active(e))
        !            31:     {
        !            32:       rem_node(&e->n);
        !            33:       e->n.next = NULL;
        !            34:     }
        !            35: }
        !            36: 
        !            37: static void
        !            38: ev_dump(resource *r)
        !            39: {
        !            40:   event *e = (event *) r;
        !            41: 
        !            42:   debug("(code %p, data %p, %s)\n",
        !            43:        e->hook,
        !            44:        e->data,
        !            45:        e->n.next ? "scheduled" : "inactive");
        !            46: }
        !            47: 
        !            48: static struct resclass ev_class = {
        !            49:   "Event",
        !            50:   sizeof(event),
        !            51:   (void (*)(resource *)) ev_postpone,
        !            52:   ev_dump,
        !            53:   NULL,
        !            54:   NULL
        !            55: };
        !            56: 
        !            57: /**
        !            58:  * ev_new - create a new event
        !            59:  * @p: resource pool
        !            60:  *
        !            61:  * This function creates a new event resource. To use it,
        !            62:  * you need to fill the structure fields and call ev_schedule().
        !            63:  */
        !            64: event *
        !            65: ev_new(pool *p)
        !            66: {
        !            67:   event *e = ralloc(p, &ev_class);
        !            68:   return e;
        !            69: }
        !            70: 
        !            71: /**
        !            72:  * ev_run - run an event
        !            73:  * @e: an event
        !            74:  *
        !            75:  * This function explicitly runs the event @e (calls its hook
        !            76:  * function) and removes it from an event list if it's linked to any.
        !            77:  *
        !            78:  * From the hook function, you can call ev_enqueue() or ev_schedule()
        !            79:  * to re-add the event.
        !            80:  */
        !            81: inline void
        !            82: ev_run(event *e)
        !            83: {
        !            84:   ev_postpone(e);
        !            85:   e->hook(e->data);
        !            86: }
        !            87: 
        !            88: /**
        !            89:  * ev_enqueue - enqueue an event
        !            90:  * @l: an event list
        !            91:  * @e: an event
        !            92:  *
        !            93:  * ev_enqueue() stores the event @e to the specified event
        !            94:  * list @l which can be run by calling ev_run_list().
        !            95:  */
        !            96: inline void
        !            97: ev_enqueue(event_list *l, event *e)
        !            98: {
        !            99:   ev_postpone(e);
        !           100:   add_tail(l, &e->n);
        !           101: }
        !           102: 
        !           103: /**
        !           104:  * ev_schedule - schedule an event
        !           105:  * @e: an event
        !           106:  *
        !           107:  * This function schedules an event by enqueueing it to a system-wide
        !           108:  * event list which is run by the platform dependent code whenever
        !           109:  * appropriate.
        !           110:  */
        !           111: void
        !           112: ev_schedule(event *e)
        !           113: {
        !           114:   ev_enqueue(&global_event_list, e);
        !           115: }
        !           116: 
        !           117: void io_log_event(void *hook, void *data);
        !           118: 
        !           119: /**
        !           120:  * ev_run_list - run an event list
        !           121:  * @l: an event list
        !           122:  *
        !           123:  * This function calls ev_run() for all events enqueued in the list @l.
        !           124:  */
        !           125: int
        !           126: ev_run_list(event_list *l)
        !           127: {
        !           128:   node *n;
        !           129:   list tmp_list;
        !           130: 
        !           131:   init_list(&tmp_list);
        !           132:   add_tail_list(&tmp_list, l);
        !           133:   init_list(l);
        !           134:   WALK_LIST_FIRST(n, tmp_list)
        !           135:     {
        !           136:       event *e = SKIP_BACK(event, n, n);
        !           137: 
        !           138:       /* This is ugly hack, we want to log just events executed from the main I/O loop */
        !           139:       if (l == &global_event_list)
        !           140:        io_log_event(e->hook, e->data);
        !           141: 
        !           142:       ev_run(e);
        !           143:     }
        !           144:   return !EMPTY_LIST(*l);
        !           145: }