contrib/ntp/ntpd/ntp_loopfilter.c

   1 /*
   2  * ntp_loopfilter.c - implements the NTP loop filter algorithm
   3  *
   4  * ATTENTION: Get approval from Dave Mills on all changes to this file!
   5  *
   6  */
   7 #ifdef HAVE_CONFIG_H
   8 # include <config.h>
   9 #endif
  10
  11 #ifdef USE_SNPRINTB
  12 # include <util.h>
  13 #endif
  14 #include "ntpd.h"
  15 #include "ntp_io.h"
  16 #include "ntp_unixtime.h"
  17 #include "ntp_stdlib.h"
  18 #include "timexsup.h"
  19
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include <ctype.h>
  23
  24 #include <signal.h>
  25 #include <setjmp.h>
  26
  27 #ifdef KERNEL_PLL
  28 #include "ntp_syscall.h"
  29 #endif /* KERNEL_PLL */
  30
  31 /*
  32  * This is an implementation of the clock discipline algorithm described
  33  * in UDel TR 97-4-3, as amended. It operates as an adaptive parameter,
  34  * hybrid phase/frequency-lock loop. A number of sanity checks are
  35  * included to protect against timewarps, timespikes and general mayhem.
  36  * All units are in s and s/s, unless noted otherwise.
  37  */
  38 #define CLOCK_MAX       .128    /* default step threshold (s) */
  39 #define CLOCK_MINSTEP   300.    /* default stepout threshold (s) */
  40 #define CLOCK_PANIC     1000.   /* default panic threshold (s) */
  41 #define CLOCK_PHI       15e-6   /* max frequency error (s/s) */
  42 #define CLOCK_PLL       16.     /* PLL loop gain (log2) */
  43 #define CLOCK_AVG       8.      /* parameter averaging constant */
  44 #define CLOCK_FLL       .25     /* FLL loop gain */
  45 #define CLOCK_FLOOR     .0005   /* startup offset floor (s) */
  46 #define CLOCK_ALLAN     11      /* Allan intercept (log2 s) */
  47 #define CLOCK_LIMIT     30      /* poll-adjust threshold */
  48 #define CLOCK_PGATE     4.      /* poll-adjust gate */
  49 #define PPS_MAXAGE      120     /* kernel pps signal timeout (s) */
  50 #define FREQTOD(x)      ((x) / 65536e6) /* NTP to double */
  51 #define DTOFREQ(x)      ((int32)((x) * 65536e6)) /* double to NTP */
  52
  53 /*
  54  * Clock discipline state machine. This is used to control the
  55  * synchronization behavior during initialization and following a
  56  * timewarp.
  57  *
  58  *      State   < step          > step          Comments
  59  *      ========================================================
  60  *      NSET    FREQ            step, FREQ      freq not set
  61  *
  62  *      FSET    SYNC            step, SYNC      freq set
  63  *
  64  *      FREQ    if (mu < 900)   if (mu < 900)   set freq direct
  65  *                  ignore          ignore
  66  *              else            else
  67  *                  freq, SYNC      freq, step, SYNC
  68  *
  69  *      SYNC    SYNC            SPIK, ignore    adjust phase/freq
  70  *
  71  *      SPIK    SYNC            if (mu < 900)   adjust phase/freq
  72  *                                  ignore
  73  *                              step, SYNC
  74  */
  75 /*
  76  * Kernel PLL/PPS state machine. This is used with the kernel PLL
  77  * modifications described in the documentation.
  78  *
  79  * If kernel support for the ntp_adjtime() system call is available, the
  80  * ntp_control flag is set. The ntp_enable and kern_enable flags can be
  81  * set at configuration time or run time using ntpdc. If ntp_enable is
  82  * false, the discipline loop is unlocked and no corrections of any kind
  83  * are made. If both ntp_control and kern_enable are set, the kernel
  84  * support is used as described above; if false, the kernel is bypassed
  85  * entirely and the daemon discipline used instead.
  86  *
  87  * There have been three versions of the kernel discipline code. The
  88  * first (microkernel) now in Solaris discipilnes the microseconds. The
  89  * second and third (nanokernel) disciplines the clock in nanoseconds.
  90  * These versions are identifed if the symbol STA_PLL is present in the
  91  * header file /usr/include/sys/timex.h. The third and current version
  92  * includes TAI offset and is identified by the symbol NTP_API with
  93  * value 4.
  94  *
  95  * Each PPS time/frequency discipline can be enabled by the atom driver
  96  * or another driver. If enabled, the STA_PPSTIME and STA_FREQ bits are
  97  * set in the kernel status word; otherwise, these bits are cleared.
  98  * These bits are also cleard if the kernel reports an error.
  99  *
 100  * If an external clock is present, the clock driver sets STA_CLK in the
 101  * status word. When the local clock driver sees this bit, it updates
 102  * via this routine, which then calls ntp_adjtime() with the STA_PLL bit
 103  * set to zero, in which case the system clock is not adjusted. This is
 104  * also a signal for the external clock driver to discipline the system
 105  * clock. Unless specified otherwise, all times are in seconds.
 106  */
 107 /*
 108  * Program variables that can be tinkered.
 109  */
 110 double  clock_max_back = CLOCK_MAX;     /* step threshold */
 111 double  clock_max_fwd =  CLOCK_MAX;     /* step threshold */
 112 double  clock_minstep = CLOCK_MINSTEP; /* stepout threshold */
 113 double  clock_panic = CLOCK_PANIC; /* panic threshold */
 114 double  clock_phi = CLOCK_PHI;  /* dispersion rate (s/s) */
 115 u_char  allan_xpt = CLOCK_ALLAN; /* Allan intercept (log2 s) */
 116
 117 /*
 118  * Program variables
 119  */
 120 static double clock_offset;     /* offset */
 121 double  clock_jitter;           /* offset jitter */
 122 double  drift_comp;             /* frequency (s/s) */
 123 static double init_drift_comp; /* initial frequency (PPM) */
 124 double  clock_stability;        /* frequency stability (wander) (s/s) */
 125 double  clock_codec;            /* audio codec frequency (samples/s) */
 126 static u_long clock_epoch;      /* last update */
 127 u_int   sys_tai;                /* TAI offset from UTC */
 128 static int loop_started;        /* TRUE after LOOP_DRIFTINIT */
 129 static void rstclock (int, double); /* transition function */
 130 static double direct_freq(double); /* direct set frequency */
 131 static void set_freq(double);   /* set frequency */
 132 #ifndef PATH_MAX
 133 # define PATH_MAX MAX_PATH
 134 #endif
 135 static char relative_path[PATH_MAX + 1]; /* relative path per recursive make */
 136 static char *this_file = NULL;
 137
 138 #ifdef KERNEL_PLL
 139 static struct timex ntv;        /* ntp_adjtime() parameters */
 140 int     pll_status;             /* last kernel status bits */
 141 #if defined(STA_NANO) && NTP_API == 4
 142 static u_int loop_tai;          /* last TAI offset */
 143 #endif /* STA_NANO */
 144 static  void    start_kern_loop(void);
 145 static  void    stop_kern_loop(void);
 146 #endif /* KERNEL_PLL */
 147
 148 /*
 149  * Clock state machine control flags
 150  */
 151 int     ntp_enable = TRUE;      /* clock discipline enabled */
 152 int     pll_control;            /* kernel support available */
 153 int     kern_enable = TRUE;     /* kernel support enabled */
 154 int     hardpps_enable;         /* kernel PPS discipline enabled */
 155 int     ext_enable;             /* external clock enabled */
 156 int     pps_stratum;            /* pps stratum */
 157 int     kernel_status;          /* from ntp_adjtime */
 158 int     force_step_once = FALSE; /* always step time once at startup (-G) */
 159 int     mode_ntpdate = FALSE;   /* exit on first clock set (-q) */
 160 int     freq_cnt;               /* initial frequency clamp */
 161 int     freq_set;               /* initial set frequency switch */
 162
 163 /*
 164  * Clock state machine variables
 165  */
 166 int     state = 0;              /* clock discipline state */
 167 u_char  sys_poll;               /* time constant/poll (log2 s) */
 168 int     tc_counter;             /* jiggle counter */
 169 double  last_offset;            /* last offset (s) */
 170
 171 u_int   tc_twinlo;              /* TC step down not before this time */
 172 u_int   tc_twinhi;              /* TC step up not before this time */
 173
 174 /*
 175  * Huff-n'-puff filter variables
 176  */
 177 static double *sys_huffpuff;    /* huff-n'-puff filter */
 178 static int sys_hufflen;         /* huff-n'-puff filter stages */
 179 static int sys_huffptr;         /* huff-n'-puff filter pointer */
 180 static double sys_mindly;       /* huff-n'-puff filter min delay */
 181
 182 #if defined(KERNEL_PLL)
 183 /* Emacs cc-mode goes nuts if we split the next line... */
 184 #define MOD_BITS (MOD_OFFSET | MOD_MAXERROR | MOD_ESTERROR | \
 185     MOD_STATUS | MOD_TIMECONST)
 186 #ifdef SIGSYS
 187 static void pll_trap (int);     /* configuration trap */
 188 static struct sigaction sigsys; /* current sigaction status */
 189 static struct sigaction newsigsys; /* new sigaction status */
 190 static sigjmp_buf env;          /* environment var. for pll_trap() */
 191 #endif /* SIGSYS */
 192 #endif /* KERNEL_PLL */
 193
 194 static void
 195 sync_status(const char *what, int ostatus, int nstatus)
 196 {
 197         char obuf[256], nbuf[256], tbuf[1024];
 198 #if defined(USE_SNPRINTB) && defined (STA_FMT)
 199         snprintb(obuf, sizeof(obuf), STA_FMT, ostatus);
 200         snprintb(nbuf, sizeof(nbuf), STA_FMT, nstatus);
 201 #else
 202         snprintf(obuf, sizeof(obuf), "%04x", ostatus);
 203         snprintf(nbuf, sizeof(nbuf), "%04x", nstatus);
 204 #endif
 205         snprintf(tbuf, sizeof(tbuf), "%s status: %s -> %s", what, obuf, nbuf);
 206         report_event(EVNT_KERN, NULL, tbuf);
 207 }
 208
 209 /*
 210  * file_name - return pointer to non-relative portion of this C file pathname
 211  */
 212 static char *file_name(void)
 213 {
 214         if (this_file == NULL) {
 215             (void)strncpy(relative_path, __FILE__, PATH_MAX);
 216             for (this_file=relative_path;
 217                 *this_file && ! isalnum((unsigned char)*this_file);
 218                 this_file++) ;
 219         }
 220         return this_file;
 221 }
 222
 223 /*
 224  * init_loopfilter - initialize loop filter data
 225  */
 226 void
 227 init_loopfilter(void)
 228 {
 229         /*
 230          * Initialize state variables.
 231          */
 232         sys_poll = ntp_minpoll;
 233         clock_jitter = LOGTOD(sys_precision);
 234         freq_cnt = (int)clock_minstep;
 235 }
 236
 237 #ifdef KERNEL_PLL
 238 /*
 239  * ntp_adjtime_error_handler - process errors from ntp_adjtime
 240  */
 241 static void
 242 ntp_adjtime_error_handler(
 243         const char *caller,     /* name of calling function */
 244         struct timex *ptimex,   /* pointer to struct timex */
 245         int ret,                /* return value from ntp_adjtime */
 246         int saved_errno,        /* value of errno when ntp_adjtime returned */
 247         int pps_call,           /* ntp_adjtime call was PPS-related */
 248         int tai_call,           /* ntp_adjtime call was TAI-related */
 249         int line                /* line number of ntp_adjtime call */
 250         )
 251 {
 252         char des[1024] = "";    /* Decoded Error Status */
 253         char *dbp, *ebp;
 254
 255         dbp = des;
 256         ebp = dbp + sizeof(des);
 257
 258         switch (ret) {
 259             case -1:
 260                 switch (saved_errno) {
 261                     case EFAULT:
 262                         msyslog(LOG_ERR, "%s: %s line %d: invalid struct timex pointer: 0x%lx",
 263                             caller, file_name(), line,
 264                             (long)((void *)ptimex)
 265                         );
 266                     break;
 267                     case EINVAL:
 268                         msyslog(LOG_ERR, "%s: %s line %d: invalid struct timex \"constant\" element value: %ld",
 269                             caller, file_name(), line,
 270                             (long)(ptimex->constant)
 271                         );
 272                     break;
 273                     case EPERM:
 274                         if (tai_call) {
 275                             errno = saved_errno;
 276                             msyslog(LOG_ERR,
 277                                 "%s: ntp_adjtime(TAI) failed: %m",
 278                                 caller);
 279                         }
 280                         errno = saved_errno;
 281                         msyslog(LOG_ERR, "%s: %s line %d: ntp_adjtime: %m",
 282                             caller, file_name(), line
 283                         );
 284                     break;
 285                     default:
 286                         msyslog(LOG_NOTICE, "%s: %s line %d: unhandled errno value %d after failed ntp_adjtime call",
 287                             caller, file_name(), line,
 288                             saved_errno
 289                         );
 290                     break;
 291                 }
 292             break;
 293 #ifdef TIME_OK
 294             case TIME_OK: /* 0: synchronized, no leap second warning */
 295                 /* msyslog(LOG_INFO, "kernel reports time is synchronized normally"); */
 296             break;
 297 #else
 298 # warning TIME_OK is not defined
 299 #endif
 300 #ifdef TIME_INS
 301             case TIME_INS: /* 1: positive leap second warning */
 302                 msyslog(LOG_INFO, "kernel reports leap second insertion scheduled");
 303             break;
 304 #else
 305 # warning TIME_INS is not defined
 306 #endif
 307 #ifdef TIME_DEL
 308             case TIME_DEL: /* 2: negative leap second warning */
 309                 msyslog(LOG_INFO, "kernel reports leap second deletion scheduled");
 310             break;
 311 #else
 312 # warning TIME_DEL is not defined
 313 #endif
 314 #ifdef TIME_OOP
 315             case TIME_OOP: /* 3: leap second in progress */
 316                 msyslog(LOG_INFO, "kernel reports leap second in progress");
 317             break;
 318 #else
 319 # warning TIME_OOP is not defined
 320 #endif
 321 #ifdef TIME_WAIT
 322             case TIME_WAIT: /* 4: leap second has occured */
 323                 msyslog(LOG_INFO, "kernel reports leap second has occurred");
 324             break;
 325 #else
 326 # warning TIME_WAIT is not defined
 327 #endif
 328 #ifdef TIME_ERROR
 329 #if 0
 330
 331 from the reference implementation of ntp_gettime():
 332
 333                 // Hardware or software error
 334         if ((time_status & (STA_UNSYNC | STA_CLOCKERR))
 335
 336         /*
 337          * PPS signal lost when either time or frequency synchronization
 338          * requested
 339          */
 340         || (time_status & (STA_PPSFREQ | STA_PPSTIME)
 341             && !(time_status & STA_PPSSIGNAL))
 342
 343         /*
 344          * PPS jitter exceeded when time synchronization requested
 345          */
 346         || (time_status & STA_PPSTIME &&
 347             time_status & STA_PPSJITTER)
 348
 349         /*
 350          * PPS wander exceeded or calibration error when frequency
 351          * synchronization requested
 352          */
 353         || (time_status & STA_PPSFREQ &&
 354             time_status & (STA_PPSWANDER | STA_PPSERROR)))
 355                 return (TIME_ERROR);
 356
 357 or, from ntp_adjtime():
 358
 359         if (  (time_status & (STA_UNSYNC | STA_CLOCKERR))
 360             || (time_status & (STA_PPSFREQ | STA_PPSTIME)
 361                 && !(time_status & STA_PPSSIGNAL))
 362             || (time_status & STA_PPSTIME
 363                 && time_status & STA_PPSJITTER)
 364             || (time_status & STA_PPSFREQ
 365                 && time_status & (STA_PPSWANDER | STA_PPSERROR))
 366            )
 367                 return (TIME_ERROR);
 368 #endif
 369
 370             case TIME_ERROR: /* 5: unsynchronized, or loss of synchronization */
 371                                 /* error (see status word) */
 372
 373                 if (ptimex->status & STA_UNSYNC)
 374                         xsbprintf(&dbp, ebp, "%sClock Unsynchronized",
 375                                  (*des) ? "; " : "");
 376
 377                 if (ptimex->status & STA_CLOCKERR)
 378                     xsbprintf(&dbp, ebp, "%sClock Error",
 379                               (*des) ? "; " : "");
 380
 381                 if (!(ptimex->status & STA_PPSSIGNAL)
 382                     && ptimex->status & STA_PPSFREQ)
 383                     xsbprintf(&dbp, ebp, "%sPPS Frequency Sync wanted but no PPS",
 384                               (*des) ? "; " : "");
 385
 386                 if (!(ptimex->status & STA_PPSSIGNAL)
 387                     && ptimex->status & STA_PPSTIME)
 388                         xsbprintf(&dbp, ebp, "%sPPS Time Sync wanted but no PPS signal",
 389                                   (*des) ? "; " : "");
 390
 391                 if (   ptimex->status & STA_PPSTIME
 392                     && ptimex->status & STA_PPSJITTER)
 393                         xsbprintf(&dbp, ebp, "%sPPS Time Sync wanted but PPS Jitter exceeded",
 394                                   (*des) ? "; " : "");
 395
 396                 if (   ptimex->status & STA_PPSFREQ
 397                     && ptimex->status & STA_PPSWANDER)
 398                         xsbprintf(&dbp, ebp, "%sPPS Frequency Sync wanted but PPS Wander exceeded",
 399                                   (*des) ? "; " : "");
 400
 401                 if (   ptimex->status & STA_PPSFREQ
 402                     && ptimex->status & STA_PPSERROR)
 403                         xsbprintf(&dbp, ebp, "%sPPS Frequency Sync wanted but Calibration error detected",
 404                                   (*des) ? "; " : "");
 405
 406                 if (pps_call && !(ptimex->status & STA_PPSSIGNAL))
 407                         report_event(EVNT_KERN, NULL,
 408                             "no PPS signal");
 409                 DPRINTF(1, ("kernel loop status %#x (%s)\n",
 410                         ptimex->status, des));
 411                 /*
 412                  * This code may be returned when ntp_adjtime() has just
 413                  * been called for the first time, quite a while after
 414                  * startup, when ntpd just starts to discipline the kernel
 415                  * time. In this case the occurrence of this message
 416                  * can be pretty confusing.
 417                  *
 418                  * HMS: How about a message when we begin kernel processing:
 419                  *    Determining kernel clock state...
 420                  * so an initial TIME_ERROR message is less confising,
 421                  * or skipping the first message (ugh),
 422                  * or ???
 423                  * msyslog(LOG_INFO, "kernel reports time synchronization lost");
 424                  */
 425                 msyslog(LOG_INFO, "kernel reports TIME_ERROR: %#x: %s",
 426                         ptimex->status, des);
 427             break;
 428 #else
 429 # warning TIME_ERROR is not defined
 430 #endif
 431             default:
 432                 msyslog(LOG_NOTICE, "%s: %s line %d: unhandled return value %d from ntp_adjtime() in %s at line %d",
 433                     caller, file_name(), line,
 434                     ret,
 435                     __func__, __LINE__
 436                 );
 437             break;
 438         }
 439         return;
 440 }
 441 #endif
 442
 443 /*
 444  * local_clock - the NTP logical clock loop filter.
 445  *
 446  * Return codes:
 447  * -1   update ignored: exceeds panic threshold
 448  * 0    update ignored: popcorn or exceeds step threshold
 449  * 1    clock was slewed
 450  * 2    clock was stepped
 451  *
 452  * LOCKCLOCK: The only thing this routine does is set the
 453  * sys_rootdisp variable equal to the peer dispersion.
 454  */
 455 int
 456 local_clock(
 457         struct  peer *peer,     /* synch source peer structure */
 458         double  fp_offset       /* clock offset (s) */
 459         )
 460 {
 461         int     rval;           /* return code */
 462         int     osys_poll;      /* old system poll */
 463         int     ntp_adj_ret;    /* returned by ntp_adjtime */
 464         double  mu;             /* interval since last update */
 465         double  clock_frequency; /* clock frequency */
 466         double  dtemp, etemp;   /* double temps */
 467         char    tbuf[80];       /* report buffer */
 468
 469         (void)ntp_adj_ret; /* not always used below... */
 470         /*
 471          * If the loop is opened or the NIST LOCKCLOCK is in use,
 472          * monitor and record the offsets anyway in order to determine
 473          * the open-loop response and then go home.
 474          */
 475 #ifndef LOCKCLOCK
 476         if (!ntp_enable)
 477 #endif /* not LOCKCLOCK */
 478         {
 479                 record_loop_stats(fp_offset, drift_comp, clock_jitter,
 480                     clock_stability, sys_poll);
 481                 return (0);
 482         }
 483
 484 #ifndef LOCKCLOCK
 485         /*
 486          * If the clock is way off, panic is declared. The clock_panic
 487          * defaults to 1000 s; if set to zero, the panic will never
 488          * occur. The allow_panic defaults to FALSE, so the first panic
 489          * will exit. It can be set TRUE by a command line option, in
 490          * which case the clock will be set anyway and time marches on.
 491          * But, allow_panic will be set FALSE when the update is less
 492          * than the step threshold; so, subsequent panics will exit.
 493          */
 494         if (fabs(fp_offset) > clock_panic && clock_panic > 0 &&
 495             !allow_panic) {
 496                 snprintf(tbuf, sizeof(tbuf),
 497                     "%+.0f s; set clock manually within %.0f s.",
 498                     fp_offset, clock_panic);
 499                 report_event(EVNT_SYSFAULT, NULL, tbuf);
 500                 return (-1);
 501         }
 502
 503         allow_panic = FALSE;
 504
 505         /*
 506          * This section simulates ntpdate. If the offset exceeds the
 507          * step threshold (128 ms), step the clock to that time and
 508          * exit. Otherwise, slew the clock to that time and exit. Note
 509          * that the slew will persist and eventually complete beyond the
 510          * life of this program. Note that while ntpdate is active, the
 511          * terminal does not detach, so the termination message prints
 512          * directly to the terminal.
 513          */
 514         if (mode_ntpdate) {
 515                 if (  ( fp_offset > clock_max_fwd  && clock_max_fwd  > 0)
 516                    || (-fp_offset > clock_max_back && clock_max_back > 0)) {
 517                         step_systime(fp_offset);
 518                         msyslog(LOG_NOTICE, "ntpd: time set %+.6f s",
 519                             fp_offset);
 520                         printf("ntpd: time set %+.6fs\n", fp_offset);
 521                 } else {
 522                         adj_systime(fp_offset);
 523                         msyslog(LOG_NOTICE, "ntpd: time slew %+.6f s",
 524                             fp_offset);
 525                         printf("ntpd: time slew %+.6fs\n", fp_offset);
 526                 }
 527                 record_loop_stats(fp_offset, drift_comp, clock_jitter,
 528                     clock_stability, sys_poll);
 529                 exit (0);
 530         }
 531
 532         /*
 533          * The huff-n'-puff filter finds the lowest delay in the recent
 534          * interval. This is used to correct the offset by one-half the
 535          * difference between the sample delay and minimum delay. This
 536          * is most effective if the delays are highly assymetric and
 537          * clockhopping is avoided and the clock frequency wander is
 538          * relatively small.
 539          */
 540         if (sys_huffpuff != NULL) {
 541                 if (peer->delay < sys_huffpuff[sys_huffptr])
 542                         sys_huffpuff[sys_huffptr] = peer->delay;
 543                 if (peer->delay < sys_mindly)
 544                         sys_mindly = peer->delay;
 545                 if (fp_offset > 0)
 546                         dtemp = -(peer->delay - sys_mindly) / 2;
 547                 else
 548                         dtemp = (peer->delay - sys_mindly) / 2;
 549                 fp_offset += dtemp;
 550                 DPRINTF(1, ("local_clock: size %d mindly %.6f huffpuff %.6f\n",
 551                             sys_hufflen, sys_mindly, dtemp));
 552         }
 553
 554         /*
 555          * Clock state machine transition function which defines how the
 556          * system reacts to large phase and frequency excursion. There
 557          * are two main regimes: when the offset exceeds the step
 558          * threshold (128 ms) and when it does not. Under certain
 559          * conditions updates are suspended until the stepout theshold
 560          * (900 s) is exceeded. See the documentation on how these
 561          * thresholds interact with commands and command line options.
 562          *
 563          * Note the kernel is disabled if step is disabled or greater
 564          * than 0.5 s or in ntpdate mode.
 565          */
 566         osys_poll = sys_poll;
 567         if (sys_poll < peer->minpoll)
 568                 sys_poll = peer->minpoll;
 569         if (sys_poll > peer->maxpoll)
 570                 sys_poll = peer->maxpoll;
 571         mu = current_time - clock_epoch;
 572         clock_frequency = drift_comp;
 573         rval = 1;
 574         if (  ( fp_offset > clock_max_fwd  && clock_max_fwd  > 0)
 575            || (-fp_offset > clock_max_back && clock_max_back > 0)
 576            || force_step_once ) {
 577                 if (force_step_once) {
 578                         force_step_once = FALSE;  /* we want this only once after startup */
 579                         msyslog(LOG_NOTICE, "Doing intital time step" );
 580                 }
 581
 582                 switch (state) {
 583
 584                 /*
 585                  * In SYNC state we ignore the first outlier and switch
 586                  * to SPIK state.
 587                  */
 588                 case EVNT_SYNC:
 589                         snprintf(tbuf, sizeof(tbuf), "%+.6f s",
 590                             fp_offset);
 591                         report_event(EVNT_SPIK, NULL, tbuf);
 592                         state = EVNT_SPIK;
 593                         return (0);
 594
 595                 /*
 596                  * In FREQ state we ignore outliers and inlyers. At the
 597                  * first outlier after the stepout threshold, compute
 598                  * the apparent frequency correction and step the phase.
 599                  */
 600                 case EVNT_FREQ:
 601                         if (mu < clock_minstep)
 602                                 return (0);
 603
 604                         clock_frequency = direct_freq(fp_offset);
 605
 606                         /* fall through to EVNT_SPIK */
 607
 608                 /*
 609                  * In SPIK state we ignore succeeding outliers until
 610                  * either an inlyer is found or the stepout threshold is
 611                  * exceeded.
 612                  */
 613                 case EVNT_SPIK:
 614                         if (mu < clock_minstep)
 615                                 return (0);
 616
 617                         /* fall through to default */
 618
 619                 /*
 620                  * We get here by default in NSET and FSET states and
 621                  * from above in FREQ or SPIK states.
 622                  *
 623                  * In NSET state an initial frequency correction is not
 624                  * available, usually because the frequency file has not
 625                  * yet been written. Since the time is outside the step
 626                  * threshold, the clock is stepped. The frequency will
 627                  * be set directly following the stepout interval.
 628                  *
 629                  * In FSET state the initial frequency has been set from
 630                  * the frequency file. Since the time is outside the
 631                  * step threshold, the clock is stepped immediately,
 632                  * rather than after the stepout interval. Guys get
 633                  * nervous if it takes 15 minutes to set the clock for
 634                  * the first time.
 635                  *
 636                  * In FREQ and SPIK states the stepout threshold has
 637                  * expired and the phase is still above the step
 638                  * threshold. Note that a single spike greater than the
 639                  * step threshold is always suppressed, even with a
 640                  * long time constant.
 641                  */
 642                 default:
 643                         snprintf(tbuf, sizeof(tbuf), "%+.6f s",
 644                             fp_offset);
 645                         report_event(EVNT_CLOCKRESET, NULL, tbuf);
 646                         step_systime(fp_offset);
 647                         reinit_timer();
 648                         tc_counter = 0;
 649                         clock_jitter = LOGTOD(sys_precision);
 650                         rval = 2;
 651                         if (state == EVNT_NSET) {
 652                                 rstclock(EVNT_FREQ, 0);
 653                                 return (rval);
 654                         }
 655                         break;
 656                 }
 657                 rstclock(EVNT_SYNC, 0);
 658         } else {
 659                 /*
 660                  * The offset is less than the step threshold. Calculate
 661                  * the jitter as the exponentially weighted offset
 662                  * differences.
 663                  */
 664                 etemp = SQUARE(clock_jitter);
 665                 dtemp = SQUARE(max(fabs(fp_offset - last_offset),
 666                     LOGTOD(sys_precision)));
 667                 clock_jitter = SQRT(etemp + (dtemp - etemp) /
 668                     CLOCK_AVG);
 669                 switch (state) {
 670
 671                 /*
 672                  * In NSET state this is the first update received and
 673                  * the frequency has not been initialized. Adjust the
 674                  * phase, but do not adjust the frequency until after
 675                  * the stepout threshold.
 676                  */
 677                 case EVNT_NSET:
 678                         adj_systime(fp_offset);
 679                         rstclock(EVNT_FREQ, fp_offset);
 680                         break;
 681
 682                 /*
 683                  * In FREQ state ignore updates until the stepout
 684                  * threshold. After that, compute the new frequency, but
 685                  * do not adjust the frequency until the holdoff counter
 686                  * decrements to zero.
 687                  */
 688                 case EVNT_FREQ:
 689                         if (mu < clock_minstep)
 690                                 return (0);
 691
 692                         clock_frequency = direct_freq(fp_offset);
 693                         /* fall through */
 694
 695                 /*
 696                  * We get here by default in FSET, SPIK and SYNC states.
 697                  * Here compute the frequency update due to PLL and FLL
 698                  * contributions. Note, we avoid frequency discipline at
 699                  * startup until the initial transient has subsided.
 700                  */
 701                 default:
 702                         if (freq_cnt == 0) {
 703
 704                                 /*
 705                                  * The FLL and PLL frequency gain constants
 706                                  * depend on the time constant and Allan
 707                                  * intercept. The PLL is always used, but
 708                                  * becomes ineffective above the Allan intercept
 709                                  * where the FLL becomes effective.
 710                                  */
 711                                 if (sys_poll >= allan_xpt)
 712                                         clock_frequency +=
 713                                               (fp_offset - clock_offset)
 714                                             / ( max(ULOGTOD(sys_poll), mu)
 715                                                * CLOCK_FLL);
 716
 717                                 /*
 718                                  * The PLL frequency gain (numerator) depends on
 719                                  * the minimum of the update interval and Allan
 720                                  * intercept. This reduces the PLL gain when the
 721                                  * FLL becomes effective.
 722                                  */
 723                                 etemp = min(ULOGTOD(allan_xpt), mu);
 724                                 dtemp = 4 * CLOCK_PLL * ULOGTOD(sys_poll);
 725                                 clock_frequency +=
 726                                     fp_offset * etemp / (dtemp * dtemp);
 727                         }
 728                         rstclock(EVNT_SYNC, fp_offset);
 729                         if (fabs(fp_offset) < CLOCK_FLOOR)
 730                                 freq_cnt = 0;
 731                         break;
 732                 }
 733         }
 734
 735 #ifdef KERNEL_PLL
 736         /*
 737          * This code segment works when clock adjustments are made using
 738          * precision time kernel support and the ntp_adjtime() system
 739          * call. This support is available in Solaris 2.6 and later,
 740          * Digital Unix 4.0 and later, FreeBSD, Linux and specially
 741          * modified kernels for HP-UX 9 and Ultrix 4. In the case of the
 742          * DECstation 5000/240 and Alpha AXP, additional kernel
 743          * modifications provide a true microsecond clock and nanosecond
 744          * clock, respectively.
 745          *
 746          * Important note: The kernel discipline is used only if the
 747          * step threshold is less than 0.5 s, as anything higher can
 748          * lead to overflow problems. This might occur if some misguided
 749          * lad set the step threshold to something ridiculous.
 750          */
 751         if (pll_control && kern_enable && freq_cnt == 0) {
 752
 753                 /*
 754                  * We initialize the structure for the ntp_adjtime()
 755                  * system call. We have to convert everything to
 756                  * microseconds or nanoseconds first. Do not update the
 757                  * system variables if the ext_enable flag is set. In
 758                  * this case, the external clock driver will update the
 759                  * variables, which will be read later by the local
 760                  * clock driver. Afterwards, remember the time and
 761                  * frequency offsets for jitter and stability values and
 762                  * to update the frequency file.
 763                  */
 764                 ZERO(ntv);
 765                 if (ext_enable) {
 766                         ntv.modes = MOD_STATUS;
 767                 } else {
 768                         ntv.modes = MOD_BITS;
 769                         ntv.offset = var_long_from_dbl(
 770                             clock_offset, &ntv.modes);
 771 #ifdef STA_NANO
 772                         ntv.constant = sys_poll;
 773 #else /* STA_NANO */
 774                         ntv.constant = sys_poll - 4;
 775 #endif /* STA_NANO */
 776                         if (ntv.constant < 0)
 777                                 ntv.constant = 0;
 778
 779                         ntv.esterror = usec_long_from_dbl(
 780                                 clock_jitter);
 781                         ntv.maxerror = usec_long_from_dbl(
 782                                 sys_rootdelay / 2 + sys_rootdisp);
 783                         ntv.status = STA_PLL;
 784
 785                         /*
 786                          * Enable/disable the PPS if requested.
 787                          */
 788                         if (hardpps_enable) {
 789                                 ntv.status |= (STA_PPSTIME | STA_PPSFREQ);
 790                                 if (!(pll_status & STA_PPSTIME))
 791                                         sync_status("PPS enabled",
 792                                                 pll_status,
 793                                                 ntv.status);
 794                         } else {
 795                                 ntv.status &= ~(STA_PPSTIME | STA_PPSFREQ);
 796                                 if (pll_status & STA_PPSTIME)
 797                                         sync_status("PPS disabled",
 798                                                 pll_status,
 799                                                 ntv.status);
 800                         }
 801                         if (sys_leap == LEAP_ADDSECOND)
 802                                 ntv.status |= STA_INS;
 803                         else if (sys_leap == LEAP_DELSECOND)
 804                                 ntv.status |= STA_DEL;
 805                 }
 806
 807                 /*
 808                  * Pass the stuff to the kernel. If it squeals, turn off
 809                  * the pps. In any case, fetch the kernel offset,
 810                  * frequency and jitter.
 811                  */
 812                 ntp_adj_ret = ntp_adjtime(&ntv);
 813                 /*
 814                  * A squeal is a return status < 0, or a state change.
 815                  */
 816                 if ((0 > ntp_adj_ret) || (ntp_adj_ret != kernel_status)) {
 817                         kernel_status = ntp_adj_ret;
 818                         ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, hardpps_enable, 0, __LINE__ - 1);
 819                 }
 820                 pll_status = ntv.status;
 821                 clock_offset = dbl_from_var_long(ntv.offset, ntv.status);
 822                 clock_frequency = FREQTOD(ntv.freq);
 823
 824                 /*
 825                  * If the kernel PPS is lit, monitor its performance.
 826                  */
 827                 if (ntv.status & STA_PPSTIME) {
 828                         clock_jitter = dbl_from_var_long(
 829                                 ntv.jitter, ntv.status);
 830                 }
 831
 832 #if defined(STA_NANO) && NTP_API == 4
 833                 /*
 834                  * If the TAI changes, update the kernel TAI.
 835                  */
 836                 if (loop_tai != sys_tai) {
 837                         loop_tai = sys_tai;
 838                         ntv.modes = MOD_TAI;
 839                         ntv.constant = sys_tai;
 840                         if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
 841                             ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 1, __LINE__ - 1);
 842                         }
 843                 }
 844 #endif /* STA_NANO */
 845         }
 846 #endif /* KERNEL_PLL */
 847
 848         /*
 849          * Clamp the frequency within the tolerance range and calculate
 850          * the frequency difference since the last update.
 851          */
 852         if (fabs(clock_frequency) > NTP_MAXFREQ)
 853                 msyslog(LOG_NOTICE,
 854                     "frequency error %.0f PPM exceeds tolerance %.0f PPM",
 855                     clock_frequency * 1e6, NTP_MAXFREQ * 1e6);
 856         dtemp = SQUARE(clock_frequency - drift_comp);
 857         if (clock_frequency > NTP_MAXFREQ)
 858                 drift_comp = NTP_MAXFREQ;
 859         else if (clock_frequency < -NTP_MAXFREQ)
 860                 drift_comp = -NTP_MAXFREQ;
 861         else
 862                 drift_comp = clock_frequency;
 863
 864         /*
 865          * Calculate the wander as the exponentially weighted RMS
 866          * frequency differences. Record the change for the frequency
 867          * file update.
 868          */
 869         etemp = SQUARE(clock_stability);
 870         clock_stability = SQRT(etemp + (dtemp - etemp) / CLOCK_AVG);
 871
 872         /*
 873          * Here we adjust the time constant by comparing the current
 874          * offset with the clock jitter. If the offset is less than the
 875          * clock jitter times a constant, then the averaging interval is
 876          * increased, otherwise it is decreased. A bit of hysteresis
 877          * helps calm the dance. Works best using burst mode. Don't
 878          * fiddle with the poll during the startup clamp period.
 879          * [Bug 3615] also observe time gates to avoid eager stepping
 880          */
 881         if (freq_cnt > 0) {
 882                 tc_counter = 0;
 883                 tc_twinlo  = current_time;
 884                 tc_twinhi  = current_time;
 885         } else if (fabs(clock_offset) < CLOCK_PGATE * clock_jitter) {
 886                 tc_counter += sys_poll;
 887                 if (tc_counter > CLOCK_LIMIT) {
 888                         tc_counter = CLOCK_LIMIT;
 889                         if (sys_poll < peer->maxpoll)
 890                                 sys_poll += (current_time >= tc_twinhi);
 891                 }
 892         } else {
 893                 tc_counter -= sys_poll << 1;
 894                 if (tc_counter < -CLOCK_LIMIT) {
 895                         tc_counter = -CLOCK_LIMIT;
 896                         if (sys_poll > peer->minpoll)
 897                                 sys_poll -= (current_time >= tc_twinlo);
 898                 }
 899         }
 900
 901         /*
 902          * If the time constant has changed, update the poll variables.
 903          *
 904          * [bug 3615] also set new time gates
 905          * The time limit for stepping down will be half the TC interval
 906          * or 60 secs from now, whatever is bigger, and the step up time
 907          * limit will be half the TC interval after the step down limit.
 908          *
 909          * The 'sys_poll' value affects the servo loop gain, and
 910          * overshooting sys_poll slows it down unnecessarily.  Stepping
 911          * down too fast also has bad effects.
 912          *
 913          * The 'tc_counter' dance itself is something that *should*
 914          * happen *once* every (1 << sys_poll) seconds, I think, but
 915          * that's not how it works right now, and adding time guards
 916          * seems the least intrusive way to handle this.
 917          */
 918         if (osys_poll != sys_poll) {
 919                 u_int deadband = 1u << (sys_poll - 1);
 920                 tc_counter = 0;
 921                 tc_twinlo  = current_time + max(deadband, 60);
 922                 tc_twinhi  = tc_twinlo + deadband;
 923                 poll_update(peer, sys_poll, 0);
 924         }
 925
 926         /*
 927          * Yibbidy, yibbbidy, yibbidy; that'h all folks.
 928          */
 929         record_loop_stats(clock_offset, drift_comp, clock_jitter,
 930             clock_stability, sys_poll);
 931         DPRINTF(1, ("local_clock: offset %.9f jit %.9f freq %.3f stab %.3f poll %d\n",
 932                     clock_offset, clock_jitter, drift_comp * 1e6,
 933                     clock_stability * 1e6, sys_poll));
 934         return (rval);
 935 #endif /* not LOCKCLOCK */
 936 }
 937
 938
 939 /*
 940  * adj_host_clock - Called once every second to update the local clock.
 941  *
 942  * LOCKCLOCK: The only thing this routine does is increment the
 943  * sys_rootdisp variable.
 944  */
 945 void
 946 adj_host_clock(
 947         void
 948         )
 949 {
 950         double  offset_adj;
 951         double  freq_adj;
 952
 953         /*
 954          * Update the dispersion since the last update. In contrast to
 955          * NTPv3, NTPv4 does not declare unsynchronized after one day,
 956          * since the dispersion check serves this function. Also,
 957          * since the poll interval can exceed one day, the old test
 958          * would be counterproductive. During the startup clamp period, the
 959          * time constant is clamped at 2.
 960          */
 961         sys_rootdisp += clock_phi;
 962 #ifndef LOCKCLOCK
 963         if (!ntp_enable || mode_ntpdate)
 964                 return;
 965         /*
 966          * Determine the phase adjustment. The gain factor (denominator)
 967          * increases with poll interval, so is dominated by the FLL
 968          * above the Allan intercept. Note the reduced time constant at
 969          * startup.
 970          */
 971         if (state != EVNT_SYNC) {
 972                 offset_adj = 0.;
 973         } else if (freq_cnt > 0) {
 974                 offset_adj = clock_offset / (CLOCK_PLL * ULOGTOD(1));
 975                 freq_cnt--;
 976 #ifdef KERNEL_PLL
 977         } else if (pll_control && kern_enable) {
 978                 offset_adj = 0.;
 979 #endif /* KERNEL_PLL */
 980         } else {
 981                 offset_adj = clock_offset / (CLOCK_PLL * ULOGTOD(sys_poll));
 982         }
 983
 984         /*
 985          * If the kernel discipline is enabled the frequency correction
 986          * drift_comp has already been engaged via ntp_adjtime() in
 987          * set_freq().  Otherwise it is a component of the adj_systime()
 988          * offset.
 989          */
 990 #ifdef KERNEL_PLL
 991         if (pll_control && kern_enable)
 992                 freq_adj = 0.;
 993         else
 994 #endif /* KERNEL_PLL */
 995                 freq_adj = drift_comp;
 996
 997         /* Bound absolute value of total adjustment to NTP_MAXFREQ. */
 998         if (offset_adj + freq_adj > NTP_MAXFREQ)
 999                 offset_adj = NTP_MAXFREQ - freq_adj;
1000         else if (offset_adj + freq_adj < -NTP_MAXFREQ)
1001                 offset_adj = -NTP_MAXFREQ - freq_adj;
1002
1003         clock_offset -= offset_adj;
1004         /*
1005          * Windows port adj_systime() must be called each second,
1006          * even if the argument is zero, to ease emulation of
1007          * adjtime() using Windows' slew API which controls the rate
1008          * but does not automatically stop slewing when an offset
1009          * has decayed to zero.
1010          */
1011         DEBUG_INSIST(enable_panic_check == TRUE);
1012         enable_panic_check = FALSE;
1013         adj_systime(offset_adj + freq_adj);
1014         enable_panic_check = TRUE;
1015 #endif /* LOCKCLOCK */
1016 }
1017
1018
1019 /*
1020  * Clock state machine. Enter new state and set state variables.
1021  */
1022 static void
1023 rstclock(
1024         int     trans,          /* new state */
1025         double  offset          /* new offset */
1026         )
1027 {
1028         DPRINTF(2, ("rstclock: mu %lu state %d poll %d count %d\n",
1029                     current_time - clock_epoch, trans, sys_poll,
1030                     tc_counter));
1031         if (trans != state && trans != EVNT_FSET)
1032                 report_event(trans, NULL, NULL);
1033         state = trans;
1034         last_offset = clock_offset = offset;
1035         clock_epoch = current_time;
1036 }
1037
1038
1039 /*
1040  * calc_freq - calculate frequency directly
1041  *
1042  * This is very carefully done. When the offset is first computed at the
1043  * first update, a residual frequency component results. Subsequently,
1044  * updates are suppresed until the end of the measurement interval while
1045  * the offset is amortized. At the end of the interval the frequency is
1046  * calculated from the current offset, residual offset, length of the
1047  * interval and residual frequency component. At the same time the
1048  * frequenchy file is armed for update at the next hourly stats.
1049  */
1050 static double
1051 direct_freq(
1052         double  fp_offset
1053         )
1054 {
1055         set_freq(fp_offset / (current_time - clock_epoch));
1056
1057         return drift_comp;
1058 }
1059
1060
1061 /*
1062  * set_freq - set clock frequency correction
1063  *
1064  * Used to step the frequency correction at startup, possibly again once
1065  * the frequency is measured (that is, transitioning from EVNT_NSET to
1066  * EVNT_FSET), and finally to switch between daemon and kernel loop
1067  * discipline at runtime.
1068  *
1069  * When the kernel loop discipline is available but the daemon loop is
1070  * in use, the kernel frequency correction is disabled (set to 0) to
1071  * ensure drift_comp is applied by only one of the loops.
1072  */
1073 static void
1074 set_freq(
1075         double  freq            /* frequency update */
1076         )
1077 {
1078         const char *    loop_desc;
1079         int ntp_adj_ret;
1080
1081         (void)ntp_adj_ret; /* not always used below... */
1082         drift_comp = freq;
1083         loop_desc = "ntpd";
1084 #ifdef KERNEL_PLL
1085         if (pll_control) {
1086                 ZERO(ntv);
1087                 ntv.modes = MOD_FREQUENCY;
1088                 if (kern_enable) {
1089                         loop_desc = "kernel";
1090                         ntv.freq = DTOFREQ(drift_comp);
1091                 }
1092                 if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
1093                     ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 0, __LINE__ - 1);
1094                 }
1095         }
1096 #endif /* KERNEL_PLL */
1097         mprintf_event(EVNT_FSET, NULL, "%s %.3f PPM", loop_desc,
1098             drift_comp * 1e6);
1099 }
1100
1101
1102 #ifdef KERNEL_PLL
1103 static void
1104 start_kern_loop(void)
1105 {
1106         static int atexit_done;
1107         int ntp_adj_ret;
1108
1109         pll_control = TRUE;
1110         ZERO(ntv);
1111         ntv.modes = MOD_BITS;
1112         ntv.status = STA_PLL | STA_UNSYNC;
1113         ntv.maxerror = MAXDISPERSE * 1.0e6;
1114         ntv.esterror = MAXDISPERSE * 1.0e6;
1115         ntv.constant = sys_poll;
1116         /*             ^^^^^^^^ why is it that here constant is
1117          * unconditionally set to sys_poll, whereas elsewhere is is
1118          * modified depending on nanosecond vs. microsecond kernel?
1119          */
1120 #ifdef SIGSYS
1121         /*
1122          * Use sigsetjmp() to save state and then call ntp_adjtime(); if
1123          * it fails, then pll_trap() will set pll_control FALSE before
1124          * returning control using siglogjmp().
1125          */
1126         newsigsys.sa_handler = pll_trap;
1127         newsigsys.sa_flags = 0;
1128         if (sigaction(SIGSYS, &newsigsys, &sigsys)) {
1129                 msyslog(LOG_ERR, "sigaction() trap SIGSYS: %m");
1130                 pll_control = FALSE;
1131         } else {
1132                 if (sigsetjmp(env, 1) == 0) {
1133                         if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
1134                             ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 0, __LINE__ - 1);
1135                         }
1136                 }
1137                 if (sigaction(SIGSYS, &sigsys, NULL)) {
1138                         msyslog(LOG_ERR,
1139                             "sigaction() restore SIGSYS: %m");
1140                         pll_control = FALSE;
1141                 }
1142         }
1143 #else /* SIGSYS */
1144         if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
1145             ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 0, __LINE__ - 1);
1146         }
1147 #endif /* SIGSYS */
1148
1149         /*
1150          * Save the result status and light up an external clock
1151          * if available.
1152          */
1153         pll_status = ntv.status;
1154         if (pll_control) {
1155                 if (!atexit_done) {
1156                         atexit_done = TRUE;
1157                         atexit(&stop_kern_loop);
1158                 }
1159 #ifdef STA_NANO
1160                 if (pll_status & STA_CLK)
1161                         ext_enable = TRUE;
1162 #endif /* STA_NANO */
1163                 report_event(EVNT_KERN, NULL,
1164                     "kernel time sync enabled");
1165         }
1166 }
1167 #endif  /* KERNEL_PLL */
1168
1169
1170 #ifdef KERNEL_PLL
1171 static void
1172 stop_kern_loop(void)
1173 {
1174         if (pll_control && kern_enable)
1175                 report_event(EVNT_KERN, NULL,
1176                     "kernel time sync disabled");
1177 }
1178 #endif  /* KERNEL_PLL */
1179
1180
1181 /*
1182  * select_loop() - choose kernel or daemon loop discipline.
1183  */
1184 void
1185 select_loop(
1186         int     use_kern_loop
1187         )
1188 {
1189         if (kern_enable == use_kern_loop)
1190                 return;
1191 #ifdef KERNEL_PLL
1192         if (pll_control && !use_kern_loop)
1193                 stop_kern_loop();
1194 #endif
1195         kern_enable = use_kern_loop;
1196 #ifdef KERNEL_PLL
1197         if (pll_control && use_kern_loop)
1198                 start_kern_loop();
1199 #endif
1200         /*
1201          * If this loop selection change occurs after initial startup,
1202          * call set_freq() to switch the frequency compensation to or
1203          * from the kernel loop.
1204          */
1205 #ifdef KERNEL_PLL
1206         if (pll_control && loop_started)
1207                 set_freq(drift_comp);
1208 #endif
1209 }
1210
1211
1212 /*
1213  * huff-n'-puff filter
1214  */
1215 void
1216 huffpuff(void)
1217 {
1218         int i;
1219
1220         if (sys_huffpuff == NULL)
1221                 return;
1222
1223         sys_huffptr = (sys_huffptr + 1) % sys_hufflen;
1224         sys_huffpuff[sys_huffptr] = 1e9;
1225         sys_mindly = 1e9;
1226         for (i = 0; i < sys_hufflen; i++) {
1227                 if (sys_huffpuff[i] < sys_mindly)
1228                         sys_mindly = sys_huffpuff[i];
1229         }
1230 }
1231
1232
1233 /*
1234  * loop_config - configure the loop filter
1235  *
1236  * LOCKCLOCK: The LOOP_DRIFTINIT and LOOP_DRIFTCOMP cases are no-ops.
1237  */
1238 void
1239 loop_config(
1240         int     item,
1241         double  freq
1242         )
1243 {
1244         int     i;
1245         double  ftemp;
1246
1247         DPRINTF(2, ("loop_config: item %d freq %f\n", item, freq));
1248         switch (item) {
1249
1250         /*
1251          * We first assume the kernel supports the ntp_adjtime()
1252          * syscall. If that syscall works, initialize the kernel time
1253          * variables. Otherwise, continue leaving no harm behind.
1254          */
1255         case LOOP_DRIFTINIT:
1256 #ifndef LOCKCLOCK
1257 #ifdef KERNEL_PLL
1258                 if (mode_ntpdate)
1259                         break;
1260
1261                 start_kern_loop();
1262 #endif /* KERNEL_PLL */
1263
1264                 /*
1265                  * Initialize frequency if given; otherwise, begin frequency
1266                  * calibration phase.
1267                  */
1268                 ftemp = init_drift_comp / 1e6;
1269                 if (ftemp > NTP_MAXFREQ)
1270                         ftemp = NTP_MAXFREQ;
1271                 else if (ftemp < -NTP_MAXFREQ)
1272                         ftemp = -NTP_MAXFREQ;
1273                 set_freq(ftemp);
1274                 if (freq_set)
1275                         rstclock(EVNT_FSET, 0);
1276                 else
1277                         rstclock(EVNT_NSET, 0);
1278                 loop_started = TRUE;
1279 #endif /* LOCKCLOCK */
1280                 break;
1281
1282         case LOOP_KERN_CLEAR:
1283 #if 0           /* XXX: needs more review, and how can we get here? */
1284 #ifndef LOCKCLOCK
1285 # ifdef KERNEL_PLL
1286                 if (pll_control && kern_enable) {
1287                         memset((char *)&ntv, 0, sizeof(ntv));
1288                         ntv.modes = MOD_STATUS;
1289                         ntv.status = STA_UNSYNC;
1290                         ntp_adjtime(&ntv);
1291                         sync_status("kernel time sync disabled",
1292                                 pll_status,
1293                                 ntv.status);
1294                    }
1295 # endif /* KERNEL_PLL */
1296 #endif /* LOCKCLOCK */
1297 #endif
1298                 break;
1299
1300         /*
1301          * Tinker command variables for Ulrich Windl. Very dangerous.
1302          */
1303         case LOOP_ALLAN:        /* Allan intercept (log2) (allan) */
1304                 allan_xpt = (u_char)freq;
1305                 break;
1306
1307         case LOOP_CODEC:        /* audio codec frequency (codec) */
1308                 clock_codec = freq / 1e6;
1309                 break;
1310
1311         case LOOP_PHI:          /* dispersion threshold (dispersion) */
1312                 clock_phi = freq / 1e6;
1313                 break;
1314
1315         case LOOP_FREQ:         /* initial frequency (freq) */
1316                 init_drift_comp = freq;
1317                 freq_set++;
1318                 break;
1319
1320         case LOOP_HUFFPUFF:     /* huff-n'-puff length (huffpuff) */
1321                 if (freq < HUFFPUFF)
1322                         freq = HUFFPUFF;
1323                 sys_hufflen = (int)(freq / HUFFPUFF);
1324                 sys_huffpuff = eallocarray(sys_hufflen, sizeof(sys_huffpuff[0]));
1325                 for (i = 0; i < sys_hufflen; i++)
1326                         sys_huffpuff[i] = 1e9;
1327                 sys_mindly = 1e9;
1328                 break;
1329
1330         case LOOP_PANIC:        /* panic threshold (panic) */
1331                 clock_panic = freq;
1332                 break;
1333
1334         case LOOP_MAX:          /* step threshold (step) */
1335                 clock_max_fwd = clock_max_back = freq;
1336                 if (freq == 0 || freq > 0.5)
1337                         select_loop(FALSE);
1338                 break;
1339
1340         case LOOP_MAX_BACK:     /* step threshold (step) */
1341                 clock_max_back = freq;
1342                 /*
1343                  * Leave using the kernel discipline code unless both
1344                  * limits are massive.  This assumes the reason to stop
1345                  * using it is that it's pointless, not that it goes wrong.
1346                  */
1347                 if (  (clock_max_back == 0 || clock_max_back > 0.5)
1348                    || (clock_max_fwd  == 0 || clock_max_fwd  > 0.5))
1349                         select_loop(FALSE);
1350                 break;
1351
1352         case LOOP_MAX_FWD:      /* step threshold (step) */
1353                 clock_max_fwd = freq;
1354                 if (  (clock_max_back == 0 || clock_max_back > 0.5)
1355                    || (clock_max_fwd  == 0 || clock_max_fwd  > 0.5))
1356                         select_loop(FALSE);
1357                 break;
1358
1359         case LOOP_MINSTEP:      /* stepout threshold (stepout) */
1360                 if (freq < CLOCK_MINSTEP)
1361                         clock_minstep = CLOCK_MINSTEP;
1362                 else
1363                         clock_minstep = freq;
1364                 break;
1365
1366         case LOOP_TICK:         /* tick increment (tick) */
1367                 set_sys_tick_precision(freq);
1368                 break;
1369
1370         case LOOP_LEAP:         /* not used, fall through */
1371         default:
1372                 msyslog(LOG_NOTICE,
1373                     "loop_config: unsupported option %d", item);
1374         }
1375 }
1376
1377
1378 #if defined(KERNEL_PLL) && defined(SIGSYS)
1379 /*
1380  * _trap - trap processor for undefined syscalls
1381  *
1382  * This nugget is called by the kernel when the SYS_ntp_adjtime()
1383  * syscall bombs because the silly thing has not been implemented in
1384  * the kernel. In this case the phase-lock loop is emulated by
1385  * the stock adjtime() syscall and a lot of indelicate abuse.
1386  */
1387 static RETSIGTYPE
1388 pll_trap(
1389         int arg
1390         )
1391 {
1392         pll_control = FALSE;
1393         siglongjmp(env, 1);
1394 }
1395 #endif /* KERNEL_PLL && SIGSYS */