linux下多个定时器(net-snmp)

yecheng_110

这是net-snmp中的代码 用setitimer和链表实现

snmp_alarm.h

1. 
   
2. #ifndef SNMP_ALARM_H
   
3. #define SNMP_ALARM_H
   
4. 
   
5. #define RETSIGTYPE void
   
6. 
   
7. typedef void (SNMPAlarmCallback) (unsigned int clientreg, void *clientarg);
   
8. 
   
9. /*
   
10. * alarm flags
    
11. */
    
12. #define SA_REPEAT 0x01          /* keep repeating every X seconds */
    
13. 
    
14. struct snmp_alarm {
    
15.     struct timeval t;
    
16.     unsigned int flags;
    
17.     unsigned int clientreg;
    
18.     struct timeval t_last;
    
19.     struct timeval t_next;
    
20.     void *clientarg;
    
21.     SNMPAlarmCallback *thecallback;
    
22.     struct snmp_alarm *next;
    
23. };
    
24. 
    
25. /*
    
26. * the ones you should need
    
27. */
    
28. void snmp_alarm_unregister(unsigned int clientreg);
    
29. void snmp_alarm_unregister_all(void);
    
30. unsigned int snmp_alarm_register(unsigned int when,
    
31.                                  unsigned int flags,
    
32.                                  SNMPAlarmCallback * thecallback,
    
33.                                  void *clientarg);
    
34. 
    
35. unsigned int snmp_alarm_register_hr(struct timeval t,
    
36.                                     unsigned int flags,
    
37.                                     SNMPAlarmCallback * cb, void *cd);
    
38. 
    
39. /*
    
40. * the ones you shouldn't
    
41. */
    
42. int init_alarm_post_config();
    
43. void sa_update_entry(struct snmp_alarm *alrm);
    
44. struct snmp_alarm *sa_find_next(void);
    
45. void run_alarms(void);
    
46. RETSIGTYPE alarm_handler(int a);
    
47. void set_an_alarm(void);
    
48. int get_next_alarm_delay_time(struct timeval *delta);
    
49. 
    
50. #endif
    

复制代码

snmp_alarm.c

1. 
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <signal.h>
   
5. #include <stdlib.h>
   
6. #include <sys/types.h>
   
7. #include <netinet/in.h>
   
8. #include <string.h>
   
9. 
   
10. #include <sys/time.h>
    
11. #include <time.h>
    
12. 
    
13. #include "snmp_alarm.h"
    
14. 
    
15. #define SNMP_MALLOC_STRUCT(s)   (struct s *) calloc(1, sizeof(struct s))
    
16. 
    
17. static struct snmp_alarm *thealarms = NULL;
    
18. static int start_alarms = 0;
    
19. static unsigned int regnum = 1;
    
20. 
    
21. int init_alarm_post_config()
    
22. {
    
23.     start_alarms = 1;
    
24.     set_an_alarm();
    
25.     return 0;
    
26. }
    
27. 
    
28. void sa_update_entry(struct snmp_alarm *a)
    
29. {
    
30.     if(a->t_last.tv_sec == 0 && a->t_last.tv_usec == 0) {
    
31.         struct timeval t_now;
    
32. 
    
33.         /*
    
34.          * Never been called yet, call time `t' from now.  
    
35.          */
    
36.         gettimeofday(&t_now, NULL);
    
37. 
    
38.         a->t_last.tv_sec = t_now.tv_sec;
    
39.         a->t_last.tv_usec = t_now.tv_usec;
    
40. 
    
41.         a->t_next.tv_sec = t_now.tv_sec + a->t.tv_sec;
    
42.         a->t_next.tv_usec = t_now.tv_usec + a->t.tv_usec;
    
43. 
    
44.         while(a->t_next.tv_usec >= 1000000) {
    
45.             a->t_next.tv_usec -= 1000000;
    
46.             a->t_next.tv_sec += 1;
    
47.         }
    
48.     }
    
49.     else if(a->t_next.tv_sec == 0 && a->t_next.tv_usec == 0) {
    
50.         /*
    
51.          * We've been called but not reset for the next call.  
    
52.          */
    
53.         if(a->flags & SA_REPEAT) {
    
54.             if(a->t.tv_sec == 0 && a->t.tv_usec == 0) {
    
55.                 printf("update_entry: illegal interval specified\n");
    
56.                 snmp_alarm_unregister(a->clientreg);
    
57.                 return;
    
58.             }
    
59. 
    
60.             a->t_next.tv_sec = a->t_last.tv_sec + a->t.tv_sec;
    
61.             a->t_next.tv_usec = a->t_last.tv_usec + a->t.tv_usec;
    
62. 
    
63.             while(a->t_next.tv_usec >= 1000000) {
    
64.                 a->t_next.tv_usec -= 1000000;
    
65.                 a->t_next.tv_sec += 1;
    
66.             }
    
67.         }
    
68.         else {
    
69.             /*
    
70.              * Single time call, remove it.  
    
71.              */
    
72.             snmp_alarm_unregister(a->clientreg);
    
73.         }
    
74.     }
    
75. }
    
76. 
    
77. /**
    
78. * This function removes the callback function from a list of registered
    
79. * alarms, unregistering the alarm.
    
80. *
    
81. * @param clientreg is a unique unsigned integer representing a registered
    
82. *        alarm which the client wants to unregister.
    
83. *
    
84. * @return void
    
85. *
    
86. * @see snmp_alarm_register
    
87. * @see snmp_alarm_register_hr
    
88. * @see snmp_alarm_unregister_all
    
89. */
    
90. void snmp_alarm_unregister(unsigned int clientreg)
    
91. {
    
92.     struct snmp_alarm *sa_ptr, **prevNext = &thealarms;
    
93. 
    
94.     for(sa_ptr = thealarms;
    
95.         sa_ptr != NULL && sa_ptr->clientreg != clientreg;
    
96.         sa_ptr = sa_ptr->next) {
    
97.         prevNext = &(sa_ptr->next);
    
98.     }
    
99. 
    
100.     if(sa_ptr != NULL) {
     
101.         *prevNext = sa_ptr->next;
     
102.         printf("unregistered alarm %d\n", sa_ptr->clientreg);
     
103.         /*
     
104.          * Note:  do not free the clientarg, its the clients responsibility
     
105.          */
     
106.         free(sa_ptr);
     
107.     }
     
108.     else {
     
109.         printf("no alarm %d to unregister\n", clientreg);
     
110.     }
     
111. }
     
112. 
     
113. /**
     
114. * This function unregisters all alarms currently stored.
     
115. *
     
116. * @return void
     
117. *
     
118. * @see snmp_alarm_register
     
119. * @see snmp_alarm_register_hr
     
120. * @see snmp_alarm_unregister
     
121. */
     
122. void snmp_alarm_unregister_all(void)
     
123. {
     
124.     struct snmp_alarm *sa_ptr, *sa_tmp;
     
125. 
     
126.     for(sa_ptr = thealarms; sa_ptr != NULL; sa_ptr = sa_tmp) {
     
127.         sa_tmp = sa_ptr->next;
     
128.         free(sa_ptr);
     
129.     }
     
130.     printf("ALL alarms unregistered\n");
     
131.     thealarms = NULL;
     
132. }
     
133. 
     
134. struct snmp_alarm *sa_find_next(void)
     
135. {
     
136.     struct snmp_alarm *a, *lowest = NULL;
     
137. 
     
138.     for(a = thealarms; a != NULL; a = a->next) {
     
139.         if(lowest == NULL) {
     
140.             lowest = a;
     
141.         }
     
142.         else if(a->t_next.tv_sec == lowest->t_next.tv_sec) {
     
143.             if(a->t_next.tv_usec < lowest->t_next.tv_usec) {
     
144.                 lowest = a;
     
145.             }
     
146.         }
     
147.         else if(a->t_next.tv_sec < lowest->t_next.tv_sec) {
     
148.             lowest = a;
     
149.         }
     
150.     }
     
151.     return lowest;
     
152. }
     
153. 
     
154. struct snmp_alarm *sa_find_specific(unsigned int clientreg)
     
155. {
     
156.     struct snmp_alarm *sa_ptr;
     
157. 
     
158.     for(sa_ptr = thealarms; sa_ptr != NULL; sa_ptr = sa_ptr->next) {
     
159.         if(sa_ptr->clientreg == clientreg) {
     
160.             return sa_ptr;
     
161.         }
     
162.     }
     
163.     return NULL;
     
164. }
     
165. 
     
166. void run_alarms(void)
     
167. {
     
168.     int done = 0;
     
169.     struct snmp_alarm *a = NULL;
     
170.     unsigned int clientreg;
     
171.     struct timeval t_now;
     
172. 
     
173.     /*
     
174.      * Loop through everything we have repeatedly looking for the next thing to
     
175.      * call until all events are finally in the future again.  
     
176.      */
     
177. 
     
178.     while(!done) {
     
179.         if((a = sa_find_next()) == NULL) {
     
180.             return;
     
181.         }
     
182. 
     
183.         gettimeofday(&t_now, NULL);
     
184. 
     
185.         if((a->t_next.tv_sec < t_now.tv_sec) ||
     
186.            ((a->t_next.tv_sec == t_now.tv_sec) &&
     
187.             (a->t_next.tv_usec < t_now.tv_usec))) {
     
188.             clientreg = a->clientreg;
     
189.             printf("run alarm %d\n", clientreg);
     
190.             (*(a->thecallback)) (clientreg, a->clientarg);
     
191.             printf("alarm %d completed\n", clientreg);
     
192. 
     
193.             if((a = sa_find_specific(clientreg)) != NULL) {
     
194.                 a->t_last.tv_sec = t_now.tv_sec;
     
195.                 a->t_last.tv_usec = t_now.tv_usec;
     
196.                 a->t_next.tv_sec = 0;
     
197.                 a->t_next.tv_usec = 0;
     
198.                 sa_update_entry(a);
     
199.             }
     
200.             else {
     
201.                 printf("alarm %d deleted itself\n", clientreg);
     
202.             }
     
203.         }
     
204.         else {
     
205.             done = 1;
     
206.         }
     
207.     }
     
208. }
     
209. 
     
210. 
     
211. 
     
212. RETSIGTYPE alarm_handler(int a)
     
213. {
     
214.     run_alarms();
     
215.     set_an_alarm();
     
216. }
     
217. 
     
218. 
     
219. 
     
220. int get_next_alarm_delay_time(struct timeval *delta)
     
221. {
     
222.     struct snmp_alarm *sa_ptr;
     
223.     struct timeval t_diff, t_now;
     
224. 
     
225.     sa_ptr = sa_find_next();
     
226. 
     
227.     if(sa_ptr) {
     
228.         gettimeofday(&t_now, 0);
     
229. 
     
230.         if((t_now.tv_sec > sa_ptr->t_next.tv_sec) ||
     
231.            ((t_now.tv_sec == sa_ptr->t_next.tv_sec) &&
     
232.             (t_now.tv_usec > sa_ptr->t_next.tv_usec))) {
     
233.             /*
     
234.              * Time has already passed.  Return the smallest possible amount of
     
235.              * time.  
     
236.              */
     
237.             delta->tv_sec = 0;
     
238.             delta->tv_usec = 1;
     
239.             return sa_ptr->clientreg;
     
240.         }
     
241.         else {
     
242.             /*
     
243.              * Time is still in the future.  
     
244.              */
     
245.             t_diff.tv_sec = sa_ptr->t_next.tv_sec - t_now.tv_sec;
     
246.             t_diff.tv_usec = sa_ptr->t_next.tv_usec - t_now.tv_usec;
     
247. 
     
248.             while(t_diff.tv_usec < 0) {
     
249.                 t_diff.tv_sec -= 1;
     
250.                 t_diff.tv_usec += 1000000;
     
251.             }
     
252. 
     
253.             delta->tv_sec = t_diff.tv_sec;
     
254.             delta->tv_usec = t_diff.tv_usec;
     
255.             return sa_ptr->clientreg;
     
256.         }
     
257.     }
     
258. 
     
259.     /*
     
260.      * Nothing Left.  
     
261.      */
     
262.     return 0;
     
263. }
     
264. 
     
265. 
     
266. void set_an_alarm(void)
     
267. {
     
268.     struct timeval delta;
     
269.     int nextalarm = get_next_alarm_delay_time(&delta);
     
270. 
     
271.     /*
     
272.      * We don't use signals if they asked us nicely not to.  It's expected
     
273.      * they'll check the next alarm time and do their own calling of
     
274.      * run_alarms().  
     
275.      */
     
276. 
     
277.     if(nextalarm) {
     
278.         struct itimerval it;
     
279. 
     
280.         it.it_value.tv_sec = delta.tv_sec;
     
281.         it.it_value.tv_usec = delta.tv_usec;
     
282.         it.it_interval.tv_sec = 0;
     
283.         it.it_interval.tv_usec = 0;
     
284. 
     
285.         signal(SIGALRM, alarm_handler);
     
286.         setitimer(ITIMER_REAL, &it, NULL);
     
287.         printf("schedule alarm %d in %d.%03d seconds\n",
     
288.                nextalarm, (int) delta.tv_sec,
     
289.                (int) (delta.tv_usec / 1000));
     
290. 
     
291.     }
     
292.     else {
     
293.         printf("no alarms found to schedule\n");
     
294.     }
     
295. }
     
296. 
     
297. 
     
298. /**
     
299. * This function registers function callbacks to occur at a speciifc time
     
300. * in the future.
     
301. *
     
302. * @param when is an unsigned integer specifying when the callback function
     
303. *             will be called in seconds.
     
304. *
     
305. * @param flags is an unsigned integer that specifies how frequent the callback
     
306. *        function is called in seconds.  Should be SA_REPEAT or 0.  If  
     
307. *        flags  is  set with SA_REPEAT, then the registered callback function
     
308. *        will be called every SA_REPEAT seconds.  If flags is 0 then the
     
309. *        function will only be called once and then removed from the
     
310. *        registered alarm list.
     
311. *
     
312. * @param thecallback is a pointer SNMPAlarmCallback which is the callback
     
313. *        function being stored and registered.
     
314. *
     
315. * @param clientarg is a void pointer used by the callback function.  This
     
316. *        pointer is assigned to snmp_alarm->clientarg and passed into the
     
317. *        callback function for the client's specifc needs.
     
318. *
     
319. * @return Returns a unique unsigned integer(which is also passed as the first
     
320. *        argument of each callback), which can then be used to remove the
     
321. *        callback from the list at a later point in the future using the
     
322. *        snmp_alarm_unregister() function.  If memory could not be allocated
     
323. *        for the snmp_alarm struct 0 is returned.
     
324. *
     
325. * @see snmp_alarm_unregister
     
326. * @see snmp_alarm_register_hr
     
327. * @see snmp_alarm_unregister_all
     
328. */
     
329. unsigned int
     
330. snmp_alarm_register(unsigned int when, unsigned int flags,
     
331.                     SNMPAlarmCallback * thecallback, void *clientarg)
     
332. {
     
333.     struct snmp_alarm **sa_pptr;
     
334. 
     
335.     if(thealarms != NULL) {
     
336.         for(sa_pptr = &thealarms; (*sa_pptr) != NULL;
     
337.             sa_pptr = &((*sa_pptr)->next)) ;
     
338.     }
     
339.     else {
     
340.         sa_pptr = &thealarms;
     
341.     }
     
342. 
     
343.     *sa_pptr = SNMP_MALLOC_STRUCT(snmp_alarm);
     
344.     if(*sa_pptr == NULL)
     
345.         return 0;
     
346. 
     
347.     if(0 == when) {
     
348.         (*sa_pptr)->t.tv_sec = 0;
     
349.         (*sa_pptr)->t.tv_usec = 1;
     
350.     }
     
351.     else {
     
352.         (*sa_pptr)->t.tv_sec = when;
     
353.         (*sa_pptr)->t.tv_usec = 0;
     
354.     }
     
355.     (*sa_pptr)->flags = flags;
     
356.     (*sa_pptr)->clientarg = clientarg;
     
357.     (*sa_pptr)->thecallback = thecallback;
     
358.     (*sa_pptr)->clientreg = regnum++;
     
359.     (*sa_pptr)->next = NULL;
     
360.     sa_update_entry(*sa_pptr);
     
361. 
     
362.     printf("registered alarm %d, t = %d.%03d, flags=0x%02x\n",
     
363.            (*sa_pptr)->clientreg, (int) (*sa_pptr)->t.tv_sec,
     
364.            (int) ((*sa_pptr)->t.tv_usec / 1000), (*sa_pptr)->flags);
     
365. 
     
366.     if(start_alarms){
     
367.         set_an_alarm();
     
368.     }
     
369. 
     
370.     return (*sa_pptr)->clientreg;
     
371. }
     
372. 
     
373. 
     
374. /**
     
375. * This function offers finer granularity as to when the callback
     
376. * function is called by making use of t->tv_usec value forming the
     
377. * "when" aspect of snmp_alarm_register().
     
378. *
     
379. * @param t is a timeval structure used to specify when the callback
     
380. *        function(alarm) will be called.  Adds the ability to specify
     
381. *        microseconds.  t.tv_sec and t.tv_usec are assigned
     
382. *        to snmp_alarm->tv_sec and snmp_alarm->tv_usec respectively internally.
     
383. *        The snmp_alarm_register function only assigns seconds(it's when
     
384. *        argument).
     
385. *
     
386. * @param flags is an unsigned integer that specifies how frequent the callback
     
387. *        function is called in seconds.  Should be SA_REPEAT or NULL.  If  
     
388. *        flags  is  set with SA_REPEAT, then the registered callback function
     
389. *        will be called every SA_REPEAT seconds.  If flags is NULL then the
     
390. *        function will only be called once and then removed from the
     
391. *        registered alarm list.
     
392. *
     
393. * @param cb is a pointer SNMPAlarmCallback which is the callback
     
394. *        function being stored and registered.
     
395. *
     
396. * @param cd is a void pointer used by the callback function.  This
     
397. *        pointer is assigned to snmp_alarm->clientarg and passed into the
     
398. *        callback function for the client's specifc needs.
     
399. *
     
400. * @return Returns a unique unsigned integer(which is also passed as the first
     
401. *        argument of each callback), which can then be used to remove the
     
402. *        callback from the list at a later point in the future using the
     
403. *        snmp_alarm_unregister() function.  If memory could not be allocated
     
404. *        for the snmp_alarm struct 0 is returned.
     
405. *
     
406. * @see snmp_alarm_register
     
407. * @see snmp_alarm_unregister
     
408. * @see snmp_alarm_unregister_all
     
409. */
     
410. unsigned int
     
411. snmp_alarm_register_hr(struct timeval t, unsigned int flags,
     
412.                        SNMPAlarmCallback * cb, void *cd)
     
413. {
     
414.     struct snmp_alarm **s = NULL;
     
415. 
     
416.     for(s = &(thealarms); *s != NULL; s = &((*s)->next)) ;
     
417. 
     
418.     *s = SNMP_MALLOC_STRUCT(snmp_alarm);
     
419.     if(*s == NULL) {
     
420.         return 0;
     
421.     }
     
422. 
     
423.     (*s)->t.tv_sec = t.tv_sec;
     
424.     (*s)->t.tv_usec = t.tv_usec;
     
425.     (*s)->flags = flags;
     
426.     (*s)->clientarg = cd;
     
427.     (*s)->thecallback = cb;
     
428.     (*s)->clientreg = regnum++;
     
429.     (*s)->next = NULL;
     
430. 
     
431.     sa_update_entry(*s);
     
432. 
     
433.     printf("registered alarm %d, t = %d.%03d, flags=0x%02x\n",
     
434.            (*s)->clientreg, (int) (*s)->t.tv_sec,
     
435.            (int) ((*s)->t.tv_usec / 1000), (*s)->flags);
     
436. 
     
437.     if(start_alarms) {
     
438.         set_an_alarm();
     
439.     }
     
440. 
     
441.     return (*s)->clientreg;
     
442. }
     
443. 
     
444. /**  @} */
     
445. 
     
446. void fun1(unsigned int clientreg, void *clientarg)
     
447. {
     
448.     fprintf(stderr,"fun:%s clientreg:%d\n",__FUNCTION__,clientreg);
     
449. }
     
450. 
     
451. void fun2(unsigned int clientreg, void *clientarg)
     
452. {
     
453.     fprintf(stderr,"fun:%s clientreg:%d\n",__FUNCTION__,clientreg);
     
454. }
     
455. 
     
456. 
     
457. //使用示例 很简单
     
458. /*int main()
     
459. {
     
460.     init_alarm_post_config();
     
461.     snmp_alarm_register(5, SA_REPEAT,fun1,NULL);
     
462.     snmp_alarm_register(10, SA_REPEAT,fun2,NULL);
     
463.     for(;;){
     
464.         pause();
     
465.     }
     
466.     return 0;
     
467. }*/
     
468. 
     

复制代码

[ 本帖最后由 yecheng_110 于 2008-10-6 23:59 编辑 ]

gawk

很有借鉴意义，不少项目中的定时器应该都是这样实现的

converse

lighttpd里面也是类似的实现,我自己写了一个定时器模块也是采用的settimer...
http://www.cppblog.com/converse/archive/2008/08/13/58731.html