Fix a serious bug in the NTPD loopfilter. Basically what happens is that
[dragonfly.git] / contrib / ntp / ntpd / ntp_loopfilter.c
1 /*
2  * ntp_loopfilter.c - implements the NTP loop filter algorithm
3  *
4  */
5 #ifdef HAVE_CONFIG_H
6 # include <config.h>
7 #endif
8
9 #include "ntpd.h"
10 #include "ntp_io.h"
11 #include "ntp_unixtime.h"
12 #include "ntp_stdlib.h"
13
14 #include <stdio.h>
15 #include <ctype.h>
16
17 #include <signal.h>
18 #include <setjmp.h>
19
20 #if defined(VMS) && defined(VMS_LOCALUNIT)      /*wjm*/
21 #include "ntp_refclock.h"
22 #endif /* VMS */
23
24 #ifdef KERNEL_PLL
25 #include "ntp_syscall.h"
26 #endif /* KERNEL_PLL */
27
28 /*
29  * This is an implementation of the clock discipline algorithm described
30  * in UDel TR 97-4-3, as amended. It operates as an adaptive parameter,
31  * hybrid phase/frequency-lock loop. A number of sanity checks are
32  * included to protect against timewarps, timespikes and general mayhem.
33  * All units are in s and s/s, unless noted otherwise.
34  */
35 #define CLOCK_MAX       .128    /* default max offset (s) */
36 #define CLOCK_PANIC     1000.   /* default panic offset (s) */
37 #define CLOCK_MAXSTAB   2e-6    /* max frequency stability (s/s) */
38 #define CLOCK_MAXERR    1e-2    /* max phase jitter (s) */
39 #define CLOCK_PHI       15e-6   /* max frequency error (s/s) */
40 #define SHIFT_PLL       4       /* PLL loop gain (shift) */
41 #define CLOCK_AVG       4.      /* FLL loop gain */
42 #define CLOCK_MINSEC    256.    /* min FLL update interval (s) */
43 #define CLOCK_MINSTEP   900.    /* step-change timeout (s) */
44 #define CLOCK_DAY       86400.  /* one day of seconds */
45 #define CLOCK_LIMIT     30      /* poll-adjust threshold */
46 #define CLOCK_PGATE     4.      /* poll-adjust gate */
47 #define CLOCK_ALLAN     1024.   /* min Allan intercept (s) */
48 #define CLOCK_ADF       1e11    /* Allan deviation factor */
49
50 /*
51  * Clock discipline state machine. This is used to control the
52  * synchronization behavior during initialization and following a
53  * timewarp.
54  *
55  *      State   < max   > max                   Comments
56  *      ====================================================
57  *      NSET    FREQ    FREQ                    no ntp.drift
58  *
59  *      FSET    TSET    if (allow) TSET,        ntp.drift
60  *                      else FREQ
61  *
62  *      TSET    SYNC    FREQ                    time set
63  *
64  *      FREQ    SYNC    if (mu < 900) FREQ      calculate frequency
65  *                      else if (allow) TSET
66  *                      else FREQ
67  *
68  *      SYNC    SYNC    if (mu < 900) SYNC      normal state
69  *                      else SPIK
70  *
71  *      SPIK    SYNC    if (allow) TSET         spike detector
72  *                      else FREQ
73  */
74 #define S_NSET  0               /* clock never set */
75 #define S_FSET  1               /* frequency set from the drift file */
76 #define S_TSET  2               /* time set */
77 #define S_PFREQ 3               /* frequency setup mode */
78 #define S_FREQ  4               /* frequency mode */
79 #define S_SYNC  5               /* clock synchronized */
80 #define S_SPIK  6               /* spike detected */
81
82 /*
83  * Kernel PLL/PPS state machine. This is used with the kernel PLL
84  * modifications described in the README.kernel file.
85  *
86  * If kernel support for the ntp_adjtime() system call is available, the
87  * ntp_control flag is set. The ntp_enable and kern_enable flags can be
88  * set at configuration time or run time using ntpdc. If ntp_enable is
89  * false, the discipline loop is unlocked and no correctios of any kind
90  * are made. If both ntp_control and kern_enable are set, the kernel
91  * support is used as described above; if false, the kernel is bypassed
92  * entirely and the daemon PLL used instead.
93  *
94  * Each update to a prefer peer sets pps_stratum if it survives the
95  * intersection algorithm and its time is within range. The PPS time
96  * discipline is enabled (STA_PPSTIME bit set in the status word) when
97  * pps_stratum is true and the PPS frequency discipline is enabled. If
98  * the PPS time discipline is enabled and the kernel reports a PPS
99  * signal is present, the pps_control variable is set to the current
100  * time. If the current time is later than pps_control by PPS_MAXAGE
101  * (120 s), this variable is set to zero.
102  *
103  * If an external clock is present, the clock driver sets STA_CLK in the
104  * status word. When the local clock driver sees this bit, it updates
105  * via this routine, which then calls ntp_adjtime() with the STA_PLL bit
106  * set to zero, in which case the system clock is not adjusted. This is
107  * also a signal for the external clock driver to discipline the system
108  * clock.
109  */
110 #define PPS_MAXAGE 120          /* kernel pps signal timeout (s) */
111
112 /*
113  * Program variables that can be tinkered.
114  */
115 double  clock_max = CLOCK_MAX;  /* max offset before step (s) */
116 double  clock_panic = CLOCK_PANIC; /* max offset before panic (s) */
117 double  clock_phi = CLOCK_PHI;  /* dispersion rate (s/s) */
118 double  clock_minstep = CLOCK_MINSTEP; /* step timeout (s) */
119 double  allan_xpt = CLOCK_ALLAN; /* minimum Allan intercept (s) */
120
121 /*
122  * Program variables
123  */
124 static double clock_offset;     /* clock offset adjustment (s) */
125 double  drift_comp;             /* clock frequency (s/s) */
126 double  clock_stability;        /* clock stability (s/s) */
127 u_long  pps_control;            /* last pps sample time */
128 static void rstclock P((int, double, double)); /* transition function */
129
130 #ifdef KERNEL_PLL
131 struct timex ntv;               /* kernel API parameters */
132 int     pll_status;             /* status bits for kernel pll */
133 int     pll_nano;               /* nanosecond kernel switch */
134 #endif /* KERNEL_PLL */
135
136 /*
137  * Clock state machine control flags
138  */
139 int     ntp_enable;             /* clock discipline enabled */
140 int     pll_control;            /* kernel support available */
141 int     kern_enable;            /* kernel support enabled */
142 int     pps_enable;             /* kernel PPS discipline enabled */
143 int     ext_enable;             /* external clock enabled */
144 int     pps_stratum;            /* pps stratum */
145 int     allow_step = TRUE;      /* allow step correction */
146 int     allow_panic = FALSE;    /* allow panic correction */
147 int     mode_ntpdate = FALSE;   /* exit on first clock set */
148
149 /*
150  * Clock state machine variables
151  */
152 u_char  sys_minpoll = NTP_MINDPOLL; /* min sys poll interval (log2 s) */
153 u_char  sys_poll = NTP_MINDPOLL; /* system poll interval (log2 s) */
154 int     state;                  /* clock discipline state */
155 int     tc_counter;             /* poll-adjust counter */
156 u_long  last_time;              /* time of last clock update (s) */
157 double  last_offset;            /* last clock offset (s) */
158 double  sys_jitter;             /* system RMS jitter (s) */
159
160 /*
161  * Huff-n'-puff filter variables
162  */
163 static double *sys_huffpuff;    /* huff-n'-puff filter */
164 static int sys_hufflen;         /* huff-n'-puff filter stages */
165 static int sys_huffptr;         /* huff-n'-puff filter pointer */
166 static double sys_mindly;       /* huff-n'-puff filter min delay */
167
168 #if defined(KERNEL_PLL)
169 /* Emacs cc-mode goes nuts if we split the next line... */
170 #define MOD_BITS (MOD_OFFSET | MOD_MAXERROR | MOD_ESTERROR | \
171     MOD_STATUS | MOD_TIMECONST)
172 #ifdef SIGSYS
173 static void pll_trap P((int));  /* configuration trap */
174 static struct sigaction sigsys; /* current sigaction status */
175 static struct sigaction newsigsys; /* new sigaction status */
176 static sigjmp_buf env;          /* environment var. for pll_trap() */
177 #endif /* SIGSYS */
178 #endif /* KERNEL_PLL */
179
180 /*
181  * init_loopfilter - initialize loop filter data
182  */
183 void
184 init_loopfilter(void)
185 {
186         /*
187          * Initialize state variables. Initially, we expect no drift
188          * file, so set the state to S_NSET.
189          */
190         rstclock(S_NSET, current_time, 0);
191 }
192
193 /*
194  * local_clock - the NTP logical clock loop filter. Returns 1 if the
195  * clock was stepped, 0 if it was slewed and -1 if it is hopeless.
196  */
197 int
198 local_clock(
199         struct peer *peer,      /* synch source peer structure */
200         double fp_offset,       /* clock offset (s) */
201         double epsil            /* jittter (square s*s) */
202         )
203 {
204         double mu;              /* interval since last update (s) */
205         double oerror;          /* previous error estimate */
206         double flladj;          /* FLL frequency adjustment (ppm) */
207         double plladj;          /* PLL frequency adjustment (ppm) */
208         double clock_frequency; /* clock frequency adjustment (ppm) */
209         double dtemp, etemp;    /* double temps */
210         int retval;             /* return value */
211
212         /*
213          * If the loop is opened, monitor and record the offsets
214          * anyway in order to determine the open-loop response.
215          */
216 #ifdef DEBUG
217         if (debug)
218                 printf(
219                     "local_clock: assocID %d off %.6f jit %.6f sta %d\n",
220                     peer->associd, fp_offset, SQRT(epsil), state);
221 #endif
222         if (!ntp_enable) {
223                 record_loop_stats(fp_offset, drift_comp, SQRT(epsil),
224                     clock_stability, sys_poll);
225                 return (0);
226         }
227
228         /*
229          * If the clock is way off, panic is declared. The clock_panic
230          * defaults to 1000 s; if set to zero, the panic will never
231          * occur. The allow_panic defaults to FALSE, so the first panic
232          * will exit. It can be set TRUE by a command line option, in
233          * which case the clock will be set anyway and time marches on.
234          * But, allow_panic will be set it FALSE when the update is
235          * within the step range; so, subsequent panics will exit.
236          */
237         if (fabs(fp_offset) > clock_panic && clock_panic > 0 &&
238             !allow_panic) {
239                 msyslog(LOG_ERR,
240                     "time correction of %.0f seconds exceeds sanity limit (%.0f); set clock manually to the correct UTC time.",
241                     fp_offset, clock_panic);
242                 return (-1);
243         }
244
245         /*
246          * If simulating ntpdate, set the clock directly, rather than
247          * using the discipline. The clock_max defines the step
248          * threshold, above which the clock will be stepped instead of
249          * slewed. The value defaults to 128 ms, but can be set to even
250          * unreasonable values. If set to zero, the clock will never be
251          * stepped.
252          *
253          * Note that if ntpdate is active, the terminal does not detach,
254          * so the termination comments print directly to the console.
255          */
256         if (mode_ntpdate) {
257                 if (allow_step && fabs(fp_offset) > clock_max &&
258                     clock_max > 0) {
259                         step_systime(fp_offset);
260                         NLOG(NLOG_SYNCEVENT|NLOG_SYSEVENT)
261                             msyslog(LOG_NOTICE, "time reset %.6f s",
262                             fp_offset);
263                         printf("ntpd: time reset %.6fs\n", fp_offset);
264                 } else {
265                         adj_systime(fp_offset);
266                         NLOG(NLOG_SYNCEVENT|NLOG_SYSEVENT)
267                             msyslog(LOG_NOTICE, "time slew %.6f s",
268                             fp_offset);
269                         printf("ntpd: time slew %.6fs\n", fp_offset);
270                 }
271                 record_loop_stats(fp_offset, drift_comp, SQRT(epsil),
272                     clock_stability, sys_poll);
273                 exit (0);
274         }
275
276         /*
277          * If the clock has never been set, set it and initialize the
278          * discipline parameters. We then switch to frequency mode to
279          * speed the inital convergence process. If lucky, after an hour
280          * the ntp.drift file is created and initialized and we don't
281          * get here again.
282          */
283         if (state == S_NSET) {
284                 step_systime(fp_offset);
285                 NLOG(NLOG_SYNCEVENT|NLOG_SYSEVENT)
286                     msyslog(LOG_NOTICE, "time set %.6f s", fp_offset);
287                 rstclock(S_PFREQ, peer->epoch, fp_offset);
288                 return (1);
289         }
290
291         /*
292          * Update the jitter estimate.
293          */
294         oerror = sys_jitter;
295         dtemp = SQUARE(sys_jitter);
296         sys_jitter = SQRT(dtemp + (epsil - dtemp) / CLOCK_AVG);
297
298         /*
299          * The huff-n'-puff filter finds the lowest delay in the recent
300          * interval. This is used to correct the offset by one-half the
301          * difference between the sample delay and minimum delay. This
302          * is most effective if the delays are highly assymetric and
303          * clockhopping is avoided and the clock frequency wander is
304          * relatively small.
305          */
306         if (sys_huffpuff != NULL) {
307                 if (peer->delay < sys_huffpuff[sys_huffptr])
308                         sys_huffpuff[sys_huffptr] = peer->delay;
309                 if (peer->delay < sys_mindly)
310                         sys_mindly = peer->delay;
311                 if (fp_offset > 0)
312                         dtemp = -(peer->delay - sys_mindly) / 2;
313                 else
314                         dtemp = (peer->delay - sys_mindly) / 2;
315                 fp_offset += dtemp;
316 #ifdef DEBUG
317                 if (debug)
318                         printf(
319                     "local_clock: size %d mindly %.6f huffpuff %.6f\n",
320                             sys_hufflen, sys_mindly, dtemp);
321 #endif
322         }
323
324         /*
325          * Clock state machine transition function. This is where the
326          * action is and defines how the system reacts to large phase
327          * and frequency errors. There are two main regimes: when the
328          * offset exceeds the step threshold and when it does not.
329          * However, if the step threshold is set to zero, a step will
330          * never occur. See the instruction manual for the details how
331          * these actions interact with the command line options.
332          */
333         retval = 0;
334         if (sys_poll > peer->maxpoll)
335                 sys_poll = peer->maxpoll;
336         else if (sys_poll < peer->minpoll)
337                 sys_poll = peer->minpoll;
338         clock_frequency = flladj = plladj = 0;
339         mu = peer->epoch - last_time;
340 #if 0
341         msyslog(LOG_ERR, "loopfilterX fp_offset %lg clock_offset %lg mu %lg clock_max %lg state %d",
342                 fp_offset, clock_offset, mu, clock_max, state);
343 #endif
344         if (fabs(fp_offset) > clock_max && clock_max > 0) {
345                 switch (state) {
346
347                 /*
348                  * In S_TSET state the time has been set at the last
349                  * valid update and the offset at that time set to zero.
350                  * If following that we cruise outside the capture
351                  * range, assume a really bad frequency error and switch
352                  * to S_FREQ state.
353                  */
354                 case S_TSET:
355                         state = S_PFREQ;
356                         break;
357
358                 /*
359                  * In S_SYNC state we ignore outlyers. At the first
360                  * outlyer after the stepout threshold, switch to S_SPIK
361                  * state.
362                  */
363                 case S_SYNC:
364                         if (mu < clock_minstep)
365                                 return (0);
366                         state = S_SPIK;
367                         return (0);
368                 /*
369                  * We do not want to include the offset from a prior 
370                  * offset adjustment in our frequency calculation,
371                  * so supply some settling time.
372                  */
373                 case S_PFREQ:
374                         if (mu >= CLOCK_MINSEC)
375                                 rstclock(S_FREQ, peer->epoch, fp_offset);
376                         return (0);
377
378                 /*
379                  * In S_FREQ state we ignore outlyers. At the first
380                  * outlyer after 900 s, compute the apparent phase and
381                  * frequency correction.
382                  */
383                 case S_FREQ:
384                         if (mu < clock_minstep)
385                                 return (0);
386                         /* fall through to S_SPIK */
387
388                 /*
389                  * In S_SPIK state a large correction is necessary.
390                  * Since the outlyer may be due to a large frequency
391                  * error, compute the apparent frequency correction.
392                  */
393                 case S_SPIK:
394                         clock_frequency = (fp_offset - clock_offset) /
395                             mu;
396                         /* fall through to default */
397
398                 /*
399                  * We get here directly in S_FSET state and indirectly
400                  * from S_FREQ and S_SPIK states. The clock is either
401                  * reset or shaken, but never stirred.
402                  */
403                 default:
404                         if (allow_step) {
405                                 step_systime(fp_offset);
406                                 NLOG(NLOG_SYNCEVENT|NLOG_SYSEVENT)
407                                     msyslog(LOG_NOTICE, "time reset %.6f s",
408                                     fp_offset);
409                                 rstclock(S_TSET, peer->epoch, 0);
410                                 retval = 1;
411                         } else {
412                                 NLOG(NLOG_SYNCEVENT|NLOG_SYSEVENT)
413                                     msyslog(LOG_NOTICE, "time slew %.6f s",
414                                     fp_offset);
415                                 rstclock(S_FREQ, peer->epoch,
416                                     fp_offset);
417                         }
418                         break;
419                 }
420         } else {
421                 switch (state) {
422
423                 /*
424                  * In S_FSET state this is the first update. Adjust the
425                  * phase, but don't adjust the frequency until the next
426                  * update.
427                  */
428                 case S_FSET:
429                         rstclock(S_TSET, peer->epoch, fp_offset);
430                         break;
431                 /*
432                  * We do not want to include the offset from a prior 
433                  * offset adjustment in our frequency calculation,
434                  * so supply some settling time.
435                  */
436                 case S_PFREQ:
437                         if (mu >= CLOCK_MINSEC)
438                                 rstclock(S_FREQ, peer->epoch, fp_offset);
439                         return (0);
440
441                 /*
442                  * In S_FREQ state ignore updates until the stepout
443                  * threshold. After that, correct the phase and
444                  * frequency and switch to S_SYNC state.
445                  */
446                 case S_FREQ:
447                         if (mu < clock_minstep)
448                                 return (0);
449                         clock_frequency = (fp_offset - clock_offset) /
450                             mu;
451                         rstclock(S_SYNC, peer->epoch, fp_offset);
452                         break;
453
454                 /*
455                  * Either the clock has just been set or the previous
456                  * update was a spike and ignored. Since this update is
457                  * not an outlyer, fold the tent and resume life.
458                  */
459                 case S_TSET:
460                 case S_SPIK:
461                         state = S_SYNC;
462                         /* fall through to default */
463
464                 /*
465                  * We come here in the normal case for linear phase and
466                  * frequency adjustments. If the offset exceeds the
467                  * previous time error estimate by CLOCK_SGATE and the
468                  * interval since the last update is less than twice the
469                  * poll interval, consider the update a popcorn spike
470                  * and ignore it.
471                  */
472                 default:
473                         allow_panic = TRUE;
474                         if (fabs(fp_offset - last_offset) >
475                             CLOCK_SGATE * oerror && mu <
476                             ULOGTOD(sys_poll + 1)) {
477 #ifdef DEBUG
478                                 if (debug)
479                                         printf(
480                                     "local_clock: popcorn %.6f %.6f\n",
481                                             fabs(fp_offset -
482                                             last_offset), CLOCK_SGATE *
483                                             oerror);
484 #endif
485                                 last_offset = fp_offset;
486                                 return (0);
487                         }
488
489                         /*
490                          * Compute the FLL and PLL frequency adjustments
491                          * conditioned on intricate weighting factors.
492                          * For the FLL, the averaging interval is
493                          * clamped to a minimum of 1024 s and the gain
494                          * is decreased from unity for mu above 1024 s
495                          * to zero below 256 s. For the PLL, the
496                          * averaging interval is clamped not to exceed
497                          * the sustem poll interval. No gain factor is
498                          * necessary, since the frequency steering above
499                          * 1024 s is negligible. Particularly for the
500                          * PLL, these measures allow oversampling, but
501                          * not undersampling and insure stability even
502                          * when the rules of fair engagement are broken.
503                          */
504                         dtemp = max(mu, allan_xpt);
505                         etemp = min(max(0, mu - CLOCK_MINSEC) /
506                             allan_xpt, 1.);
507                         flladj = fp_offset * etemp / (dtemp *
508                             CLOCK_AVG);
509                         dtemp = ULOGTOD(SHIFT_PLL + 2 + sys_poll);
510                         etemp = min(mu, ULOGTOD(sys_poll));
511                         plladj = fp_offset * etemp / (dtemp * dtemp);
512                         last_time = peer->epoch;
513                         last_offset = clock_offset = fp_offset;
514                         break;
515                 }
516         }
517
518 #if defined(KERNEL_PLL)
519         /*
520          * This code segment works when clock adjustments are made using
521          * precision time kernel support and the ntp_adjtime() system
522          * call. This support is available in Solaris 2.6 and later,
523          * Digital Unix 4.0 and later, FreeBSD, Linux and specially
524          * modified kernels for HP-UX 9 and Ultrix 4. In the case of the
525          * DECstation 5000/240 and Alpha AXP, additional kernel
526          * modifications provide a true microsecond clock and nanosecond
527          * clock, respectively.
528          */
529         if (pll_control && kern_enable) {
530
531                 /*
532                  * We initialize the structure for the ntp_adjtime()
533                  * system call. We have to convert everything to
534                  * microseconds or nanoseconds first. Do not update the
535                  * system variables if the ext_enable flag is set. In
536                  * this case, the external clock driver will update the
537                  * variables, which will be read later by the local
538                  * clock driver. Afterwards, remember the time and
539                  * frequency offsets for jitter and stability values and
540                  * to update the drift file.
541                  */
542                 memset(&ntv,  0, sizeof(ntv));
543                 if (ext_enable) {
544                         ntv.modes = MOD_STATUS;
545                 } else {
546                         ntv.modes = MOD_BITS;
547                         if (clock_offset < 0)
548                                 dtemp = -.5;
549                         else
550                                 dtemp = .5;
551                         if (pll_nano) {
552                                 ntv.offset = (int32)(clock_offset *
553                                     1e9 + dtemp);
554                                 ntv.constant = sys_poll;
555                         } else {
556                                 ntv.offset = (int32)(clock_offset *
557                                     1e6 + dtemp);
558                                 ntv.constant = sys_poll - 4;
559                         }
560 #if 0
561                         msyslog(LOG_ERR, "loopfilter2 offset %d components: %lg %lg",
562                                 ntv.offset, clock_offset * 1e9, dtemp);
563 #endif
564                         if (clock_frequency != 0) {
565                                 ntv.modes |= MOD_FREQUENCY;
566                                 ntv.freq = (int32)((clock_frequency +
567                                     drift_comp) * 65536e6);
568 #if 0
569                                 msyslog(LOG_ERR, "loopfilter2 freq %d components: %lg %lg",
570                                         ntv.freq, clock_frequency, drift_comp);
571 #endif
572                         }
573                         ntv.esterror = (u_int32)(sys_jitter * 1e6);
574                         ntv.maxerror = (u_int32)((sys_rootdelay / 2 +
575                             sys_rootdispersion) * 1e6);
576                         ntv.status = STA_PLL;
577
578                         /*
579                          * Set the leap bits in the status word.
580                          */
581                         if (sys_leap == LEAP_NOTINSYNC) {
582                                 ntv.status |= STA_UNSYNC;
583                         } else if (calleapwhen(sys_reftime.l_ui) <
584                                     CLOCK_DAY) {
585                                 if (sys_leap & LEAP_ADDSECOND)
586                                         ntv.status |= STA_INS;
587                                 else if (sys_leap & LEAP_DELSECOND)
588                                         ntv.status |= STA_DEL;
589                         }
590
591                         /*
592                          * Switch to FLL mode if the poll interval is
593                          * greater than MAXDPOLL, so that the kernel
594                          * loop behaves as the daemon loop; viz.,
595                          * selects the FLL when necessary, etc. For
596                          * legacy only.
597                          */
598                         if (sys_poll > NTP_MAXDPOLL)
599                                 ntv.status |= STA_FLL;
600
601                         /*
602                          * If the PPS signal is up and enabled, light
603                          * the frequency bit. If the PPS driver is
604                          * working, light the phase bit as well. If not,
605                          * douse the lights, since somebody else may
606                          * have left the switch on.
607                          */
608                         if (pps_enable && pll_status & STA_PPSSIGNAL) {
609                                 ntv.status |= STA_PPSFREQ;
610                                 if (pps_stratum < STRATUM_UNSPEC)
611                                         ntv.status |= STA_PPSTIME;
612                         } else {
613                                 ntv.status &= ~(STA_PPSFREQ |
614                                     STA_PPSTIME);
615                         }
616                 }
617
618                 /*
619                  * Pass the stuff to the kernel. If it squeals, turn off
620                  * the pigs. In any case, fetch the kernel offset and
621                  * frequency and pretend we did it here.
622                  */
623                 if (ntp_adjtime(&ntv) == TIME_ERROR) {
624                         if (ntv.status != pll_status)
625                                 msyslog(LOG_ERR,
626                                     "kernel time discipline status change %x",
627                                     ntv.status);
628                         ntv.status &= ~(STA_PPSFREQ | STA_PPSTIME);
629                 }
630                 pll_status = ntv.status;
631                 if (pll_nano)
632                         clock_offset = ntv.offset / 1e9;
633                 else
634                         clock_offset = ntv.offset / 1e6;
635                 clock_frequency = ntv.freq / 65536e6 - drift_comp;
636                 flladj = plladj = 0;
637
638                 /*
639                  * If the kernel PPS is lit, monitor its performance.
640                  */
641                 if (ntv.status & STA_PPSTIME) {
642                         pps_control = current_time;
643                         if (pll_nano)
644                                 sys_jitter = ntv.jitter / 1e9;
645                         else
646                                 sys_jitter = ntv.jitter / 1e6;
647                 }
648         }
649 #endif /* KERNEL_PLL */
650  
651         /*
652          * Adjust the clock frequency and calculate the stability. If
653          * kernel support is available, we use the results of the kernel
654          * discipline instead of the PLL/FLL discipline. In this case,
655          * drift_comp is a sham and used only for updating the drift
656          * file and for billboard eye candy.
657          */
658         etemp = clock_frequency + flladj + plladj;
659         drift_comp += etemp;
660         if (drift_comp > NTP_MAXFREQ)
661                 drift_comp = NTP_MAXFREQ;
662         else if (drift_comp <= -NTP_MAXFREQ)
663                 drift_comp = -NTP_MAXFREQ;
664         dtemp = SQUARE(clock_stability);
665         etemp = SQUARE(etemp) - dtemp;
666         clock_stability = SQRT(dtemp + etemp / CLOCK_AVG);
667
668         /*
669          * In SYNC state, adjust the poll interval. The trick here is to
670          * compare the apparent frequency change induced by the system
671          * jitter over the poll interval, or fritter, to the frequency
672          * stability. If the fritter is greater than the stability,
673          * phase noise predominates and the averaging interval is
674          * increased; otherwise, it is decreased. A bit of hysteresis
675          * helps calm the dance. Works best using burst mode.
676          */
677         if (state == S_SYNC) {
678                 if (sys_jitter / ULOGTOD(sys_poll) > clock_stability &&
679                     fabs(clock_offset) < CLOCK_PGATE * sys_jitter) {
680                         tc_counter += sys_poll;
681                         if (tc_counter > CLOCK_LIMIT) {
682                                 tc_counter = CLOCK_LIMIT;
683                                 if (sys_poll < peer->maxpoll) {
684                                         tc_counter = 0;
685                                         sys_poll++;
686                                 }
687                         }
688                 } else {
689                         tc_counter -= sys_poll << 1;
690                         if (tc_counter < -CLOCK_LIMIT) {
691                                 tc_counter = -CLOCK_LIMIT;
692                                 if (sys_poll > peer->minpoll) {
693                                         tc_counter = 0;
694                                         sys_poll--;
695                                 }
696                         }
697                 }
698         }
699
700         /*
701          * Update the system time variables.
702          */
703         dtemp = peer->disp + sys_jitter;
704         if ((peer->flags & FLAG_REFCLOCK) == 0 && dtemp < MINDISPERSE)
705                 dtemp = MINDISPERSE;
706         sys_rootdispersion = peer->rootdispersion + dtemp;
707         record_loop_stats(last_offset, drift_comp, sys_jitter,
708             clock_stability, sys_poll);
709 #ifdef DEBUG
710         if (debug)
711                 printf(
712                     "local_clock: mu %.0f noi %.3f stb %.3f pol %d cnt %d\n",
713                     mu, sys_jitter * 1e6 / mu, clock_stability * 1e6,
714                     sys_poll, tc_counter);
715 #endif /* DEBUG */
716         return (retval);
717 }
718
719
720 /*
721  * adj_host_clock - Called once every second to update the local clock.
722  */
723 void
724 adj_host_clock(
725         void
726         )
727 {
728         double adjustment;
729
730         /*
731          * Update the dispersion since the last update. In contrast to
732          * NTPv3, NTPv4 does not declare unsynchronized after one day,
733          * since the dispersion check serves this function. Also,
734          * since the poll interval can exceed one day, the old test
735          * would be counterproductive. Note we do this even with
736          * external clocks, since the clock driver will recompute the
737          * maximum error and the local clock driver will pick it up and
738          * pass to the common refclock routines. Very elegant.
739          */
740         sys_rootdispersion += clock_phi;
741
742         /*
743          * Declare PPS kernel unsync if the pps signal has not been
744          * heard for a few minutes.
745          */
746         if (pps_control && current_time - pps_control > PPS_MAXAGE) {
747                 if (pps_control)
748                         NLOG(NLOG_SYSEVENT) /* conditional if clause */
749                             msyslog(LOG_INFO, "pps sync disabled");
750                 pps_control = 0;
751         }
752         if (!ntp_enable)
753                 return;
754
755         /*
756          * If the phase-lock loop is implemented in the kernel, we
757          * have no business going further.
758          */
759         if (pll_control && kern_enable)
760                 return;
761
762         /*
763          * Intricate wrinkle for legacy only. If the local clock driver
764          * is in use and selected for synchronization, somebody else may
765          * tinker the adjtime() syscall. If this is the case, the driver
766          * is marked prefer and we have to avoid calling adjtime(),
767          * since that may truncate the other guy's requests.
768          */
769         if (sys_peer != 0) {
770                 if (sys_peer->refclktype == REFCLK_LOCALCLOCK &&
771                     sys_peer->flags & FLAG_PREFER)
772                         return;
773         }
774         adjustment = clock_offset / ULOGTOD(SHIFT_PLL + sys_poll);
775         clock_offset -= adjustment;
776         adj_systime(adjustment + drift_comp);
777 }
778
779
780 /*
781  * Clock state machine. Enter new state and set state variables.
782  */
783 static void
784 rstclock(
785         int trans,              /* new state */
786         double epoch,           /* last time */
787         double offset           /* last offset */
788         )
789 {
790         tc_counter = 0;
791         sys_poll = NTP_MINPOLL;
792         state = trans;
793         last_time = epoch;
794         last_offset = clock_offset = offset;
795 }
796
797
798 /*
799  * huff-n'-puff filter
800  */
801 void
802 huffpuff()
803 {
804         int i;
805
806         if (sys_huffpuff == NULL)
807                 return;
808         sys_huffptr = (sys_huffptr + 1) % sys_hufflen;
809         sys_huffpuff[sys_huffptr] = 1e9;
810         sys_mindly = 1e9;
811         for (i = 0; i < sys_hufflen; i++) {
812                 if (sys_huffpuff[i] < sys_mindly)
813                         sys_mindly = sys_huffpuff[i];
814         }
815 }
816
817
818 /*
819  * loop_config - configure the loop filter
820  */
821 void
822 loop_config(
823         int item,
824         double freq
825         )
826 {
827         int i;
828
829         switch (item) {
830
831         case LOOP_DRIFTINIT:
832
833 #ifdef KERNEL_PLL
834                 /*
835                  * Assume the kernel supports the ntp_adjtime() syscall.
836                  * If that syscall works, initialize the kernel
837                  * variables. Otherwise, continue leaving no harm
838                  * behind. While at it, ask to set nanosecond mode. If
839                  * the kernel agrees, rejoice; othewise, it does only
840                  * microseconds.
841                  */
842                 pll_control = 1;
843                 memset(&ntv, 0, sizeof(ntv));
844 #ifdef STA_NANO
845                 ntv.modes = MOD_BITS | MOD_NANO;
846 #else
847                 ntv.modes = MOD_BITS;
848 #endif /* STA_NANO */
849                 ntv.maxerror = MAXDISPERSE;
850                 ntv.esterror = MAXDISPERSE;
851                 ntv.status = STA_UNSYNC;
852 #ifdef SIGSYS
853                 /*
854                  * Use sigsetjmp() to save state and then call
855                  * ntp_adjtime(); if it fails, then siglongjmp() is used
856                  * to return control
857                  */
858                 newsigsys.sa_handler = pll_trap;
859                 newsigsys.sa_flags = 0;
860                 if (sigaction(SIGSYS, &newsigsys, &sigsys)) {
861                         msyslog(LOG_ERR,
862                             "sigaction() fails to save SIGSYS trap: %m");
863                         pll_control = 0;
864                 }
865                 if (sigsetjmp(env, 1) == 0)
866                         ntp_adjtime(&ntv);
867                 if ((sigaction(SIGSYS, &sigsys,
868                     (struct sigaction *)NULL))) {
869                         msyslog(LOG_ERR,
870                             "sigaction() fails to restore SIGSYS trap: %m");
871                         pll_control = 0;
872                 }
873 #else /* SIGSYS */
874                 ntp_adjtime(&ntv);
875 #endif /* SIGSYS */
876                 pll_status = ntv.status;
877                 if (pll_control) {
878 #ifdef STA_NANO
879                         if (pll_status & STA_NANO)
880                                 pll_nano = 1;
881                         if (pll_status & STA_CLK)
882                                 ext_enable = 1;
883 #endif /* STA_NANO */
884                         msyslog(LOG_NOTICE,
885                            "kernel time discipline status %04x",
886                             pll_status);
887                 }
888 #endif /* KERNEL_PLL */
889                 break;
890
891         case LOOP_DRIFTCOMP:
892
893                 /*
894                  * Initialize the kernel frequency and clamp to
895                  * reasonable value. Also set the initial state to
896                  * S_FSET to indicated the frequency has been
897                  * initialized from the previously saved drift file.
898                  */
899                 rstclock(S_FSET, current_time, 0);
900                 drift_comp = freq;
901                 if (drift_comp > NTP_MAXFREQ)
902                         drift_comp = NTP_MAXFREQ;
903                 if (drift_comp < -NTP_MAXFREQ)
904                         drift_comp = -NTP_MAXFREQ;
905
906 #ifdef KERNEL_PLL
907                 /*
908                  * Sanity check. If the kernel is enabled, load the
909                  * frequency and light up the loop. If not, set the
910                  * kernel frequency to zero and leave the loop dark. In
911                  * either case set the time to zero to cancel any
912                  * previous nonsense.
913                  */
914                 if (pll_control) {
915                         memset((char *)&ntv, 0, sizeof(ntv));
916                         ntv.modes = MOD_OFFSET | MOD_FREQUENCY;
917                         if (kern_enable) {
918                                 ntv.modes |= MOD_STATUS;
919                                 ntv.status = STA_PLL;
920                                 ntv.freq = (int32)(drift_comp *
921                                     65536e6);
922                         }
923                         msyslog(LOG_ERR, "loopfilter1 offset %d freq %d (%lg)",
924                                 ntv.offset, ntv.freq, drift_comp
925                         );
926                         (void)ntp_adjtime(&ntv);
927                 }
928 #endif /* KERNEL_PLL */
929                 break;
930
931         /*
932          * Special tinker variables for Ulrich Windl. Very dangerous.
933          */
934         case LOOP_MAX:                  /* step threshold */
935                 clock_max = freq;
936                 break;
937
938         case LOOP_PANIC:                /* panic exit threshold */
939                 clock_panic = freq;
940                 break;
941
942         case LOOP_PHI:                  /* dispersion rate */
943                 clock_phi = freq;
944                 break;
945
946         case LOOP_MINSTEP:              /* watchdog bark */
947                 clock_minstep = freq; 
948                 break;
949
950         case LOOP_MINPOLL:              /* ephemeral association poll */
951                 if (freq < NTP_MINPOLL)
952                         freq = NTP_MINPOLL;
953                 sys_minpoll = (u_char)freq;
954                 break;
955
956         case LOOP_ALLAN:                /* minimum Allan intercept */
957                 if (freq < CLOCK_ALLAN)
958                         freq = CLOCK_ALLAN;
959                 allan_xpt = freq;
960                 break;
961         
962         case LOOP_HUFFPUFF:             /* huff-n'-puff filter length */
963                 if (freq < HUFFPUFF)
964                         freq = HUFFPUFF;
965                 sys_hufflen = (int)(freq / HUFFPUFF);
966                 sys_huffpuff = (double *)emalloc(sizeof(double) *
967                     sys_hufflen);
968                 for (i = 0; i < sys_hufflen; i++)
969                         sys_huffpuff[i] = 1e9;
970                 sys_mindly = 1e9;
971                 break;
972         }
973 }
974
975
976 #if defined(KERNEL_PLL) && defined(SIGSYS)
977 /*
978  * _trap - trap processor for undefined syscalls
979  *
980  * This nugget is called by the kernel when the SYS_ntp_adjtime()
981  * syscall bombs because the silly thing has not been implemented in
982  * the kernel. In this case the phase-lock loop is emulated by
983  * the stock adjtime() syscall and a lot of indelicate abuse.
984  */
985 static RETSIGTYPE
986 pll_trap(
987         int arg
988         )
989 {
990         pll_control = 0;
991         siglongjmp(env, 1);
992 }
993 #endif /* KERNEL_PLL && SIGSYS */