d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
73108a1664
freebsd-skq/sys/kern/kern_ntptime.c

958 lines
29 KiB
C
Raw Normal View History

Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/***********************************************************************
* *
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
* Copyright (c) David L. Mills 1993-2001 *
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* *
* 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. *
* *
**********************************************************************/
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Adapted from the original sources for FreeBSD and timecounters by:
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
* Poul-Henning Kamp <phk@FreeBSD.org>.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* The 32bit version of the "LP" macros seems a bit past its "sell by"
* date so I have retained only the 64bit version and included it directly
* in this file.
Update our kernel ntp code to the latest from David Mills. The main change is the addition of the FLL code, which is used by the latest versions of xntpd. The kernel PPS code is also updated, although I can't test that yet.
1996-12-30 18:26:28 +00:00
*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Only minor changes done to interface with the timecounters over in
* sys/kern/kern_clock.c. Some of the comments below may be (even more)
* confusing and/or plain wrong in that context.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Make POWERFAIL_NMI, PPS_SYNC and NATM new style options. This also fixes a couple of defunct options; submitted by bde.
1998-01-31 05:00:21 +00:00
Use __FBSDID().
2003-06-11 00:56:59 +00:00
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
#include "opt_ntp.h"
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
#include <sys/param.h>
#include <sys/systm.h>
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#include <sys/sysproto.h>
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
#include <sys/kernel.h>
#include <sys/proc.h>
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
#include <sys/lock.h>
#include <sys/mutex.h>
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#include <sys/time.h>
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
#include <sys/timex.h>
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
#include <sys/timetc.h>
Introduce std_pps_ioctl() to automagically DTRT. Add scaling capability to timex.offset, ntpd-4.0.73 will support this.
1998-06-13 09:30:26 +00:00
#include <sys/timepps.h>
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
#include <sys/sysctl.h>
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Single-precision macros for 64-bit machines
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Annual NTP kernel code spring-cleaning: Use int64_t rather than long long for the fixpoint type. Don't discard fractional nanosecond frequency correction.
2004-03-14 15:23:05 +00:00
typedef int64_t l_fp;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#define L_ADD(v, u) ((v) += (u))
#define L_SUB(v, u) ((v) -= (u))
Annual NTP kernel code spring-cleaning: Use int64_t rather than long long for the fixpoint type. Don't discard fractional nanosecond frequency correction.
2004-03-14 15:23:05 +00:00
#define L_ADDHI(v, a) ((v) += (int64_t)(a) << 32)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#define L_NEG(v) ((v) = -(v))
#define L_RSHIFT(v, n) \
do { \
if ((v) < 0) \
(v) = -(-(v) >> (n)); \
else \
(v) = (v) >> (n); \
} while (0)
#define L_MPY(v, a) ((v) *= (a))
#define L_CLR(v) ((v) = 0)
#define L_ISNEG(v) ((v) < 0)
Annual NTP kernel code spring-cleaning: Use int64_t rather than long long for the fixpoint type. Don't discard fractional nanosecond frequency correction.
2004-03-14 15:23:05 +00:00
#define L_LINT(v, a) ((v) = (int64_t)(a) << 32)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#define L_GINT(v) ((v) < 0 ? -(-(v) >> 32) : (v) >> 32)
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Generic NTP kernel interface
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* These routines constitute 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 other routines in this module to adjust the
* phase and frequency of the clock discipline loop which controls the
* system clock.
*
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
* When the kernel time is reckoned directly in nanoseconds (NTP_NANO
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* defined), the time at each tick interrupt is derived directly from
* the kernel time variable. When the kernel time is reckoned in
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
* microseconds, (NTP_NANO undefined), the time is derived from the
* kernel time variable together with a variable representing the
* leftover nanoseconds at the last tick interrupt. In either case, the
* current nanosecond time is reckoned from these values plus an
* interpolated value derived by the clock routines in another
* architecture-specific module. The interpolation can use either a
* dedicated counter or a processor cycle counter (PCC) implemented in
* some architectures.
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
*
* Note that all routines must run at priority splclock or higher.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Phase/frequency-lock loop (PLL/FLL) definitions
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* The nanosecond clock discipline uses two variable types, time
* variables and frequency variables. Both types are represented as 64-
* bit fixed-point quantities with the decimal point between two 32-bit
* halves. On a 32-bit machine, each half is represented as a single
* word and mathematical operations are done using multiple-precision
* arithmetic. On a 64-bit machine, ordinary computer arithmetic is
* used.
*
* A time variable is a signed 64-bit fixed-point number in ns and
* fraction. It represents the remaining time offset to be amortized
* over succeeding tick interrupts. The maximum time offset is about
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
* 0.5 s and the resolution is about 2.3e-10 ns.
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
*
* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* |s s s| ns |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | fraction |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* A frequency variable is a signed 64-bit fixed-point number in ns/s
* and fraction. It represents the ns and fraction to be added to the
* kernel time variable at each second. The maximum frequency offset is
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
* about +-500000 ns/s and the resolution is about 2.3e-10 ns/s.
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
*
* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* |s s s s s s s s s s s s s| ns/s |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | fraction |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* The following variables establish the state of the PLL/FLL and the
* residual time and frequency offset of the local clock.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#define SHIFT_PLL 4 /* PLL loop gain (shift) */
#define SHIFT_FLL 2 /* FLL loop gain (shift) */
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
static int time_state = TIME_OK; /* clock state */
static int time_status = STA_UNSYNC; /* clock status bits */
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
static long time_tai; /* TAI offset (s) */
static long time_monitor; /* last time offset scaled (ns) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
static long time_constant; /* poll interval (shift) (s) */
static long time_precision = 1; /* clock precision (ns) */
static long time_maxerror = MAXPHASE / 1000; /* maximum error (us) */
static long time_esterror = MAXPHASE / 1000; /* estimated error (us) */
static long time_reftime; /* time at last adjustment (s) */
static l_fp time_offset; /* time offset (ns) */
static l_fp time_freq; /* frequency offset (ns/s) */
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
static l_fp time_adj; /* tick adjust (ns/s) */
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
static int64_t time_adjtime; /* correction from adjtime(2) (usec) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#ifdef PPS_SYNC
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* The following variables are used when a pulse-per-second (PPS) signal
* is available and connected via a modem control lead. They establish
* the engineering parameters of the clock discipline loop when
* controlled by the PPS signal.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#define PPS_FAVG 2 /* min freq avg interval (s) (shift) */
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
#define PPS_FAVGDEF 8 /* default freq avg int (s) (shift) */
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
#define PPS_FAVGMAX 15 /* max freq avg interval (s) (shift) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#define PPS_PAVG 4 /* phase avg interval (s) (shift) */
#define PPS_VALID 120 /* PPS signal watchdog max (s) */
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
#define PPS_MAXWANDER 100000 /* max PPS wander (ns/s) */
#define PPS_POPCORN 2 /* popcorn spike threshold (shift) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
static struct timespec pps_tf[3]; /* phase median filter */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
static l_fp pps_freq; /* scaled frequency offset (ns/s) */
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
static long pps_fcount; /* frequency accumulator */
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
static long pps_jitter; /* nominal jitter (ns) */
static long pps_stabil; /* nominal stability (scaled ns/s) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
static long pps_lastsec; /* time at last calibration (s) */
static int pps_valid; /* signal watchdog counter */
static int pps_shift = PPS_FAVG; /* interval duration (s) (shift) */
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
static int pps_shiftmax = PPS_FAVGDEF; /* max interval duration (s) (shift) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
static int pps_intcnt; /* wander counter */
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* PPS signal quality monitors
*/
static long pps_calcnt; /* calibration intervals */
static long pps_jitcnt; /* jitter limit exceeded */
static long pps_stbcnt; /* stability limit exceeded */
static long pps_errcnt; /* calibration errors */
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
#endif /* PPS_SYNC */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* End of phase/frequency-lock loop (PLL/FLL) definitions
*/
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
static void ntp_init(void);
static void hardupdate(long offset);
Add system call implementation of ntp_gettime(2). Moved most of the work to ntp_gettime1(), which is now called by ntp_gettime() and ntp_sysctl(). Reviewed by: imp, phk, njl, peter Approved by: njl
2004-11-18 23:44:49 +00:00
static void ntp_gettime1(struct ntptimeval *ntvp);
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Add system call implementation of ntp_gettime(2). Moved most of the work to ntp_gettime1(), which is now called by ntp_gettime() and ntp_sysctl(). Reviewed by: imp, phk, njl, peter Approved by: njl
2004-11-18 23:44:49 +00:00
static void
ntp_gettime1(struct ntptimeval *ntvp)
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
{
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
struct timespec atv; /* nanosecond time */
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
nanotime(&atv);
Add system call implementation of ntp_gettime(2). Moved most of the work to ntp_gettime1(), which is now called by ntp_gettime() and ntp_sysctl(). Reviewed by: imp, phk, njl, peter Approved by: njl
2004-11-18 23:44:49 +00:00
ntvp->time.tv_sec = atv.tv_sec;
ntvp->time.tv_nsec = atv.tv_nsec;
ntvp->maxerror = time_maxerror;
ntvp->esterror = time_esterror;
ntvp->tai = time_tai;
ntvp->time_state = time_state;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* 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.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*
* Hardware or software error
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) ||
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* PPS signal lost when either time or frequency synchronization
* requested
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
(time_status & (STA_PPSFREQ | STA_PPSTIME) &&
!(time_status & STA_PPSSIGNAL)) ||
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* PPS jitter exceeded when time synchronization requested
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
(time_status & STA_PPSTIME &&
time_status & STA_PPSJITTER) ||
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* PPS wander exceeded or calibration error when frequency
* synchronization requested
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
(time_status & STA_PPSFREQ &&
time_status & (STA_PPSWANDER | STA_PPSERROR)))
Add system call implementation of ntp_gettime(2). Moved most of the work to ntp_gettime1(), which is now called by ntp_gettime() and ntp_sysctl(). Reviewed by: imp, phk, njl, peter Approved by: njl
2004-11-18 23:44:49 +00:00
ntvp->time_state = TIME_ERROR;
}
Place function comment above the right function.
2004-11-19 00:58:30 +00:00
/*
* ntp_gettime() - NTP user application interface
*
* See the timex.h header file for synopsis and API description. Note
* that the TAI offset is returned in the ntvtimeval.tai structure
* member.
*/
Add system call implementation of ntp_gettime(2). Moved most of the work to ntp_gettime1(), which is now called by ntp_gettime() and ntp_sysctl(). Reviewed by: imp, phk, njl, peter Approved by: njl
2004-11-18 23:44:49 +00:00
#ifndef _SYS_SYSPROTO_H_
struct ntp_gettime_args {
struct ntptimeval *ntvp;
};
#endif
/* ARGSUSED */
int
ntp_gettime(struct thread *td, struct ntp_gettime_args *uap)
{
struct ntptimeval ntv;
ntp_gettime1(&ntv);
return (copyout(&ntv, uap->ntvp, sizeof(ntv)));
}
static int
ntp_sysctl(SYSCTL_HANDLER_ARGS)
{
struct ntptimeval ntv; /* temporary structure */
ntp_gettime1(&ntv);
return (sysctl_handle_opaque(oidp, &ntv, sizeof(ntv), req));
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
}
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
SYSCTL_NODE(_kern, OID_AUTO, ntp_pll, CTLFLAG_RW, 0, "");
SYSCTL_PROC(_kern_ntp_pll, OID_AUTO, gettime, CTLTYPE_OPAQUE|CTLFLAG_RD,
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
0, sizeof(struct ntptimeval) , ntp_sysctl, "S,ntptimeval", "");
Move KERN_NTP to a more suitable file.
1995-11-14 09:07:14 +00:00
pps_shiftmax only exists #ifdef PPS_SYNC Found by: Roger Hardiman <roger@cs.strath.ac.uk>
1999-08-30 16:21:32 +00:00
#ifdef PPS_SYNC
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shiftmax, CTLFLAG_RW, &pps_shiftmax, 0, "");
Create a separate pps_offset variable to use for applying the hardpps() produced offset component. This is tested and behaved stable with frequency offsets from -338.05 to +499.91 PPM. Interestingly the machine I tested this on would fail if the clock were slower than 14.3132 MHz whereas it was perfectly happy to run at 16.384 MHz, in other words [-340PPM ... +14.4%] Make pps_shift tweakable with sysctl.
2000-01-04 12:04:39 +00:00
SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shift, CTLFLAG_RW, &pps_shift, 0, "");
Updates to the ntp pll from John Hay. Submitted by: jhay
2000-09-10 09:13:34 +00:00
SYSCTL_INT(_kern_ntp_pll, OID_AUTO, time_monitor, CTLFLAG_RD, &time_monitor, 0, "");
Add a couple of strategic sysctls for monitoring. In the rather obscure case of hardpps(), use a type-II PLL if the external signal is phase locked, but a FLL if it isn't.
2000-01-23 14:52:37 +00:00
SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, pps_freq, CTLFLAG_RD, &pps_freq, sizeof(pps_freq), "I", "");
SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, time_freq, CTLFLAG_RD, &time_freq, sizeof(time_freq), "I", "");
pps_shiftmax only exists #ifdef PPS_SYNC Found by: Roger Hardiman <roger@cs.strath.ac.uk>
1999-08-30 16:21:32 +00:00
#endif
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
* ntp_adjtime() - NTP daemon application interface
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
*
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* See the timex.h header file for synopsis and API description. Note
* that the timex.constant structure member has a dual purpose to set
* the time constant and to set the TAI offset.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#ifndef _SYS_SYSPROTO_H_
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
struct ntp_adjtime_args {
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
struct timex *tp;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
};
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#endif
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
/*
* MPSAFE
*/
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
int
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
ntp_adjtime(struct thread *td, struct ntp_adjtime_args *uap)
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
{
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
struct timex ntv; /* temporary structure */
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
long freq; /* frequency ns/s) */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
int modes; /* mode bits from structure */
int s; /* caller priority */
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
int error;
error = copyin((caddr_t)uap->tp, (caddr_t)&ntv, sizeof(ntv));
if (error)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
return(error);
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
* Update selected clock variables - only the superuser can
* change anything. Note that there is no error checking here on
* the assumption the superuser should know what it is doing.
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* Note that either the time constant or TAI offset are loaded
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
* from the ntv.constant member, depending on the mode bits. If
* the STA_PLL bit in the status word is cleared, the state and
* status words are reset to the initial values at boot.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
mtx_lock(&Giant);
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
modes = ntv.modes;
Allow !suser() R/O access to ntp_adjtime() Noticed by: Reg Clemens <reg@dwf.com>
1999-03-15 08:35:40 +00:00
if (modes)
Change the suser() API to take advantage of td_ucred as well as do a general cleanup of the API. The entire API now consists of two functions similar to the pre-KSE API. The suser() function takes a thread pointer as its only argument. The td_ucred member of this thread must be valid so the only valid thread pointers are curthread and a few kernel threads such as thread0. The suser_cred() function takes a pointer to a struct ucred as its first argument and an integer flag as its second argument. The flag is currently only used for the PRISON_ROOT flag. Discussed on: smp@
2002-04-01 21:31:13 +00:00
error = suser(td);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (error)
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
goto done2;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
s = splclock();
if (modes & MOD_MAXERROR)
time_maxerror = ntv.maxerror;
if (modes & MOD_ESTERROR)
time_esterror = ntv.esterror;
if (modes & MOD_STATUS) {
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
if (time_status & STA_PLL && !(ntv.status & STA_PLL)) {
time_state = TIME_OK;
time_status = STA_UNSYNC;
#ifdef PPS_SYNC
pps_shift = PPS_FAVG;
#endif /* PPS_SYNC */
}
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
time_status &= STA_RONLY;
time_status |= ntv.status & ~STA_RONLY;
}
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
if (modes & MOD_TIMECONST) {
if (ntv.constant < 0)
time_constant = 0;
else if (ntv.constant > MAXTC)
time_constant = MAXTC;
else
time_constant = ntv.constant;
}
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
if (modes & MOD_TAI) {
if (ntv.constant > 0) /* XXX zero & negative numbers ? */
time_tai = ntv.constant;
}
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
#ifdef PPS_SYNC
if (modes & MOD_PPSMAX) {
if (ntv.shift < PPS_FAVG)
pps_shiftmax = PPS_FAVG;
else if (ntv.shift > PPS_FAVGMAX)
pps_shiftmax = PPS_FAVGMAX;
else
pps_shiftmax = ntv.shift;
}
#endif /* PPS_SYNC */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (modes & MOD_NANO)
time_status |= STA_NANO;
if (modes & MOD_MICRO)
time_status &= ~STA_NANO;
if (modes & MOD_CLKB)
time_status |= STA_CLK;
if (modes & MOD_CLKA)
time_status &= ~STA_CLK;
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
if (modes & MOD_FREQUENCY) {
freq = (ntv.freq * 1000LL) >> 16;
if (freq > MAXFREQ)
L_LINT(time_freq, MAXFREQ);
else if (freq < -MAXFREQ)
L_LINT(time_freq, -MAXFREQ);
Annual NTP kernel code spring-cleaning: Use int64_t rather than long long for the fixpoint type. Don't discard fractional nanosecond frequency correction.
2004-03-14 15:23:05 +00:00
else {
/*
* ntv.freq is [PPM * 2^16] = [us/s * 2^16]
* time_freq is [ns/s * 2^32]
*/
time_freq = ntv.freq * 1000LL * 65536LL;
}
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
#ifdef PPS_SYNC
pps_freq = time_freq;
#endif /* PPS_SYNC */
}
Deal with MOD_FREQUENCY before MOD_OFFSET because the latter is the one which runs the actual update. This fixes a bug where there were a delay in applying the frequency adjustment. In extreme cases this could result in marginal stability of the kernel-pll.
2004-01-24 21:48:43 +00:00
if (modes & MOD_OFFSET) {
if (time_status & STA_NANO)
hardupdate(ntv.offset);
else
hardupdate(ntv.offset * 1000);
}
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* Retrieve all clock variables. Note that the TAI offset is
* returned only by ntp_gettime();
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (time_status & STA_NANO)
In the ntp_adjtime(2) syscall, return our actual estimate of unapplied offset correction instead of the most recent offset applied.
2002-04-15 08:58:24 +00:00
ntv.offset = L_GINT(time_offset);
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
else
In the ntp_adjtime(2) syscall, return our actual estimate of unapplied offset correction instead of the most recent offset applied.
2002-04-15 08:58:24 +00:00
ntv.offset = L_GINT(time_offset) / 1000; /* XXX rounding ? */
Dang, lost some LL's there.
1999-04-04 10:53:59 +00:00
ntv.freq = L_GINT((time_freq / 1000LL) << 16);
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
ntv.maxerror = time_maxerror;
ntv.esterror = time_esterror;
ntv.status = time_status;
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
ntv.constant = time_constant;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (time_status & STA_NANO)
ntv.precision = time_precision;
else
ntv.precision = time_precision / 1000;
ntv.tolerance = MAXFREQ * SCALE_PPM;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
#ifdef PPS_SYNC
ntv.shift = pps_shift;
Dang, lost some LL's there.
1999-04-04 10:53:59 +00:00
ntv.ppsfreq = L_GINT((pps_freq / 1000LL) << 16);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (time_status & STA_NANO)
ntv.jitter = pps_jitter;
else
ntv.jitter = pps_jitter / 1000;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
ntv.stabil = pps_stabil;
ntv.calcnt = pps_calcnt;
ntv.errcnt = pps_errcnt;
ntv.jitcnt = pps_jitcnt;
ntv.stbcnt = pps_stbcnt;
#endif /* PPS_SYNC */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
splx(s);
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
error = copyout((caddr_t)&ntv, (caddr_t)uap->tp, sizeof(ntv));
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (error)
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
goto done2;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* 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 &&
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
time_status & (STA_PPSWANDER | STA_PPSERROR))) {
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
td->td_retval[0] = TIME_ERROR;
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
} else {
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
td->td_retval[0] = time_state;
Pushdown Giant for: profil(), ntp_adjtime(), ogethostname(), osethostname(), ogethostid(), osethostid()
2001-09-01 05:47:58 +00:00
}
done2:
mtx_unlock(&Giant);
Fix a division which I had made a multiplication. Fix return value from ntp_adjtime(). Submitted by: jhay
1999-04-04 19:56:04 +00:00
return (error);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
}
/*
* second_overflow() - called after ntp_tick_adjust()
*
* This routine is ordinarily called immediately following the above
* routine ntp_tick_adjust(). While these two routines are normally
* combined, they are separated here only for the purposes of
* simulation.
*/
void
Hide the private parts of timecounter from a couple of places that don't really need to know the gory details.
2002-04-26 21:31:44 +00:00
ntp_update_second(int64_t *adjustment, time_t *newsec)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
{
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
int tickrate;
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
l_fp ftemp; /* 32/64-bit temporary */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
/*
* On rollover of the second both the nanosecond and microsecond
* clocks are updated and the state machine cranked as
* necessary. The phase adjustment to be used for the next
* second is calculated and the maximum error is increased by
* the tolerance.
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
time_maxerror += MAXFREQ / 1000;
/*
* Leap second processing. If in leap-insert state at
* the end of the day, the system clock is set back one
* second; if in leap-delete state, the system clock is
* set ahead one second. The nano_time() routine or
* external clock driver will insure that reported time
* is always monotonic.
*/
switch (time_state) {
/*
* No warning.
*/
case TIME_OK:
if (time_status & STA_INS)
time_state = TIME_INS;
else if (time_status & STA_DEL)
time_state = TIME_DEL;
break;
/*
* Insert second 23:59:60 following second
* 23:59:59.
*/
case TIME_INS:
if (!(time_status & STA_INS))
time_state = TIME_OK;
else if ((*newsec) % 86400 == 0) {
(*newsec)--;
time_state = TIME_OOP;
During a positive leap second, the tai_time offset should be incremented at the start of the leap second, not after the leap second has been inserted. This is because at the start of the leap second, we set the time back one second. This setting back one second is the moment that the offset changes. The old code set it back after the leap second, but that's one second too late. The negative leap second case is handled correctly. Reviewed by: phk
2003-06-25 20:56:40 +00:00
time_tai++;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
}
break;
/*
* Delete second 23:59:59.
*/
case TIME_DEL:
if (!(time_status & STA_DEL))
time_state = TIME_OK;
else if (((*newsec) + 1) % 86400 == 0) {
(*newsec)++;
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
time_tai--;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
time_state = TIME_WAIT;
}
break;
/*
* Insert second in progress.
*/
case TIME_OOP:
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
time_state = TIME_WAIT;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
break;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Wait for status bits to clear.
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
case TIME_WAIT:
if (!(time_status & (STA_INS | STA_DEL)))
time_state = TIME_OK;
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
}
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
* Compute the total time adjustment for the next second
* in ns. The offset is reduced by a factor depending on
* whether the PPS signal is operating. Note that the
* value is in effect scaled by the clock frequency,
* since the adjustment is added at each tick interrupt.
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
*/
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
ftemp = time_offset;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#ifdef PPS_SYNC
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
/* XXX even if PPS signal dies we should finish adjustment ? */
if (time_status & STA_PPSTIME && time_status &
Updates to the ntp pll from John Hay. Submitted by: jhay
2000-09-10 09:13:34 +00:00
STA_PPSSIGNAL)
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
L_RSHIFT(ftemp, pps_shift);
else
L_RSHIFT(ftemp, SHIFT_PLL + time_constant);
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
#else
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
L_RSHIFT(ftemp, SHIFT_PLL + time_constant);
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
#endif /* PPS_SYNC */
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
time_adj = ftemp;
L_SUB(time_offset, ftemp);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
L_ADD(time_adj, time_freq);
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
/*
* Apply any correction from adjtime(2). If more than one second
* off we slew at a rate of 5ms/s (5000 PPM) else 500us/s (500PPM)
* until the last second is slewed the final < 500 usecs.
*/
if (time_adjtime != 0) {
if (time_adjtime > 1000000)
tickrate = 5000;
else if (time_adjtime < -1000000)
tickrate = -5000;
else if (time_adjtime > 500)
tickrate = 500;
else if (time_adjtime < -500)
tickrate = -500;
else
Annual NTP kernel code spring-cleaning: Use int64_t rather than long long for the fixpoint type. Don't discard fractional nanosecond frequency correction.
2004-03-14 15:23:05 +00:00
tickrate = time_adjtime;
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
time_adjtime -= tickrate;
L_LINT(ftemp, tickrate * 1000);
L_ADD(time_adj, ftemp);
}
Hide the private parts of timecounter from a couple of places that don't really need to know the gory details.
2002-04-26 21:31:44 +00:00
*adjustment = time_adj;
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#ifdef PPS_SYNC
if (pps_valid > 0)
pps_valid--;
else
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
time_status &= ~STA_PPSSIGNAL;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#endif /* PPS_SYNC */
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
}
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* ntp_init() - initialize variables and structures
*
* This routine must be called after the kernel variables hz and tick
* are set or changed and before the next tick interrupt. In this
* particular implementation, these values are assumed set elsewhere in
* the kernel. The design allows the clock frequency and tick interval
* to be changed while the system is running. So, this routine should
* probably be integrated with the code that does that.
*/
static void
ntp_init()
{
/*
* The following variables are initialized only at startup. Only
* those structures not cleared by the compiler need to be
* initialized, and these only in the simulator. In the actual
* kernel, any nonzero values here will quickly evaporate.
*/
L_CLR(time_offset);
L_CLR(time_freq);
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
#ifdef PPS_SYNC
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
pps_tf[0].tv_sec = pps_tf[0].tv_nsec = 0;
pps_tf[1].tv_sec = pps_tf[1].tv_nsec = 0;
pps_tf[2].tv_sec = pps_tf[2].tv_nsec = 0;
Update to latest version from Dave Mills. Mostly textual.
1999-04-04 10:28:42 +00:00
pps_fcount = 0;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
L_CLR(pps_freq);
#endif /* PPS_SYNC */
}
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Explicitly have the timecounter init happen after the cpu_initclocks is called. Otherwise (depending on a non-deterministic sort), the timecounter code can be initialized before the clock rate has been set (on ia64) and it assumes hz = 100, rather than the real value of 1024. I'm not sure how much gets upset by this. Glanced at by: phk
2003-01-06 01:01:08 +00:00
SYSINIT(ntpclocks, SI_SUB_CLOCKS, SI_ORDER_MIDDLE, ntp_init, NULL)
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* hardupdate() - local clock update
*
* This routine is called by ntp_adjtime() to update the local clock
* phase and frequency. The implementation is of an adaptive-parameter,
* hybrid phase/frequency-lock loop (PLL/FLL). The routine computes new
* time and frequency offset estimates for each call. If the kernel PPS
* discipline code is configured (PPS_SYNC), the PPS signal itself
* determines the new time offset, instead of the calling argument.
* Presumably, calls to ntp_adjtime() occur only when the caller
* believes the local clock is valid within some bound (+-128 ms with
* NTP). If the caller's time is far different than the PPS time, an
* argument will ensue, and it's not clear who will lose.
*
* For uncompensated quartz crystal oscillators and nominal update
* intervals less than 256 s, operation should be in phase-lock mode,
* where the loop is disciplined to phase. For update intervals greater
* than 1024 s, operation should be in frequency-lock mode, where the
* loop is disciplined to frequency. Between 256 s and 1024 s, the mode
* is selected by the STA_MODE status bit.
*/
static void
hardupdate(offset)
long offset; /* clock offset (ns) */
{
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
long mtemp;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
l_fp ftemp;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* Select how the phase is to be controlled and from which
* source. If the PPS signal is present and enabled to
* discipline the time, the PPS offset is used; otherwise, the
* argument offset is used.
*/
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
if (!(time_status & STA_PLL))
return;
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
if (!(time_status & STA_PPSTIME && time_status &
STA_PPSSIGNAL)) {
if (offset > MAXPHASE)
time_monitor = MAXPHASE;
else if (offset < -MAXPHASE)
time_monitor = -MAXPHASE;
else
time_monitor = offset;
L_LINT(time_offset, time_monitor);
}
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
/*
* Select how the frequency is to be controlled and in which
* mode (PLL or FLL). If the PPS signal is present and enabled
* to discipline the frequency, the PPS frequency is used;
* otherwise, the argument offset is used to compute it.
*/
if (time_status & STA_PPSFREQ && time_status & STA_PPSSIGNAL) {
time_reftime = time_second;
return;
}
if (time_status & STA_FREQHOLD || time_reftime == 0)
time_reftime = time_second;
mtemp = time_second - time_reftime;
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
L_LINT(ftemp, time_monitor);
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
L_RSHIFT(ftemp, (SHIFT_PLL + 2 + time_constant) << 1);
L_MPY(ftemp, mtemp);
L_ADD(time_freq, ftemp);
time_status &= ~STA_MODE;
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp >
MAXSEC)) {
L_LINT(ftemp, (time_monitor << 4) / mtemp);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
L_RSHIFT(ftemp, SHIFT_FLL + 4);
L_ADD(time_freq, ftemp);
time_status |= STA_MODE;
}
time_reftime = time_second;
if (L_GINT(time_freq) > MAXFREQ)
L_LINT(time_freq, MAXFREQ);
else if (L_GINT(time_freq) < -MAXFREQ)
L_LINT(time_freq, -MAXFREQ);
}
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
#ifdef PPS_SYNC
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
* hardpps() - discipline CPU clock oscillator to external PPS signal
*
* This routine is called at each PPS interrupt in order to discipline
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* the CPU clock oscillator to the PPS signal. There are two independent
* first-order feedback loops, one for the phase, the other for the
* frequency. The phase loop measures and grooms the PPS phase offset
* and leaves it in a handy spot for the seconds overflow routine. The
* frequency loop averages successive PPS phase differences and
* calculates the PPS frequency offset, which is also processed by the
* seconds overflow routine. The code requires the caller to capture the
* time and architecture-dependent hardware counter values in
* nanoseconds at the on-time PPS signal transition.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Note that, on some Unix systems this routine runs at an interrupt
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
* priority level higher than the timer interrupt routine hardclock().
* Therefore, the variables used are distinct from the hardclock()
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* variables, except for the actual time and frequency variables, which
* are determined by this routine and updated atomically.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
void
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
hardpps(tsp, nsec)
struct timespec *tsp; /* time at PPS */
long nsec; /* hardware counter at PPS */
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
{
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
long u_sec, u_nsec, v_nsec; /* temps */
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
l_fp ftemp;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* The signal is first processed by a range gate and frequency
* discriminator. The range gate rejects noise spikes outside
* the range +-500 us. The frequency discriminator rejects input
* signals with apparent frequency outside the range 1 +-500
* PPM. If two hits occur in the same second, we ignore the
* later hit; if not and a hit occurs outside the range gate,
* keep the later hit for later comparison, but do not process
* it.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
time_status |= STA_PPSSIGNAL | STA_PPSJITTER;
time_status &= ~(STA_PPSWANDER | STA_PPSERROR);
pps_valid = PPS_VALID;
u_sec = tsp->tv_sec;
u_nsec = tsp->tv_nsec;
if (u_nsec >= (NANOSECOND >> 1)) {
u_nsec -= NANOSECOND;
u_sec++;
}
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
v_nsec = u_nsec - pps_tf[0].tv_nsec;
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
if (u_sec == pps_tf[0].tv_sec && v_nsec < NANOSECOND -
MAXFREQ)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
return;
pps_tf[2] = pps_tf[1];
pps_tf[1] = pps_tf[0];
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
pps_tf[0].tv_sec = u_sec;
pps_tf[0].tv_nsec = u_nsec;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* Compute the difference between the current and previous
* counter values. If the difference exceeds 0.5 s, assume it
* has wrapped around, so correct 1.0 s. If the result exceeds
* the tick interval, the sample point has crossed a tick
* boundary during the last second, so correct the tick. Very
* intricate.
*/
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
u_nsec = nsec;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (u_nsec > (NANOSECOND >> 1))
u_nsec -= NANOSECOND;
else if (u_nsec < -(NANOSECOND >> 1))
u_nsec += NANOSECOND;
Don't run FLL fodder through the median-filter. Reduce max integration time to 128sec and use 50% exponential decay rather than 256sec/25%.
1999-03-16 08:39:37 +00:00
pps_fcount += u_nsec;
Update to the 2001-04-02 version of the nanokernel code from Dave Mills.
2001-04-16 13:05:05 +00:00
if (v_nsec > MAXFREQ || v_nsec < -MAXFREQ)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
return;
time_status &= ~STA_PPSJITTER;
/*
* A three-stage median filter is used to help denoise the PPS
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
* time. The median sample becomes the time offset estimate; the
* difference between the other two samples becomes the time
* dispersion (jitter) estimate.
*/
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
if (pps_tf[0].tv_nsec > pps_tf[1].tv_nsec) {
if (pps_tf[1].tv_nsec > pps_tf[2].tv_nsec) {
v_nsec = pps_tf[1].tv_nsec; /* 0 1 2 */
u_nsec = pps_tf[0].tv_nsec - pps_tf[2].tv_nsec;
} else if (pps_tf[2].tv_nsec > pps_tf[0].tv_nsec) {
v_nsec = pps_tf[0].tv_nsec; /* 2 0 1 */
u_nsec = pps_tf[2].tv_nsec - pps_tf[1].tv_nsec;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
} else {
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
v_nsec = pps_tf[2].tv_nsec; /* 0 2 1 */
u_nsec = pps_tf[0].tv_nsec - pps_tf[1].tv_nsec;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
}
} else {
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
if (pps_tf[1].tv_nsec < pps_tf[2].tv_nsec) {
v_nsec = pps_tf[1].tv_nsec; /* 2 1 0 */
u_nsec = pps_tf[2].tv_nsec - pps_tf[0].tv_nsec;
Updates to the ntp pll from John Hay. Submitted by: jhay
2000-09-10 09:13:34 +00:00
} else if (pps_tf[2].tv_nsec < pps_tf[0].tv_nsec) {
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
v_nsec = pps_tf[0].tv_nsec; /* 1 0 2 */
u_nsec = pps_tf[1].tv_nsec - pps_tf[2].tv_nsec;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
} else {
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
v_nsec = pps_tf[2].tv_nsec; /* 1 2 0 */
u_nsec = pps_tf[1].tv_nsec - pps_tf[0].tv_nsec;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
}
}
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Updates to the ntp pll from John Hay. Submitted by: jhay
2000-09-10 09:13:34 +00:00
* Nominal jitter is due to PPS signal noise and interrupt
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* latency. If it exceeds the popcorn threshold, the sample is
* discarded. otherwise, if so enabled, the time offset is
* updated. We can tolerate a modest loss of data here without
* much degrading time accuracy.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
if (u_nsec > (pps_jitter << PPS_POPCORN)) {
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
time_status |= STA_PPSJITTER;
pps_jitcnt++;
} else if (time_status & STA_PPSTIME) {
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
time_monitor = -v_nsec;
L_LINT(time_offset, time_monitor);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
}
pps_jitter += (u_nsec - pps_jitter) >> PPS_FAVG;
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
u_sec = pps_tf[0].tv_sec - pps_lastsec;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (u_sec < (1 << pps_shift))
return;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* At the end of the calibration interval the difference between
* the first and last counter values becomes the scaled
* frequency. It will later be divided by the length of the
* interval to determine the frequency update. If the frequency
* exceeds a sanity threshold, or if the actual calibration
* interval is not equal to the expected length, the data are
* discarded. We can tolerate a modest loss of data here without
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
* much degrading frequency accuracy.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_calcnt++;
Don't run FLL fodder through the median-filter. Reduce max integration time to 128sec and use 50% exponential decay rather than 256sec/25%.
1999-03-16 08:39:37 +00:00
v_nsec = -pps_fcount;
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
pps_lastsec = pps_tf[0].tv_sec;
Don't run FLL fodder through the median-filter. Reduce max integration time to 128sec and use 50% exponential decay rather than 256sec/25%.
1999-03-16 08:39:37 +00:00
pps_fcount = 0;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
u_nsec = MAXFREQ << pps_shift;
if (v_nsec > u_nsec || v_nsec < -u_nsec || u_sec != (1 <<
pps_shift)) {
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
time_status |= STA_PPSERROR;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_errcnt++;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
return;
}
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
* Here the raw frequency offset and wander (stability) is
* calculated. If the wander is less than the wander threshold
* for four consecutive averaging intervals, the interval is
* doubled; if it is greater than the threshold for four
* consecutive intervals, the interval is halved. The scaled
* frequency offset is converted to frequency offset. The
* stability metric is calculated as the average of recent
* frequency changes, but is used only for performance
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
* monitoring.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
L_LINT(ftemp, v_nsec);
L_RSHIFT(ftemp, pps_shift);
L_SUB(ftemp, pps_freq);
u_nsec = L_GINT(ftemp);
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
if (u_nsec > PPS_MAXWANDER) {
L_LINT(ftemp, PPS_MAXWANDER);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_intcnt--;
time_status |= STA_PPSWANDER;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
pps_stbcnt++;
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
} else if (u_nsec < -PPS_MAXWANDER) {
L_LINT(ftemp, -PPS_MAXWANDER);
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_intcnt--;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
time_status |= STA_PPSWANDER;
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_stbcnt++;
} else {
pps_intcnt++;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
}
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
if (pps_intcnt >= 4) {
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_intcnt = 4;
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
if (pps_shift < pps_shiftmax) {
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_shift++;
pps_intcnt = 0;
}
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
} else if (pps_intcnt <= -4 || pps_shift > pps_shiftmax) {
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
pps_intcnt = -4;
if (pps_shift > PPS_FAVG) {
pps_shift--;
pps_intcnt = 0;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
}
}
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
if (u_nsec < 0)
u_nsec = -u_nsec;
pps_stabil += (u_nsec * SCALE_PPM - pps_stabil) >> PPS_FAVG;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
/*
Update to the latest nanokernel from Dave Mills.
1999-08-30 12:04:49 +00:00
* The PPS frequency is recalculated and clamped to the maximum
* MAXFREQ. If enabled, the system clock frequency is updated as
* well.
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
*/
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
L_ADD(pps_freq, ftemp);
u_nsec = L_GINT(pps_freq);
if (u_nsec > MAXFREQ)
L_LINT(pps_freq, MAXFREQ);
else if (u_nsec < -MAXFREQ)
L_LINT(pps_freq, -MAXFREQ);
Update the NTP kernel PLL code to the 2000-08-29 version of Dave Mills nanokernel. The FreeBSD private mode hardpps Type 2 PLL has been removed.
2000-09-04 08:19:32 +00:00
if (time_status & STA_PPSFREQ)
Integrate the new "nanokernel" PLL from Dave Mills. This code is backwards compatible with the older "microkernel" PLL, but allows ntpd v4 to use nanosecond resolution. Many other improvements. PPS_SYNC and hardpps() are NOT supported yet.
1999-03-08 12:36:14 +00:00
time_freq = pps_freq;
Move almost all the ntp related stuff from kern_clock.c to kern_ntptime.c. The only bit left over is that which is executed in all calls to hardclock(). Various cleanups and staticizing along the road.
1998-01-14 20:48:16 +00:00
}
#endif /* PPS_SYNC */
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
#ifndef _SYS_SYSPROTO_H_
struct adjtime_args {
struct timeval *delta;
struct timeval *olddelta;
};
#endif
/*
* MPSAFE
*/
/* ARGSUSED */
int
adjtime(struct thread *td, struct adjtime_args *uap)
{
struct timeval atv;
int error;
if ((error = suser(td)))
suser is Giant safe, so optimize a pointless case.
2002-04-19 09:20:13 +00:00
return (error);
mtx_lock(&Giant);
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
if (uap->olddelta) {
atv.tv_sec = time_adjtime / 1000000;
atv.tv_usec = time_adjtime % 1000000;
if (atv.tv_usec < 0) {
atv.tv_usec += 1000000;
atv.tv_sec--;
}
error = copyout(&atv, uap->olddelta, sizeof(atv));
if (error)
goto done2;
}
if (uap->delta) {
error = copyin(uap->delta, &atv, sizeof(atv));
if (error)
goto done2;
time_adjtime = (int64_t)atv.tv_sec * 1000000 + atv.tv_usec;
}
done2:
mtx_unlock(&Giant);
return (error);
}
Reference in New Issue Copy Permalink