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