GENWiki

Premier IT Outsourcing and Support Services within the UK

User Tools

Site Tools


rfc:rfc1589

Network Working Group D. Mills Request for Comments: 1589 University of Delaware Category: Informational March 1994

              A Kernel Model for Precision Timekeeping

Status of this Memo

 This memo provides information for the Internet community.  This memo
 does not specify an Internet standard of any kind.  Distribution of
 this memo is unlimited.

Overview

 This memorandum describes an engineering model which implements a
 precision time-of-day function for a generic operating system. The
 model is based on the principles of disciplined oscillators and
 phase-lock loops (PLL) often found in the engineering literature. It
 has been implemented in the Unix kernel for several workstations,
 including those made by Sun Microsystems and Digital Equipment. The
 model changes the way the system clock is adjusted in time and
 frequency, as well as provides mechanisms to discipline its frequency
 to an external precision timing source. The model incorporates a
 generic system-call interface for use with the Network Time Protocol
 (NTP) or similar time synchronization protocol. The NTP Version 3
 daemon xntpd operates with this model to provide synchronization
 limited in principle only by the accuracy and stability of the
 external timing source.
 This memorandum does not obsolete or update any RFC. It does not
 propose a standard protocol, specification or algorithm. It is
 intended to provoke comment, refinement and alternative
 implementations. While a working knowledge of NTP is not required for
 an understanding of the design principles or implementation of the
 model, it may be helpful in understanding how the model behaves in a
 fully functional timekeeping system. The architecture and design of
 NTP is described in [1], while the current NTP Version 3 protocol
 specification is given in RFC-1305 [2] and a subset of the protocol,
 the Simple Network Time Protocol (SNTP), in RFC-1361 [4].
 The model has been implemented in three Unix kernels for Sun
 Microsystems and Digital Equipment workstations. In addition, for the
 Digital machines the model provides improved precision to one
 microsecond (us). Since these specific implementations involve
 modifications to licensed code, they cannot be provided directly.
 Inquiries should be directed to the manufacturer's representatives.
 However, the engineering model for these implementations, including a

Mills [Page 1] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 simulator with code segments almost identical to the implementations,
 but not involving licensed code, is available via anonymous FTP from
 host louie.udel.edu in the directory pub/ntp and compressed tar
 archive kernel.tar.Z. The NTP Version 3 distribution can be obtained
 via anonymous ftp from the same host and directory in the compressed
 tar archive xntp3.3g.tar.Z, where the version number shown as 3.3g
 may be adjusted for new versions as they occur.

1. Introduction

 This memorandum describes a model and programming interface for
 generic operating system software that manages the system clock and
 timer functions. The model provides improved accuracy and stability
 for most workstations and servers using the Network Time Protocol
 (NTP) or similar time synchronization protocol. This memorandum
 describes the principles of design and implementation of the model.
 Related technical reports discuss the design approach, engineering
 analysis and performance evaluation of the model as implemented in
 Unix kernels for Sun Microsystems and Digital Equipment workstations.
 The NTP Version 3 daemon xntpd operates with these implementations to
 provide improved accuracy and stability, together with diminished
 overhead in the operating system and network. In addition, the model
 supports the use of external timing sources, such as precision
 pulse-per-second (PPS) signals and the industry standard IRIG timing
 signals. The NTP daemon automatically detects the presence of the new
 features and utilizes them when available.
 There are three prototype implementations of the model presented in
 this memorandum, one each for the Sun Microsystems SPARCstation with
 the SunOS 4.1.x kernel, Digital Equipment DECstation 5000 with the
 Ultrix 4.x kernel and Digital Equipment 3000 AXP Alpha with the OSF/1
 V1.x kernel. In addition, for the DECstation 5000/240 and 3000 AXP
 Alpha machines, a special feature provides improved precision to 1 us
 (Sun 4.1.x kernels already do provide 1-us precision). Other than
 improving the system clock accuracy, stability and precision, these
 implementations do not change the operation of existing Unix system
 calls which manage the system clock, such as gettimeofday(),
 settimeofday() and adjtime(); however, if the new features are in
 use, the operations of gettimeofday() and adjtime() can be controlled
 instead by new system calls ntp_gettime() and ntp_adjtime() as
 described below.
 A detailed description of the variables and algorithms is given in
 the hope that similar functionality can be incorporated in Unix
 kernels for other machines. The algorithms involve only minor changes
 to the system clock and interval timer routines and include
 interfaces for application programs to learn the system clock status
 and certain statistics of the time synchronization process. Detailed

Mills [Page 2] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 installation instructions are given in a specific README files
 included in the kernel distributions.
 In this memorandum, NTP Version 3 and the Unix implementation xntp3
 are used as an example application of the new system calls for use by
 a synchronization daemon. In principle, the new system calls can be
 used by other protocols and implementations as well. Even in cases
 where the local time is maintained by periodic exchanges of messages
 at relatively long intervals, such as using the NIST Automated
 Computer Time Service, the ability to precisely adjust the system
 clock frequency simplifies the synchronization procedures and allows
 the telephone call frequency to be considerably reduced.

2. Design Approach

 While not strictly necessary for an understanding or implementation
 of the model, it may be helpful to briefly describe how NTP operates
 to control the system clock in a client workstation. As described in
 [1], the NTP protocol exchanges timestamps with one or more peers
 sharing a synchronization subnet to calculate the time offsets
 between peer clocks and the local clock. These offsets are processed
 by several algorithms which refine and combine the offsets to produce
 an ensemble average, which is then used to adjust the local clock
 time and frequency. The manner in which the local clock is adjusted
 represents the main topic of this memorandum. The goal in the
 enterprise is the most accurate and stable system clock possible with
 the available kernel software and workstation hardware.
 In order to understand how the new software works, it is useful to
 review how most Unix kernels maintain the system time. In the Unix
 design a hardware counter interrupts the kernel at a fixed rate: 100
 Hz in the SunOS kernel, 256 Hz in the Ultrix kernel and 1024 Hz in
 the OSF/1 kernel. Since the Ultrix timer interval (reciprocal of the
 rate) does not evenly divide one second in microseconds, the Ultrix
 kernel adds 64 microseconds once each second, so the timescale
 consists of 255 advances of 3906 us plus one of 3970 us. Similarly,
 the OSF/1 kernel adds 576 us once each second, so its timescale
 consists of 1023 advances of 976 us plus one of 1552 us.
 2.1. Mechanisms to Adjust Time and Frequency
    In most Unix kernels it is possible to slew the system clock to a
    new offset relative to the current time by using the adjtime()
    system call. To do this the clock frequency is changed by adding
    or subtracting a fixed amount (tickadj) at each timer interrupt
    (tick) for a calculated number of ticks. Since this calculation
    involves dividing the requested offset by tickadj, it is possible
    to slew to a new offset with a precision only of tickadj, which is

Mills [Page 3] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    usually in the neighborhood of 5 us, but sometimes much more. This
    results in a roundoff error which can accumulate to an
    unacceptable degree, so that special provisions must be made in
    the clock adjustment procedures of the synchronization daemon.
    In order to implement a frequency-discipline function, it is
    necessary to provide time offset adjustments to the kernel at
    regular adjustment intervals using the adjtime() system call. In
    order to reduce the system clock jitter to the regime considered
    in this memorandum, it is necessary that the adjustment interval
    be relatively small, in the neighborhood of 1 s. However, the Unix
    adjtime() implementation requires each offset adjustment to
    complete before another one can be begun, which means that large
    adjustments must be amortized in possibly many adjustment
    intervals. The requirement to implement the adjustment interval
    and compensate for roundoff error considerably complicates the
    synchronizing daemon implementation.
    In the new model this scheme is replaced by another that
    represents the system clock as a multiple-word, precision-time
    variable in order to provide very precise clock adjustments. At
    each timer interrupt a precisely calibrated quantity is added to
    the kernel time variable and overflows propagated as required. The
    quantity is computed as in the NTP local clock model described in
    [3], which operates as an adaptive-parameter, first-order, type-II
    phase-lock loop (PLL). In principle, this PLL design can provide
    precision control of the system clock oscillator within 1 us and
    frequency to within parts in 10^11. While precisions of this order
    are surely well beyond the capabilities of the CPU clock
    oscillator used in typical workstations, they are appropriate
    using precision external oscillators as described below.
    The PLL design is identical to the one originally implemented in
    NTP and described in [3]. In this design the software daemon
    simulates the PLL using the adjtime() system call; however, the
    daemon implementation is considerably complicated by the
    considerations described above. The modified kernel routines
    implement the PLL in the kernel using precision time and frequency
    representions, so that these complications are avoided. A new
    system call ntp_adjtime() is called only as each new time update
    is determined, which in NTP occurs at intervals of from 16 s to
    1024 s. In addition, doing frequency compensation in the kernel
    means that the system time runs true even if the daemon were to
    cease operation or the network paths to the primary
    synchronization source fail.
    In the new model the new ntp_adjtime() operates in a way similar
    to the original adjtime() system call, but does so independently

Mills [Page 4] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    of adjtime(), which continues to operate in its traditional
    fashion. When used with NTP, it is the design intent that
    settimeofday() or adjtime() be used only for system time
    adjustments greater than +-128 ms, although the dynamic range of
    the new model is much larger at +-512 ms. It has been the Internet
    experience that the need to change the system time in increments
    greater than +-128 ms is extremely rare and is usually associated
    with a hardware or software malfunction or system reboot.
    The easiest way to set the time is with the settimeofday() system
    call; however, this can under some conditions cause the clock to
    jump backward. If this cannot be tolerated, adjtime() can be used
    to slew the clock to the new value without running backward or
    affecting the frequency discipline process. Once the system clock
    has been set within +-128 ms, the ntp_adjtime() system call is
    used to provide periodic updates including the time offset,
    maximum error, estimated error and PLL time constant. With NTP the
    update interval depends on the measured dispersion and time
    constant; however, the scheme is quite forgiving and neither
    moderate loss of updates nor variations in the update interval are
    serious.
 2.2 Daemon and Application Interface
    Unix application programs can read the system clock using the
    gettimeofday() system call, which returns only the system time and
    timezone data. For some applications it is useful to know the
    maximum error of the reported time due to all causes, including
    clock reading errors, oscillator frequency errors and accumulated
    latencies on the path to a primary synchronization source.
    However, in the new model the PLL adjusts the system clock to
    compensate for its intrinsic frequency error, so that the time
    errors expected in normal operation will usually be much less than
    the maximum error. The programming interface includes a new system
    call ntp_gettime(), which returns the system time, as well as the
    maximum error and estimated error. This interface is intended to
    support applications that need such things, including distributed
    file systems, multimedia teleconferencing and other real-time
    applications. The programming interface also includes the new
    system call ntp_adjtime() mentioned previously, which can be used
    to read and write kernel variables for time and frequency
    adjustment, PLL time constant, leap-second warning and related
    data.
    In addition, the kernel adjusts the maximum error to grow by an
    amount equal to the oscillator frequency tolerance times the
    elapsed time since the last update. The default engineering
    parameters have been optimized for update intervals in the order

Mills [Page 5] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    of 64 s. For other intervals the PLL time constant can be adjusted
    to optimize the dynamic response over intervals of 16-1024 s.
    Normally, this is automatically done by NTP. In any case, if
    updates are suspended, the PLL coasts at the frequency last
    determined, which usually results in errors increasing only to a
    few tens of milliseconds over a day using room-temperature quartz
    oscillators of typical modern workstations.
    While any synchronization daemon can in principle be modified to
    use the new system calls, the most likely will be users of the NTP
    Version 3 daemon xntpd. The xntpd code determines whether the new
    system calls are implemented and automatically reconfigures as
    required. When implemented, the daemon reads the frequency offset
    from a file and provides it and the initial time constant via
    ntp_adjtime(). In subsequent calls to ntp_adjtime(), only the time
    offset and time constant are affected. The daemon reads the
    frequency from the kernel using ntp_adjtime() at intervals of
    about one hour and writes it to a system file. This information is
    recovered when the daemon is restarted after reboot, for example,
    so the sometimes extensive training period to learn the frequency
    separately for each system can be avoided.
 2.3. Precision Clocks for DECstation 5000/240 and 3000 AXP Alpha
    The stock microtime() routine in the Ultrix kernel returns system
    time to the precision of the timer interrupt interval, which is in
    the 1-4 ms range. However, in the DECstation 5000/240 and possibly
    other machines of that family, there is an undocumented IOASIC
    hardware register that counts system bus cycles at a rate of 25
    MHz. The new microtime() routine for the Ultrix kernel uses this
    register to interpolate system time between timer interrupts. This
    results in a precision of 1 us for all time values obtained via
    the gettimeofday() and ntp_gettime() system calls. For the Digital
    Equipment 3000 AXP Alpha, the architecture provides a hardware
    Process Cycle Counter and a machine instruction rpcc to read it.
    This counter operates at the fundamental frequency of the CPU
    clock or some submultiple of it, 133.333 MHz for the 3000/400 for
    example. The new microtime() routine for the OSF/1 kernel uses
    this counter in the same fashion as the Ultrix routine.
    In both the Ultrix and OSF/1 kernels the gettimeofday() and
    ntp_gettime() system call use the new microtime() routine, which
    returns the actual interpolated value, but does not change the
    kernel time variable. Therefore, other routines that access the
    kernel time variable directly and do not call either
    gettimeofday(), ntp_gettime() or microtime() will continue their
    present behavior. The microtime() feature is independent of other
    features described here and is operative even if the kernel PLL or

Mills [Page 6] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    new system calls have not been implemented.
    The SunOS kernel already includes a system clock with 1-us
    resolution; so, in principle, no microtime() routine is necessary.
    An existing kernel routine uniqtime() implements this function,
    but it is coded in the C language and is rather slow at 42-85 us
    per call. A replacement microtime() routine coded in assembler
    language is available in the NTP Version 3 distribution and is
    much faster at about 3 us per call.
 2.4. External Time and Frequency Discipline
    The overall accuracy of a time synchronization subnet with respect
    to Coordinated Universal Time (UTC) depends on the accuracy and
    stability of the primary synchronization source, usually a radio
    or satellite receiver, and the system clock oscillator of the
    primary server. As discussed in [5], the traditional interface
    using an RS232 protocol and serial port precludes the full
    accuracy of the radio clock. In addition, the poor stability of
    typical CPU clock oscillators limits the accuracy, whether or not
    precision time sources are available. There are, however, several
    ways in which the system clock accuracy and stability can be
    improved to the degree limited only by the accuracy and stability
    of the synchronization source and the jitter of the operating
    system.
    Many radio clocks produce special signals that can be used by
    external equipment to precisely synchronize time and frequency.
    Most produce a pulse-per-second (PPS) signal that can be read via
    a modem-control lead of a serial port and some produce a special
    IRIG signal that can be read directly by a bus peripheral, such as
    the KSI/Odetics TPRO IRIG SBus interface, or indirectly via the
    audio codec of some workstations, as described in [5]. In the NTP
    Version 3 distribution, the PPS signal can be used to augment the
    less precise ASCII serial timecode to improve accuracy to the
    order of microseconds. Support is also included in the
    distribution for the TPRO interface as well as the audio codec;
    however, the latter requires a modified kernel audio driver
    contained in the bsd_audio.tar.Z distribution in the same host and
    directory as the NTP Version 3 distribution mentioned previously.
    2.4.1. PPS Signal
       The NTP Version 3 distribution includes a special ppsclock
       module for the SunOS 4.1.x kernel that captures the PPS signal
       presented via a modem-control lead of a serial port. Normally,
       the ppsclock module produces a timestamp at each transition of
       the PPS signal and provides it to the synchronization daemon

Mills [Page 7] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       for integration with the serial ASCII timecode, also produced
       by the radio clock. With the conventional PLL implementation in
       either the daemon or the kernel as described above, the
       accuracy of this scheme is limited by the intrinsic stability
       of the CPU clock oscillator to a millisecond or two, depending
       on environmental temperature variations.
       The ppsclock module has been modified to in addition call a new
       kernel routine hardpps() once each second. The kernel routine
       compares the timestamp with a sample of the CPU clock
       oscillator to develop a frequency offset estimate. This offset
       is used to discipline the oscillator frequency, nominally to
       within a few parts in 10^8, which is about two orders of
       magnitude better than the undisciplined oscillator. The new
       feature is conditionally compiled in the code described below
       only if the PPS_SYNC option is used in the kernel configuration
       file.
       When using the PPS signal to adjust the time, there is a
       problem with the SunOS implementation which is very delicate to
       fix. The Sun serial port interrupt routine operates at
       interrupt priority level 12, while the timer interrupt routine
       operates at priority 10. Thus, it is possible that the PPS
       signal interrupt can occur during the timer interrupt routine,
       with result that a tick increment can be missed and the
       returned time early by one tick. It may happen that, if the CPU
       clock oscillator is within a few ppm of the PPS oscillator,
       this condition can persist for two or more successive PPS
       interrupts. A useful workaround has been to use a median filter
       to process the PPS sample offsets. In this filter the sample
       offsets in a window of 20 samples are sorted by offset and the
       six highest and six lowest outlyers discarded. The average of
       the eight samples remaining becomes the output of the filter.
       The problem is not nearly so serious when using the PPS signal
       to discipline the frequency of the CPU clock oscillator. In
       this case the quantity of interest is the contents of the
       microseconds counter only, which does not depend on the kernel
       time variable.
    2.4.2. External Clocks
       It is possible to replace the system clock function with an
       external bus peripheral. The TPRO device mentioned previously
       can be used to provide IRIG-synchronized time with a precision
       of 1 us. A driver for this device tprotime.c and header file
       tpro.h are included in the kernel.tar.Z distribution mentioned
       previously. Using this device the system clock is read directly

Mills [Page 8] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       from the interface; however, the device does not record the
       year, so special provisions have to be made to obtain the year
       from the kernel time variable and initialize the driver
       accordingly. This feature is conditionally compiled in the code
       described below only if the EXT_CLOCK option is used in the
       kernel configuration file.
       While the system clock function is provided directly by the
       microtime() routine in the driver, the kernel time variable
       must be disciplined as well, since not all system timing
       functions use the microtime() routine. This is done by
       measuring the difference between the microtime() clock and
       kernel time variable and using the difference to adjust the
       kernel PLL as if the adjustment were provided by an external
       peer and NTP.
       A good deal of error checking is done in the TPRO driver, since
       the system clock is vulnerable to a misbehaving radio clock,
       IRIG signal source, interface cables and TPRO device itself.
       Unfortunately, there is no easy way to utilize the extensive
       diversity and redundancy capabilities available in the NTP
       synchronization daemon. In order to avoid disruptions that
       might occur if the TPRO time is far different from the kernel
       time variable, the latter is used instead of the former if the
       difference between the two exceeds 1000 s; presumably in that
       case operator intervention is required.
    2.4.3. External Oscillators
       Even if a source of PPS or IRIG signals is not available, it is
       still possible to improve the stability of the system clock
       through the use of a specialized bus peripheral. In order to
       explore the benefits of such an approach, a special SBus
       peripheral caled HIGHBALL has been constructed. The device
       includes a pair of 32-bit hardware counters in Unix timeval
       format, together with a precision, oven-controlled quartz
       oscillator with a stability of a few parts in 10^9. A driver
       for this device hightime.c and header file high.h are included
       in the kernel.tar.Z distribution mentioned previously. This
       feature is conditionally compiled in the code described below
       only if the EXT_CLOCK and HIGHBALL options are used in the
       kernel configuration file.
       Unlike the external clock case, where the system clock function
       is provided directly by the microtime() routine in the driver,
       the HIGHBALL counter offsets with respect to UTC must be
       provided first.  This is done using the ordinary kernel PLL,
       but controlling the counter offsets directly, rather than the

Mills [Page 9] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       kernel time variable. At first, this might seem to defeat the
       purpose of the design, since the jitter and wander of the
       synchronization source will affect the counter offsets and thus
       the accuracy of the time. However, the jitter is much reduced
       by the PLL and the wander is small, especially if using a radio
       clock or another primary server disciplined in the same way.
       In practice, the scheme works to reduce the incidental wander
       to a few parts in 10^8, or about the same as using the PPS
       signal.
       As in the previous case, the kernel time variable must be
       disciplined as well, since not all system timing functions use
       the microtime() routine. However, the kernel PLL cannot be used
       for this, since it is already in use providing offsets for the
       HIGHBALL counters. Therefore, a special correction is
       calculated from the difference between the microtime() clock
       and the kernel time variable and used to adjust the kernel time
       variable at the next timer interrupt. This somewhat roundabout
       approach is necessary in order that the adjustment does not
       cause the kernel time variable to jump backwards and possibly
       lose or duplicate a timer event.
 2.5 Other Features
    It is a design feature of the NTP architecture that the system
    clocks in a synchronization subnet are to read the same or nearly
    the same values before during and after a leap-second event, as
    declared by national standards bodies. The new model is designed
    to implement the leap event upon command by an ntp_adjtime()
    argument. The intricate and sometimes arcane details of the model
    and implementation are discussed in [3] and [5]. Further details
    are given in the technical summary later in this memorandum.

3. Technical Summary

 In order to more fully understand the workings of the model, a stand-
 alone simulator kern.c and header file timex.h are included in the
 kernel.tar.Z distribution mentioned previously. In addition, a
 complete C program kern_ntptime.c which implements the ntp_gettime()
 and ntp_adjtime() functions is provided, but with the vendor-specific
 argument-passing code deleted. Since the distribution is somewhat
 large, due to copious comments and ornamentation, it is impractical
 to include a listing of these programs in this memorandum. In any
 case, implementors may choose to snip portions of the simulator for
 use in new kernel designs, but, due to formatting conventions, this
 would be difficult if included in this memorandum.

Mills [Page 10] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 The kern.c program is an implementation of an adaptive-parameter,
 first-order, type-II phase-lock loop. The system clock is implemented
 using a set of variables and algorithms defined in the simulator and
 driven by explicit offsets generated by a driver program also
 included in the program. The algorithms include code fragments almost
 identical to those in the machine-specific kernel implementations and
 operate in the same way, but the operations can be understood
 separately from any licensed source code into which these fragments
 may be integrated. The code fragments themselves are not derived from
 any licensed code. The following discussion assumes that the
 simulator code is available for inspection.
 3.1. PLL Simulation
    The simulator operates in conformance with the analytical model
    described in [3]. The main() program operates as a driver for the
    fragments hardupdate(), hardclock(), second_overflow(), hardpps()
    and microtime(), although not all functions implemented in these
    fragments are simulated. The program simulates the PLL at each
    timer interrupt and prints a summary of critical program variables
    at each time update.
    There are three defined options in the kernel configuration file
    specific to each implementation. The PPS_SYNC option provides
    support for a pulse-per-second (PPS) signal, which is used to
    discipline the frequency of the CPU clock oscillator. The
    EXT_CLOCK option provides support for an external kernel-readable
    clock, such as the KSI/Odetics TPRO IRIG interface or HIGHBALL
    precision oscillator, both for the SBus. The TPRO option provides
    support for the former, while the HIGHBALL option provides support
    for the latter. External clocks are implemented as the microtime()
    clock driver, with the specific source code selected by the kernel
    configuration file.
    3.1.1. The hardupdate() Fragment
       The hardupdate() fragment is called by ntp_adjtime() as each
       update is computed to adjust the system clock phase and
       frequency. Note that the time constant is in units of powers of
       two, so that multiplies can be done by simple shifts. The phase
       variable is computed as the offset divided by the time
       constant. Then, the time since the last update is computed and
       clamped to a maximum (for robustness) and to zero if
       initializing. The offset is multiplied (sorry about the ugly
       multiply) by the result and divided by the square of the time
       constant and then added to the frequency variable. Note that
       all shifts are assumed to be positive and that a shift of a
       signed quantity to the right requires a little dance.

Mills [Page 11] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       With the defines given, the maximum time offset is determined
       by the size in bits of the long type (32 or 64) less the
       SHIFT_UPDATE scale factor (12) or at least 20 bits (signed).
       The scale factor is chosen so that there is no loss of
       significance in later steps, which may involve a right shift up
       to SHIFT_UPDATE bits. This results in a time adjustment range
       over +-512 ms. Since time_constant must be greater than or
       equal to zero, the maximum frequency offset is determined by
       the SHIFT_USEC scale factor (16) or at least 16 bits (signed).
       This results in a frequency adjustment range over +-31,500 ppm.
       In the addition step, the value of offset * mtemp is not
       greater than MAXPHASE * MAXSEC = 31 bits (signed), which will
       not overflow a long add on a 32-bit machine. There could be a
       loss of precision due to the right shift of up to 12 bits,
       since time_constant is bounded at 6. This results in a net
       worst-case frequency resolution of about .063 ppm, which is not
       significant for most quartz oscillators. The worst case could
       be realized only if the NTP peer misbehaves according to the
       protocol specification.
       The time_offset value is clamped upon entry. The time_phase
       variable is an accumulator, so is clamped to the tolerance on
       every call. This helps to damp transients before the oscillator
       frequency has been determined, as well as to satisfy the
       correctness assertions if the time synchronization protocol or
       implementation misbehaves.
    3.1.2. The hardclock() Fragment
       The hardclock() fragment is inserted in the hardware timer
       interrupt routine at the point the system clock is to be
       incremented. Previous to this fragment the time_update variable
       has been initialized to the value computed by the adjtime()
       system call in the stock Unix kernel, normally plus/minus the
       tickadj value, which is usually in the order of 5 us. The
       time_phase variable, which represents the instantaneous phase
       of the system clock, is advanced by time_adj, which is
       calculated in the second_overflow() fragment described below.
       If the value of time_phase exceeds 1 us in scaled units,
       time_update is increased by the (signed) excess and time_phase
       retains the residue.
       Except in the case of an external oscillator such as the
       HIGHBALL interface, the hardclock() fragment advances the
       system clock by the value of tick plus time_update. However, in
       the case of an external oscillator, the system clock is
       obtained directly from the interface and time_update used to

Mills [Page 12] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       discipline that interface instead. However, the system clock
       must still be disciplined as explained previously, so the value
       of clock_cpu computed by the second_overflow() fragment is used
       instead.
    3.1.3. The second_overflow() Fragment
       The second_overflow() fragment is inserted at the point where
       the microseconds field of the system time variable is being
       checked for overflow. Upon overflow the maximum error
       time_maxerror is increased by time_tolerance to reflect the
       maximum time offset due to oscillator frequency error. Then,
       the increment time_adj to advance the kernel time variable is
       calculated from the (scaled) time_offset and time_freq
       variables updated at the last call to the hardclock() fragment.
       The phase adjustment is calculated as a (signed) fraction of
       the time_offset remaining, where the fraction is added to
       time_adj, then subtracted from time_offset. This technique
       provides a rapid convergence when offsets are high, together
       with good resolution when offsets are low. The frequency
       adjustment is the sum of the (scaled) time_freq variable, an
       adjustment necessary when the tick interval does not evenly
       divide one second fixtick and PPS frequency adjustment pps_ybar
       (if configured).
       The scheme of approximating exact multiply/divide operations
       with shifts produces good results, except when an exact
       calculation is required, such as when the PPS signal is being
       used to discipling the CPU clock oscillator frequency, as
       described below. As long as the actual oscillator frequency is
       a power of two in seconds, no correction is required. However,
       in the SunOS kernel the clock frequency is 100 Hz, which
       results in an error factor of 0.78. In this case the code
       increases time_adj by a factor of 1.25, which results in an
       overall error less than three percent.
       On rollover of the day, the leap-second state machine described
       below  determines whether a second is to be inserted or deleted
       in the timescale. The microtime() routine insures that the
       reported time is always monotonically increasing.
    3.1.4. The hardpps() Fragment
       The hardpps() fragment is operative only if the PPS_SYNC option
       is specified in the kernel configuration file. It is called
       from the serial port driver or equivalent interface at the on-
       time transition of the PPS signal. The fragment operates as a

Mills [Page 13] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       first-order, type-I frequency-lock loop (FLL) controlled by the
       difference between the frequency represented by the pps_ybar
       variable and the frequency of the hardware clock oscillator.
       In order to avoid calling the microtime() routine more than
       once for each PPS transition, the interface requires the
       calling program to capture the system time and hardware counter
       contents at the on-time transition of the PPS signal and
       provide a pointer to the timestamp (Unix timeval) and counter
       contents as arguments to the hardpps() call. The hardware
       counter contents can be determined by saving the microseconds
       field of the system time, calling the microtime() routine, and
       subtracting the saved value. If a counter overflow has occured
       during the process, the resulting microseconds value will be
       negative, in which case the caller adds 1000000 to normalize
       the microseconds field.
       The frequency of the hardware oscillator can be determined from
       the difference in hardware counter readings at the beginning
       and end of the calibration interval divided by the duration of
       the interval. However, the oscillator frequency tolerance, as
       much as 100 ppm, may cause the difference to exceed the tick
       value, creating an ambiguity. In order to avoid this ambiguity,
       the hardware counter value at the beginning of the interval is
       increased by the current pps_ybar value once each second, but
       computed modulo the tick value. At the end of the interval, the
       difference between this value and the value computed from the
       hardware counter is used as a control signal sample for the
       FLL.
       Control signal samples which exceed the frequency tolerance are
       discarded, as well as samples resulting from excessive interval
       duration jitter. Surviving samples are then processed by a
       three-stage median filter. The signal which drives the FLL is
       derived from the median sample, while the average of
       differences between the other two samples is used as a measure
       of dispersion. If the dispersion is below the threshold
       pps_dispmax, the median is used to correct the pps_ybar value
       with a weight expressed as a shift PPS_AVG (2). In addition to
       the averaging function, pps_disp is increased by the amount
       pps_dispinc once each second. The result is that, should the
       dispersion be exceptionally high, or if the PPS signal fails
       for some reason, the pps_disp will eventually exceed
       pps_dispmax and raise an alarm.
       Initially, an approximate value for pps_ybar is not known, so
       the duration of the calibration interval must be kept small to
       avoid overflowing the tick. The time difference at the end of

Mills [Page 14] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       the calibration interval is measured. If greater than a
       fraction tick/4, the interval is reduced by half. If less than
       this fraction for four successive calibration intervals, the
       interval is doubled. This design automatically adapts to
       nominal jitter in the PPS signal, as well as the value of tick.
       The duration of the calibration interval is set by the
       pps_shift variable as a shift in powers of two. The minimum
       value PPS_SHIFT (2) is chosen so that with the highest CPU
       oscillator frequency 1024 Hz and frequency tolerance 100 ppm
       the tick will not overflow. The maximum value PPS_SHIFTMAX (8)
       is chosen such that the maximum averaging time is about 1000 s
       as determined by measurements of Allan variance [5].
       Should the PPS signal fail, the current frequency estimate
       pps_ybar continues to be used, so the nominal frequency remains
       correct subject only to the instability of the undisciplined
       oscillator. The procedure to save and restore the frequency
       estimate works as follows. When setting the frequency from a
       file, the time_freq value is set as the file value minus the
       pps_ybar value; when retrieving the frequency, the two values
       are added before saving in the file. This scheme provides a
       seamless interface should the PPS signal fail or the kernel
       configuration change. Note that the frequency discipline is
       active whether or not the synchronization daemon is active.
       Since all Unix systems take some time after reboot to build a
       running system, usually by that time the discipline process has
       already settled down and the initial transients due to
       frequency discipline have damped out.
    3.1.4. External Clock Interface
       The external clock driver interface is implemented with two
       routines, microtime(), which returns the current clock time,
       and clock_set(), which furnishes the apparent system time
       derived from the kernel time variable. The latter routine is
       called only when the clock is set using the settimeofday()
       system call, but can be called from within the driver, such as
       when the year rolls over, for example.
       In the stock SunOS kernel and modified Ultrix and OSF/1
       kernels, the microtime() routine returns the kernel time
       variable plus an interpolation between timer interrupts based
       on the contents of a hardware counter. In the case of an
       external clock, such as described above, the system clock is
       read directly from the hardware clock registers. Examples of
       external clock drivers are in the tprotime.c and hightime.c
       routines included in the kernel.tar.Z distribution.

Mills [Page 15] RFC 1589 Kernel Model for Precision Timekeeping March 1994

       The external clock routines return a status code which
       indicates whether the clock is operating correctly and the
       nature of the problem, if not. The return code is interpreted
       by the ntp_gettime() system call, which transitions the status
       state machine to the TIME_ERR state if an error code is
       returned. This is the only error checking implemented for the
       external clock in the present version of the code.
    The simulator has been used to check the PLL operation over the
    design envelope of +-512 ms in time error and +-100 ppm in
    frequency error. This confirms that no overflows occur and that
    the loop initially converges in about 15 minutes for timer
    interrupt rates from 50 Hz to 1024 Hz. The loop has a normal
    overshoot of a few percent and a final convergence time of several
    hours, depending on the initial time and frequency error.
 3.2. Leap Seconds
    It does not seem generally useful in the user application
    interface to provide additional details private to the kernel and
    synchronization protocol, such as stratum, reference identifier,
    reference timestamp and so forth. It would in principle be
    possible for the application to independently evaluate the quality
    of time and project into the future how long this time might be
    "valid." However, to do that properly would duplicate the
    functionality of the synchronization protocol and require
    knowledge of many mundane details of the platform architecture,
    such as the subnet configuration, reachability status and related
    variables. For the curious, the ntp_adjtime() system call can be
    used to reveal some of these mysteries.
    However, the user application may need to know whether a leap
    second is scheduled, since this might affect interval calculations
    spanning the event. A leap-warning condition is determined by the
    synchronization protocol (if remotely synchronized), by the
    timecode receiver (if available), or by the operator (if awake).
    This condition is set by the synchronization daemon on the day the
    leap second is to occur (30 June or 31 December, as announced) by
    specifying in a ntp_adjtime() system call a clock status of either
    TIME_DEL, if a second is to be deleted, or TIME_INS, if a second
    is to be inserted. Note that, on all occasions since the inception
    of the leap-second scheme, there has never been a deletion
    occasion, nor is there likely to be one in future. If the value is
    TIME_DEL, the kernel adds one second to the system time
    immediately following second 23:59:58 and resets the clock status
    to TIME_OK. If the value is TIME_INS, the kernel subtracts one
    second from the system time immediately following second 23:59:59
    and resets the clock status to TIME_OOP, in effect causing system

Mills [Page 16] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    time to repeat second 59. Immediately following the repeated
    second, the kernel resets the clock status to TIME_OK.
    Depending upon the system call implementation, the reported time
    during a leap second may repeat (with the TIME_OOP return code set
    to advertise that fact) or be monotonically adjusted until system
    time "catches up" to reported time. With the latter scheme the
    reported time will be correct before and shortly after the leap
    second (depending on the number of microtime() calls during the
    leap second), but freeze or slowly advance during the leap second
    itself. However, Most programs will probably use the ctime()
    library routine to convert from timeval (seconds, microseconds)
    format to tm format (seconds, minutes,...). If this routine is
    modified to use the ntp_gettime() system call and inspect the
    return code, it could simply report the leap second as second 60.
 3.3. Clock Status State Machine
    The various options possible with the system clock model described
    in this memorandum require a careful examination of the state
    transitions, status indications and recovery procedures should a
    crucial signal or interface fail. In this section is presented a
    prototype state machine designed to support leap second insertion
    and deletion, as well as reveal various kinds of errors in the
    synchronization process. The states of this machine are decoded as
    follows:
    TIME_OK   If an external clock is present, it is working properly
              and the system clock is derived from it. If no external
              clock is present, the synchronization daemon is working
              properly and the system clock is synchronized to a radio
              clock or one or more peers.
    TIME_INS  An insertion of one second in the system clock has been
              declared following the last second of the current day,
              but has not yet been executed.
    TIME_DEL  A deletion of the last second of the current day has
              been declared, but not yet executed.
    TIME_OOP  An insertion of one second in the system clock has been
              declared following the last second of the current day.
              The second is in progress, but not yet completed.
              Library conversion routines should interpret this second
              as 23:59:60.

Mills [Page 17] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    TIME_BAD  Either (a) the synchronization daemon has declared the
              protocol is not working properly, (b) all sources of
              outside synchronization have been lost or (c) an
              external clock is present and it has just become
              operational following a non-operational condition.
    TIME_ERR  An external clock is present, but is in a non-
              operational condition.
    In all except the TIME_ERR state the system clock is derived from
    either an external clock, if present, or the kernel time variable,
    if not. In the TIME_ERR state the external clock is present, but
    not working properly, so the system clock may be derived from the
    kernel time variable. The following diagram indicates the normal
    transitions of the state machine. Not all valid transitions are
    shown.
        +--------+     +--------+     +--------+     +--------+
        |        |     |        |     |        |     |        |
        |TIME_BAD|---->|TIME_OK |<----|TIME_OOP|<----|TIME_INS|
        |        |     |        |     |        |     |        |
        +--------+     +--------+     +--------+     +--------+
             A              A
             |              |
             |              |
        +--------+     +--------+
        |        |     |        |
        |TIME_ERR|     |TIME_DEL|
        |        |     |        |
        +--------+     +--------+
    The state machine makes a transition once each second at an
    instant where the microseconds field of the kernel time variable
    overflows and one second is added to the seconds field. However,
    this condition is checked at each timer interrupt, which may not
    exactly coincide with the actual instant of overflow. This may
    lead to some interesting anomalies, such as a status indication of
    a leap second in progress (TIME_OOP) when actually the leap second
    had already expired.
    The following state transitions are executed automatically by the
    kernel:
    any state -> TIME_ERR   This transition occurs when an external
                            clock is present and an attempt is made to
                            read it when in a non-operational
                            condition.

Mills [Page 18] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    TIME_INS -> TIME_OOP    This transition occurs immediately
                            following second 86,400 of the current day
                            when an insert-second event has been
                            declared.
    TIME_OOP -> TIME_OK     This transition occurs immediately
                            following second 86,401 of the current
                            day; that is, one second after entry to
                            the TIME_OOP state.
    TIME_DEL -> TIME_OK     This transition occurs immediately
                            following second 86,399 of the current day
                            when a delete-second event has been
                            declared.
    The following state transitions are executed by specific
    ntp_adjtime() system calls:
    TIME_OK -> TIME_INS     This transition occurs as the result of a
                            ntp_adjtime() system call to declare an
                            insert-second event.
    TIME_OK -> TIME_DEL     This transition occurs as the result of a
                            ntp_adjtime() system call to declare a
                            delete-second event.
    any state -> TIME_BAD   This transition occurs as the result of a
                            ntp_adjtime() system call to declare loss
                            of all sources of synchronization or in
                            other cases of error.
    The following table summarizes the actions just before, during and
    just after a leap-second event. Each line in the table shows the
    UTC and NTP times at the beginning of the second. The left column
    shows the behavior when no leap event is to occur. In the middle
    column the state machine is in TIME_INS at the end of UTC second
    23:59:59 and the NTP time has just reached 400. The NTP time is
    set back one second to 399 and the machine enters TIME_OOP. At the
    end of the repeated second the machine enters TIME_OK and the UTC
    and NTP times are again in correspondence. In the right column the
    state machine is in TIME_DEL at the end of UTC second 23:59:58 and
    the NTP time has just reached 399. The NTP time is incremented,
    the machine enters TIME_OK and both UTC and NTP times are again in
    correspondence.

Mills [Page 19] RFC 1589 Kernel Model for Precision Timekeeping March 1994

                 No Leap       Leap Insert    Leap Delete
                 UTC NTP         UTC NTP        UTC NTP
            ---------------------------------------------
            23:59:58|398    23:59:58|398   23:59:58|398
                    |               |              |
            23:59:59|399    23:59:59|399   00:00:00|400
                    |               |              |
            00:00:00|400    23:59:60|399   00:00:01|401
                    |               |              |
            00:00:01|401    00:00:00|400   00:00:02|402
                    |               |              |
            00:00:02|402    00:00:01|401   00:00:03|403
                    |               |              |
    To determine local midnight without fuss, the kernel code simply
    finds the residue of the time.tv_sec (or time.tv_sec + 1) value
    mod 86,400, but this requires a messy divide. Probably a better
    way to do this is to initialize an auxiliary counter in the
    settimeofday() routine using an ugly divide and increment the
    counter at the same time the time.tv_sec is incremented in the
    timer interrupt routine. For future embellishment.

4. Programming Model and Interfaces

 This section describes the programming model for the synchronization
 daemon and user application programs. The ideas are based on
 suggestions from Jeff Mogul and Philip Gladstone and a similar
 interface designed by the latter. It is important to point out that
 the functionality of the original Unix adjtime() system call is
 preserved, so that the modified kernel will work as the unmodified
 one, should the new features not be in use. In this case the
 ntp_adjtime() system call can still be used to read and write kernel
 variables that might be used by a synchronization daemon other than
 NTP, for example.
 4.1. The ntp_gettime() System Call
    The syntax and semantics of the ntp_gettime() call are given in
    the following fragment of the timex.h header file. This file is
    identical, except for the SHIFT_HZ define, in the SunOS, Ultrix
    and OSF/1 kernel distributions. (The SHIFT_HZ define represents
    the logarithm to the base 2 of the clock oscillator frequency
    specific to each system type.) Note that the timex.h file calls
    the syscall.h system header file, which must be modified to define
    the SYS_ntp_gettime system call specific to each system type. The
    kernel distributions include directions on how to do this.

Mills [Page 20] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    /*
     * This header file defines the Network Time Protocol (NTP)
     * interfaces for user and daemon application programs. These are
     * implemented using private system calls and data structures and
     * require specific kernel support.
     *
     * NAME
     *   ntp_gettime - NTP user application interface
     *
     * SYNOPSIS
     *   #include <sys/timex.h>
     *
     *   int system call(SYS_ntp_gettime, tptr)
     *
     *   int SYS_ntp_gettime     defined in syscall.h header file
     *   struct ntptimeval *tptr pointer to ntptimeval structure
     *
     * NTP user interface - used to read kernel clock values
     * Note: maximum error = NTP synch distance = dispersion + delay /
     * 2
     * estimated error = NTP dispersion.
     */
    struct ntptimeval {
         struct timeval time;    /* current time */
         long maxerror;          /* maximum error (us) */
         long esterror;          /* estimated error (us) */
    };
    The ntp_gettime() system call returns three values in the
    ntptimeval structure: the current time in unix timeval format plus
    the maximum and estimated errors in microseconds. While the 32-bit
    long data type limits the error quantities to something more than
    an hour, in practice this is not significant, since the protocol
    itself will declare an unsynchronized condition well below that
    limit. In the NTP Version 3 specification, if the protocol
    computes either of these values in excess of 16 seconds, they are
    clamped to that value and the system clock declared
    unsynchronized.
    Following is a detailed description of the ntptimeval structure
    members.

Mills [Page 21] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    struct timeval time;    /* current time */
       This member returns the current system time, expressed as a
       Unix timeval structure. The timeval structure consists of two
       32-bit words; the first returns the number of seconds past 1
       January 1970, while the second returns the number of
       microseconds.
    long maxerror;          /* maximum error (us) */
       This member returns the time_maxerror kernel variable in
       microseconds. See the entry for this variable in section 5 for
       additional information.
    long esterror;          /* estimated error (us) */
       This member returns the time_esterror kernel variable in
       microseconds. See the entry for this variable in section 5 for
       additional information.

Mills [Page 22] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 4.2. The ntp_adjtime() System Call
    The syntax and semantics of the ntp_adjtime() call are given in
    the following fragment of the timex.h header file. Note that, as
    in the ntp_gettime() system call, the syscall.h system header file
    must be modified to define the SYS_ntp_adjtime system call
    specific to each system type.
    /*
     * NAME
     *   ntp_adjtime - NTP daemon application interface
     *
     * SYNOPSIS
     *   #include <sys/timex.h>
     *
     *   int system call(SYS_ntp_adjtime, mode, tptr)
     *
     *   int SYS_ntp_adjtime     defined in syscall.h header file
     *   struct timex *tptr      pointer to timex structure
     *
     * NTP daemon interface - used to discipline kernel clock
     * oscillator
     */
    struct timex {
        int mode;                /* mode selector */
        long offset;             /* time offset (us) */
        long frequency;          /* frequency offset (scaled ppm) */
        long maxerror;           /* maximum error (us) */
        long esterror;           /* estimated error (us) */
        int status;              /* clock command/status */
        long time_constant;      /* pll time constant */
        long precision;          /* clock precision (us) (read only)
                                  */
        long tolerance;          /* clock frequency tolerance (scaled
                                  * ppm) (read only) */
        /*
         * The following read-only structure members are implemented
         * only if the PPS signal discipline is configured in the
         * kernel.
         */
        long ybar;               /* frequency estimate (scaled ppm) */
        long disp;               /* dispersion estimate (scaled ppm)
                                  */
        int shift;               /* interval duration (s) (shift) */
        long calcnt;             /* calibration intervals */
        long jitcnt;             /* jitter limit exceeded */
        long discnt;             /* dispersion limit exceeded */
    };

Mills [Page 23] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    The ntp_adjtime() system call is used to read and write certain
    time-related kernel variables summarized in this and subsequent
    sections. Writing these variables can only be done in superuser
    mode. To write a variable, the mode structure member is set with
    one or more bits, one of which is assigned each of the following
    variables in turn. The current values for all variables are
    returned in any case; therefore, a mode argument of zero means to
    return these values without changing anything.
    Following is a description of the timex structure members.
    int mode;               /* mode selector */
       This is a bit-coded variable selecting one or more structure
       members, with one bit assigned each member. If a bit is set,
       the value of the associated member variable is copied to the
       corresponding kernel variable; if not, the member is ignored.
       The bits are assigned as given in the following fragment of the
       timex.h header file. Note that the precision and tolerance are
       determined by the kernel and cannot be changed by
       ntp_adjtime().
       /*
        * Mode codes (timex.mode)
        */
       #define ADJ_OFFSET       0x0001    /* time offset */
       #define ADJ_FREQUENCY    0x0002    /* frequency offset */
       #define ADJ_MAXERROR     0x0004    /* maximum time error */
       #define ADJ_ESTERROR     0x0008    /* estimated time error */
       #define ADJ_STATUS       0x0010    /* clock status */
       #define ADJ_TIMECONST    0x0020    /* pll time constant */
    long offset;            /* time offset (us) */
       If selected, this member replaces the value of the time_offset
       kernel variable in microseconds. The absolute value must be
       less than MAXPHASE microseconds defined in the timex.h header
       file. See the entry for this variable in section 5 for
       additional information.
       If within range and the PPS signal and/or external oscillator
       are configured and operating properly, the clock status is
       automatically set to TIME_OK.

Mills [Page 24] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long time_constant;     /* pll time constant */
       If selected, this member replaces the value of the
       time_constant kernel variable. The value must be between zero
       and MAXTC defined in the timex.h header file. See the entry for
       this variable in section 5 for additional information.
    long frequency;         /* frequency offset (scaled ppm) */
       If selected, this member replaces the value of the
       time_frequency kernel variable. The value is in ppm, with the
       integer part in the high order 16 bits and fraction in the low
       order 16 bits. The absolute value must be in the range less
       than MAXFREQ ppm defined in the timex.h header file. See the
       entry for this variable in section 5 for additional
       information.
    long maxerror;          /* maximum error (us) */
       If selected, this member replaces the value of the
       time_maxerror kernel variable in microseconds. See the entry
       for this variable in section 5 for additional information.
    long esterror;          /* estimated error (us) */
       If selected, this member replaces the value of the
       time_esterror kernel variable in microseconds. See the entry
       for this variable in section 5 for additional information.
    int status;             /* clock command/status */
       If selected, this member replaces the value of the time_status
       kernel variable. See the entry for this variable in section 5
       for additional information.
       In order to set this variable by ntp_adjtime(), either (a) the
       current clock status must be TIME_OK or (b) the member value is
       TIME_BAD; that is, the ntp_adjtime() call can always set the
       clock to the unsynchronized state or, if the clock is running
       correctly, can set it to any state. In any case, the
       ntp_adjtime() call always returns the current state in this
       member, so the caller can determine whether or not the request
       succeeded.

Mills [Page 25] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long time_constant;     /* pll time constant */
       If selected, this member replaces the value of the
       time_constant kernel variable. The value must be between zero
       and MAXTC defined in the timex.h header file. See the entry for
       this variable in section 5 for additional information.
    long precision;         /* clock precision (us) (read only) */
       This member returns the time_precision kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.
    long tolerance;         /* clock frequency tolerance (scaled ppm)
                             */
       This member returns the time_tolerance kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.
    long ybar;              /* frequency estimate (scaled ppm) */
       This member returns the pps_ybar kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.
    long disp;              /* dispersion estimate (scaled ppm) */
       This member returns the pps_disp kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.
    int shift;              /* interval duration (s) (shift) */
       This member returns the pps_shift kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.

Mills [Page 26] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long calcnt;            /* calibration intervals */
       This member returns the pps_calcnt kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.
    long jitcnt;            /* jitter limit exceeded */
       This member returns the pps_jittcnt kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.
    long discnt;            /* dispersion limit exceeded */
       This member returns the pps_discnt kernel variable in
       microseconds. The variable can be written only by the kernel.
       See the entry for this variable in section 5 for additional
       information.

Mills [Page 27] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 4.3. Command/Status Codes
    The kernel routines use the system clock status variable
    time_status, which records whether the clock is synchronized,
    waiting for a leap second, etc. The value of this variable is
    returned as the result code by both the ntp_gettime() and
    ntp_adjtime() system calls. In addition, it can be explicitly read
    and written using the ntp_adjtime() system call, but can be
    written only in superuser mode. Values presently defined in the
    timex.h header file are as follows:
    /*
     * Clock command/status codes (timex.status)
     */
    #define TIME_OK    0    /* clock synchronized */
    #define TIME_INS   1    /* insert leap second */
    #define TIME_DEL   2    /* delete leap second */
    #define TIME_OOP   3    /* leap second in progress */
    #define TIME_BAD   4    /* kernel clock not synchronized */
    #define TIME_ERR   5    /* external oscillator not
                               synchronized */
    A detailed description of these codes as used by the leap-second
    state machine is given later in this memorandum. In case of a
    negative result code, the kernel has intercepted an invalid
    address or (in case of the ntp_adjtime() system call), a superuser
    violation.

5. Kernel Variables

 This section contains a list of kernel variables and a detailed
 description of their function, initial value, scaling and limits.
 5.1. Interface Variables
    The following variables are read and set by the ntp_adjtime()
    system call. Additional automatic variables are used as
    temporaries as described in the code fragments.
    int time_status = TIME_BAD;
       This variable controls the state machine used to insert or
       delete leap seconds and show the status of the timekeeping
       system, PPS signal and external oscillator, if configured.

Mills [Page 28] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long time_offset = 0;
       This variable is used by the PLL to adjust the system time in
       small increments. It is scaled by (1 << SHIFT_UPDATE) (12) in
       microseconds. The maximum value that can be represented is
       about +-512 ms and the minimum value or precision is a few
       parts in 10^10 s.
    long time_constant = 0;      /* pll time constant */
       This variable determines the bandwidth or "stiffness" of the
       PLL. The value is used as a shift between zero and MAXTC (6),
       with the effective PLL time constant equal to a multiple of (1
       << time_constant) in seconds. For room-temperature quartz
       oscillator the recommended default value is 2, which
       corresponds to a PLL time constant of about 900 s and a maximum
       update interval of about 64 s. The maximum update interval
       scales directly with the time constant, so that at the maximum
       time constant of 6, the update interval can be as large as 1024
       s.
       Values of time_constant between zero and 2 can be used if quick
       convergence is necessary; values between 2 and 6 can be used to
       reduce network load, but at a modest cost in accuracy. Values
       above 6 are appropriate only if an external oscillator is
       present.
    long time_tolerance = MAXFREQ; /* frequency tolerance (ppm) */
       This variable represents the maximum frequency error or
       tolerance in ppm of the particular CPU clock oscillator and is
       a property of the architecture; however, in principle it could
       change as result of the presence of external discipline
       signals, for instance. It is expressed as a positive number
       greater than zero in parts-per-million (ppm).
       The recommended value of MAXFREQ is 200 ppm is appropriate for
       room-temperature quartz oscillators used in typical
       workstations. However, it can change due to the operating
       condition of the PPS signal and/or external oscillator. With
       either the PPS signal or external oscillator, the recommended
       value for MAXFREQ is 100 ppm.

Mills [Page 29] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long time_precision = 1000000 / HZ; /* clock precision (us) */
       This variable represents the maximum error in reading the
       system clock in microseconds. It is usually based on the number
       of microseconds between timer interrupts, 10000 us for the
       SunOS kernel, 3906 us for the Ultrix kernel, 976 us for the
       OSF/1 kernel. However, in cases where the time can be
       interpolated between timer interrupts with microsecond
       resolution, such as in the unmodified SunOS kernel and modified
       Ultrix and OSF/1 kernels, the precision is specified as 1 us.
       In cases where a PPS signal or external oscillator is
       available, the precision can depend on the operating condition
       of the signal or oscillator. This variable is determined by the
       kernel for use by the synchronization daemon, but is otherwise
       not used by the kernel.
    long time_maxerror = MAXPHASE; /* maximum error */
       This variable establishes the maximum error of the indicated
       time relative to the primary synchronization source in
       microseconds. For NTP, the value is initialized by a
       ntp_adjtime() call to the synchronization distance, which is
       equal to the root dispersion plus one-half the root delay. It
       is increased by a small amount (time_tolerance) each second to
       reflect the clock frequency tolerance. This variable is
       computed by the synchronization daemon and the kernel, but is
       otherwise not used by the kernel.
    long time_esterror = MAXPHASE; /* estimated error */
       This variable establishes the expected error of the indicated
       time relative to the primary synchronization source in
       microseconds. For NTP, the value is determined as the root
       dispersion, which represents the best estimate of the actual
       error of the system clock based on its past behavior, together
       with observations of multiple clocks within the peer group.
       This variable is computed by the synchronization daemon and
       returned in system calls, but is otherwise not used by the
       kernel.

Mills [Page 30] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 5.2. Phase-Lock Loop Variables
    The following variables establish the state of the PLL and the
    residual time and frequency offset of the system clock. Additional
    automatic variables are used as temporaries as described in the
    code fragments.
    long time_phase = 0;         /* phase offset (scaled us) */
       The time_phase variable represents the phase of the kernel time
       variable at each tick of the clock. This variable is scaled by
       (1 << SHIFT_SCALE) (23) in microseconds, giving a maximum
       adjustment of about +-256 us/tick and a resolution less than
       one part in 10^12.
    long time_offset = 0;        /* time offset (scaled us) */
       The time_offset variable represents the time offset of the CPU
       clock oscillator. It is recalculated as each update to the
       system clock is received via the hardupdate() routine and at
       each second in the seconds_overflow routine. This variable is
       scaled by (1 << SHIFT_UPDATE) (12) in microseconds, giving a
       maximum adjustment of about +-512 ms and a resolution of a few
       parts in 10^10 s.
    long time_freq = 0;          /* frequency offset (scaled ppm) */
       The time_freq variable represents the frequency offset of the
       CPU clock oscillator. It is recalculated as each update to the
       system clock is received via the hardupdate() routine. It can
       also be set via ntp_adjtime() from a value stored in a file
       when the synchronization daemon is first started. It can be
       retrieved via ntp_adjtime() and written to the file about once
       per hour by the daemon. The time_freq variable is scaled by (1
       << SHIFT_KF) (16) ppm, giving it a maximum value well in excess
       of the limit of +-256 ppm imposed by other constraints. The
       precision of this representation (frequency resolution) is
       parts in 10^11, which is adequate for all but the best external
       oscillators.
    time_adj = 0;                /* tick adjust (scaled 1 / HZ) */
       The time_adj variable is the adjustment added to the value of
       tick at each timer interrupt. It is computed once each second
       from the time_offset, time_freq and, if the PPS signal is
       present, the ps_ybar variable once each second.

Mills [Page 31] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long time_reftime = 0;       /* time at last adjustment (s) */
       This variable is the seconds portion of the system time on the
       last update received by the hardupdate() routine. It is used to
       compute the time_freq variable as the time since the last
       update increases.
    int fixtick = 1000000 % HZ;  /* amortization factor */
       In the Ultrix and OSF/1 kernels, the interval between timer
       interrupts does not evenly divide the number of microseconds in
       the second. In order that the clock runs at a precise rate, it
       is necessary to introduce an amortization factor into the local
       timescale. In the original Unix code, the value of fixtick is
       amortized once each second, introducing an additional source of
       jitter; in the new model the value is amortized at each tick of
       the system clock, reducing the jitter by the reciprocal of the
       clock oscillator frequency. This is not a new kernel variable,
       but a new use of an existing kernel variable.
 5.3. Pulse-per-second (PPS) Frequency-Lock Loop Variables
    The following variables are used only if a pulse-per-second (PPS)
    signal is available and connected via a modem-control lead, such
    as produced by the optional ppsclock feature incorporated in the
    serial port driver. They establish the design parameters of the
    PPS frequency-lock loop used to discipline the CPU clock
    oscillator to an external PPS signal. Additional automatic
    variables are used as temporaries as described in the code
    fragments.
    long pps_usec;          /* microseconds at last pps */
       The pps_usec variable is latched from a high resolution counter
       or external oscillator at each PPS interrupt. In determining
       this value, only the hardware counter contents are used, not
       the contents plus the kernel time variable, as returned by the
       microtime() routine.
    long pps_ybar = 0;      /* pps frequency offset estimate */
       The pps_ybar variable is the average CPU clock oscillator
       frequency offset relative to the PPS disciplining signal. It is
       scaled in the same units as the time_freq variable.

Mills [Page 32] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    pps_disp = MAXFREQ;     /* dispersion estimate (scaled ppm) */
       The pps_disp variable represents the average sample dispersion
       measured over the last three samples. It is scaled in the same
       units as the time_freq variable.
    pps_dispmax = MAXFREQ / 2; /* dispersion threshold */
       The pps_dispmax variable is used as a dispersion threshold. If
       pps_disp is less than this threshold, the median sample is used
       to update the pps_ybar estimate; if not, the sample is
       discarded.
    pps_dispinc = MAXFREQ >> (PPS_SHIFT + 4); /* pps dispersion
    increment/sec */
       The pps_dispinc variable is the increment to add to pps_disp
       once each second. It is computed such that, if no PPS samples
       have arrived for several calibration intervals, the value of
       pps_disp will exceed the pps_dispmax threshold and raise an
       alarm.
    int pps_mf[] = {0, 0, 0};    /* pps median filter */
       The pps-mf[] array is used as a median filter to detect and
       discard jitter in the PPS signal.
    int pps_count = 0;           /* pps calibrate interval counter */
       The pps_count variable measures the length of the calibration
       interval used to calculate the frequency. It normally counts
       from zero to the value 1 << pps_shift.
    pps_shift = PPS_SHIFT;       /* interval duration (s) (shift) */
       The pps_shift variable determines the duration of the
       calibration interval, 1 << pps_shift s.
    pps_intcnt = 0;              /* intervals at current duration */
       The pps_intcnt variable counts the number of calibration
       intervals at the current interval duration. It is reset to zero
       after four intervals and when the interval duration is changed.
    long pps_calcnt = 0;         /* calibration intervals */
       The pps_calcnt variable counts the number of calibration
       intervals.

Mills [Page 33] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    long pps_jitcnt = 0;         /* jitter limit exceeded */
       The pps_jitcnt variable counts the number of resets due to
       excessive jitter or frequency offset. These resets are
       usually due to excessive noise in the PPS signal or
       interface.
    long pps_discnt = 0;         /* dispersion limit exceeded */
       The pps_discnt variable counts the number of calibration
       intervals where the dispersion is above the pps_dispmax
       limit.  These resets are usually due to excessive frequency
       wander in the PPS signal source.

Mills [Page 34] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 5.4. External Oscillator Variables
    The following variables are used only if an external oscillator
    (HIGHBALL or TPRO) is present. Additional automatic variables are
    used as temporaries as described in the code fragments.
    int clock_count = 0;         /* CPU clock counter */
       The clock_count variable counts the seconds between adjustments
       to the kernel time variable to discipline it to the external
       clock.
    struct timeval clock_offset; /* HIGHBALL clock offset */
       The clock_offset variable defines the offset between system
       time and the HIGHBALL counters.
    long clock_cpu = 0;          /* CPU clock adjust */
       The clock_cpu variable contains the offset between the system
       clock and the HIGHBALL clock for use in disciplining the kernel
       time variable.

6. Architecture Constants

 Following is a list of the important architecture constants that
 establish the response and stability of the PLL and provide maximum
 bounds on behavior in order to satisfy correctness assertions made in
 the protocol specification. Additional definitions are given in the
 timex.h header file.
 6.1. Phase-lock loop (PLL) definitions
    The following defines establish the performance envelope of the
    PLL. They establish the maximum phase error (MAXPHASE), maximum
    frequency error (MAXFREQ), minimum interval between updates
    (MINSEC) and maximum interval between updates (MAXSEC). The intent
    of these bounds is to force the PLL to operate within predefined
    limits in order to satisfy correctness assertions of the
    synchronization protocol. An excursion which exceeds these bounds
    is clamped to the bound and operation proceeds normally. In
    practice, this can occur only if something has failed or is
    operating out of tolerance, but otherwise the PLL continues to
    operate in a stable mode.
    MAXPHASE must be set greater than or equal to CLOCK.MAX (128 ms),
    as defined in the NTP specification. CLOCK.MAX establishes the
    maximum time offset allowed before the system time is reset,

Mills [Page 35] RFC 1589 Kernel Model for Precision Timekeeping March 1994

    rather than incrementally adjusted. Here, the maximum offset is
    clamped to MAXPHASE only in order to prevent overflow errors due
    to defective programming.
    MAXFREQ reflects the manufacturing frequency tolerance of the CPU
    oscillator plus the maximum slew rate allowed by the protocol. It
    should be set to at least the intrinsic frequency tolerance of the
    oscillator plus 100 ppm for vernier frequency adjustments. If the
    kernel frequency discipline code is installed (PPS_SYNC), the CPU
    oscillator frequency is disciplined to an external source,
    presumably with negligible frequency error.
    #define MAXPHASE 512000      /* max phase error (us) */
    #ifdef PPS_SYNC
    #define MAXFREQ 100          /* max frequency error (ppm) */
    #else
    #define MAXFREQ 200          /* max frequency error (ppm) */
    #endif /* PPS_SYNC */
    #define MINSEC 16            /* min interval between updates (s)
                                  */
    #define MAXSEC 1200          /* max interval between updates (s)
                                  */
 6.2. Pulse-per-second (PPS) Frequency-lock Loop (FLL) Definitions
    The following defines and declarations are used only if a pulse-
    per-second (PPS) signal is available and connected via a modem-
    control lead, such as produced by the optional ppsclock feature
    incorporated in the serial port driver. They establish the design
    parameters of the frequency-lock loop (FLL) used to discipline the
    CPU clock oscillator to the PPS oscillator.
    PPS_AVG is the averaging constant used to update the FLL from
    frequency samples measured for each calibration interval.
    PPS_SHIFT and PPS_SHIFTMAX are the minimum and maximem,
    respectively, of the calibration interval represented as a power
    of two. The PPS_DISPINC is the initial increment to pps_disp at
    each second.
    #define PPS_AVG 2            /* pps averaging constant (shift) */
    #define PPS_SHIFT 2          /* min interval duration (s) (shift)
                                  */
    #define PPS_SHIFTMAX 6       /* max interval duration (s) (shift)
                                  */
    #define PPS_DISPINC 0        /* dispersion increment (us/s) */

Mills [Page 36] RFC 1589 Kernel Model for Precision Timekeeping March 1994

 6.3. External Oscillator Definitions
    The following definitions and declarations are used only if an
    external oscillator (HIGHBALL or TPRO) is configured on the
    system.
    #define CLOCK_INTERVAL 30    /* CPU clock update interval (s) */

7. References

 [1] Mills, D., "Internet time synchronization: the Network Time
     Protocol", IEEE Trans. Communications COM-39, 10 (October 1991),
     1482- 1493. Also in: Yang, Z., and T.A. Marsland (Eds.). Global
     States and Time in Distributed Systems, IEEE Press, Los Alamitos,
     CA, 91-102.
 [2] Mills, D., "Network Time Protocol (Version 3) specification,
     implementation and analysis", RFC 1305, University of Delaware,
     March 1992, 113 pp.
 [3] Mills, D., "Modelling and analysis of computer network clocks",
     Electrical Engineering Department Report 92-5-2, University of
     Delaware, May 1992, 29 pp.
 [4] Mills, D., "Simple Network Time Protocol (SNTP)", RFC 1361,
     University of Delaware, August 1992, 10 pp.
 [5] Mills, D., "Precision synchronizatin of computer network clocks",
     Electrical Engineering Department Report 93-11-1, University of
     Delaware, November 1993, 66 pp.

Security Considerations

 Security issues are not discussed in this memo.

Author's Address

 David L. Mills
 Electrical Engineering Department
 University of Delaware
 Newark, DE 19716
 Phone: (302) 831-8247
 EMail: mills@udel.edu

Mills [Page 37]

/data/webs/external/dokuwiki/data/pages/rfc/rfc1589.txt · Last modified: 1994/03/02 22:44 by 127.0.0.1

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki