freebsd-dev/usr.sbin/xntpd/lib/systime.c

377 lines
9.2 KiB
C
Raw Normal View History

1994-09-29 23:04:24 +00:00
/*
1993-12-21 18:36:48 +00:00
* systime -- routines to fiddle a UNIX clock.
*/
1994-09-29 23:04:24 +00:00
#include <stdio.h>
1993-12-21 18:36:48 +00:00
#include <sys/types.h>
#include <sys/time.h>
1994-09-29 23:04:24 +00:00
#if defined(SYS_HPUX) || defined(sgi) || defined(SYS_BSDI) || defined(SYS_44BSD)
1993-12-21 18:36:48 +00:00
#include <sys/param.h>
#include <utmp.h>
#endif
#ifdef SYS_LINUX
1994-09-29 23:04:24 +00:00
#include "sys/timex.h"
1993-12-21 18:36:48 +00:00
#endif
#include "ntp_fp.h"
#include "ntp_syslog.h"
#include "ntp_unixtime.h"
#include "ntp_stdlib.h"
#if defined(STEP_SLEW)
#define SLEWALWAYS
#endif
extern int debug;
/*
* These routines (init_systime, get_systime, step_systime, adj_systime)
* implement an interface between the (more or less) system independent
* bits of NTP and the peculiarities of dealing with the Unix system
* clock. These routines will run with good precision fairly independently
* of your kernel's value of tickadj. I couldn't tell the difference
* between tickadj==40 and tickadj==5 on a microvax, though I prefer
* to set tickadj == 500/hz when in doubt. At your option you
* may compile this so that your system's clock is always slewed to the
* correct time even for large corrections. Of course, all of this takes
* a lot of code which wouldn't be needed with a reasonable tickadj and
* a willingness to let the clock be stepped occasionally. Oh well.
*/
/*
* Clock variables. We round calls to adjtime() to adj_precision
* microseconds, and limit the adjustment to tvu_maxslew microseconds
* (tsf_maxslew fractional sec) in one adjustment interval. As we are
* thus limited in the speed and precision with which we can adjust the
* clock, we compensate by keeping the known "error" in the system time
* in sys_clock_offset. This is added to timestamps returned by get_systime().
* We also remember the clock precision we computed from the kernel in
* case someone asks us.
*/
1994-09-29 23:04:24 +00:00
long sys_clock;
1994-04-03 19:50:51 +00:00
1994-09-29 23:04:24 +00:00
long adj_precision; /* adj precision in usec (tickadj) */
long tvu_maxslew; /* maximum adjust doable in 1<<CLOCK_ADJ sec (usec) */
1993-12-21 18:36:48 +00:00
1994-09-29 23:04:24 +00:00
u_long tsf_maxslew; /* same as above, as long format */
1993-12-21 18:36:48 +00:00
l_fp sys_clock_offset; /* correction for current system time */
/*
* get_systime - return the system time in timestamp format
* As a side effect, update sys_clock.
*/
void
get_systime(ts)
l_fp *ts;
{
struct timeval tv;
#if !defined(SLEWALWAYS)
/*
* Quickly get the time of day and convert it
*/
(void) GETTIMEOFDAY(&tv, (struct timezone *)0);
TVTOTS(&tv, ts);
ts->l_uf += TS_ROUNDBIT; /* guaranteed not to overflow */
#else
/*
* Get the time of day, convert to time stamp format
* and add in the current time offset. Then round
* appropriately.
*/
(void) GETTIMEOFDAY(&tv, (struct timezone *)0);
TVTOTS(&tv, ts);
L_ADD(ts, &sys_clock_offset);
if (ts->l_uf & TS_ROUNDBIT)
1994-09-29 23:04:24 +00:00
L_ADDUF(ts, TS_ROUNDBIT);
1993-12-21 18:36:48 +00:00
#endif /* !defined(SLEWALWAYS) */
ts->l_ui += JAN_1970;
ts->l_uf &= TS_MASK;
sys_clock = ts->l_ui;
}
/*
* step_systime - do a step adjustment in the system time (at least from
* NTP's point of view.
*/
int
step_systime(ts)
l_fp *ts;
{
1995-05-30 03:57:47 +00:00
#ifdef SLEWALWAYS
1993-12-21 18:36:48 +00:00
#ifdef STEP_SLEW
1994-09-29 23:04:24 +00:00
register u_long tmp_ui;
register u_long tmp_uf;
1993-12-21 18:36:48 +00:00
int isneg;
int n;
/*
* Take the absolute value of the offset
*/
tmp_ui = ts->l_ui;
tmp_uf = ts->l_uf;
if (M_ISNEG(tmp_ui, tmp_uf)) {
M_NEG(tmp_ui, tmp_uf);
isneg = 1;
} else
isneg = 0;
if (tmp_ui >= 3) { /* Step it and slew we might win */
n = step_systime_real(ts);
if (!n) return n;
1995-05-30 03:57:47 +00:00
if (isneg)
1993-12-21 18:36:48 +00:00
ts->l_ui = ~0;
else
ts->l_ui = ~0;
}
#endif
/*
* Just add adjustment into the current offset. The update
* routine will take care of bringing the system clock into
* line.
*/
L_ADD(&sys_clock_offset, ts);
return 1;
#else /* SLEWALWAYS */
return step_systime_real(ts);
#endif /* SLEWALWAYS */
}
int max_no_complete = 20;
/*
* adj_systime - called once every 1<<CLOCK_ADJ seconds to make system time
* adjustments.
*/
int
adj_systime(ts)
l_fp *ts;
{
1994-09-29 23:04:24 +00:00
register u_long offset_i, offset_f;
register long temp;
register u_long residual;
1993-12-21 18:36:48 +00:00
register int isneg = 0;
struct timeval adjtv, oadjtv;
l_fp oadjts;
1994-09-29 23:04:24 +00:00
long adj = ts->l_f;
1993-12-21 18:36:48 +00:00
int rval;
adjtv.tv_sec = adjtv.tv_usec = 0;
/*
* Move the current offset into the registers
*/
offset_i = sys_clock_offset.l_ui;
offset_f = sys_clock_offset.l_uf;
/*
* Add the new adjustment into the system offset. Adjust the
* system clock to minimize this.
*/
M_ADDF(offset_i, offset_f, adj);
if (M_ISNEG(offset_i, offset_f)) {
isneg = 1;
M_NEG(offset_i, offset_f);
}
#ifdef DEBUG
if (debug > 4)
syslog(LOG_DEBUG, "adj_systime(%s): offset = %s%s\n",
mfptoa((adj<0?-1:0), adj, 9), isneg?"-":"",
umfptoa(offset_i, offset_f, 9));
#endif
adjtv.tv_sec = 0;
if (offset_i > 0 || offset_f >= tsf_maxslew) {
/*
* Slew is bigger than we can complete in
* the adjustment interval. Make a maximum
* sized slew and reduce sys_clock_offset by this
* much.
*/
M_SUBUF(offset_i, offset_f, tsf_maxslew);
if (!isneg) {
adjtv.tv_usec = tvu_maxslew;
} else {
adjtv.tv_usec = -tvu_maxslew;
M_NEG(offset_i, offset_f);
}
#ifdef DEBUG
if (debug > 4)
1994-09-29 23:04:24 +00:00
printf("systime: maximum slew: %s%s, remainder = %s\n",
1993-12-21 18:36:48 +00:00
isneg?"-":"", umfptoa(0, tsf_maxslew, 9),
mfptoa(offset_i, offset_f, 9));
#endif
} else {
/*
* We can do this slew in the time period. Do our
* best approximation (rounded), save residual for
* next adjustment.
*
* Note that offset_i is guaranteed to be 0 here.
*/
TSFTOTVU(offset_f, temp);
#ifndef ADJTIME_IS_ACCURATE
/*
* Round value to be an even multiple of adj_precision
*/
residual = temp % adj_precision;
temp -= residual;
if (residual << 1 >= adj_precision)
temp += adj_precision;
#endif /* ADJTIME_IS_ACCURATE */
TVUTOTSF(temp, residual);
M_SUBUF(offset_i, offset_f, residual);
if (isneg) {
adjtv.tv_usec = -temp;
M_NEG(offset_i, offset_f);
} else {
adjtv.tv_usec = temp;
}
#ifdef DEBUG
if (debug > 4)
1994-09-29 23:04:24 +00:00
printf(
"systime: adjtv = %s, adjts = %s, sys_clock_offset = %s\n",
1993-12-21 18:36:48 +00:00
tvtoa(&adjtv), umfptoa(0, residual, 9),
mfptoa(offset_i, offset_f, 9));
#endif
}
if (adjtime(&adjtv, &oadjtv) < 0) {
syslog(LOG_ERR, "Can't do time adjustment: %m");
rval = 0;
1994-02-03 22:09:07 +00:00
} else {
sys_clock_offset.l_ui = offset_i;
sys_clock_offset.l_uf = offset_f;
1993-12-21 18:36:48 +00:00
rval = 1;
#ifdef DEBUGRS6000
1994-02-03 22:09:07 +00:00
syslog(LOG_ERR, "adj_systime(%s): offset = %s%s\n",
mfptoa((adj<0?-1:0), adj, 9), isneg?"-":"",
umfptoa(offset_i, offset_f, 9));
syslog(LOG_ERR, "%d %d %d %d\n", (int) adjtv.tv_sec,
(int) adjtv.tv_usec, (int) oadjtv.tv_sec, (int)
oadjtv.tv_usec);
1993-12-21 18:36:48 +00:00
#endif /* DEBUGRS6000 */
1994-02-03 22:09:07 +00:00
if (oadjtv.tv_sec != 0 || oadjtv.tv_usec != 0) {
sTVTOTS(&oadjtv, &oadjts);
L_ADD(&sys_clock_offset, &oadjts);
if (max_no_complete > 0) {
syslog(LOG_WARNING,
"Previous time adjustment didn't complete");
1993-12-21 18:36:48 +00:00
#ifdef DEBUG
1994-02-03 22:09:07 +00:00
if (debug > 4)
syslog(LOG_DEBUG,
"Previous adjtime() incomplete, residual = %s\n",
tvtoa(&oadjtv));
1993-12-21 18:36:48 +00:00
#endif
1994-02-03 22:09:07 +00:00
if (--max_no_complete == 0)
syslog(LOG_WARNING,
"*** No more 'Prev time adj didn't complete'");
}
}
1993-12-21 18:36:48 +00:00
}
return(rval);
}
/*
* This is used by ntpdate even when xntpd does not use it! WLJ
*/
int
step_systime_real(ts)
l_fp *ts;
{
struct timeval timetv, adjtv;
int isneg = 0;
#if defined(SYS_HPUX)
struct utmp ut;
time_t oldtime;
#endif
/*
* We can afford to be sloppy here since if this is called
* the time is really screwed and everything is being reset.
*/
L_ADD(&sys_clock_offset, ts);
if (L_ISNEG(&sys_clock_offset)) {
isneg = 1;
L_NEG(&sys_clock_offset);
}
TSTOTV(&sys_clock_offset, &adjtv);
(void) GETTIMEOFDAY(&timetv, (struct timezone *)0);
#if defined(SYS_HPUX)
oldtime = timetv.tv_sec;
#endif
#ifdef DEBUG
if (debug > 3)
syslog(LOG_DEBUG, "step: %s, sys_clock_offset = %s, adjtv = %s, timetv = %s\n",
lfptoa(ts, 9), lfptoa(&sys_clock_offset, 9), tvtoa(&adjtv),
utvtoa(&timetv));
#endif
if (isneg) {
timetv.tv_sec -= adjtv.tv_sec;
timetv.tv_usec -= adjtv.tv_usec;
if (timetv.tv_usec < 0) {
timetv.tv_sec--;
timetv.tv_usec += 1000000;
}
} else {
timetv.tv_sec += adjtv.tv_sec;
timetv.tv_usec += adjtv.tv_usec;
if (timetv.tv_usec >= 1000000) {
timetv.tv_sec++;
timetv.tv_usec -= 1000000;
}
}
if (SETTIMEOFDAY(&timetv, (struct timezone *)0) != 0) {
syslog(LOG_ERR, "Can't set time of day: %m");
return 0;
}
#ifdef DEBUG
if (debug > 3)
syslog(LOG_DEBUG, "step: new timetv = %s\n", utvtoa(&timetv));
#endif
sys_clock_offset.l_ui = sys_clock_offset.l_uf = 0;
#if defined(SYS_HPUX)
#if (SYS_HPUX < 10)
/*
* CHECKME: is this correct when called by ntpdate?????
*/
_clear_adjtime();
#endif
/*
* Write old and new time entries in utmp and wtmp if step adjustment
* is greater than one second.
*/
if (oldtime != timetv.tv_sec) {
1994-02-03 22:09:07 +00:00
memset((char *)&ut, 0, sizeof(ut));
1993-12-21 18:36:48 +00:00
ut.ut_type = OLD_TIME;
ut.ut_time = oldtime;
(void)strcpy(ut.ut_line, OTIME_MSG);
pututline(&ut);
setutent();
ut.ut_type = NEW_TIME;
ut.ut_time = timetv.tv_sec;
(void)strcpy(ut.ut_line, NTIME_MSG);
pututline(&ut);
utmpname(WTMP_FILE);
ut.ut_type = OLD_TIME;
ut.ut_time = oldtime;
(void)strcpy(ut.ut_line, OTIME_MSG);
pututline(&ut);
ut.ut_type = NEW_TIME;
ut.ut_time = timetv.tv_sec;
(void)strcpy(ut.ut_line, NTIME_MSG);
pututline(&ut);
endutent();
}
#endif
return 1;
}