Statistics
| Branch: | Revision:

iof-bird / bird-2.0.1 / lib / event.c @ 6b3f1a54

History | View | Annotate | Download (2.94 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 (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
}