* more fixups for the generated .c file
[olsrd.git] / src / scheduler.c
1 /*
2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
3  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met:
9  *
10  * * Redistributions of source code must retain the above copyright 
11  *   notice, this list of conditions and the following disclaimer.
12  * * Redistributions in binary form must reproduce the above copyright 
13  *   notice, this list of conditions and the following disclaimer in 
14  *   the documentation and/or other materials provided with the 
15  *   distribution.
16  * * Neither the name of olsr.org, olsrd nor the names of its 
17  *   contributors may be used to endorse or promote products derived 
18  *   from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
24  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Visit http://www.olsr.org for more information.
34  *
35  * If you find this software useful feel free to make a donation
36  * to the project. For more information see the website or contact
37  * the copyright holders.
38  *
39  * $Id: scheduler.c,v 1.39 2007/04/25 22:08:16 bernd67 Exp $
40  */
41
42
43 #include "defs.h"
44 #include "scheduler.h"
45 #include "log.h"
46 #include "tc_set.h"
47 #include "link_set.h"
48 #include "duplicate_set.h"
49 #include "mpr_selector_set.h"
50 #include "mid_set.h"
51 #include "mpr.h"
52 #include "olsr.h"
53 #include "build_msg.h"
54
55 #if defined WIN32
56 extern olsr_bool olsr_win32_end_request;
57 extern olsr_bool olsr_win32_end_flag;
58 #endif
59
60 /* Timer data, global. Externed in defs.h */
61 clock_t now_times;              /* current idea of times(2) reported uptime */
62 struct timeval now;             /* current idea of time */
63 struct tm *nowtm;               /* current idea of time (in tm) */
64
65 static float pollrate;
66
67 /* Lists */
68 static struct timeout_entry *timeout_functions;
69 static struct event_entry *event_functions;
70
71 static olsr_bool link_changes; /* is set if changes occur in MPRS set */ 
72
73 void
74 signal_link_changes(olsr_bool val)
75 {
76   link_changes = val;
77 }
78
79 static void 
80 trigger_dijkstra(void *foo __attribute__((unused)))
81 {
82   OLSR_PRINTF(3, "Triggering Dijkstra\n");
83
84   changes_neighborhood = OLSR_TRUE;
85   changes_topology = OLSR_TRUE;
86   changes_force = OLSR_TRUE;
87 }
88
89 /**
90  *Main scheduler event loop. Polls at every
91  *sched_poll_interval and calls all functions
92  *that are timed out or that are triggered.
93  *Also calls the olsr_process_changes()
94  *function at every poll.
95  *
96  *
97  *@return nada
98  */
99
100 void
101 scheduler(void)
102 {
103   struct timespec remainder_spec;
104   struct timespec sleeptime_spec;
105
106   /*
107    *Used to calculate sleep time
108    */
109   clock_t end_of_loop;
110   struct timeval time_used;
111   struct timeval interval;
112   struct timeval sleeptime_val;
113
114   olsr_u32_t interval_usec;
115
116   struct event_entry *entry;
117   struct timeout_entry *time_out_entry;
118
119   struct interface *ifn;
120
121   /* Global buffer for times(2) calls */
122   struct tms tms_buf;
123  
124   link_changes = OLSR_FALSE;
125
126   if(olsr_cnf->lq_level > 1 && olsr_cnf->lq_dinter > 0.0)
127     olsr_register_scheduler_event(trigger_dijkstra, NULL, olsr_cnf->lq_dinter, 0, NULL);
128
129   pollrate = olsr_cnf->pollrate;
130   interval_usec = (olsr_u32_t)(pollrate * 1000000);
131
132   interval.tv_sec = interval_usec / 1000000;
133   interval.tv_usec = interval_usec % 1000000;
134
135   OLSR_PRINTF(1, "Scheduler started - polling every %0.2f seconds\n", pollrate);
136   OLSR_PRINTF(3, "Max jitter is %f\n\n", olsr_cnf->max_jitter);
137
138   /* Main scheduler event loop */
139   for(;;)
140     {
141       /* Update now_times */
142       now_times = times(&tms_buf);
143
144       /* Update the global timestamp - kept for plugin compat */
145       gettimeofday(&now, NULL);
146       nowtm = localtime((time_t *)&now.tv_sec);
147
148       while (nowtm == NULL)
149         {
150           nowtm = localtime((time_t *)&now.tv_sec);
151         }
152
153
154       /* Run timout functions (before packet generation) */
155
156       time_out_entry = timeout_functions;
157       
158       while(time_out_entry)
159         {
160           time_out_entry->function();
161           time_out_entry = time_out_entry->next;
162         }
163
164       /* Update */
165       
166       olsr_process_changes();
167
168
169       /* Check for changes in topology */
170       if(link_changes)
171         {
172           OLSR_PRINTF(3, "ANSN UPDATED %d\n\n", get_local_ansn());
173           increase_local_ansn();
174           link_changes = OLSR_FALSE;
175         }
176
177
178       /* Check scheduled events */
179       entry = event_functions;
180
181       /* UPDATED - resets timer upon triggered execution */
182       while(entry)
183         {
184           entry->since_last += pollrate;
185
186           /* Timed out */
187           if((entry->since_last > entry->interval) ||
188              /* Triggered */
189              ((entry->trigger != NULL) &&
190               (*(entry->trigger) == 1)))
191             {
192               /* Run scheduled function */
193               entry->function(entry->param);
194
195               /* Set jitter */
196               entry->since_last = (float) random()/RAND_MAX;
197               entry->since_last *= olsr_cnf->max_jitter;
198               
199               /* Reset trigger */
200               if(entry->trigger != NULL)
201                 *(entry->trigger) = 0;
202               
203               //OLSR_PRINTF(3, "Since_last jitter: %0.2f\n", entry->since_last);
204
205             }
206
207           entry = entry->next;
208         }
209
210
211
212       /* looping trough interfaces and emmittin pending data */
213       for (ifn = ifnet; ifn ; ifn = ifn->int_next) 
214         { 
215           if(net_output_pending(ifn) && TIMED_OUT(ifn->fwdtimer)) 
216             net_output(ifn);
217         }
218
219
220       end_of_loop = times(&tms_buf);
221
222       //printf("Tick diff: %d\n", end_of_loop - now_times);
223       time_used.tv_sec = ((end_of_loop - now_times) * olsr_cnf->system_tick_divider) / 1000;
224       time_used.tv_usec = ((end_of_loop - now_times) * olsr_cnf->system_tick_divider) % 1000;
225
226       //printf("Time used: %d.%04d\n", time_used.tv_sec, time_used.tv_usec);
227
228       if(timercmp(&time_used, &interval, <))
229         {
230           timersub(&interval, &time_used, &sleeptime_val);
231           
232           // printf("sleeptime_val = %u.%06u\n",
233           //        sleeptime_val.tv_sec, sleeptime_val.tv_usec);
234           
235           sleeptime_spec.tv_sec = sleeptime_val.tv_sec;
236           sleeptime_spec.tv_nsec = sleeptime_val.tv_usec * 1000;
237           
238           while(nanosleep(&sleeptime_spec, &remainder_spec) < 0)
239             sleeptime_spec = remainder_spec;
240         }
241
242 #if defined WIN32
243       // the Ctrl-C signal handler thread asks us to exit
244
245       if (olsr_win32_end_request)
246         break;
247 #endif
248       
249     }//end for
250
251 #if defined WIN32
252   // tell the Ctrl-C signal handler thread that we have exited
253
254   olsr_win32_end_flag = TRUE;
255
256   // the Ctrl-C signal handler thread will exit the process and
257   // hence also kill us
258   
259   while (1)
260     Sleep(1000);
261 #endif
262 }
263
264
265 /*
266  *
267  *@param initial how long utnil the first generation
268  *@param trigger pointer to a boolean indicating that
269  *this function should be triggered immediatley
270  */
271 int
272 olsr_register_scheduler_event(void (*event_function)(void *), 
273                               void *par,
274                               float interval, 
275                               float initial, 
276                               olsr_u8_t *trigger)
277 {
278   struct event_entry *new_entry;
279
280   OLSR_PRINTF(3, "Scheduler event registered int: %0.2f\n", interval);
281
282   /* check that this entry is not added already */
283   new_entry = event_functions;
284   while(new_entry)
285     {
286       if((new_entry->function == event_function) &&
287          (new_entry->param == par) &&
288          (new_entry->trigger == trigger) &&
289          (new_entry->interval == interval))
290         {
291           fprintf(stderr, "Register scheduler event: Event alread registered!\n");
292           olsr_syslog(OLSR_LOG_ERR, "Register scheduler event: Event alread registered!\n");
293           return 0;
294         }
295       new_entry = new_entry->next;
296     }
297
298   new_entry = olsr_malloc(sizeof(struct event_entry), "add scheduler event");
299
300   new_entry->function = event_function;
301   new_entry->param = par;
302   new_entry->interval = interval;
303   new_entry->since_last = interval - initial;
304   new_entry->next = event_functions;
305   new_entry->trigger = trigger;
306
307   event_functions = new_entry;
308
309   return 1;
310 }
311
312
313
314 /*
315  *
316  *@param initial how long until the first generation
317  *@param trigger pointer to a boolean indicating that
318  *this function should be triggered immediatley
319  */
320 int
321 olsr_remove_scheduler_event(void (*event_function)(void *), 
322                             void *par,
323                             float interval, 
324                             float initial __attribute__((unused)), 
325                             olsr_u8_t *trigger)
326 {
327   struct event_entry *entry, *prev;
328
329   prev = NULL;
330   entry = event_functions;
331
332   while(entry)
333     {
334       if((entry->function == event_function) &&
335          (entry->param == par) &&
336          (entry->trigger == trigger) &&
337          (entry->interval == interval))
338         {
339           if(entry == event_functions)
340             {
341               event_functions = entry->next;
342             }
343           else
344             {
345               prev->next = entry->next;
346             }
347           free(entry);
348           return 1;
349         }
350
351       prev = entry;
352       entry = entry->next;
353     }
354
355   return 0;
356 }
357
358
359 int
360 olsr_register_timeout_function(void (*time_out_function)(void))
361 {
362   struct timeout_entry *new_entry;
363
364   /* check that this entry is not added already */
365   new_entry = timeout_functions;
366   while(new_entry)
367     {
368       if(new_entry->function == time_out_function)
369         {
370           fprintf(stderr, "Register scheduler timeout: Event alread registered!\n");
371           olsr_syslog(OLSR_LOG_ERR, "Register scheduler timeout: Event alread registered!\n");
372           return 0;
373         }
374       new_entry = new_entry->next;
375     }
376
377   new_entry = olsr_malloc(sizeof(struct timeout_entry), "scheduler add timeout");
378
379   new_entry->function = time_out_function;
380   new_entry->next = timeout_functions;
381
382   timeout_functions = new_entry;
383
384   return 1;
385 }
386
387
388
389 int
390 olsr_remove_timeout_function(void (*time_out_function)(void))
391 {
392   struct timeout_entry *entry, *prev;
393
394   /* check that this entry is not added already */
395   entry = timeout_functions;
396   prev = NULL;
397
398   while(entry)
399     {
400       if(entry->function == time_out_function)
401         {
402           if(entry == timeout_functions)
403             {
404               timeout_functions = entry->next;
405             }
406           else
407             {
408               prev->next = entry->next;
409             }
410           free(entry);
411           return 1;
412         }
413       prev = entry;
414       entry = entry->next;
415     }
416
417   return 0;
418 }
419