adjtimex.c File Reference

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <mat.h>
#include <math.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <sys/types.h>
#include <syscall.h>
#include <time.h>
#include <unistd.h>
#include <utmp.h>
#include <sys/ioctl.h>
#include <linux/rtc.h>

Go to the source code of this file.

Classes
struct	cmos_adj
Defines
#define	_GNU_SOURCE
#define	LOG_PATH   "/var/log/clocks.log"
#define	WTMP_PATH   "/var/log/wtmp"
#define	ADJPATH   "/etc/adjtime"
#define	RTC_JITTER   .000025
#define	SECONDSPERDAY   86400
#define	BUFLEN   128
#define	CMOS_VALID   1
#define	SYS_VALID   2
#define	REF_VALID   4
#define	HELP   131
#define	CMOS_READ(addr)   ({outb(0x70,(addr)|0x80); inb(0x71);})
#define	SHIFT   (1<<16)
Functions
	_syscall1 (int, adjtimex, struct timex *, txcp)
void	compare (void)
void	failntpdate ()
void	reset_time_status (void)
static double	compare_cmos_sys (void)
cmos_adj *	get_cmos_adjustment (void)
void	log_times (void)
int	valid_system_rate (double ftime_sys, double ftime_ref, double sigma_ref)
int	valid_cmos_rate (double ftime_cmos, double ftime_ref, double sigma_ref)
void	sethackent (void)
void	endhackent (void)
hack *	gethackent (void)
void	puthackent (struct hack *ph)
time_t	mkgmtime (struct tm *tp)
int	compare_tm (struct tm *first, struct tm *second)
static void *	xmalloc (int n)
static void *	xrealloc (void *pv, int n)
void	review (void)
void	kalman_update (double *x, int xr, double *p, double *h, double *z, int zr, double *r)
void	usage (void)
void	probe_time (int *hz, int *tick_min, int *tick_mid, int *tick_max, long *maxfreq)
int	main (int argc, char *argv[])
static void	outb (short port, char val)
static unsigned char	inb (short port)
void	cmos_init ()
static int	cmos_read_bcd (int addr)
static void	cmos_read_time (struct tm *tm)
static void	xusleep (long microseconds)
Variables
	prev
cmos_adj	ca
timex	txc
option	longopt []
int	adjusting = 0
int	comparing = 0
int	logging = 0
int	reviewing = 0
int	resetting = 0
int	interval = 10
int	count = 8
int	marked
int	universal = 0
int	watch
int	undisturbed_sys = 0
int	undisturbed_cmos = 0
char *	timeserver
static FILE *	lfile

---

Define Documentation

#define _GNU_SOURCE

Definition at line 13 of file adjtimex.c.

#define ADJPATH   "/etc/adjtime"

Referenced by compare(), get_cmos_adjustment(), and valid_system_rate().

#define BUFLEN   128

Referenced by log_times(), valid_cmos_rate(), and valid_system_rate().

#define CMOS_READ (  addr   )     ({outb(0x70,(addr)|0x80); inb(0x71);})

Definition at line 559 of file adjtimex.c. Referenced by cmos_read_bcd(), cmos_read_time(), and compare_cmos_sys().

#define CMOS_VALID   1

Definition at line 109 of file adjtimex.c. Referenced by review().

#define HELP   131

Definition at line 122 of file adjtimex.c. Referenced by main().

#define LOG_PATH   "/var/log/clocks.log"

#define REF_VALID   4

Definition at line 111 of file adjtimex.c. Referenced by review().

#define RTC_JITTER   .000025

Referenced by review().

#define SECONDSPERDAY   86400

Referenced by compare(), and review().

#define SHIFT   (1<<16)

Referenced by compare(), and review().

#define SYS_VALID   2

Definition at line 110 of file adjtimex.c. Referenced by review().

#define WTMP_PATH   "/var/log/wtmp"

Referenced by valid_system_rate().

---

Function Documentation

_syscall1 (  int  , adjtimex  , struct timex *  , txcp  )

Definition at line 44 of file adjtimex.c. : * read RTC once any update in progress is done. The update * can take just over 2ms. We wait 10 to 20ms. There is no need to * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP. * If you need to know *exactly* when a second has started, enable * periodic update complete interrupts, (via ioctl) and then * immediately read /dev/rtc which will block until you get the IRQ. * Once the read clears, read the RTC time (again via ioctl). Easy. However it doesn't say how to restore the interrupt setup. Until I find out about that, I'll continue to use the poll-wait. */ static int using_dev_rtc = 0; struct hack { double ref; /* reference time for time hack */ double sigma_ref; /* expected error in above (or zero if no reference time available) */ time_t log; /* reference time as time_t */ double sys; /* system time */ int tick; /* "tick" system parameter */ int freq; /* "freq" system parameter */ char sys_ok; /* nonzero if system clock undisturbed during previous period */ double cmos; /* CMOS time */ char cmos_ok; /* nonzero if cmos clock undisturbed during previous period */ char valid; /* bit flags (see below) */ double sys_rate, sys_sigma; double cmos_rate, cmos_sigma; double relative_rate, relative_sigma; } prev;

void cmos_init (   )

Definition at line 522 of file adjtimex.c. Referenced by compare(), and compare_cmos_sys(). { if (using_dev_rtc < 0) { cmos_fd = open ("/dev/rtc", O_RDONLY); if (cmos_fd >= 0) { using_dev_rtc = 1; return; } using_dev_rtc = 0; } else if (using_dev_rtc > 0) return; #ifdef USE_INLINE_ASM_IO if (ioperm (0x70, 2, 1)) { fprintf (stderr, "clock: unable to get I/O port access\n"); exit (1); } #else if (cmos_fd < 0) cmos_fd = open ("/dev/port", O_RDWR); if (cmos_fd < 0) { perror ("unable to open /dev/port read/write : "); exit (1); } if (lseek (cmos_fd, 0x70, 0) < 0 || lseek (cmos_fd, 0x71, 0) < 0) { perror ("unable to seek port 0x70 in /dev/port : "); exit (1); } #endif }

static int cmos_read_bcd (  int  addr  )  [inline, static]

Definition at line 562 of file adjtimex.c. References CMOS_READ. Referenced by cmos_read_time(), and compare_cmos_sys(). { int b; b = CMOS_READ (addr); return (b & 15) + (b >> 4) * 10; }

static void cmos_read_time (  struct tm *  tm  )  [static]

Definition at line 571 of file adjtimex.c. References CMOS_READ, and cmos_read_bcd(). Referenced by compare(). { if (using_dev_rtc > 0) ioctl (cmos_fd, RTC_RD_TIME, tm); else { long i; /* read RTC exactly on falling edge of update flag */ /* Wait for rise.... (may take up to 1 second) */ for (i = 0; i < 10000000; i++) if (CMOS_READ (10) & 0x80) break; /* Wait for fall.... (must try at least 2.228 ms) */ for (i = 0; i < 1000000; i++) if (!(CMOS_READ (10) & 0x80)) break; /* The "do" loop is "low-risk programming" */ /* In theory it should never run more than once */ do { tm->tm_sec = cmos_read_bcd (0); tm->tm_min = cmos_read_bcd (2); tm->tm_hour = cmos_read_bcd (4); tm->tm_wday = cmos_read_bcd (6); tm->tm_mday = cmos_read_bcd (7); tm->tm_mon = cmos_read_bcd (8); tm->tm_year = cmos_read_bcd (9); } while (tm->tm_sec != cmos_read_bcd (0)); } }

void compare (  void   )

Definition at line 623 of file adjtimex.c. References ADJPATH, adjusting, cmos_init(), cmos_read_time(), count, interval, logging, marked, mkgmtime(), probe_time(), puthackent(), reset_time_status(), resetting, SECONDSPERDAY, SHIFT, universal, and xusleep(). Referenced by main(). { struct timex txc; struct tm tm; time_t cmos_time; time_t last_time; double cmos_sec, system_sec, dif, dif_prev = 0.; FILE *adj; double factor; double cmos_adjustment; double not_adjusted; int loops = 0; extern char *optarg; struct timeval now; int wrote_to_log = 0; int hz, tick_min, tick_mid, tick_max; long maxfreq; probe_time(&hz, &tick_min, &tick_mid, &tick_max, &maxfreq); /* Read adjustment parameters first */ if ((adj = fopen (ADJPATH, "r")) == NULL) { perror (ADJPATH); exit (2); } if (fscanf (adj, "%lf %ld %lf", &factor, &last_time, &not_adjusted) < 0) { perror (ADJPATH); exit (2); } fclose (adj); #ifdef DEBUG /* cmos clock last adjusted at Tue Aug 26 11:43:57 1997 (= 872610237) current cmos time Tue Aug 26 21:27:05 1997 EDT (= 872645225) */ { struct tm bdt; if (universal) { bdt = *gmtime(&last_time); (void)mkgmtime(&bdt); /* set tzname */ } else { bdt = *localtime(&last_time); (void)mktime(&bdt); /* set tzname */ } printf ("cmos clock last adjusted %.24s %s " "(= %ld)\n", ctime(&last_time), tzname[tm.tm_isdst?1:0], (long) last_time); } #endif cmos_init (); while (count != 0) { if (count > 0) count--; cmos_read_time (&tm); /* fetch system time immediately */ gettimeofday (&now, NULL); tm.tm_mon--; /* DOS uses 1 base */ tm.tm_wday -= 3; /* DOS uses 3 - 9 for week days */ tm.tm_isdst = -1; /* don't know whether it's daylight */ if ((tm.tm_year += (epoch - 1900)) <= 69) tm.tm_year += 100; if (universal) cmos_time = mkgmtime(&tm); else cmos_time = mktime (&tm); /* printf ("%s", asctime (&tm)); */ system_sec = now.tv_sec + .000001*now.tv_usec; /* If we're adjusting time parameters, we want to make a log entry only for the first two comparisons (before we change the parameters). Otherwise, we want to log the first and last comparisons in order to maximize the duration. */ if (logging && (wrote_to_log ^ (adjusting?(loops==0):(count!=0)))) { struct hack h; h.ref = 0; h.sigma_ref = 0; h.log = (time_t)system_sec; h.sys = system_sec; txc.modes = 0; adjtimex(&txc); h.tick = txc.tick; h.freq = txc.freq; h.sys_ok = wrote_to_log; h.cmos = cmos_time; h.cmos_ok = wrote_to_log; puthackent(&h); wrote_to_log = 1; } #ifdef DEBUG printf (" current cmos time %.24s %s (= %ld)\n", asctime(&tm), tzname[tm.tm_isdst?1:0], (long) cmos_time); #endif cmos_adjustment = ((double) (cmos_time - last_time)) * factor / SECONDSPERDAY + not_adjusted; cmos_sec = cmos_time + cmos_adjustment; #ifdef DEBUG printf ( " time since last adjustment %10.6f days (= %9d sec)\n", (int) (cmos_time - last_time) / (double)SECONDSPERDAY, (int) (cmos_time - last_time)); printf ( " factor %10.6f sec/day\n", factor); printf ( " adjustment %10.6f + %7.6f = %7.6f sec\n", ((double) (cmos_time - last_time))*factor/SECONDSPERDAY, not_adjusted, cmos_adjustment); #endif dif = system_sec - cmos_sec; txc.modes = 0; if (adjtimex (&txc) < 0) {perror ("adjtimex"); exit(1);} /* --- current --- -- suggested -- cmos time system-cmos error_ppm tick freq tick freq 1094939320 -14394.974188 1094939330 -14394.971203 298.5 10001 1290819 1094939340 -14394.968203 300.0 10001 1290819 9998 1289097 */ if (! marked++ ) { if (interval) printf ( " --- current --- -- suggested --\n" "cmos time system-cmos error_ppm tick freq tick freq\n"); else printf ( "cmos time system-cmos error_ppm tick freq\n"); } printf ("%9ld %11.6f", (long) cmos_sec, dif); if (++loops > 1) { /* print difference in rates */ #define SHIFT (1<<16) double second_diff, error_ppm; second_diff = dif - dif_prev; error_ppm = second_diff/interval*1000000; printf ("%11.1f %6ld %9ld", error_ppm, txc.tick, txc.freq); if (loops > 2) { /* print suggested values */ long tick_delta = 0, freq_delta = 0; tick_delta = ceil((-error_ppm + txc.freq/SHIFT - hz)/hz); error_ppm += tick_delta*hz; freq_delta = -error_ppm*SHIFT; printf(" %6ld %9ld\n", txc.tick + tick_delta, txc.freq + freq_delta); if (loops > 4 && adjusting) { txc.modes = ADJ_FREQUENCY | ADJ_TICK; txc.tick += tick_delta; txc.freq += freq_delta; if (adjtimex (&txc) < 0) { perror ("adjtimex"); exit(1); } if (resetting) reset_time_status(); loops -= 3; } } else printf("\n"); } else printf("\n"); dif_prev = dif; if (interval == 0) break; if (count) /* if it is not the last round */ xusleep (interval*1000000L - 900000); /* reading RTC takes 1 sec */ } }

static double compare_cmos_sys (  void   )  [static]

Definition at line 1219 of file adjtimex.c. References cmos_init(), CMOS_READ, cmos_read_bcd(), mkgmtime(), and universal. Referenced by log_times(). { struct tm tm; time_t cmos_time; double system_sec; double dif; int i; extern char *optarg; struct timeval now; if (geteuid() != 0) { struct tm bdt; char before[256], after[256]; int fd = open("/proc/rtc", O_RDONLY); if (fd == -1) { fprintf(stderr, "kernel lacks enhanced real time clock support, " "so only root can read RTC\n"); exit(1); } read(fd, before, sizeof(before)); close(fd); do { fd = open("/proc/rtc", O_RDONLY); read(fd, after, sizeof(after)); gettimeofday (&now, NULL); close(fd); } while (!strncmp(before, after, strlen(after))); strptime(after, "rtc_time : %H:%M:%S\nrtc_date : %Y-%m-%d", &bdt); if (universal) /* also set tm_wday and tm_yday */ cmos_time = mkgmtime(&bdt); else cmos_time = mktime(&bdt); #ifdef DEBUG printf("RTC says date & time are %.24s %s\n", asctime(&bdt), tzname[bdt.tm_isdst?1:0]); #endif system_sec = now.tv_sec + .000001 * now.tv_usec; dif = (double)cmos_time - system_sec; return dif; } else /* I am superuser */ { cmos_init (); /* read RTC exactly on falling edge of update flag */ /* Wait for rise.... (may take up to 1 second) */ for (i = 0; i < 10000000; i++) if (CMOS_READ (10) & 0x80) break; /* Wait for fall.... (must try at least 2.228 ms) */ for (i = 0; i < 1000000; i++) if (!(CMOS_READ (10) & 0x80)) break; /* The "do" loop is "low-risk programming" */ /* In theory it should never run more than once */ do { tm.tm_sec = cmos_read_bcd (0); tm.tm_min = cmos_read_bcd (2); tm.tm_hour = cmos_read_bcd (4); tm.tm_wday = cmos_read_bcd (6); tm.tm_mday = cmos_read_bcd (7); tm.tm_mon = cmos_read_bcd (8); tm.tm_year = cmos_read_bcd (9); } while (tm.tm_sec != cmos_read_bcd (0)); /* fetch system time immediately */ gettimeofday (&now, NULL); tm.tm_mon--; /* DOS uses 1 base */ tm.tm_wday -= 3; /* DOS uses 3 - 9 for week days */ tm.tm_isdst = -1; /* don't know whether it's daylight */ if ((tm.tm_year += (epoch - 1900)) <= 69) tm.tm_year += 100; #ifdef DEBUG printf (" mday=%d mon=%d wday=%d year=%d\n", tm.tm_mday, tm.tm_mon, tm.tm_wday, tm.tm_year); printf ("Cmos time %d:%02d:%02d\n", tm.tm_hour, tm.tm_min, tm.tm_sec); #endif } /* * Mktime assumes we're giving it local time. If the CMOS clock is in * GMT, we have to set up TZ so mktime knows it. Tzset gets called * implicitly by the time code, but only the first time. When * changing the environment variable, better call tzset explicitly. */ if (universal) { #ifdef ZONESWITCH zone = (char *) getenv ("TZ"); /* save original time zone */ (void) putenv ("TZ="); tzset (); cmos_time = mktime (&tm); /* now put back the original zone */ if (zone) { if ((strlen (zone) + 4) > sizeof (zonebuf)) { fprintf (stderr, "Size of TZ variable is too long\n"); exit (2); } strcpy (zonebuf, "TZ="); strcat (zonebuf, zone); putenv (zonebuf); } else { /* wasn't one, so clear it */ putenv ("TZ"); } tzset (); printf ("%s", ctime (&cmos_time)); #else /* !ZONESWITCH */ cmos_time = mkgmtime(&tm); #endif } else { cmos_time = mktime (&tm); /* printf ("%s", asctime (&tm)); */ } system_sec = now.tv_sec + .000001 * now.tv_usec; #ifdef DEBUG printf ("Number of seconds since 1/1/1970 is %ld\n", (long) cmos_time); #endif dif = (double)cmos_time - system_sec; return dif; }

int compare_tm (  struct tm *  first, struct tm *  second )

Definition at line 1498 of file adjtimex.c. Referenced by mkgmtime(). { if (first->tm_year < second->tm_year) return -1; if (first->tm_year > second->tm_year) return 1; if (first->tm_mon < second->tm_mon) return -1; if (first->tm_mon > second->tm_mon) return 1; if (first->tm_mday < second->tm_mday) return -1; if (first->tm_mday > second->tm_mday) return 1; if (first->tm_hour < second->tm_hour) return -1; if (first->tm_hour > second->tm_hour) return 1; if (first->tm_min < second->tm_min) return -1; if (first->tm_min > second->tm_min) return 1; if (first->tm_sec < second->tm_sec) return -1; if (first->tm_sec > second->tm_sec) return 1; return 0; }

void endhackent (  void   )

Definition at line 1381 of file adjtimex.c. References lfile. Referenced by review(), sethackent(), and valid_system_rate(). { if (lfile) fclose(lfile); lfile = NULL; }

void failntpdate (   )

Referenced by log_times().

struct cmos_adj * get_cmos_adjustment (  void   )

Definition at line 1193 of file adjtimex.c. References ADJPATH, cmos_adj::ca_adj_time, cmos_adj::ca_factor, and cmos_adj::ca_remainder. Referenced by review(), and valid_system_rate(). { FILE *adj; static struct cmos_adj ca; if ((adj = fopen (ADJPATH, "r")) == NULL) { perror (ADJPATH); exit (2); } if (fscanf (adj, "%lf %ld %lf", &ca.ca_factor, &ca.ca_adj_time, &ca.ca_remainder) < 0) { perror (ADJPATH); exit (2); } fclose (adj); #ifdef DEBUG printf ("CMOS clock was last adjusted %s", ctime(&ca.ca_adj_time)); #endif return &ca; }

struct hack * gethackent (  void   )

Definition at line 1390 of file adjtimex.c. References lfile, and sethackent(). Referenced by review(), and valid_system_rate(). { char buf[256], sys_flag, cmos_flag, junk[26]; static struct hack h; if (!lfile) sethackent(); if (!lfile) return NULL; while(fgets(buf, sizeof(buf), lfile)) { int tokens; if (buf[0] == '#') continue; tokens = sscanf(buf, "%25s %25s %lf %lf %lf %d %d %c %lf %c", junk, junk, &h.ref, &h.sigma_ref, &h.sys, &h.tick, &h.freq, &sys_flag, &h.cmos, &cmos_flag); if (tokens != 10) continue; h.sys_ok = (tolower(sys_flag) == 'y'); h.cmos_ok = (tolower(cmos_flag) == 'y'); if (h.ref) h.log = (time_t)h.ref; else if (h.sys) h.log = (time_t)h.sys; else h.log = (time_t)h.cmos; h.valid = 0; return &h; } return NULL; }

static unsigned char inb (  short  port  )  [inline, static]

Definition at line 507 of file adjtimex.c. { unsigned char ret; #ifdef USE_INLINE_ASM_IO __asm__ volatile ("in%B0 %1,%0":"=a" (ret):"d" (port)); #else lseek (cmos_fd, port, 0); read (cmos_fd, &ret, 1); #endif return ret; }

void kalman_update (  double *  x, int  xr, double *  p, double *  h, double *  z, int  zr, double *  r )

Definition at line 1801 of file adjtimex.c. References mat_add(), mat_copy(), mat_mul(), mat_mul_nt(), mat_one(), mat_similarity(), mat_sub(), sym_factor(), and sym_rdiv(). Referenced by review(). { static double k[4], num[4], denom[4], v[4], w[4]; int pr=xr, pc=xr, hr=zr, hc=xr, rr=zr, rc=zr, kr=xr, kc=zr, nr=xr, nc=zr, dr=zr, dc=zr, vr=xr, vc=1, wr=zr, wc=1; /* find the Kalman gain k: k = p h' /(h p h' + r) */ mat_mul_nt(p,pr,pc, h,hr,hc, num,nr,nc); mat_similarity(h,hr,hc, p,pr,pc, denom,dr,dc); mat_add(denom,dr,dc, r,rr,rc, denom,dr,dc); if (sym_factor(denom,dr,dc, denom,dr,dc)) return; /* failure - singular */ sym_rdiv(num,nr,nc, denom,dr,dc, k,kr,kc); /* update the state x: x <- x + k (z - h x) */ mat_mul(h,hr,hc, x,xr,1, w,wr,wc); mat_sub(z,zr,1, w,wr,wc, w,wr,wc); mat_mul(k,kr,kc, w,wr,wc, v,vr,vc); mat_add(x,xr,1, v,vr,vc, x,xr,1); /* update the covariance p: p <- (I - k h) p */ mat_one(v,xr,xr); mat_mul(k,kr,kc, h,hr,hc, w,xr,xr); mat_sub(v,xr,xr, w,xr,xr, w,xr,xr); mat_mul(w,xr,xr, p,xr,xr, v,xr,xr); mat_copy(v,xr,xr, p,xr,xr); }

void log_times (  void   )

Definition at line 843 of file adjtimex.c. References BUFLEN, compare_cmos_sys(), failntpdate(), puthackent(), timeserver, txc, valid_cmos_rate(), valid_system_rate(), and watch. Referenced by main(). { #ifdef NET_TIME_CLIENT struct protoent proto; int sockfd, val, len, c; struct sockaddr sa={AF_INET, "127.0.0.1"}; struct hostent he; #endif double sigma_ref, cmos_ahead; char ch, buf[64], *s; int n, ret; struct timeval tv_sys; struct timezone tz; struct tm bdt; time_t when, tref; double ftime_ref, ftime_sys, ftime_cmos; if (watch) { while(1) { printf("Please press <enter> when you know the time of day: "); ch = getchar(); gettimeofday(&tv_sys, &tz); when = tv_sys.tv_sec; bdt = *localtime(&when); /* set default values for most fields */ strftime(buf, sizeof(buf), "%Z", &bdt); printf(" system time then was %.24s %s\n", asctime(&bdt), buf); ftime_sys = tv_sys.tv_sec + tv_sys.tv_usec*.000001; printf("What time was that according to your reference (%s)?\n" "(hh:mm:ss, or `r' to retry, or `q' to quit): ", buf); if (fgets(buf, sizeof(buf), stdin) == NULL) exit(1); s = buf; while(isspace(*s)) s++; if (*s == 'q') exit(0); if (*s == 'r') continue; strptime(buf, "%T", &bdt); /* set time fields from user input */ printf(" reference time is %s", asctime(&bdt)); tref = ftime_ref = mktime(&bdt); /* construct a time_t corresponding to the user input */ printf(" mktime returns time of %s", ctime(&tref)); printf("reference time - system time = %12.3f - %12.3f " "= %4.3f sec\n", ftime_ref, ftime_sys, ftime_ref - ftime_sys); printf("How big could the error be in this, in seconds?\n" "(or `r' to retry, or `q' to quit) [.5] : "); if (fgets(buf, sizeof(buf), stdin) == NULL) exit(1); s = buf; while(isspace(*s)) s++; if (*s == 'q') exit(0); if (*s == 'r') continue; n = sscanf(buf, "%lf", &sigma_ref); if (n < 1) sigma_ref = .5; else if (sigma_ref < .02) { printf("You get credit for .02 sec.\n"); sigma_ref = .02; } break; } } else if (timeserver) { FILE *ifile; char command[128]; char buf[BUFLEN]; char *str[5]; int i, n=0; double d, mean=0, val, var=0, num=0; #ifdef NTPDATE_STUB ifile = fopen("../ntpdate-sample", "r"); #else sprintf(command, "ntpdate -d %.32s ", timeserver); ifile = popen(command, "r"); #endif if (ifile == NULL) failntpdate("call to ntpdate failed"); /* read and save the significant lines, which should look like this: filter offset: -0.02800 -0.01354 -0.01026 -0.01385 offset -0.013543 1 Sep 11:51:23 ntpdate[598]: adjust time server 1.2.3.4 offset -0.013543 sec */ while(fgets(buf, BUFLEN, ifile)) if (strstr(buf, "offset") && n < 4) str[n++] = strdup(buf); fclose(ifile); if (n != 3) failntpdate("cannot understand ntpdate output"); gettimeofday(&tv_sys, &tz); ftime_sys = tv_sys.tv_sec; /* ntpdate selects the offset from one of its samples (the one with the shortest round-trip delay?) */ ftime_ref = ftime_sys + atof(strstr(str[2], "offset") + 6); { time_t now = (time_t)ftime_ref; bdt = *gmtime(&now); printf(" reference time is %s", ctime(&now)); printf("reference time - system time = %12.3f - %12.3f " "= %4.3f sec\n", ftime_ref, ftime_sys, ftime_ref - ftime_sys); } /* The first saved line shows the offsets for each of ntpdate's samples. Find their variance, which we will use to indicate the accuracy of the offset we're using. This is probably conservative, since the offset we're using is probably not close to the mean. */ s = strstr(str[0], ":"); if (s++ == NULL) failntpdate("cannot understand ntpdate output"); for (i = 0; i < 4; i++) { val = strtod(s, &s); d = val - mean; num += 1.; var = (num-1)/num*(var + d*d/num); mean = ((num-1.)*mean + val)/num; } sigma_ref = sqrt(var); #ifdef OWN_IMPLEMENTATION /* this is not even close to working yet */ proto = *getprotobyname("UDP"); sockfd = socket(AF_INET, SOCK_DGRAM, proto.p_proto); he = *gethostbyname("localhost"); len = he.h_length; memcpy(sa.sa_data, he.h_addr_list[0], len); #ifdef SEND val = connect(sockfd, &sa, len); if (val == -1) {perror("connect"); exit(1);} /* int connect(int sockfd, struct sockaddr *serv_addr, int addrlen ); int send(int s, const void *msg, int len , unsigned int flags); int sendto(int s, const void *msg, int len unsigned int flags, const struct sockaddr *to, int tolen); */ #endif /* SEND */ val = sendto(sockfd, (const void *)" ", 1, 0, &sa, len); if (val == -1) {perror("sendto"); exit(1);} sigma_ref = .010; #endif /* OWN_IMPLEMENTATION */ } else /* no absolute time reference */ { time_t now; gettimeofday(&tv_sys, &tz); now = (time_t)tv_sys.tv_sec; bdt = *gmtime(&now); ftime_sys = tv_sys.tv_sec + tv_sys.tv_usec*.000001; ftime_ref = 0; sigma_ref = 0; } cmos_ahead = compare_cmos_sys(); ftime_cmos = ftime_sys + cmos_ahead; /* -reference-time- --------system-time---------- --cmos-time---- 1997-06-14 20:22 888888888.888 -3 888888888.888 10000 6666666 n 888888888.888 y */ { struct hack h; h.ref = ftime_ref; h.sigma_ref = sigma_ref; h.log = (time_t)ftime_ref; h.sys = ftime_sys; txc.modes = 0; ret = adjtimex(&txc); h.tick = txc.tick; h.freq = txc.freq; h.sys_ok = valid_system_rate(ftime_sys, ftime_ref, sigma_ref); h.cmos = ftime_cmos; h.cmos_ok = valid_cmos_rate(ftime_cmos, ftime_ref, sigma_ref); puthackent(&h); } }

int main (  int  argc, char *  argv[] )

Definition at line 273 of file adjtimex.c. References adjusting, compare(), comparing, count, HELP, interval, log_path, log_times(), logging, longopt, probe_time(), reset_time_status(), resetting, review(), reviewing, timeserver, txc, universal, usage(), and watch. { int ret, saveerr, changes; extern char *optarg; int c; txc.modes = 0; while((c = getopt_long_only(argc, argv, "a::c::l::e:f:h:i:m:o:prPPsPS:RT:t:uvw", longopt, NULL)) != -1) { switch(c) { case 'a': adjusting = 1; if (optarg) count = atoi(optarg); break; case 'c': comparing = 1; if (optarg) count = atoi(optarg); break; case 'l': logging = 1; if (optarg) log_path = strdup(optarg); if (!log_path) { fprintf (stderr, "insufficient memory\n"); exit(1); } break; case 'h': timeserver = strdup(optarg); if (!timeserver) { fprintf (stderr, "insufficient memory\n"); exit(1); } logging = 1; break; case 'r': reviewing = 1; if (optarg) log_path = strdup(optarg); if (!log_path) { fprintf (stderr, "insufficient memory\n"); exit(1); } break; case 'i': interval = atoi (optarg); if (interval <= 1 || interval > 1000) { fprintf (stderr, "repeat interval out of range\n"); exit (1); } break; case 'p': F_print = 1; break; case 'o': txc.offset = atol(optarg); txc.modes |= ADJ_OFFSET; break; case 's': txc.offset = atol(optarg); txc.modes |= ADJ_OFFSET_SINGLESHOT; break; case 'S': txc.status = atol(optarg); txc.modes |= ADJ_STATUS; break; case 'R': resetting = 1; break; case 'f': txc.freq = atol(optarg); txc.modes |= ADJ_FREQUENCY; break; case 'm': txc.maxerror = atol(optarg); txc.modes |= ADJ_MAXERROR; break; case 'e': txc.esterror = atol(optarg); txc.modes |= ADJ_ESTERROR; break; case 'T': txc.constant = atol(optarg); txc.modes |= ADJ_TIMECONST; break; case 't': txc.tick = atol(optarg); txc.modes |= ADJ_TICK; break; case 'u': universal = 1; break; case 'v': { printf("adjtimex %s\n", VERSION); exit(0); } case 'w': watch = 1; logging = 1; break; case HELP: usage(); break; case '?': default: fprintf(stderr, "For valid options, try 'adjtimex --help'\n"); exit(1); } } changes = txc.modes; if (count <= 0 ) { fprintf(stderr, "loop count out of range\n"); exit(1); } if (reviewing) { review(); exit(0); } if (adjusting || comparing) { if (changes || F_print) { fprintf(stderr, "-adjust or -compare cannot be used with any other options that" " set values\n"); exit(1); } compare(); } if (logging) { /* if (geteuid() != 0) { fprintf(stderr, "sorry, only root can record clock comparisons\n"); exit(1); } */ log_times(); exit(0); } if ((txc.modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT && txc.modes != ADJ_OFFSET_SINGLESHOT) { fprintf(stderr, "-singleshot cannot be used with " "any other option except -print\n"); usage(); } errno = 0; ret = adjtimex(&txc); saveerr = errno; if (F_print) { printf(" mode: %d\n" " offset: %ld\n" " frequency: %ld\n" " maxerror: %ld\n" " esterror: %ld\n" " status: %d\n" "time_constant: %ld\n" " precision: %ld\n" " tolerance: %ld\n" " tick: %ld\n" " raw time: %ds %dus = %d.%06d\n", txc.modes, txc.offset, txc.freq, txc.maxerror, txc.esterror, txc.status, txc.constant, txc.precision, txc.tolerance, txc.tick, (int)txc.time.tv_sec, (int)txc.time.tv_usec, (int)txc.time.tv_sec, (int)txc.time.tv_usec); if (saveerr == 0 && ret != 0) printf(" return value = %d\n"