Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/kern/kern_ntptime.c

395 lines
11 KiB
C
Raw Blame History

/* $NetBSD: kern_ntptime.c,v 1.21 2002/05/03 01:22:30 eeh Exp $ */
/******************************************************************************
* *
* Copyright (c) David L. Mills 1993, 1994 *
* *
* Permission to use, copy, modify, and distribute this software and its *
* documentation for any purpose and without fee is hereby granted, provided *
* that the above copyright notice appears in all copies and that both the *
* copyright notice and this permission notice appear in supporting *
* documentation, and that the name University of Delaware not be used in *
* advertising or publicity pertaining to distribution of the software *
* without specific, written prior permission. The University of Delaware *
* makes no representations about the suitability this software for any *
* purpose. It is provided "as is" without express or implied warranty. *
* *
******************************************************************************/
/*
* Modification history kern_ntptime.c
*
* 24 Sep 94 David L. Mills
* Tightened code at exits.
*
* 24 Mar 94 David L. Mills
* Revised syscall interface to include new variables for PPS
* time discipline.
*
* 14 Feb 94 David L. Mills
* Added code for external clock
*
* 28 Nov 93 David L. Mills
* Revised frequency scaling to conform with adjusted parameters
*
* 17 Sep 93 David L. Mills
* Created file
*/
/*
* ntp_gettime(), ntp_adjtime() - precision time interface for SunOS
* V4.1.1 and V4.1.3
*
* These routines consitute the Network Time Protocol (NTP) interfaces
* for user and daemon application programs. The ntp_gettime() routine
* provides the time, maximum error (synch distance) and estimated error
* (dispersion) to client user application programs. The ntp_adjtime()
* routine is used by the NTP daemon to adjust the system clock to an
* externally derived time. The time offset and related variables set by
* this routine are used by hardclock() to adjust the phase and
* frequency of the phase-lock loop which controls the system clock.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: kern_ntptime.c,v 1.21 2002/05/03 01:22:30 eeh Exp $");
#include "opt_ntp.h"
#include <sys/param.h>
#include <sys/resourcevar.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/sysctl.h>
#include <sys/timex.h>
#include <sys/vnode.h>
#include <sys/mount.h>
#include <sys/syscallargs.h>
#include <machine/cpu.h>
#ifdef NTP
/*
* The following variables are used by the hardclock() routine in the
* kern_clock.c module and are described in that module.
*/
extern int time_state; /* clock state */
extern int time_status; /* clock status bits */
extern long time_offset; /* time adjustment (us) */
extern long time_freq; /* frequency offset (scaled ppm) */
extern long time_maxerror; /* maximum error (us) */
extern long time_esterror; /* estimated error (us) */
extern long time_constant; /* pll time constant */
extern long time_precision; /* clock precision (us) */
extern long time_tolerance; /* frequency tolerance (scaled ppm) */
#ifdef PPS_SYNC
/*
* The following variables are used only if the PPS signal discipline
* is configured in the kernel.
*/
extern int pps_shift; /* interval duration (s) (shift) */
extern long pps_freq; /* pps frequency offset (scaled ppm) */
extern long pps_jitter; /* pps jitter (us) */
extern long pps_stabil; /* pps stability (scaled ppm) */
extern long pps_jitcnt; /* jitter limit exceeded */
extern long pps_calcnt; /* calibration intervals */
extern long pps_errcnt; /* calibration errors */
extern long pps_stbcnt; /* stability limit exceeded */
#endif /* PPS_SYNC */
/*ARGSUSED*/
/*
* ntp_gettime() - NTP user application interface
*/
int
sys_ntp_gettime(p, v, retval)
struct proc *p;
void *v;
register_t *retval;
{
struct sys_ntp_gettime_args /* {
syscallarg(struct ntptimeval *) ntvp;
} */ *uap = v;
struct timeval atv;
struct ntptimeval ntv;
int error = 0;
int s;
if (SCARG(uap, ntvp)) {
s = splclock();
#ifdef EXT_CLOCK
/*
* The microtime() external clock routine returns a
* status code. If less than zero, we declare an error
* in the clock status word and return the kernel
* (software) time variable. While there are other
* places that call microtime(), this is the only place
* that matters from an application point of view.
*/
if (microtime(&atv) < 0) {
time_status |= STA_CLOCKERR;
ntv.time = time;
} else
time_status &= ~STA_CLOCKERR;
#else /* EXT_CLOCK */
microtime(&atv);
#endif /* EXT_CLOCK */
ntv.time = atv;
ntv.maxerror = time_maxerror;
ntv.esterror = time_esterror;
(void) splx(s);
error = copyout((caddr_t)&ntv, (caddr_t)SCARG(uap, ntvp),
sizeof(ntv));
}
if (!error) {
/*
* Status word error decode. If any of these conditions
* occur, an error is returned, instead of the status
* word. Most applications will care only about the fact
* the system clock may not be trusted, not about the
* details.
*
* Hardware or software error
*/
if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) ||
/*
* PPS signal lost when either time or frequency
* synchronization requested
*/
(time_status & (STA_PPSFREQ | STA_PPSTIME) &&
!(time_status & STA_PPSSIGNAL)) ||
/*
* PPS jitter exceeded when time synchronization
* requested
*/
(time_status & STA_PPSTIME &&
time_status & STA_PPSJITTER) ||
/*
* PPS wander exceeded or calibration error when
* frequency synchronization requested
*/
(time_status & STA_PPSFREQ &&
time_status & (STA_PPSWANDER | STA_PPSERROR)))
*retval = TIME_ERROR;
else
*retval = (register_t)time_state;
}
return(error);
}
/* ARGSUSED */
/*
* ntp_adjtime() - NTP daemon application interface
*/
int
sys_ntp_adjtime(p, v, retval)
struct proc *p;
void *v;
register_t *retval;
{
struct sys_ntp_adjtime_args /* {
syscallarg(struct timex *) tp;
} */ *uap = v;
struct timex ntv;
int error = 0;
if ((error = copyin((caddr_t)SCARG(uap, tp), (caddr_t)&ntv,
sizeof(ntv))) != 0)
return (error);
if (ntv.modes != 0 && (error = suser(p->p_ucred, &p->p_acflag)) != 0)
return (error);
return (ntp_adjtime1(&ntv, v, retval));
}
int
ntp_adjtime1(ntv, v, retval)
struct timex *ntv;
void *v;
register_t *retval;
{
struct sys_ntp_adjtime_args /* {
syscallarg(struct timex *) tp;
} */ *uap = v;
int error = 0;
int modes;
int s;
/*
* Update selected clock variables. Note that there is no error
* checking here on the assumption the superuser should know
* what it is doing.
*/
modes = ntv->modes;
s = splclock();
if (modes & MOD_FREQUENCY)
#ifdef PPS_SYNC
time_freq = ntv->freq - pps_freq;
#else /* PPS_SYNC */
time_freq = ntv->freq;
#endif /* PPS_SYNC */
if (modes & MOD_MAXERROR)
time_maxerror = ntv->maxerror;
if (modes & MOD_ESTERROR)
time_esterror = ntv->esterror;
if (modes & MOD_STATUS) {
time_status &= STA_RONLY;
time_status |= ntv->status & ~STA_RONLY;
}
if (modes & MOD_TIMECONST)
time_constant = ntv->constant;
if (modes & MOD_OFFSET)
hardupdate(ntv->offset);
/*
* Retrieve all clock variables
*/
if (time_offset < 0)
ntv->offset = -(-time_offset >> SHIFT_UPDATE);
else
ntv->offset = time_offset >> SHIFT_UPDATE;
#ifdef PPS_SYNC
ntv->freq = time_freq + pps_freq;
#else /* PPS_SYNC */
ntv->freq = time_freq;
#endif /* PPS_SYNC */
ntv->maxerror = time_maxerror;
ntv->esterror = time_esterror;
ntv->status = time_status;
ntv->constant = time_constant;
ntv->precision = time_precision;
ntv->tolerance = time_tolerance;
#ifdef PPS_SYNC
ntv->shift = pps_shift;
ntv->ppsfreq = pps_freq;
ntv->jitter = pps_jitter >> PPS_AVG;
ntv->stabil = pps_stabil;
ntv->calcnt = pps_calcnt;
ntv->errcnt = pps_errcnt;
ntv->jitcnt = pps_jitcnt;
ntv->stbcnt = pps_stbcnt;
#endif /* PPS_SYNC */
(void)splx(s);
error = copyout((caddr_t)ntv, (caddr_t)SCARG(uap, tp), sizeof(*ntv));
if (!error) {
/*
* Status word error decode. See comments in
* ntp_gettime() routine.
*/
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)))
*retval = TIME_ERROR;
else
*retval = (register_t)time_state;
}
return error;
}
/*
* return information about kernel precision timekeeping
*/
int
sysctl_ntptime(where, sizep)
void *where;
size_t *sizep;
{
struct timeval atv;
struct ntptimeval ntv;
int s;
/*
* Construct ntp_timeval.
*/
s = splclock();
#ifdef EXT_CLOCK
/*
* The microtime() external clock routine returns a
* status code. If less than zero, we declare an error
* in the clock status word and return the kernel
* (software) time variable. While there are other
* places that call microtime(), this is the only place
* that matters from an application point of view.
*/
if (microtime(&atv) < 0) {
time_status |= STA_CLOCKERR;
ntv.time = time;
} else {
time_status &= ~STA_CLOCKERR;
}
#else /* EXT_CLOCK */
microtime(&atv);
#endif /* EXT_CLOCK */
ntv.time = atv;
ntv.maxerror = time_maxerror;
ntv.esterror = time_esterror;
splx(s);
#ifdef notyet
/*
* Status word error decode. If any of these conditions
* occur, an error is returned, instead of the status
* word. Most applications will care only about the fact
* the system clock may not be trusted, not about the
* details.
*
* Hardware or software error
*/
if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) ||
ntv.time_state = TIME_ERROR;
/*
* PPS signal lost when either time or frequency
* synchronization requested
*/
(time_status & (STA_PPSFREQ | STA_PPSTIME) &&
!(time_status & STA_PPSSIGNAL)) ||
/*
* PPS jitter exceeded when time synchronization
* requested
*/
(time_status & STA_PPSTIME &&
time_status & STA_PPSJITTER) ||
/*
* PPS wander exceeded or calibration error when
* frequency synchronization requested
*/
(time_status & STA_PPSFREQ &&
time_status & (STA_PPSWANDER | STA_PPSERROR)))
ntv.time_state = TIME_ERROR;
else
ntv.time_state = time_state;
#endif /* notyet */
return (sysctl_rdstruct(where, sizep, NULL, &ntv, sizeof(ntv)));
}
#else /* !NTP */
/* For some reason, raising SIGSYS (as sys_nosys would) is problematic. */
int
sys_ntp_gettime(p, v, retval)
struct proc *p;
void *v;
register_t *retval;
{
return(ENOSYS);
}
#endif /* !NTP */
Reference in New Issue View Git Blame Copy Permalink