Annotation of embedaddon/ntp/ntpd/ntp_timer.c, revision 1.1.1.1
1.1 misho 1: /*
2: * ntp_timer.c - event timer support routines
3: */
4: #ifdef HAVE_CONFIG_H
5: # include <config.h>
6: #endif
7:
8: #include "ntp_machine.h"
9: #include "ntpd.h"
10: #include "ntp_stdlib.h"
11:
12: #include <stdio.h>
13: #include <signal.h>
14: #ifdef HAVE_SYS_SIGNAL_H
15: # include <sys/signal.h>
16: #endif
17: #ifdef HAVE_UNISTD_H
18: # include <unistd.h>
19: #endif
20:
21: #if defined(HAVE_IO_COMPLETION_PORT)
22: # include "ntp_iocompletionport.h"
23: # include "ntp_timer.h"
24: #endif
25:
26: #ifdef KERNEL_PLL
27: #include "ntp_syscall.h"
28: #endif /* KERNEL_PLL */
29:
30: #ifdef OPENSSL
31: #include <openssl/rand.h>
32: #endif /* OPENSSL */
33:
34: /*
35: * These routines provide support for the event timer. The timer is
36: * implemented by an interrupt routine which sets a flag once every
37: * 2**EVENT_TIMEOUT seconds (currently 4), and a timer routine which
38: * is called when the mainline code gets around to seeing the flag.
39: * The timer routine dispatches the clock adjustment code if its time
40: * has come, then searches the timer queue for expiries which are
41: * dispatched to the transmit procedure. Finally, we call the hourly
42: * procedure to do cleanup and print a message.
43: */
44: volatile int interface_interval = 300; /* update interface every 5 minutes as default */
45:
46: /*
47: * Alarm flag. The mainline code imports this.
48: */
49: volatile int alarm_flag;
50:
51: /*
52: * The counters and timeouts
53: */
54: static u_long interface_timer; /* interface update timer */
55: static u_long adjust_timer; /* second timer */
56: static u_long stats_timer; /* stats timer */
57: static u_long huffpuff_timer; /* huff-n'-puff timer */
58: u_long leapsec; /* leapseconds countdown */
59: l_fp sys_time; /* current system time */
60: #ifdef OPENSSL
61: static u_long revoke_timer; /* keys revoke timer */
62: static u_long keys_timer; /* session key timer */
63: u_long sys_revoke = KEY_REVOKE; /* keys revoke timeout (log2 s) */
64: u_long sys_automax = NTP_AUTOMAX; /* key list timeout (log2 s) */
65: #endif /* OPENSSL */
66:
67: /*
68: * Statistics counter for the interested.
69: */
70: volatile u_long alarm_overflow;
71:
72: #define MINUTE 60
73: #define HOUR (60 * MINUTE)
74: #define DAY (24 * HOUR)
75:
76: u_long current_time; /* seconds since startup */
77:
78: /*
79: * Stats. Number of overflows and number of calls to transmit().
80: */
81: u_long timer_timereset;
82: u_long timer_overflows;
83: u_long timer_xmtcalls;
84:
85: #if defined(VMS)
86: static int vmstimer[2]; /* time for next timer AST */
87: static int vmsinc[2]; /* timer increment */
88: #endif /* VMS */
89:
90: #if defined SYS_WINNT
91: static HANDLE WaitableTimerHandle = NULL;
92: #else
93: static RETSIGTYPE alarming (int);
94: #endif /* SYS_WINNT */
95:
96: #if !defined(VMS)
97: # if !defined SYS_WINNT || defined(SYS_CYGWIN32)
98: # ifndef HAVE_TIMER_SETTIME
99: struct itimerval itimer;
100: # else
101: static timer_t ntpd_timerid;
102: struct itimerspec itimer;
103: # endif /* HAVE_TIMER_SETTIME */
104: # endif /* SYS_WINNT */
105: #endif /* VMS */
106:
107: /*
108: * reinit_timer - reinitialize interval timer.
109: */
110: void
111: reinit_timer(void)
112: {
113: #if !defined(SYS_WINNT) && !defined(VMS)
114: # if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
115: timer_gettime(ntpd_timerid, &itimer);
116: if (itimer.it_value.tv_sec < 0 || itimer.it_value.tv_sec > (1<<EVENT_TIMEOUT)) {
117: itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
118: }
119: if (itimer.it_value.tv_nsec < 0 ) {
120: itimer.it_value.tv_nsec = 0;
121: }
122: if (itimer.it_value.tv_sec == 0 && itimer.it_value.tv_nsec == 0) {
123: itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
124: itimer.it_value.tv_nsec = 0;
125: }
126: itimer.it_interval.tv_sec = (1<<EVENT_TIMEOUT);
127: itimer.it_interval.tv_nsec = 0;
128: timer_settime(ntpd_timerid, 0 /*!TIMER_ABSTIME*/, &itimer, NULL);
129: # else
130: getitimer(ITIMER_REAL, &itimer);
131: if (itimer.it_value.tv_sec < 0 || itimer.it_value.tv_sec > (1<<EVENT_TIMEOUT)) {
132: itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
133: }
134: if (itimer.it_value.tv_usec < 0 ) {
135: itimer.it_value.tv_usec = 0;
136: }
137: if (itimer.it_value.tv_sec == 0 && itimer.it_value.tv_usec == 0) {
138: itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
139: itimer.it_value.tv_usec = 0;
140: }
141: itimer.it_interval.tv_sec = (1<<EVENT_TIMEOUT);
142: itimer.it_interval.tv_usec = 0;
143: setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0);
144: # endif
145: # endif /* VMS */
146: }
147:
148: /*
149: * init_timer - initialize the timer data structures
150: */
151: void
152: init_timer(void)
153: {
154: /*
155: * Initialize...
156: */
157: alarm_flag = 0;
158: alarm_overflow = 0;
159: adjust_timer = 1;
160: stats_timer = 0;
161: huffpuff_timer = 0;
162: interface_timer = 0;
163: current_time = 0;
164: timer_overflows = 0;
165: timer_xmtcalls = 0;
166: timer_timereset = 0;
167:
168: #if !defined(SYS_WINNT)
169: /*
170: * Set up the alarm interrupt. The first comes 2**EVENT_TIMEOUT
171: * seconds from now and they continue on every 2**EVENT_TIMEOUT
172: * seconds.
173: */
174: # if !defined(VMS)
175: # if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
176: if (timer_create (CLOCK_REALTIME, NULL, &ntpd_timerid) ==
177: # ifdef SYS_VXWORKS
178: ERROR
179: # else
180: -1
181: # endif
182: )
183: {
184: fprintf (stderr, "timer create FAILED\n");
185: exit (0);
186: }
187: (void) signal_no_reset(SIGALRM, alarming);
188: itimer.it_interval.tv_sec = itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
189: itimer.it_interval.tv_nsec = itimer.it_value.tv_nsec = 0;
190: timer_settime(ntpd_timerid, 0 /*!TIMER_ABSTIME*/, &itimer, NULL);
191: # else
192: (void) signal_no_reset(SIGALRM, alarming);
193: itimer.it_interval.tv_sec = itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
194: itimer.it_interval.tv_usec = itimer.it_value.tv_usec = 0;
195: setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0);
196: # endif
197: # else /* VMS */
198: vmsinc[0] = 10000000; /* 1 sec */
199: vmsinc[1] = 0;
200: lib$emul(&(1<<EVENT_TIMEOUT), &vmsinc, &0, &vmsinc);
201:
202: sys$gettim(&vmstimer); /* that's "now" as abstime */
203:
204: lib$addx(&vmsinc, &vmstimer, &vmstimer);
205: sys$setimr(0, &vmstimer, alarming, alarming, 0);
206: # endif /* VMS */
207: #else /* SYS_WINNT */
208: /*
209: * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
210: * Under Windows/NT,
211: */
212:
213: WaitableTimerHandle = CreateWaitableTimer(NULL, FALSE, NULL);
214: if (WaitableTimerHandle == NULL) {
215: msyslog(LOG_ERR, "CreateWaitableTimer failed: %m");
216: exit(1);
217: }
218: else {
219: DWORD Period = (1<<EVENT_TIMEOUT) * 1000;
220: LARGE_INTEGER DueTime;
221: DueTime.QuadPart = Period * 10000i64;
222: if (!SetWaitableTimer(WaitableTimerHandle, &DueTime, Period, NULL, NULL, FALSE) != NO_ERROR) {
223: msyslog(LOG_ERR, "SetWaitableTimer failed: %m");
224: exit(1);
225: }
226: }
227:
228: #endif /* SYS_WINNT */
229: }
230:
231: #if defined(SYS_WINNT)
232: extern HANDLE
233: get_timer_handle(void)
234: {
235: return WaitableTimerHandle;
236: }
237: #endif
238:
239: /*
240: * timer - event timer
241: */
242: void
243: timer(void)
244: {
245: register struct peer *peer, *next_peer;
246: u_int n;
247:
248: /*
249: * The basic timerevent is one second. This is used to adjust
250: * the system clock in time and frequency, implement the
251: * kiss-o'-deatch function and implement the association
252: * polling function..
253: */
254: current_time++;
255: get_systime(&sys_time);
256: if (adjust_timer <= current_time) {
257: adjust_timer += 1;
258: adj_host_clock();
259: #ifdef REFCLOCK
260: for (n = 0; n < NTP_HASH_SIZE; n++) {
261: for (peer = peer_hash[n]; peer != 0; peer = next_peer) {
262: next_peer = peer->next;
263: if (peer->flags & FLAG_REFCLOCK)
264: refclock_timer(peer);
265: }
266: }
267: #endif /* REFCLOCK */
268: }
269:
270: /*
271: * Now dispatch any peers whose event timer has expired. Be
272: * careful here, since the peer structure might go away as the
273: * result of the call.
274: */
275: for (n = 0; n < NTP_HASH_SIZE; n++) {
276: for (peer = peer_hash[n]; peer != 0; peer = next_peer) {
277: next_peer = peer->next;
278: if (peer->action && peer->nextaction <=
279: current_time)
280: peer->action(peer);
281:
282: /*
283: * Restrain the non-burst packet rate not more
284: * than one packet every 16 seconds. This is
285: * usually tripped using iburst and minpoll of
286: * 128 s or less.
287: */
288: if (peer->throttle > 0)
289: peer->throttle--;
290: if (peer->nextdate <= current_time) {
291: #ifdef REFCLOCK
292: if (peer->flags & FLAG_REFCLOCK)
293: refclock_transmit(peer);
294: else
295: transmit(peer);
296: #else /* REFCLOCK */
297: transmit(peer);
298: #endif /* REFCLOCK */
299: }
300: }
301: }
302:
303: /*
304: * Orphan mode is active when enabled and when no servers less
305: * than the orphan stratum are available. A server with no other
306: * synchronization source is an orphan. It shows offset zero and
307: * reference ID the loopback address.
308: */
309: if (sys_orphan < STRATUM_UNSPEC && sys_peer == NULL) {
310: if (sys_leap == LEAP_NOTINSYNC) {
311: sys_leap = LEAP_NOWARNING;
312: #ifdef OPENSSL
313: if (crypto_flags)
314: crypto_update();
315: #endif /* OPENSSL */
316: }
317: sys_stratum = (u_char)sys_orphan;
318: if (sys_stratum > 1)
319: sys_refid = htonl(LOOPBACKADR);
320: else
321: memcpy(&sys_refid, "LOOP", 4);
322: sys_offset = 0;
323: sys_rootdelay = 0;
324: sys_rootdisp = 0;
325: }
326:
327: /*
328: * Leapseconds. If a leap is pending, decrement the time
329: * remaining. If less than one day remains, set the leap bits.
330: * When no time remains, clear the leap bits and increment the
331: * TAI. If kernel suppport is not available, do the leap
332: * crudely. Note a leap cannot be pending unless the clock is
333: * set.
334: */
335: if (leapsec > 0) {
336: leapsec--;
337: if (leapsec == 0) {
338: sys_leap = LEAP_NOWARNING;
339: sys_tai = leap_tai;
340: #ifdef KERNEL_PLL
341: if (!(pll_control && kern_enable))
342: step_systime(-1.0);
343: #else /* KERNEL_PLL */
344: #ifndef SYS_WINNT /* WinNT port has its own leap second handling */
345: step_systime(-1.0);
346: #endif /* SYS_WINNT */
347: #endif /* KERNEL_PLL */
348: report_event(EVNT_LEAP, NULL, NULL);
349: } else {
350: if (leapsec < DAY)
351: sys_leap = LEAP_ADDSECOND;
352: if (leap_tai > 0)
353: sys_tai = leap_tai - 1;
354: }
355: }
356:
357: /*
358: * Update huff-n'-puff filter.
359: */
360: if (huffpuff_timer <= current_time) {
361: huffpuff_timer += HUFFPUFF;
362: huffpuff();
363: }
364:
365: #ifdef OPENSSL
366: /*
367: * Garbage collect expired keys.
368: */
369: if (keys_timer <= current_time) {
370: keys_timer += 1 << sys_automax;
371: auth_agekeys();
372: }
373:
374: /*
375: * Garbage collect key list and generate new private value. The
376: * timer runs only after initial synchronization and fires about
377: * once per day.
378: */
379: if (revoke_timer <= current_time && sys_leap !=
380: LEAP_NOTINSYNC) {
381: revoke_timer += 1 << sys_revoke;
382: RAND_bytes((u_char *)&sys_private, 4);
383: }
384: #endif /* OPENSSL */
385:
386: /*
387: * Interface update timer
388: */
389: if (interface_interval && interface_timer <= current_time) {
390:
391: timer_interfacetimeout(current_time +
392: interface_interval);
393: DPRINTF(2, ("timer: interface update\n"));
394: interface_update(NULL, NULL);
395: }
396:
397: /*
398: * Finally, write hourly stats.
399: */
400: if (stats_timer <= current_time) {
401: stats_timer += HOUR;
402: write_stats();
403: if (sys_tai != 0 && sys_time.l_ui > leap_expire)
404: report_event(EVNT_LEAPVAL, NULL, NULL);
405: }
406: }
407:
408:
409: #ifndef SYS_WINNT
410: /*
411: * alarming - tell the world we've been alarmed
412: */
413: static RETSIGTYPE
414: alarming(
415: int sig
416: )
417: {
418: #if !defined(VMS)
419: if (initializing)
420: return;
421: if (alarm_flag)
422: alarm_overflow++;
423: else
424: alarm_flag++;
425: #else /* VMS AST routine */
426: if (!initializing) {
427: if (alarm_flag) alarm_overflow++;
428: else alarm_flag = 1; /* increment is no good */
429: }
430: lib$addx(&vmsinc,&vmstimer,&vmstimer);
431: sys$setimr(0,&vmstimer,alarming,alarming,0);
432: #endif /* VMS */
433: }
434: #endif /* SYS_WINNT */
435:
436: void
437: timer_interfacetimeout(u_long timeout)
438: {
439: interface_timer = timeout;
440: }
441:
442:
443: /*
444: * timer_clr_stats - clear timer module stat counters
445: */
446: void
447: timer_clr_stats(void)
448: {
449: timer_overflows = 0;
450: timer_xmtcalls = 0;
451: timer_timereset = current_time;
452: }
453:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ntp_timer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd