Statistics
| Branch: | Revision:

iof-bird-daemon / lib / event.c @ b933281e

History | View | Annotate | Download (2.78 KB)

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 (e->n.next)
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
};
54

    
55
/**
56
 * ev_new - create a new event
57
 * @p: resource pool
58
 *
59
 * This function creates a new event resource. To use it,
60
 * you need to fill the structure fields and call ev_schedule().
61
 */
62
event *
63
ev_new(pool *p)
64
{
65
  event *e = ralloc(p, &ev_class);
66

    
67
  e->hook = NULL;
68
  e->data = NULL;
69
  e->n.next = NULL;
70
  return e;
71
}
72

    
73
/**
74
 * ev_run - run an event
75
 * @e: an event
76
 *
77
 * This function explicitly runs the event @e (calls its hook
78
 * function) and removes it from an event list if it's linked to any.
79
 *
80
 * From the hook function, you can call ev_enqueue() or ev_schedule()
81
 * to re-add the event.
82
 */
83
inline void
84
ev_run(event *e)
85
{
86
  ev_postpone(e);
87
  e->hook(e->data);
88
}
89

    
90
/**
91
 * ev_enqueue - enqueue an event
92
 * @l: an event list
93
 * @e: an event
94
 *
95
 * ev_enqueue() stores the event @e to the specified event
96
 * list @l which can be run by calling ev_run_list().
97
 */
98
inline void
99
ev_enqueue(event_list *l, event *e)
100
{
101
  ev_postpone(e);
102
  add_tail(l, &e->n);
103
}
104

    
105
/**
106
 * ev_schedule - schedule an event
107
 * @e: an event
108
 *
109
 * This function schedules an event by enqueueing it to a system-wide
110
 * event list which is run by the platform dependent code whenever
111
 * appropriate.
112
 */
113
void
114
ev_schedule(event *e)
115
{
116
  ev_enqueue(&global_event_list, e);
117
}
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
      ev_run(e);
138
    }
139
  return !EMPTY_LIST(*l);
140
}