xref: /freebsd/contrib/ntp/ntpd/ntp_timer.c (revision 5b9c547c) 
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 #include "ntp_calendar.h"
12 #include "ntp_leapsec.h"
13 
14 #if defined(HAVE_IO_COMPLETION_PORT)
15 # include "ntp_iocompletionport.h"
16 # include "ntp_timer.h"
17 #endif
18 
19 #include <stdio.h>
20 #include <signal.h>
21 #ifdef HAVE_SYS_SIGNAL_H
22 # include <sys/signal.h>
23 #endif
24 #ifdef HAVE_UNISTD_H
25 # include <unistd.h>
26 #endif
27 
28 #ifdef KERNEL_PLL
29 #include "ntp_syscall.h"
30 #endif /* KERNEL_PLL */
31 
32 #ifdef AUTOKEY
33 #include <openssl/rand.h>
34 #endif	/* AUTOKEY */
35 
36 
37 /* TC_ERR represents the timer_create() error return value. */
38 #ifdef SYS_VXWORKS
39 #define	TC_ERR	ERROR
40 #else
41 #define	TC_ERR	(-1)
42 #endif
43 
44 static void check_leapsec(u_int32, const time_t*, int/*BOOL*/);
45 
46 /*
47  * These routines provide support for the event timer.  The timer is
48  * implemented by an interrupt routine which sets a flag once every
49  * second, and a timer routine which is called when the mainline code
50  * gets around to seeing the flag.  The timer routine dispatches the
51  * clock adjustment code if its time has come, then searches the timer
52  * queue for expiries which are dispatched to the transmit procedure.
53  * Finally, we call the hourly procedure to do cleanup and print a
54  * message.
55  */
56 volatile int interface_interval;     /* init_io() sets def. 300s */
57 
58 /*
59  * Alarm flag. The mainline code imports this.
60  */
61 volatile int alarm_flag;
62 
63 /*
64  * The counters and timeouts
65  */
66 static  u_long interface_timer;	/* interface update timer */
67 static	u_long adjust_timer;	/* second timer */
68 static	u_long stats_timer;	/* stats timer */
69 static	u_long leapf_timer;	/* Report leapfile problems once/day */
70 static	u_long huffpuff_timer;	/* huff-n'-puff timer */
71 static	u_long worker_idle_timer;/* next check for idle intres */
72 u_long	leapsec;	        /* seconds to next leap (proximity class) */
73 int     leapdif;                /* TAI difference step at next leap second*/
74 u_long	orphwait; 		/* orphan wait time */
75 #ifdef AUTOKEY
76 static	u_long revoke_timer;	/* keys revoke timer */
77 static	u_long keys_timer;	/* session key timer */
78 u_long	sys_revoke = KEY_REVOKE; /* keys revoke timeout (log2 s) */
79 u_long	sys_automax = NTP_AUTOMAX; /* key list timeout (log2 s) */
80 #endif	/* AUTOKEY */
81 
82 /*
83  * Statistics counter for the interested.
84  */
85 volatile u_long alarm_overflow;
86 
87 u_long current_time;		/* seconds since startup */
88 
89 /*
90  * Stats.  Number of overflows and number of calls to transmit().
91  */
92 u_long timer_timereset;
93 u_long timer_overflows;
94 u_long timer_xmtcalls;
95 
96 #if defined(VMS)
97 static int vmstimer[2]; 	/* time for next timer AST */
98 static int vmsinc[2];		/* timer increment */
99 #endif /* VMS */
100 
101 #ifdef SYS_WINNT
102 HANDLE WaitableTimerHandle;
103 #else
104 static	RETSIGTYPE alarming (int);
105 #endif /* SYS_WINNT */
106 
107 #if !defined(VMS)
108 # if !defined SYS_WINNT || defined(SYS_CYGWIN32)
109 #  ifdef HAVE_TIMER_CREATE
110 static timer_t timer_id;
111 typedef struct itimerspec intervaltimer;
112 #   define	itv_frac	tv_nsec
113 #  else
114 typedef struct itimerval intervaltimer;
115 #   define	itv_frac	tv_usec
116 #  endif
117 intervaltimer itimer;
118 # endif
119 #endif
120 
121 #if !defined(SYS_WINNT) && !defined(VMS)
122 void	set_timer_or_die(const intervaltimer *);
123 #endif
124 
125 
126 #if !defined(SYS_WINNT) && !defined(VMS)
127 void
128 set_timer_or_die(
129 	const intervaltimer *	ptimer
130 	)
131 {
132 	const char *	setfunc;
133 	int		rc;
134 
135 # ifdef HAVE_TIMER_CREATE
136 	setfunc = "timer_settime";
137 	rc = timer_settime(timer_id, 0, &itimer, NULL);
138 # else
139 	setfunc = "setitimer";
140 	rc = setitimer(ITIMER_REAL, &itimer, NULL);
141 # endif
142 	if (-1 == rc) {
143 		msyslog(LOG_ERR, "interval timer %s failed, %m",
144 			setfunc);
145 		exit(1);
146 	}
147 }
148 #endif	/* !SYS_WINNT && !VMS */
149 
150 
151 /*
152  * reinit_timer - reinitialize interval timer after a clock step.
153  */
154 void
155 reinit_timer(void)
156 {
157 #if !defined(SYS_WINNT) && !defined(VMS)
158 	ZERO(itimer);
159 # ifdef HAVE_TIMER_CREATE
160 	timer_gettime(timer_id, &itimer);
161 # else
162 	getitimer(ITIMER_REAL, &itimer);
163 # endif
164 	if (itimer.it_value.tv_sec < 0 ||
165 	    itimer.it_value.tv_sec > (1 << EVENT_TIMEOUT))
166 		itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
167 	if (itimer.it_value.itv_frac < 0)
168 		itimer.it_value.itv_frac = 0;
169 	if (0 == itimer.it_value.tv_sec &&
170 	    0 == itimer.it_value.itv_frac)
171 		itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
172 	itimer.it_interval.tv_sec = (1 << EVENT_TIMEOUT);
173 	itimer.it_interval.itv_frac = 0;
174 	set_timer_or_die(&itimer);
175 # endif /* VMS */
176 }
177 
178 
179 /*
180  * init_timer - initialize the timer data structures
181  */
182 void
183 init_timer(void)
184 {
185 	/*
186 	 * Initialize...
187 	 */
188 	alarm_flag = FALSE;
189 	alarm_overflow = 0;
190 	adjust_timer = 1;
191 	stats_timer = SECSPERHR;
192 	leapf_timer = SECSPERDAY;
193 	huffpuff_timer = 0;
194 	interface_timer = 0;
195 	current_time = 0;
196 	timer_overflows = 0;
197 	timer_xmtcalls = 0;
198 	timer_timereset = 0;
199 
200 #ifndef SYS_WINNT
201 	/*
202 	 * Set up the alarm interrupt.	The first comes 2**EVENT_TIMEOUT
203 	 * seconds from now and they continue on every 2**EVENT_TIMEOUT
204 	 * seconds.
205 	 */
206 # ifndef VMS
207 #  ifdef HAVE_TIMER_CREATE
208 	if (TC_ERR == timer_create(CLOCK_REALTIME, NULL, &timer_id)) {
209 		msyslog(LOG_ERR, "timer_create failed, %m");
210 		exit(1);
211 	}
212 #  endif
213 	signal_no_reset(SIGALRM, alarming);
214 	itimer.it_interval.tv_sec =
215 		itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
216 	itimer.it_interval.itv_frac = itimer.it_value.itv_frac = 0;
217 	set_timer_or_die(&itimer);
218 # else	/* VMS follows */
219 	vmsinc[0] = 10000000;		/* 1 sec */
220 	vmsinc[1] = 0;
221 	lib$emul(&(1<<EVENT_TIMEOUT), &vmsinc, &0, &vmsinc);
222 
223 	sys$gettim(&vmstimer);	/* that's "now" as abstime */
224 
225 	lib$addx(&vmsinc, &vmstimer, &vmstimer);
226 	sys$setimr(0, &vmstimer, alarming, alarming, 0);
227 # endif	/* VMS */
228 #else	/* SYS_WINNT follows */
229 	/*
230 	 * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
231 	 * Under Windows/NT,
232 	 */
233 
234 	WaitableTimerHandle = CreateWaitableTimer(NULL, FALSE, NULL);
235 	if (WaitableTimerHandle == NULL) {
236 		msyslog(LOG_ERR, "CreateWaitableTimer failed: %m");
237 		exit(1);
238 	}
239 	else {
240 		DWORD		Period;
241 		LARGE_INTEGER	DueTime;
242 		BOOL		rc;
243 
244 		Period = (1 << EVENT_TIMEOUT) * 1000;
245 		DueTime.QuadPart = Period * 10000i64;
246 		rc = SetWaitableTimer(WaitableTimerHandle, &DueTime,
247 				      Period, NULL, NULL, FALSE);
248 		if (!rc) {
249 			msyslog(LOG_ERR, "SetWaitableTimer failed: %m");
250 			exit(1);
251 		}
252 	}
253 
254 #endif	/* SYS_WINNT */
255 }
256 
257 
258 /*
259  * intres_timeout_req(s) is invoked in the parent to schedule an idle
260  * timeout to fire in s seconds, if not reset earlier by a call to
261  * intres_timeout_req(0), which clears any pending timeout.  When the
262  * timeout expires, worker_idle_timer_fired() is invoked (again, in the
263  * parent).
264  *
265  * sntp and ntpd each provide implementations adapted to their timers.
266  */
267 void
268 intres_timeout_req(
269 	u_int	seconds		/* 0 cancels */
270 	)
271 {
272 	if (0 == seconds) {
273 		worker_idle_timer = 0;
274 		return;
275 	}
276 	worker_idle_timer = current_time + seconds;
277 }
278 
279 
280 /*
281  * timer - event timer
282  */
283 void
284 timer(void)
285 {
286 	struct peer *	p;
287 	struct peer *	next_peer;
288 	l_fp		now;
289 	time_t          tnow;
290 
291 	/*
292 	 * The basic timerevent is one second.  This is used to adjust the
293 	 * system clock in time and frequency, implement the kiss-o'-death
294 	 * function and the association polling function.
295 	 */
296 	current_time++;
297 	if (adjust_timer <= current_time) {
298 		adjust_timer += 1;
299 		adj_host_clock();
300 #ifdef REFCLOCK
301 		for (p = peer_list; p != NULL; p = next_peer) {
302 			next_peer = p->p_link;
303 			if (FLAG_REFCLOCK & p->flags)
304 				refclock_timer(p);
305 		}
306 #endif /* REFCLOCK */
307 	}
308 
309 	/*
310 	 * Now dispatch any peers whose event timer has expired. Be
311 	 * careful here, since the peer structure might go away as the
312 	 * result of the call.
313 	 */
314 	for (p = peer_list; p != NULL; p = next_peer) {
315 		next_peer = p->p_link;
316 
317 		/*
318 		 * Restrain the non-burst packet rate not more
319 		 * than one packet every 16 seconds. This is
320 		 * usually tripped using iburst and minpoll of
321 		 * 128 s or less.
322 		 */
323 		if (p->throttle > 0)
324 			p->throttle--;
325 		if (p->nextdate <= current_time) {
326 #ifdef REFCLOCK
327 			if (FLAG_REFCLOCK & p->flags)
328 				refclock_transmit(p);
329 			else
330 #endif	/* REFCLOCK */
331 				transmit(p);
332 		}
333 	}
334 
335 	/*
336 	 * Orphan mode is active when enabled and when no servers less
337 	 * than the orphan stratum are available. A server with no other
338 	 * synchronization source is an orphan. It shows offset zero and
339 	 * reference ID the loopback address.
340 	 */
341 	if (sys_orphan < STRATUM_UNSPEC && sys_peer == NULL &&
342 	    current_time > orphwait) {
343 		if (sys_leap == LEAP_NOTINSYNC) {
344 			sys_leap = LEAP_NOWARNING;
345 #ifdef AUTOKEY
346 			if (crypto_flags)
347 				crypto_update();
348 #endif	/* AUTOKEY */
349 		}
350 		sys_stratum = (u_char)sys_orphan;
351 		if (sys_stratum > 1)
352 			sys_refid = htonl(LOOPBACKADR);
353 		else
354 			memcpy(&sys_refid, "LOOP", 4);
355 		sys_offset = 0;
356 		sys_rootdelay = 0;
357 		sys_rootdisp = 0;
358 	}
359 
360 	get_systime(&now);
361 	time(&tnow);
362 
363 	/*
364 	 * Leapseconds. Get time and defer to worker if either something
365 	 * is imminent or every 8th second.
366 	 */
367 	if (leapsec > LSPROX_NOWARN || 0 == (current_time & 7))
368 		check_leapsec(now.l_ui, &tnow,
369                                 (sys_leap == LEAP_NOTINSYNC));
370         if (sys_leap != LEAP_NOTINSYNC) {
371                 if (leapsec >= LSPROX_ANNOUNCE && leapdif) {
372 		        if (leapdif > 0)
373 			        sys_leap = LEAP_ADDSECOND;
374 		        else
375 			        sys_leap = LEAP_DELSECOND;
376                 } else {
377                         sys_leap = LEAP_NOWARNING;
378                 }
379 	}
380 
381 	/*
382 	 * Update huff-n'-puff filter.
383 	 */
384 	if (huffpuff_timer <= current_time) {
385 		huffpuff_timer += HUFFPUFF;
386 		huffpuff();
387 	}
388 
389 #ifdef AUTOKEY
390 	/*
391 	 * Garbage collect expired keys.
392 	 */
393 	if (keys_timer <= current_time) {
394 		keys_timer += 1 << sys_automax;
395 		auth_agekeys();
396 	}
397 
398 	/*
399 	 * Generate new private value. This causes all associations
400 	 * to regenerate cookies.
401 	 */
402 	if (revoke_timer && revoke_timer <= current_time) {
403 		revoke_timer += 1 << sys_revoke;
404 		RAND_bytes((u_char *)&sys_private, 4);
405 	}
406 #endif	/* AUTOKEY */
407 
408 	/*
409 	 * Interface update timer
410 	 */
411 	if (interface_interval && interface_timer <= current_time) {
412 		timer_interfacetimeout(current_time +
413 		    interface_interval);
414 		DPRINTF(2, ("timer: interface update\n"));
415 		interface_update(NULL, NULL);
416 	}
417 
418 	if (worker_idle_timer && worker_idle_timer <= current_time)
419 		worker_idle_timer_fired();
420 
421 	/*
422 	 * Finally, write hourly stats and do the hourly
423 	 * and daily leapfile checks.
424 	 */
425 	if (stats_timer <= current_time) {
426 		stats_timer += SECSPERHR;
427 		write_stats();
428 		if (leapf_timer <= current_time) {
429 			leapf_timer += SECSPERDAY;
430 			check_leap_file(TRUE, now.l_ui, &tnow);
431 		} else {
432 			check_leap_file(FALSE, now.l_ui, &tnow);
433 		}
434 	}
435 }
436 
437 
438 #ifndef SYS_WINNT
439 /*
440  * alarming - tell the world we've been alarmed
441  */
442 static RETSIGTYPE
443 alarming(
444 	int sig
445 	)
446 {
447 # ifdef DEBUG
448 	const char *msg = "alarming: initializing TRUE\n";
449 # endif
450 
451 	if (!initializing) {
452 		if (alarm_flag) {
453 			alarm_overflow++;
454 # ifdef DEBUG
455 			msg = "alarming: overflow\n";
456 # endif
457 		} else {
458 # ifndef VMS
459 			alarm_flag++;
460 # else
461 			/* VMS AST routine, increment is no good */
462 			alarm_flag = 1;
463 # endif
464 # ifdef DEBUG
465 			msg = "alarming: normal\n";
466 # endif
467 		}
468 	}
469 # ifdef VMS
470 	lib$addx(&vmsinc, &vmstimer, &vmstimer);
471 	sys$setimr(0, &vmstimer, alarming, alarming, 0);
472 # endif
473 # ifdef DEBUG
474 	if (debug >= 4)
475 		write(1, msg, strlen(msg));
476 # endif
477 }
478 #endif /* SYS_WINNT */
479 
480 
481 void
482 timer_interfacetimeout(u_long timeout)
483 {
484 	interface_timer = timeout;
485 }
486 
487 
488 /*
489  * timer_clr_stats - clear timer module stat counters
490  */
491 void
492 timer_clr_stats(void)
493 {
494 	timer_overflows = 0;
495 	timer_xmtcalls = 0;
496 	timer_timereset = current_time;
497 }
498 
499 static void
500 check_leapsec(
501 	u_int32        now  ,
502 	const time_t * tpiv ,
503         int/*BOOL*/    reset)
504 {
505 	leap_result_t lsdata;
506 	u_int32       lsprox;
507 
508 #ifndef SYS_WINNT  /* WinNT port has its own leap second handling */
509 # ifdef KERNEL_PLL
510 	leapsec_electric(pll_control && kern_enable);
511 # else
512 	leapsec_electric(0);
513 # endif
514 #endif
515 	if (reset)	{
516 		lsprox = LSPROX_NOWARN;
517 		leapsec_reset_frame();
518 		memset(&lsdata, 0, sizeof(lsdata));
519 	} else if (leapsec_query(&lsdata, now, tpiv)) {
520 		/* Full hit. Eventually step the clock, but always
521 		 * announce the leap event has happened.
522 		 */
523 		if (lsdata.warped < 0) {
524 			step_systime(lsdata.warped);
525 			msyslog(LOG_NOTICE, "Inserting positive leap second.");
526 		} else 	if (lsdata.warped > 0) {
527 			step_systime(lsdata.warped);
528 			msyslog(LOG_NOTICE, "Inserting negative leap second.");
529 		}
530 		report_event(EVNT_LEAP, NULL, NULL);
531 		lsprox  = LSPROX_NOWARN;
532 		leapsec = LSPROX_NOWARN;
533 		sys_tai = lsdata.tai_offs;
534 	} else {
535 		lsprox  = lsdata.proximity;
536 		sys_tai = lsdata.tai_offs;
537 	}
538 
539 	/* We guard against panic alarming during the red alert phase.
540 	 * Strange and evil things might happen if we go from stone cold
541 	 * to piping hot in one step. If things are already that wobbly,
542 	 * we let the normal clock correction take over, even if a jump
543 	 * is involved.
544          * Also make sure the alarming events are edge-triggered, that is,
545          * ceated only when the threshold is crossed.
546          */
547 	if (  (leapsec > 0 || lsprox < LSPROX_ALERT)
548 	    && leapsec < lsprox                     ) {
549 		if (  leapsec < LSPROX_SCHEDULE
550                    && lsprox >= LSPROX_SCHEDULE) {
551 			if (lsdata.dynamic)
552 				report_event(PEVNT_ARMED, sys_peer, NULL);
553 			else
554 				report_event(EVNT_ARMED, NULL, NULL);
555 		}
556 		leapsec = lsprox;
557 	}
558 	if (leapsec > lsprox) {
559 		if (  leapsec >= LSPROX_SCHEDULE
560                    && lsprox   < LSPROX_SCHEDULE) {
561 			report_event(EVNT_DISARMED, NULL, NULL);
562 		}
563 		leapsec = lsprox;
564 	}
565 
566         if (leapsec >= LSPROX_SCHEDULE)
567                 leapdif = lsdata.tai_diff;
568         else
569                 leapdif = 0;
570 }
571