2 * ntp_timer.c - event timer support routines
8 #include "ntp_machine.h"
10 #include "ntp_stdlib.h"
11 #include "ntp_calendar.h"
12 #include "ntp_leapsec.h"
14 #if defined(HAVE_IO_COMPLETION_PORT)
15 # include "ntp_iocompletionport.h"
16 # include "ntp_timer.h"
21 #ifdef HAVE_SYS_SIGNAL_H
22 # include <sys/signal.h>
29 #include "ntp_syscall.h"
30 #endif /* KERNEL_PLL */
33 #include <openssl/rand.h>
37 /* TC_ERR represents the timer_create() error return value. */
45 static void check_leapsec(u_int32, const time_t*, int/*BOOL*/);
48 * These routines provide support for the event timer. The timer is
49 * implemented by an interrupt routine which sets a flag once every
50 * second, and a timer routine which is called when the mainline code
51 * gets around to seeing the flag. The timer routine dispatches the
52 * clock adjustment code if its time has come, then searches the timer
53 * queue for expiries which are dispatched to the transmit procedure.
54 * Finally, we call the hourly procedure to do cleanup and print a
57 volatile int interface_interval; /* init_io() sets def. 300s */
60 * Alarm flag. The mainline code imports this.
62 volatile int alarm_flag;
65 * The counters and timeouts
67 static u_long interface_timer; /* interface update timer */
68 static u_long adjust_timer; /* second timer */
69 static u_long stats_timer; /* stats timer */
70 static u_long leapf_timer; /* Report leapfile problems once/day */
71 static u_long huffpuff_timer; /* huff-n'-puff timer */
72 static u_long worker_idle_timer;/* next check for idle intres */
73 u_long leapsec; /* seconds to next leap (proximity class) */
74 int leapdif; /* TAI difference step at next leap second*/
75 u_long orphwait; /* orphan wait time */
77 static u_long revoke_timer; /* keys revoke timer */
78 static u_long keys_timer; /* session key timer */
79 u_long sys_revoke = KEY_REVOKE; /* keys revoke timeout (log2 s) */
80 u_long sys_automax = NTP_AUTOMAX; /* key list timeout (log2 s) */
84 * Statistics counter for the interested.
86 volatile u_long alarm_overflow;
88 u_long current_time; /* seconds since startup */
91 * Stats. Number of overflows and number of calls to transmit().
93 u_long timer_timereset;
94 u_long timer_overflows;
95 u_long timer_xmtcalls;
98 static int vmstimer[2]; /* time for next timer AST */
99 static int vmsinc[2]; /* timer increment */
103 HANDLE WaitableTimerHandle;
105 static RETSIGTYPE alarming (int);
106 #endif /* SYS_WINNT */
109 # if !defined SYS_WINNT || defined(SYS_CYGWIN32)
110 # ifdef HAVE_TIMER_CREATE
111 static timer_t timer_id;
112 typedef struct itimerspec intervaltimer;
113 # define itv_frac tv_nsec
115 typedef struct itimerval intervaltimer;
116 # define itv_frac tv_usec
118 intervaltimer itimer;
122 #if !defined(SYS_WINNT) && !defined(VMS)
123 void set_timer_or_die(const intervaltimer *);
127 #if !defined(SYS_WINNT) && !defined(VMS)
130 const intervaltimer * ptimer
133 const char * setfunc;
136 # ifdef HAVE_TIMER_CREATE
137 setfunc = "timer_settime";
138 rc = timer_settime(timer_id, 0, &itimer, NULL);
140 setfunc = "setitimer";
141 rc = setitimer(ITIMER_REAL, &itimer, NULL);
144 msyslog(LOG_ERR, "interval timer %s failed, %m",
149 #endif /* !SYS_WINNT && !VMS */
153 * reinit_timer - reinitialize interval timer after a clock step.
158 #if !defined(SYS_WINNT) && !defined(VMS)
160 # ifdef HAVE_TIMER_CREATE
161 timer_gettime(timer_id, &itimer);
163 getitimer(ITIMER_REAL, &itimer);
165 if (itimer.it_value.tv_sec < 0 ||
166 itimer.it_value.tv_sec > (1 << EVENT_TIMEOUT))
167 itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
168 if (itimer.it_value.itv_frac < 0)
169 itimer.it_value.itv_frac = 0;
170 if (0 == itimer.it_value.tv_sec &&
171 0 == itimer.it_value.itv_frac)
172 itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
173 itimer.it_interval.tv_sec = (1 << EVENT_TIMEOUT);
174 itimer.it_interval.itv_frac = 0;
175 set_timer_or_die(&itimer);
181 * init_timer - initialize the timer data structures
192 stats_timer = SECSPERHR;
193 leapf_timer = SECSPERDAY;
203 * Set up the alarm interrupt. The first comes 2**EVENT_TIMEOUT
204 * seconds from now and they continue on every 2**EVENT_TIMEOUT
208 # ifdef HAVE_TIMER_CREATE
209 if (TC_ERR == timer_create(CLOCK_REALTIME, NULL, &timer_id)) {
210 msyslog(LOG_ERR, "timer_create failed, %m");
214 signal_no_reset(SIGALRM, alarming);
215 itimer.it_interval.tv_sec =
216 itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
217 itimer.it_interval.itv_frac = itimer.it_value.itv_frac = 0;
218 set_timer_or_die(&itimer);
219 # else /* VMS follows */
220 vmsinc[0] = 10000000; /* 1 sec */
222 lib$emul(&(1<<EVENT_TIMEOUT), &vmsinc, &0, &vmsinc);
224 sys$gettim(&vmstimer); /* that's "now" as abstime */
226 lib$addx(&vmsinc, &vmstimer, &vmstimer);
227 sys$setimr(0, &vmstimer, alarming, alarming, 0);
229 #else /* SYS_WINNT follows */
231 * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
235 WaitableTimerHandle = CreateWaitableTimer(NULL, FALSE, NULL);
236 if (WaitableTimerHandle == NULL) {
237 msyslog(LOG_ERR, "CreateWaitableTimer failed: %m");
242 LARGE_INTEGER DueTime;
245 Period = (1 << EVENT_TIMEOUT) * 1000;
246 DueTime.QuadPart = Period * 10000i64;
247 rc = SetWaitableTimer(WaitableTimerHandle, &DueTime,
248 Period, NULL, NULL, FALSE);
250 msyslog(LOG_ERR, "SetWaitableTimer failed: %m");
255 #endif /* SYS_WINNT */
260 * intres_timeout_req(s) is invoked in the parent to schedule an idle
261 * timeout to fire in s seconds, if not reset earlier by a call to
262 * intres_timeout_req(0), which clears any pending timeout. When the
263 * timeout expires, worker_idle_timer_fired() is invoked (again, in the
266 * sntp and ntpd each provide implementations adapted to their timers.
270 u_int seconds /* 0 cancels */
274 worker_idle_timer = 0;
277 worker_idle_timer = current_time + seconds;
282 * timer - event timer
288 struct peer * next_peer;
293 * The basic timerevent is one second. This is used to adjust the
294 * system clock in time and frequency, implement the kiss-o'-death
295 * function and the association polling function.
298 if (adjust_timer <= current_time) {
302 for (p = peer_list; p != NULL; p = next_peer) {
303 next_peer = p->p_link;
304 if (FLAG_REFCLOCK & p->flags)
307 #endif /* REFCLOCK */
311 * Now dispatch any peers whose event timer has expired. Be
312 * careful here, since the peer structure might go away as the
313 * result of the call.
315 for (p = peer_list; p != NULL; p = next_peer) {
316 next_peer = p->p_link;
319 * Restrain the non-burst packet rate not more
320 * than one packet every 16 seconds. This is
321 * usually tripped using iburst and minpoll of
326 if (p->nextdate <= current_time) {
328 if (FLAG_REFCLOCK & p->flags)
329 refclock_transmit(p);
331 #endif /* REFCLOCK */
337 * Orphan mode is active when enabled and when no servers less
338 * than the orphan stratum are available. A server with no other
339 * synchronization source is an orphan. It shows offset zero and
340 * reference ID the loopback address.
342 if (sys_orphan < STRATUM_UNSPEC && sys_peer == NULL &&
343 current_time > orphwait) {
344 if (sys_leap == LEAP_NOTINSYNC) {
345 set_sys_leap(LEAP_NOWARNING);
351 sys_stratum = (u_char)sys_orphan;
353 sys_refid = htonl(LOOPBACKADR);
355 memcpy(&sys_refid, "LOOP", 4);
365 * Leapseconds. Get time and defer to worker if either something
366 * is imminent or every 8th second.
368 if (leapsec > LSPROX_NOWARN || 0 == (current_time & 7))
369 check_leapsec(now.l_ui, &tnow,
370 (sys_leap == LEAP_NOTINSYNC));
371 if (sys_leap != LEAP_NOTINSYNC) {
372 if (leapsec >= LSPROX_ANNOUNCE && leapdif) {
374 set_sys_leap(LEAP_ADDSECOND);
376 set_sys_leap(LEAP_DELSECOND);
378 set_sys_leap(LEAP_NOWARNING);
383 * Update huff-n'-puff filter.
385 if (huffpuff_timer <= current_time) {
386 huffpuff_timer += HUFFPUFF;
392 * Garbage collect expired keys.
394 if (keys_timer <= current_time) {
395 keys_timer += 1 << sys_automax;
400 * Generate new private value. This causes all associations
401 * to regenerate cookies.
403 if (revoke_timer && revoke_timer <= current_time) {
404 revoke_timer += 1 << sys_revoke;
405 RAND_bytes((u_char *)&sys_private, 4);
410 * Interface update timer
412 if (interface_interval && interface_timer <= current_time) {
413 timer_interfacetimeout(current_time +
415 DPRINTF(2, ("timer: interface update\n"));
416 interface_update(NULL, NULL);
419 if (worker_idle_timer && worker_idle_timer <= current_time)
420 worker_idle_timer_fired();
423 * Finally, write hourly stats and do the hourly
424 * and daily leapfile checks.
426 if (stats_timer <= current_time) {
427 stats_timer += SECSPERHR;
429 if (leapf_timer <= current_time) {
430 leapf_timer += SECSPERDAY;
431 check_leap_file(TRUE, now.l_ui, &tnow);
433 check_leap_file(FALSE, now.l_ui, &tnow);
441 * alarming - tell the world we've been alarmed
449 const char *msg = "alarming: initializing TRUE\n";
456 msg = "alarming: overflow\n";
462 /* VMS AST routine, increment is no good */
466 msg = "alarming: normal\n";
471 lib$addx(&vmsinc, &vmstimer, &vmstimer);
472 sys$setimr(0, &vmstimer, alarming, alarming, 0);
476 (void)(-1 == write(1, msg, strlen(msg)));
479 #endif /* SYS_WINNT */
483 timer_interfacetimeout(u_long timeout)
485 interface_timer = timeout;
490 * timer_clr_stats - clear timer module stat counters
493 timer_clr_stats(void)
497 timer_timereset = current_time;
502 check_leap_sec_in_progress( const leap_result_t *lsdata ) {
503 int prv_leap_sec_in_progress = leap_sec_in_progress;
504 leap_sec_in_progress = lsdata->tai_diff && (lsdata->ddist < 3);
506 /* if changed we may have to update the leap status sent to clients */
507 if (leap_sec_in_progress != prv_leap_sec_in_progress)
508 set_sys_leap(sys_leap);
515 const time_t * tpiv ,
518 static const char leapmsg_p_step[] =
519 "Positive leap second, stepped backward.";
520 static const char leapmsg_p_slew[] =
521 "Positive leap second, no step correction. "
522 "System clock will be inaccurate for a long time.";
524 static const char leapmsg_n_step[] =
525 "Negative leap second, stepped forward.";
526 static const char leapmsg_n_slew[] =
527 "Negative leap second, no step correction. "
528 "System clock will be inaccurate for a long time.";
530 leap_result_t lsdata;
533 int/*BOOL*/ update_autokey = FALSE;
536 #ifndef SYS_WINNT /* WinNT port has its own leap second handling */
538 leapsec_electric(pll_control && kern_enable);
544 leap_smear.enabled = leap_smear_intv != 0;
547 lsprox = LSPROX_NOWARN;
548 leapsec_reset_frame();
549 memset(&lsdata, 0, sizeof(lsdata));
551 int fired = leapsec_query(&lsdata, now, tpiv);
553 DPRINTF(1, ("*** leapsec_query: fired %i, now %u (0x%08X), tai_diff %i, ddist %u\n",
554 fired, now, now, lsdata.tai_diff, lsdata.ddist));
557 leap_smear.in_progress = 0;
558 leap_smear.doffset = 0.0;
560 if (leap_smear.enabled) {
561 if (lsdata.tai_diff) {
562 if (leap_smear.interval == 0) {
563 leap_smear.interval = leap_smear_intv;
564 leap_smear.intv_end = lsdata.ttime.Q_s;
565 leap_smear.intv_start = leap_smear.intv_end - leap_smear.interval;
566 DPRINTF(1, ("*** leapsec_query: setting leap_smear interval %li, begin %.0f, end %.0f\n",
567 leap_smear.interval, leap_smear.intv_start, leap_smear.intv_end));
571 if (leap_smear.interval)
572 DPRINTF(1, ("*** leapsec_query: clearing leap_smear interval\n"));
573 leap_smear.interval = 0;
576 if (leap_smear.interval) {
578 if (dtemp >= leap_smear.intv_start && dtemp <= leap_smear.intv_end) {
579 double leap_smear_time = dtemp - leap_smear.intv_start;
581 * For now we just do a linear interpolation over the smear interval
584 // linear interpolation
585 leap_smear.doffset = -(leap_smear_time * lsdata.tai_diff / leap_smear.interval);
587 // Google approach: lie(t) = (1.0 - cos(pi * t / w)) / 2.0
588 leap_smear.doffset = -((double) lsdata.tai_diff - cos( M_PI * leap_smear_time / leap_smear.interval)) / 2.0;
591 * TODO see if we're inside an inserted leap second, so we need to compute
592 * leap_smear.doffset = 1.0 - leap_smear.doffset
594 leap_smear.in_progress = 1;
595 #if 0 && defined( DEBUG )
596 msyslog(LOG_NOTICE, "*** leapsec_query: [%.0f:%.0f] (%li), now %u (%.0f), smear offset %.6f ms\n",
597 leap_smear.intv_start, leap_smear.intv_end, leap_smear.interval,
598 now, leap_smear_time, leap_smear.doffset);
600 DPRINTF(1, ("*** leapsec_query: [%.0f:%.0f] (%li), now %u (%.0f), smear offset %.6f ms\n",
601 leap_smear.intv_start, leap_smear.intv_end, leap_smear.interval,
602 now, leap_smear_time, leap_smear.doffset));
609 leap_smear.interval = 0;
612 * Update the current leap smear offset, eventually 0.0 if outside smear interval.
614 DTOLFP(leap_smear.doffset, &leap_smear.offset);
616 #endif /* LEAP_SMEAR */
619 /* Full hit. Eventually step the clock, but always
620 * announce the leap event has happened.
622 const char *leapmsg = NULL;
623 if (lsdata.warped < 0) {
624 if (clock_max_back > 0.0 &&
625 clock_max_back < fabs(lsdata.warped)) {
626 step_systime(lsdata.warped);
627 leapmsg = leapmsg_p_step;
629 leapmsg = leapmsg_p_slew;
631 } else if (lsdata.warped > 0) {
632 if (clock_max_fwd > 0.0 &&
633 clock_max_fwd < fabs(lsdata.warped)) {
634 step_systime(lsdata.warped);
635 leapmsg = leapmsg_n_step;
637 leapmsg = leapmsg_n_slew;
641 msyslog(LOG_NOTICE, "%s", leapmsg);
642 report_event(EVNT_LEAP, NULL, NULL);
644 update_autokey = TRUE;
646 lsprox = LSPROX_NOWARN;
647 leapsec = LSPROX_NOWARN;
648 sys_tai = lsdata.tai_offs;
651 update_autokey = (sys_tai != lsdata.tai_offs);
653 lsprox = lsdata.proximity;
654 sys_tai = lsdata.tai_offs;
658 /* We guard against panic alarming during the red alert phase.
659 * Strange and evil things might happen if we go from stone cold
660 * to piping hot in one step. If things are already that wobbly,
661 * we let the normal clock correction take over, even if a jump
663 * Also make sure the alarming events are edge-triggered, that is,
664 * ceated only when the threshold is crossed.
666 if ( (leapsec > 0 || lsprox < LSPROX_ALERT)
667 && leapsec < lsprox ) {
668 if ( leapsec < LSPROX_SCHEDULE
669 && lsprox >= LSPROX_SCHEDULE) {
671 report_event(PEVNT_ARMED, sys_peer, NULL);
673 report_event(EVNT_ARMED, NULL, NULL);
677 if (leapsec > lsprox) {
678 if ( leapsec >= LSPROX_SCHEDULE
679 && lsprox < LSPROX_SCHEDULE) {
680 report_event(EVNT_DISARMED, NULL, NULL);
685 if (leapsec >= LSPROX_SCHEDULE)
686 leapdif = lsdata.tai_diff;
690 check_leap_sec_in_progress(&lsdata);
694 crypto_update_taichange();