#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef USE_SNPRINTB
# include <util.h>
#endif
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_unixtime.h"
#include "ntp_stdlib.h"
#include <limits.h>
#include <stdio.h>
#include <ctype.h>
#include <signal.h>
#include <setjmp.h>
#ifdef KERNEL_PLL
#include "ntp_syscall.h"
#endif
#include <os/trace.h>
#define CLOCK_MAX .128
#define CLOCK_MINSTEP 300.
#define CLOCK_PANIC 1000.
#define CLOCK_PHI 15e-6
#define CLOCK_PLL 16.
#define CLOCK_AVG 8.
#define CLOCK_FLL .25
#define CLOCK_FLOOR .0005
#define CLOCK_ALLAN 11
#define CLOCK_LIMIT 30
#define CLOCK_PGATE 4.
#define PPS_MAXAGE 120
#define FREQTOD(x) ((x) / 65536e6)
#define DTOFREQ(x) ((int32)((x) * 65536e6))
double clock_max_back = CLOCK_MAX;
double clock_max_fwd = CLOCK_MAX;
double clock_minstep = CLOCK_MINSTEP;
double clock_panic = CLOCK_PANIC;
double clock_phi = CLOCK_PHI;
u_char allan_xpt = CLOCK_ALLAN;
static double clock_offset;
double clock_jitter;
double drift_comp;
static double init_drift_comp;
double clock_stability;
double clock_codec;
static u_long clock_epoch;
u_int sys_tai;
static int loop_started;
static void rstclock (int, double);
static double direct_freq(double);
static void set_freq(double);
#ifndef PATH_MAX
# define PATH_MAX MAX_PATH
#endif
static char relative_path[PATH_MAX + 1];
static char *this_file = NULL;
#ifdef KERNEL_PLL
static struct timex ntv;
int pll_status;
#if defined(STA_NANO) && NTP_API == 4
static u_int loop_tai;
#endif
static void start_kern_loop(void);
static void stop_kern_loop(void);
#endif
int ntp_enable = TRUE;
int pll_control;
int kern_enable = TRUE;
int hardpps_enable;
int ext_enable;
int pps_stratum;
int kernel_status;
int force_step_once = FALSE;
int mode_ntpdate = FALSE;
int freq_cnt;
int freq_set;
int state = 0;
u_char sys_poll;
int tc_counter;
double last_offset;
static double *sys_huffpuff;
static int sys_hufflen;
static int sys_huffptr;
static double sys_mindly;
#if defined(KERNEL_PLL)
#define MOD_BITS (MOD_OFFSET | MOD_MAXERROR | MOD_ESTERROR | \
MOD_STATUS | MOD_TIMECONST)
#ifdef SIGSYS
static void pll_trap (int);
static struct sigaction sigsys;
static struct sigaction newsigsys;
static sigjmp_buf env;
#endif
#endif
static void
sync_status(const char *what, int ostatus, int nstatus)
{
char obuf[256], nbuf[256], tbuf[1024];
#if defined(USE_SNPRINTB) && defined (STA_FMT)
snprintb(obuf, sizeof(obuf), STA_FMT, ostatus);
snprintb(nbuf, sizeof(nbuf), STA_FMT, nstatus);
#else
snprintf(obuf, sizeof(obuf), "%04x", ostatus);
snprintf(nbuf, sizeof(nbuf), "%04x", nstatus);
#endif
snprintf(tbuf, sizeof(tbuf), "%s status: %s -> %s", what, obuf, nbuf);
report_event(EVNT_KERN, NULL, tbuf);
}
static char *file_name(void)
{
if (this_file == NULL) {
(void)strncpy(relative_path, __FILE__, PATH_MAX);
for (this_file=relative_path;
*this_file && ! isalnum((unsigned char)*this_file);
this_file++) ;
}
return this_file;
}
void
init_loopfilter(void)
{
sys_poll = ntp_minpoll;
clock_jitter = LOGTOD(sys_precision);
freq_cnt = (int)clock_minstep;
}
#ifdef KERNEL_PLL
static void
ntp_adjtime_error_handler(
const char *caller,
struct timex *ptimex,
int ret,
int saved_errno,
int pps_call,
int tai_call,
int line
)
{
char des[1024] = "";
switch (ret) {
case -1:
switch (saved_errno) {
case EFAULT:
msyslog(LOG_ERR, "%s: %s line %d: invalid struct timex pointer: 0x%lx",
caller, file_name(), line,
(long)((void *)ptimex)
);
break;
case EINVAL:
msyslog(LOG_ERR, "%s: %s line %d: invalid struct timex \"constant\" element value: %ld",
caller, file_name(), line,
(long)(ptimex->constant)
);
break;
case EPERM:
if (tai_call) {
errno = saved_errno;
msyslog(LOG_ERR,
"%s: ntp_adjtime(TAI) failed: %m",
caller);
}
errno = saved_errno;
msyslog(LOG_ERR, "%s: %s line %d: ntp_adjtime: %m",
caller, file_name(), line
);
break;
default:
msyslog(LOG_NOTICE, "%s: %s line %d: unhandled errno value %d after failed ntp_adjtime call",
caller, file_name(), line,
saved_errno
);
break;
}
break;
#ifdef TIME_OK
case TIME_OK:
break;
#else
# warning TIME_OK is not defined
#endif
#ifdef TIME_INS
case TIME_INS:
msyslog(LOG_INFO, "kernel reports leap second insertion scheduled");
break;
#else
# warning TIME_INS is not defined
#endif
#ifdef TIME_DEL
case TIME_DEL:
msyslog(LOG_INFO, "kernel reports leap second deletion scheduled");
break;
#else
# warning TIME_DEL is not defined
#endif
#ifdef TIME_OOP
case TIME_OOP:
msyslog(LOG_INFO, "kernel reports leap second in progress");
break;
#else
# warning TIME_OOP is not defined
#endif
#ifdef TIME_WAIT
case TIME_WAIT:
msyslog(LOG_INFO, "kernel reports leap second has occurred");
break;
#else
# warning TIME_WAIT is not defined
#endif
#ifdef TIME_ERROR
#if 0
from the reference implementation of ntp_gettime():
if ((time_status & (STA_UNSYNC | STA_CLOCKERR))
|| (time_status & (STA_PPSFREQ | STA_PPSTIME)
&& !(time_status & STA_PPSSIGNAL))
|| (time_status & STA_PPSTIME &&
time_status & STA_PPSJITTER)
|| (time_status & STA_PPSFREQ &&
time_status & (STA_PPSWANDER | STA_PPSERROR)))
return (TIME_ERROR);
or, from ntp_adjtime():
if ( (time_status & (STA_UNSYNC | STA_CLOCKERR))
|| (time_status & (STA_PPSFREQ | STA_PPSTIME)
&& !(time_status & STA_PPSSIGNAL))
|| (time_status & STA_PPSTIME
&& time_status & STA_PPSJITTER)
|| (time_status & STA_PPSFREQ
&& time_status & (STA_PPSWANDER | STA_PPSERROR))
)
return (TIME_ERROR);
#endif
case TIME_ERROR:
if (ptimex->status & STA_UNSYNC)
snprintf(des, sizeof(des), "%s%sClock Unsynchronized",
des, (*des) ? "; " : "");
if (ptimex->status & STA_CLOCKERR)
snprintf(des, sizeof(des), "%s%sClock Error",
des, (*des) ? "; " : "");
if (!(ptimex->status & STA_PPSSIGNAL)
&& ptimex->status & STA_PPSFREQ)
snprintf(des, sizeof(des), "%s%sPPS Frequency Sync wanted but no PPS",
des, (*des) ? "; " : "");
if (!(ptimex->status & STA_PPSSIGNAL)
&& ptimex->status & STA_PPSTIME)
snprintf(des, sizeof(des), "%s%sPPS Time Sync wanted but no PPS signal",
des, (*des) ? "; " : "");
if ( ptimex->status & STA_PPSTIME
&& ptimex->status & STA_PPSJITTER)
snprintf(des, sizeof(des), "%s%sPPS Time Sync wanted but PPS Jitter exceeded",
des, (*des) ? "; " : "");
if ( ptimex->status & STA_PPSFREQ
&& ptimex->status & STA_PPSWANDER)
snprintf(des, sizeof(des), "%s%sPPS Frequency Sync wanted but PPS Wander exceeded",
des, (*des) ? "; " : "");
if ( ptimex->status & STA_PPSFREQ
&& ptimex->status & STA_PPSERROR)
snprintf(des, sizeof(des), "%s%sPPS Frequency Sync wanted but Calibration error detected",
des, (*des) ? "; " : "");
if (pps_call && !(ptimex->status & STA_PPSSIGNAL))
report_event(EVNT_KERN, NULL,
"no PPS signal");
DPRINTF(1, ("kernel loop status %#x (%s)\n",
ptimex->status, des));
msyslog(LOG_INFO, "kernel reports TIME_ERROR: %#x: %s",
ptimex->status, des);
break;
#else
# warning TIME_ERROR is not defined
#endif
default:
msyslog(LOG_NOTICE, "%s: %s line %d: unhandled return value %d from ntp_adjtime() in %s at line %d",
caller, file_name(), line,
ret,
__func__, __LINE__
);
break;
}
return;
}
#endif
int
local_clock(
struct peer *peer,
double fp_offset
)
{
int rval;
int osys_poll;
int ntp_adj_ret;
double mu;
double clock_frequency;
double dtemp, etemp;
char tbuf[80];
(void)ntp_adj_ret;
#ifndef LOCKCLOCK
if (!ntp_enable)
#endif
{
record_loop_stats(fp_offset, drift_comp, clock_jitter,
clock_stability, sys_poll);
return (0);
}
#ifndef LOCKCLOCK
if (fabs(fp_offset) > clock_panic && clock_panic > 0 &&
!allow_panic) {
snprintf(tbuf, sizeof(tbuf),
"%+.0f s; set clock manually within %.0f s.",
fp_offset, clock_panic);
report_event(EVNT_SYSFAULT, NULL, tbuf);
return (-1);
}
allow_panic = FALSE;
if (mode_ntpdate) {
if ( ( fp_offset > clock_max_fwd && clock_max_fwd > 0)
|| (-fp_offset > clock_max_back && clock_max_back > 0)) {
step_systime(fp_offset);
msyslog(LOG_NOTICE, "ntpd: time set %+.6f s",
fp_offset);
printf("ntpd: time set %+.6fs\n", fp_offset);
} else {
adj_systime(fp_offset);
msyslog(LOG_NOTICE, "ntpd: time slew %+.6f s",
fp_offset);
printf("ntpd: time slew %+.6fs\n", fp_offset);
}
record_loop_stats(fp_offset, drift_comp, clock_jitter,
clock_stability, sys_poll);
exit (0);
}
if (sys_huffpuff != NULL) {
if (peer->delay < sys_huffpuff[sys_huffptr])
sys_huffpuff[sys_huffptr] = peer->delay;
if (peer->delay < sys_mindly)
sys_mindly = peer->delay;
if (fp_offset > 0)
dtemp = -(peer->delay - sys_mindly) / 2;
else
dtemp = (peer->delay - sys_mindly) / 2;
fp_offset += dtemp;
DPRINTF(1, ("local_clock: size %d mindly %.6f huffpuff %.6f\n",
sys_hufflen, sys_mindly, dtemp));
}
osys_poll = sys_poll;
if (sys_poll < peer->minpoll)
sys_poll = peer->minpoll;
if (sys_poll > peer->maxpoll)
sys_poll = peer->maxpoll;
mu = current_time - clock_epoch;
clock_frequency = drift_comp;
rval = 1;
if ( ( fp_offset > clock_max_fwd && clock_max_fwd > 0)
|| (-fp_offset > clock_max_back && clock_max_back > 0)
|| force_step_once ) {
if (force_step_once) {
force_step_once = FALSE;
msyslog(LOG_NOTICE, "Doing intital time step" );
}
switch (state) {
case EVNT_SYNC:
snprintf(tbuf, sizeof(tbuf), "%+.6f s",
fp_offset);
report_event(EVNT_SPIK, NULL, tbuf);
state = EVNT_SPIK;
msyslog(LOG_DEBUG, "SYNC state ignoring %+.6f s",
fp_offset);
return (0);
case EVNT_FREQ:
if (mu < clock_minstep) {
msyslog(LOG_DEBUG, "FREQ state ignoring %+.6f s",
fp_offset);
return (0);
}
clock_frequency = direct_freq(fp_offset);
case EVNT_SPIK:
if (mu < clock_minstep) {
msyslog(LOG_DEBUG, "SPIK state ignoring %+.6f s",
fp_offset);
return (0);
}
default:
snprintf(tbuf, sizeof(tbuf), "%+.6f s",
fp_offset);
report_event(EVNT_CLOCKRESET, NULL, tbuf);
step_systime(fp_offset);
msyslog(LOG_NOTICE, "time set %+.6f s", fp_offset);
reinit_timer();
tc_counter = 0;
clock_jitter = LOGTOD(sys_precision);
rval = 2;
if (state == EVNT_NSET) {
rstclock(EVNT_FREQ, 0);
return (rval);
}
break;
}
rstclock(EVNT_SYNC, 0);
} else {
etemp = SQUARE(clock_jitter);
dtemp = SQUARE(max(fabs(fp_offset - last_offset),
LOGTOD(sys_precision)));
clock_jitter = SQRT(etemp + (dtemp - etemp) /
CLOCK_AVG);
switch (state) {
case EVNT_NSET:
adj_systime(fp_offset);
rstclock(EVNT_FREQ, fp_offset);
break;
case EVNT_FREQ:
if (mu < clock_minstep) {
msyslog(LOG_DEBUG, "FREQ state ignoring %+.6f s",
fp_offset);
return (0);
}
clock_frequency = direct_freq(fp_offset);
default:
if (freq_cnt == 0) {
if (sys_poll >= allan_xpt)
clock_frequency +=
(fp_offset - clock_offset)
/ ( max(ULOGTOD(sys_poll), mu)
* CLOCK_FLL);
etemp = min(ULOGTOD(allan_xpt), mu);
dtemp = 4 * CLOCK_PLL * ULOGTOD(sys_poll);
clock_frequency +=
fp_offset * etemp / (dtemp * dtemp);
}
rstclock(EVNT_SYNC, fp_offset);
if (fabs(fp_offset) < CLOCK_FLOOR)
freq_cnt = 0;
break;
}
}
#ifdef KERNEL_PLL
if (pll_control && kern_enable && freq_cnt == 0) {
ZERO(ntv);
if (ext_enable) {
ntv.modes = MOD_STATUS;
} else {
#ifdef STA_NANO
ntv.modes = MOD_BITS | MOD_NANO;
#else
ntv.modes = MOD_BITS;
#endif
if (clock_offset < 0)
dtemp = -.5;
else
dtemp = .5;
#ifdef STA_NANO
ntv.offset = (int32)(clock_offset * 1e9 +
dtemp);
ntv.constant = sys_poll;
#else
ntv.offset = (int32)(clock_offset * 1e6 +
dtemp);
ntv.constant = sys_poll - 4;
#endif
if (ntv.constant < 0)
ntv.constant = 0;
ntv.esterror = (u_int32)(clock_jitter * 1e6);
ntv.maxerror = (u_int32)((sys_rootdelay / 2 +
sys_rootdisp) * 1e6);
ntv.status = STA_PLL;
if (hardpps_enable) {
ntv.status |= (STA_PPSTIME | STA_PPSFREQ);
if (!(pll_status & STA_PPSTIME))
sync_status("PPS enabled",
pll_status,
ntv.status);
} else {
ntv.status &= ~(STA_PPSTIME | STA_PPSFREQ);
if (pll_status & STA_PPSTIME)
sync_status("PPS disabled",
pll_status,
ntv.status);
}
if (sys_leap == LEAP_ADDSECOND)
ntv.status |= STA_INS;
else if (sys_leap == LEAP_DELSECOND)
ntv.status |= STA_DEL;
}
ntp_adj_ret = ntp_adjtime(&ntv);
if ((0 > ntp_adj_ret) || (ntp_adj_ret != kernel_status)) {
kernel_status = ntp_adj_ret;
ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, hardpps_enable, 0, __LINE__ - 1);
}
pll_status = ntv.status;
#ifdef STA_NANO
clock_offset = ntv.offset / 1e9;
#else
clock_offset = ntv.offset / 1e6;
#endif
clock_frequency = FREQTOD(ntv.freq);
if (ntv.status & STA_PPSTIME) {
#ifdef STA_NANO
clock_jitter = ntv.jitter / 1e9;
#else
clock_jitter = ntv.jitter / 1e6;
#endif
}
#if defined(STA_NANO) && NTP_API == 4
if (loop_tai != sys_tai) {
loop_tai = sys_tai;
ntv.modes = MOD_TAI;
ntv.constant = sys_tai;
if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 1, __LINE__ - 1);
}
}
#endif
}
#endif
if (fabs(clock_frequency) > NTP_MAXFREQ)
msyslog(LOG_NOTICE,
"frequency error %.0f PPM exceeds tolerance %.0f PPM",
clock_frequency * 1e6, NTP_MAXFREQ * 1e6);
dtemp = SQUARE(clock_frequency - drift_comp);
if (clock_frequency > NTP_MAXFREQ)
drift_comp = NTP_MAXFREQ;
else if (clock_frequency < -NTP_MAXFREQ)
drift_comp = -NTP_MAXFREQ;
else
drift_comp = clock_frequency;
etemp = SQUARE(clock_stability);
clock_stability = SQRT(etemp + (dtemp - etemp) / CLOCK_AVG);
if (freq_cnt > 0) {
tc_counter = 0;
} else if (fabs(clock_offset) < CLOCK_PGATE * clock_jitter) {
tc_counter += sys_poll;
if (tc_counter > CLOCK_LIMIT) {
tc_counter = CLOCK_LIMIT;
if (sys_poll < peer->maxpoll) {
tc_counter = 0;
sys_poll++;
}
}
} else {
tc_counter -= sys_poll << 1;
if (tc_counter < -CLOCK_LIMIT) {
tc_counter = -CLOCK_LIMIT;
if (sys_poll > peer->minpoll) {
tc_counter = 0;
sys_poll--;
}
}
}
if (osys_poll != sys_poll)
poll_update(peer, sys_poll);
record_loop_stats(clock_offset, drift_comp, clock_jitter,
clock_stability, sys_poll);
DPRINTF(1, ("local_clock: offset %.9f jit %.9f freq %.3f stab %.3f poll %d\n",
clock_offset, clock_jitter, drift_comp * 1e6,
clock_stability * 1e6, sys_poll));
return (rval);
#endif
}
void
adj_host_clock(
void
)
{
double offset_adj;
double freq_adj;
sys_rootdisp += clock_phi;
#ifndef LOCKCLOCK
if (!ntp_enable || mode_ntpdate)
return;
if (state != EVNT_SYNC) {
offset_adj = 0.;
} else if (freq_cnt > 0) {
offset_adj = clock_offset / (CLOCK_PLL * ULOGTOD(1));
freq_cnt--;
#ifdef KERNEL_PLL
} else if (pll_control && kern_enable) {
offset_adj = 0.;
#endif
} else {
offset_adj = clock_offset / (CLOCK_PLL * ULOGTOD(sys_poll));
}
#ifdef KERNEL_PLL
if (pll_control && kern_enable)
freq_adj = 0.;
else
#endif
freq_adj = drift_comp;
if (offset_adj + freq_adj > NTP_MAXFREQ)
offset_adj = NTP_MAXFREQ - freq_adj;
else if (offset_adj + freq_adj < -NTP_MAXFREQ)
offset_adj = -NTP_MAXFREQ - freq_adj;
clock_offset -= offset_adj;
DEBUG_INSIST(enable_panic_check == TRUE);
enable_panic_check = FALSE;
adj_systime(offset_adj + freq_adj);
enable_panic_check = TRUE;
#endif
}
static void
rstclock(
int trans,
double offset
)
{
DPRINTF(2, ("rstclock: mu %lu state %d poll %d count %d\n",
current_time - clock_epoch, trans, sys_poll,
tc_counter));
if (trans != state && trans != EVNT_FSET)
report_event(trans, NULL, NULL);
state = trans;
last_offset = clock_offset = offset;
clock_epoch = current_time;
}
static double
direct_freq(
double fp_offset
)
{
set_freq(fp_offset / (current_time - clock_epoch));
return drift_comp;
}
static void
set_freq(
double freq
)
{
const char * loop_desc;
int ntp_adj_ret;
if (freq != drift_comp) {
os_trace("drift PPM:%.3f -> %.3f", drift_comp * 1e6, freq * 1e6);
msyslog(LOG_NOTICE, "drift PPM:%.3f -> %.3f", drift_comp * 1e6, freq * 1e6);
}
(void)ntp_adj_ret;
drift_comp = freq;
loop_desc = "ntpd";
#ifdef KERNEL_PLL
if (pll_control) {
ZERO(ntv);
ntv.modes = MOD_FREQUENCY;
if (kern_enable) {
loop_desc = "kernel";
ntv.freq = DTOFREQ(drift_comp);
}
if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 0, __LINE__ - 1);
}
}
#endif
mprintf_event(EVNT_FSET, NULL, "%s %.3f PPM", loop_desc,
drift_comp * 1e6);
}
#ifdef KERNEL_PLL
static void
start_kern_loop(void)
{
static int atexit_done;
int ntp_adj_ret;
pll_control = TRUE;
ZERO(ntv);
ntv.modes = MOD_BITS;
ntv.status = STA_PLL;
ntv.maxerror = MAXDISPERSE;
ntv.esterror = MAXDISPERSE;
ntv.constant = sys_poll;
#ifdef SIGSYS
newsigsys.sa_handler = pll_trap;
newsigsys.sa_flags = 0;
if (sigaction(SIGSYS, &newsigsys, &sigsys)) {
msyslog(LOG_ERR, "sigaction() trap SIGSYS: %m");
pll_control = FALSE;
} else {
if (sigsetjmp(env, 1) == 0) {
if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 0, __LINE__ - 1);
}
}
if (sigaction(SIGSYS, &sigsys, NULL)) {
msyslog(LOG_ERR,
"sigaction() restore SIGSYS: %m");
pll_control = FALSE;
}
}
#else
if ((ntp_adj_ret = ntp_adjtime(&ntv)) != 0) {
ntp_adjtime_error_handler(__func__, &ntv, ntp_adj_ret, errno, 0, 0, __LINE__ - 1);
}
#endif
pll_status = ntv.status;
if (pll_control) {
if (!atexit_done) {
atexit_done = TRUE;
atexit(&stop_kern_loop);
}
#ifdef STA_NANO
if (pll_status & STA_CLK)
ext_enable = TRUE;
#endif
report_event(EVNT_KERN, NULL,
"kernel time sync enabled");
}
}
#endif
#ifdef KERNEL_PLL
static void
stop_kern_loop(void)
{
if (pll_control && kern_enable)
report_event(EVNT_KERN, NULL,
"kernel time sync disabled");
}
#endif
void
select_loop(
int use_kern_loop
)
{
if (kern_enable == use_kern_loop)
return;
#ifdef KERNEL_PLL
if (pll_control && !use_kern_loop)
stop_kern_loop();
#endif
kern_enable = use_kern_loop;
#ifdef KERNEL_PLL
if (pll_control && use_kern_loop)
start_kern_loop();
#endif
#ifdef KERNEL_PLL
if (pll_control && loop_started)
set_freq(drift_comp);
#endif
}
void
huffpuff(void)
{
int i;
if (sys_huffpuff == NULL)
return;
sys_huffptr = (sys_huffptr + 1) % sys_hufflen;
sys_huffpuff[sys_huffptr] = 1e9;
sys_mindly = 1e9;
for (i = 0; i < sys_hufflen; i++) {
if (sys_huffpuff[i] < sys_mindly)
sys_mindly = sys_huffpuff[i];
}
}
void
loop_config(
int item,
double freq
)
{
int i;
double ftemp;
DPRINTF(2, ("loop_config: item %d freq %f\n", item, freq));
switch (item) {
case LOOP_DRIFTINIT:
#ifndef LOCKCLOCK
#ifdef KERNEL_PLL
if (mode_ntpdate)
break;
start_kern_loop();
#endif
ftemp = init_drift_comp / 1e6;
if (ftemp > NTP_MAXFREQ)
ftemp = NTP_MAXFREQ;
else if (ftemp < -NTP_MAXFREQ)
ftemp = -NTP_MAXFREQ;
set_freq(ftemp);
if (freq_set)
rstclock(EVNT_FSET, 0);
else
rstclock(EVNT_NSET, 0);
loop_started = TRUE;
#endif
break;
case LOOP_KERN_CLEAR:
#if 0
#ifndef LOCKCLOCK
# ifdef KERNEL_PLL
if (pll_control && kern_enable) {
memset((char *)&ntv, 0, sizeof(ntv));
ntv.modes = MOD_STATUS;
ntv.status = STA_UNSYNC;
ntp_adjtime(&ntv);
sync_status("kernel time sync disabled",
pll_status,
ntv.status);
}
# endif
#endif
#endif
break;
case LOOP_ALLAN:
allan_xpt = (u_char)freq;
break;
case LOOP_CODEC:
clock_codec = freq / 1e6;
break;
case LOOP_PHI:
clock_phi = freq / 1e6;
break;
case LOOP_FREQ:
init_drift_comp = freq;
freq_set++;
break;
case LOOP_HUFFPUFF:
if (freq < HUFFPUFF)
freq = HUFFPUFF;
sys_hufflen = (int)(freq / HUFFPUFF);
sys_huffpuff = eallocarray(sys_hufflen, sizeof(sys_huffpuff[0]));
for (i = 0; i < sys_hufflen; i++)
sys_huffpuff[i] = 1e9;
sys_mindly = 1e9;
break;
case LOOP_PANIC:
clock_panic = freq;
break;
case LOOP_MAX:
clock_max_fwd = clock_max_back = freq;
if (freq == 0 || freq > 0.5)
select_loop(FALSE);
break;
case LOOP_MAX_BACK:
clock_max_back = freq;
if ( (clock_max_back == 0 || clock_max_back > 0.5)
|| (clock_max_fwd == 0 || clock_max_fwd > 0.5))
select_loop(FALSE);
break;
case LOOP_MAX_FWD:
clock_max_fwd = freq;
if ( (clock_max_back == 0 || clock_max_back > 0.5)
|| (clock_max_fwd == 0 || clock_max_fwd > 0.5))
select_loop(FALSE);
break;
case LOOP_MINSTEP:
if (freq < CLOCK_MINSTEP)
clock_minstep = CLOCK_MINSTEP;
else
clock_minstep = freq;
break;
case LOOP_TICK:
set_sys_tick_precision(freq);
break;
case LOOP_LEAP:
default:
msyslog(LOG_NOTICE,
"loop_config: unsupported option %d", item);
}
}
#if defined(KERNEL_PLL) && defined(SIGSYS)
static RETSIGTYPE
pll_trap(
int arg
)
{
pll_control = FALSE;
siglongjmp(env, 1);
}
#endif