1291 lines
46 KiB
C
1291 lines
46 KiB
C
/*
|
|
* hwclock.c
|
|
*
|
|
* clock.c was written by Charles Hedrick, hedrick@cs.rutgers.edu, Apr 1992
|
|
* Modified for clock adjustments - Rob Hooft <hooft@chem.ruu.nl>, Nov 1992
|
|
* Improvements by Harald Koenig <koenig@nova.tat.physik.uni-tuebingen.de>
|
|
* and Alan Modra <alan@spri.levels.unisa.edu.au>.
|
|
*
|
|
* Major rewrite by Bryan Henderson <bryanh@giraffe-data.com>, 96.09.19.
|
|
* The new program is called hwclock. New features:
|
|
* - You can set the hardware clock without also modifying the system clock.
|
|
* - You can read and set the clock with finer than 1 second precision.
|
|
* - When you set the clock, hwclock automatically refigures the drift
|
|
* rate, based on how far off the clock was before you set it.
|
|
*
|
|
* Reshuffled things, added sparc code, and re-added alpha stuff
|
|
* by David Mosberger <davidm@azstarnet.com>
|
|
* and Jay Estabrook <jestabro@amt.tay1.dec.com>
|
|
* and Martin Ostermann <ost@coments.rwth-aachen.de>, aeb@cwi.nl, 990212.
|
|
*
|
|
* Fix for Award 2094 bug, Dave Coffin (dcoffin@shore.net) 11/12/98
|
|
*/
|
|
|
|
/*
|
|
* clock [-u] -r - read hardware clock
|
|
* clock [-u] -w - write hardware clock from system time
|
|
* clock [-u] -s - set system time from hardware clock
|
|
* clock [-u] -a - set system time from hardware clock, adjust the time
|
|
* to correct for systematic error, and write it back to
|
|
* the hardware clock
|
|
* -u indicates cmos clock is kept in universal time
|
|
* -A indicates cmos clock is kept in Alpha ARC console time (0 == 1980)
|
|
* -J indicates we're dealing with a Jensen (early DEC Alpha PC)
|
|
*/
|
|
|
|
/*
|
|
* Explanation of `adjusting' (Rob Hooft):
|
|
*
|
|
* The problem with my machine is that its CMOS clock is 10 seconds
|
|
* per day slow. With this version of clock.c, and my '/etc/rc.local'
|
|
* reading '/etc/clock -au' instead of '/etc/clock -u -s', this error
|
|
* is automatically corrected at every boot.
|
|
*
|
|
* To do this job, the program reads and writes the file '/etc/adjtime'
|
|
* to determine the correction, and to save its data. In this file are
|
|
* three numbers:
|
|
*
|
|
* 1) the correction in seconds per day. (So if your clock runs 5
|
|
* seconds per day fast, the first number should read -5.0)
|
|
* 2) the number of seconds since 1/1/1970 the last time the program
|
|
* was used
|
|
* 3) the remaining part of a second which was leftover after the last
|
|
* adjustment
|
|
*
|
|
* Installation and use of this program:
|
|
*
|
|
* a) create a file '/etc/adjtime' containing as the first and only line:
|
|
* '0.0 0 0.0'
|
|
* b) run 'clock -au' or 'clock -a', depending on whether your cmos is in
|
|
* universal or local time. This updates the second number.
|
|
* c) set your system time using the 'date' command.
|
|
* d) update your cmos time using 'clock -wu' or 'clock -w'
|
|
* e) replace the first number in /etc/adjtime by your correction.
|
|
* f) put the command 'clock -au' or 'clock -a' in your '/etc/rc.local'
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#include <sys/stat.h>
|
|
#include <shhopt.h>
|
|
|
|
#include "clock.h"
|
|
#include "../version.h"
|
|
#include "nls.h"
|
|
|
|
#define MYNAME "hwclock"
|
|
#define VERSION "2.4c"
|
|
|
|
char *progname = MYNAME;
|
|
|
|
/* The struct that holds our hardware access routines */
|
|
struct clock_ops *ur;
|
|
|
|
#define FLOOR(arg) ((arg >= 0 ? (int) arg : ((int) arg) - 1));
|
|
|
|
/* Here the information for time adjustments is kept. */
|
|
#define ADJPATH "/etc/adjtime"
|
|
|
|
/* Store the date here when "badyear" flag is set. */
|
|
#define LASTDATE "/var/lib/lastdate"
|
|
|
|
struct adjtime {
|
|
/* This is information we keep in the adjtime file that tells us how
|
|
to do drift corrections. Elements are all straight from the
|
|
adjtime file, so see documentation of that file for details.
|
|
Exception is <dirty>, which is an indication that what's in this
|
|
structure is not what's in the disk file (because it has been
|
|
updated since read from the disk file).
|
|
*/
|
|
bool dirty;
|
|
float drift_factor;
|
|
time_t last_adj_time;
|
|
float not_adjusted;
|
|
time_t last_calib_time;
|
|
};
|
|
|
|
bool debug;
|
|
/* We are running in debug mode, wherein we put a lot of information about
|
|
what we're doing to standard output. */
|
|
|
|
bool badyear;
|
|
/* Workaround for Award 4.50g BIOS bug: keep the year in a file. */
|
|
|
|
/*
|
|
* Almost all Award BIOS's made between 04/26/94 and 05/31/95
|
|
* have a nasty bug limiting the RTC year byte to the range 94-99.
|
|
* Any year between 2000 and 2093 gets changed to 2094, every time
|
|
* you start the system.
|
|
* With the --badyear option, we write the date to file and hope
|
|
* that the file is updated at least once a year.
|
|
* I recommend putting this command "hwclock --badyear" in the monthly
|
|
* crontab, just to be safe. -- Dave Coffin 11/12/98
|
|
*/
|
|
void
|
|
write_date_to_file (struct tm *tm) {
|
|
FILE *fp;
|
|
|
|
if ((fp = fopen(LASTDATE,"w"))) {
|
|
fprintf(fp,"%02d.%02d.%04d\n", tm->tm_mday, tm->tm_mon+1,
|
|
tm->tm_year+1900);
|
|
fclose(fp);
|
|
} else
|
|
perror(LASTDATE);
|
|
}
|
|
|
|
void
|
|
read_date_from_file (struct tm *tm) {
|
|
int last_mday, last_mon, last_year;
|
|
FILE *fp;
|
|
|
|
if ((fp = fopen(LASTDATE,"r"))) {
|
|
if (fscanf (fp,"%d.%d.%d\n", &last_mday, &last_mon, &last_year) == 3) {
|
|
tm->tm_year = last_year-1900;
|
|
if ((tm->tm_mon << 5) + tm->tm_mday < ((last_mon-1) << 5) + last_mday)
|
|
tm->tm_year ++;
|
|
}
|
|
fclose(fp);
|
|
}
|
|
write_date_to_file (tm);
|
|
}
|
|
|
|
static float
|
|
time_diff(struct timeval subtrahend, struct timeval subtractor) {
|
|
/*---------------------------------------------------------------------------
|
|
The difference in seconds between two times in "timeval" format.
|
|
----------------------------------------------------------------------------*/
|
|
return( (subtrahend.tv_sec - subtractor.tv_sec)
|
|
+ (subtrahend.tv_usec - subtractor.tv_usec) / 1E6 );
|
|
}
|
|
|
|
|
|
static struct timeval
|
|
time_inc(struct timeval addend, float increment) {
|
|
/*----------------------------------------------------------------------------
|
|
The time, in "timeval" format, which is <increment> seconds after
|
|
the time <addend>. Of course, <increment> may be negative.
|
|
-----------------------------------------------------------------------------*/
|
|
struct timeval newtime;
|
|
|
|
newtime.tv_sec = addend.tv_sec + (int) increment;
|
|
newtime.tv_usec = addend.tv_usec + (increment - (int) increment) * 1E6;
|
|
|
|
/* Now adjust it so that the microsecond value is between 0 and 1 million */
|
|
if (newtime.tv_usec < 0) {
|
|
newtime.tv_usec += 1E6;
|
|
newtime.tv_sec -= 1;
|
|
} else if (newtime.tv_usec >= 1E6) {
|
|
newtime.tv_usec -= 1E6;
|
|
newtime.tv_sec += 1;
|
|
}
|
|
return(newtime);
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
read_adjtime(struct adjtime *adjtime_p, int *rc_p) {
|
|
/*----------------------------------------------------------------------------
|
|
Read the adjustment parameters out of the /etc/adjtime file.
|
|
|
|
Return them as the adjtime structure <*adjtime_p>.
|
|
|
|
If there is no /etc/adjtime file, return defaults.
|
|
If values are missing from the file, return defaults for them.
|
|
|
|
return *rc_p = 0 if all OK, !=0 otherwise.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
FILE *adjfile;
|
|
int rc; /* local return code */
|
|
struct stat statbuf; /* We don't even use the contents of this. */
|
|
|
|
rc = stat(ADJPATH, &statbuf);
|
|
if (rc < 0 && errno == ENOENT) {
|
|
/* He doesn't have a adjtime file, so we'll use defaults. */
|
|
adjtime_p->drift_factor = 0;
|
|
adjtime_p->last_adj_time = 0;
|
|
adjtime_p->not_adjusted = 0;
|
|
adjtime_p->last_calib_time = 0;
|
|
|
|
*rc_p = 0;
|
|
} else {
|
|
adjfile = fopen(ADJPATH, "r"); /* open file for reading */
|
|
if (adjfile == NULL) {
|
|
outsyserr("cannot open file " ADJPATH);
|
|
*rc_p = 2;
|
|
} else {
|
|
char line1[81]; /* String: first line of adjtime file */
|
|
char line2[81]; /* String: second line of adjtime file */
|
|
|
|
line1[0] = '\0'; /* In case fgets fails */
|
|
fgets(line1, sizeof(line1), adjfile);
|
|
line2[0] = '\0'; /* In case fgets fails */
|
|
fgets(line2, sizeof(line2), adjfile);
|
|
|
|
fclose(adjfile);
|
|
|
|
/* Set defaults in case values are missing from file */
|
|
adjtime_p->drift_factor = 0;
|
|
adjtime_p->last_adj_time = 0;
|
|
adjtime_p->not_adjusted = 0;
|
|
adjtime_p->last_calib_time = 0;
|
|
|
|
sscanf(line1, "%f %d %f",
|
|
&adjtime_p->drift_factor,
|
|
(int *) &adjtime_p->last_adj_time,
|
|
&adjtime_p->not_adjusted);
|
|
|
|
sscanf(line2, "%d", (int *) &adjtime_p->last_calib_time);
|
|
|
|
*rc_p = 0;
|
|
}
|
|
adjtime_p->dirty = FALSE;
|
|
|
|
if (debug) {
|
|
printf(_("Last drift adjustment done at %d seconds after 1969\n"),
|
|
(int) adjtime_p->last_adj_time);
|
|
printf(_("Last calibration done at %d seconds after 1969\n"),
|
|
(int) adjtime_p->last_calib_time);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
synchronize_to_clock_tick(int *retcode_p) {
|
|
/*-----------------------------------------------------------------------------
|
|
Wait until the falling edge of the Hardware Clock's update flag so
|
|
that any time that is read from the clock immediately after we
|
|
return will be exact.
|
|
|
|
The clock only has 1 second precision, so it gives the exact time only
|
|
once per second, right on the falling edge of the update flag.
|
|
|
|
We wait (up to one second) either blocked waiting for an rtc device
|
|
or in a CPU spin loop. The former is probably not very accurate.
|
|
|
|
Return *retcode_p == 0 if it worked, nonzero if it didn't.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
if (debug) printf(_("Waiting for clock tick...\n"));
|
|
|
|
*retcode_p = ur->synchronize_to_clock_tick();
|
|
|
|
if (debug) printf(_("...got clock tick\n"));
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
mktime_tz(struct tm tm, const bool universal,
|
|
bool *valid_p, time_t *systime_p) {
|
|
/*-----------------------------------------------------------------------------
|
|
Convert a time in broken down format (hours, minutes, etc.) into standard
|
|
unix time (seconds into epoch). Return it as *systime_p.
|
|
|
|
The broken down time is argument <tm>. This broken down time is either in
|
|
local time zone or UTC, depending on value of logical argument "universal".
|
|
True means it is in UTC.
|
|
|
|
If the argument contains values that do not constitute a valid time,
|
|
and mktime() recognizes this, return *valid_p == false and
|
|
*systime_p undefined. However, mktime() sometimes goes ahead and
|
|
computes a fictional time "as if" the input values were valid,
|
|
e.g. if they indicate the 31st day of April, mktime() may compute
|
|
the time of May 1. In such a case, we return the same fictional
|
|
value mktime() does as *systime_p and return *valid_p == true.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
time_t mktime_result; /* The value returned by our mktime() call */
|
|
char *zone; /* Local time zone name */
|
|
|
|
/* We use the C library function mktime(), but since it only works on
|
|
local time zone input, we may have to fake it out by temporarily
|
|
changing the local time zone to UTC.
|
|
*/
|
|
zone = (char *) getenv("TZ"); /* remember original time zone */
|
|
mktime_result = mktime(&tm);
|
|
if (universal) {
|
|
/* Set timezone to UTC */
|
|
setenv("TZ", "", TRUE);
|
|
/* Note: tzset() gets called implicitly by the time code, but only the
|
|
first time. When changing the environment variable, better call
|
|
tzset() explicitly.
|
|
*/
|
|
tzset();
|
|
}
|
|
mktime_result = mktime(&tm);
|
|
if (mktime_result == -1) {
|
|
/* This apparently (not specified in mktime() documentation) means
|
|
the 'tm' structure does not contain valid values (however, not
|
|
containing valid values does _not_ imply mktime() returns -1).
|
|
*/
|
|
*valid_p = FALSE;
|
|
*systime_p = 0;
|
|
if (debug)
|
|
printf(_("Invalid values in hardware clock: "
|
|
"%2d/%.2d/%.2d %.2d:%.2d:%.2d\n"),
|
|
tm.tm_year, tm.tm_mon+1, tm.tm_mday,
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec
|
|
);
|
|
} else {
|
|
*valid_p = TRUE;
|
|
*systime_p = mktime_result;
|
|
if (debug)
|
|
printf(_("Hw clock time : %.2d:%.2d:%.2d = %d seconds since 1969\n"),
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec, (int) *systime_p);
|
|
}
|
|
/* now put back the original zone. */
|
|
if (zone) setenv("TZ", zone, TRUE);
|
|
else unsetenv("TZ");
|
|
tzset();
|
|
}
|
|
|
|
|
|
static void
|
|
read_hardware_clock(const bool universal, bool *valid_p, time_t *systime_p){
|
|
/*----------------------------------------------------------------------------
|
|
Read the hardware clock and return the current time via <tm> argument.
|
|
|
|
Use the method indicated by <method> argument to access the hardware clock.
|
|
-----------------------------------------------------------------------------*/
|
|
struct tm tm;
|
|
int err;
|
|
|
|
err = ur->read_hardware_clock(&tm);
|
|
|
|
if (badyear)
|
|
read_date_from_file(&tm);
|
|
|
|
if (debug)
|
|
printf (_("Time read from Hardware Clock: %02d:%02d:%02d\n"),
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
|
mktime_tz(tm, universal, valid_p, systime_p);
|
|
}
|
|
|
|
|
|
static void
|
|
set_hardware_clock(const time_t newtime,
|
|
const bool universal,
|
|
const bool testing) {
|
|
/*----------------------------------------------------------------------------
|
|
Set the Hardware Clock to the time <newtime>, in local time zone or UTC,
|
|
according to <universal>.
|
|
----------------------------------------------------------------------------*/
|
|
int err;
|
|
struct tm new_broken_time;
|
|
/* Time to which we will set Hardware Clock, in broken down format, in
|
|
the time zone of caller's choice
|
|
*/
|
|
|
|
if (universal)
|
|
new_broken_time = *gmtime(&newtime);
|
|
else
|
|
new_broken_time = *localtime(&newtime);
|
|
|
|
if (debug)
|
|
printf(_("Setting Hardware Clock to %.2d:%.2d:%.2d "
|
|
"= %d seconds since 1969\n"),
|
|
new_broken_time.tm_hour, new_broken_time.tm_min,
|
|
new_broken_time.tm_sec, (int) newtime);
|
|
|
|
if (testing)
|
|
printf(_("Clock not changed - testing only.\n"));
|
|
else {
|
|
if (badyear) {
|
|
/*
|
|
* Write the real year to a file, then write a fake year
|
|
* between 1995 and 1998 to the RTC. This way, Award BIOS boots
|
|
* on 29 Feb 2000 thinking that it's 29 Feb 1996.
|
|
*/
|
|
write_date_to_file (&new_broken_time);
|
|
new_broken_time.tm_year = 95 + ((new_broken_time.tm_year+1) & 3);
|
|
}
|
|
err = ur->set_hardware_clock(&new_broken_time);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
set_hardware_clock_exact(const time_t settime,
|
|
const struct timeval ref_time,
|
|
const bool universal,
|
|
const bool testing) {
|
|
/*----------------------------------------------------------------------------
|
|
Set the Hardware Clock to the time "settime", in local time zone or UTC,
|
|
according to "universal".
|
|
|
|
But correct "settime" and wait for a fraction of a second so that
|
|
"settime" is the value of the Hardware Clock as of system time
|
|
"ref_time", which is in the past. For example, if "settime" is
|
|
14:03:05 and "ref_time" is 12:10:04.5 and the current system
|
|
time is 12:10:06.0: Wait .5 seconds (to make exactly 2 seconds since
|
|
"ref_time") and then set the Hardware Clock to 14:03:07, thus
|
|
getting a precise and retroactive setting of the clock.
|
|
|
|
(Don't be confused by the fact that the system clock and the Hardware
|
|
Clock differ by two hours in the above example. That's just to remind
|
|
you that there are two independent time scales here).
|
|
|
|
This function ought to be able to accept set times as fractional times.
|
|
Idea for future enhancement.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
time_t newtime; /* Time to which we will set Hardware Clock */
|
|
struct timeval now_time; /* locally used time */
|
|
|
|
gettimeofday(&now_time, NULL);
|
|
newtime = settime + (int) time_diff(now_time, ref_time) + 1;
|
|
if (debug)
|
|
printf(_("Time elapsed since reference time has been %.6f seconds.\n"
|
|
"Delaying further to reach the next full second.\n"),
|
|
time_diff(now_time, ref_time));
|
|
|
|
/* Now delay some more until Hardware Clock time newtime arrives */
|
|
do gettimeofday(&now_time, NULL);
|
|
while (time_diff(now_time, ref_time) < newtime - settime);
|
|
|
|
set_hardware_clock(newtime, universal, testing);
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
display_time(const bool hclock_valid, const time_t systime,
|
|
const float sync_duration) {
|
|
/*----------------------------------------------------------------------------
|
|
Put the time "systime" on standard output in display format.
|
|
Except if hclock_valid == false, just tell standard output that we don't
|
|
know what time it is.
|
|
|
|
Include in the output the adjustment "sync_duration".
|
|
-----------------------------------------------------------------------------*/
|
|
if (!hclock_valid)
|
|
fprintf(stderr, _("The Hardware Clock registers contain values that are "
|
|
"either invalid (e.g. 50th day of month) or beyond the range "
|
|
"we can handle (e.g. Year 2095).\n"));
|
|
else {
|
|
char *ctime_now; /* Address of static storage containing time string */
|
|
|
|
/* For some strange reason, ctime() is designed to include a newline
|
|
character at the end. We have to remove that.
|
|
*/
|
|
ctime_now = ctime(&systime); /* Compute display value for time */
|
|
*(ctime_now+strlen(ctime_now)-1) = '\0'; /* Cut off trailing newline */
|
|
|
|
printf(_("%s %.6f seconds\n"), ctime_now, -(sync_duration));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
interpret_date_string(const char *date_opt, time_t * const time_p) {
|
|
/*----------------------------------------------------------------------------
|
|
Interpret the value of the --date option, which is something like
|
|
"13:05:01". In fact, it can be any of the myriad ASCII strings that specify
|
|
a time which the "date" program can understand. The date option value in
|
|
question is our "dateopt" argument.
|
|
|
|
The specified time is in the local time zone.
|
|
|
|
Our output, "*time_p", is a seconds-into-epoch time.
|
|
|
|
We use the "date" program to interpret the date string. "date" must be
|
|
runnable by issuing the command "date" to the /bin/sh shell. That means
|
|
in must be in the current PATH.
|
|
|
|
If anything goes wrong (and many things can), we return return code
|
|
10 and arbitrary *time_p. Otherwise, return code is 0 and *time_p
|
|
is valid.
|
|
----------------------------------------------------------------------------*/
|
|
FILE *date_child_fp;
|
|
char date_resp[100];
|
|
const char magic[]="seconds-into-epoch=";
|
|
char date_command[100];
|
|
int retcode; /* our eventual return code */
|
|
int rc; /* local return code */
|
|
|
|
if (date_opt == NULL) {
|
|
fprintf(stderr, _("No --date option specified.\n"));
|
|
retcode = 14;
|
|
} else if (strchr(date_opt, '"') != NULL) {
|
|
/* Quotation marks in date_opt would ruin the date command we construct.
|
|
*/
|
|
fprintf(stderr, _("The value of the --date option is not a valid date.\n"
|
|
"In particular, it contains quotation marks.\n"));
|
|
retcode = 12;
|
|
} else {
|
|
sprintf(date_command, "date --date=\"%s\" +seconds-into-epoch=%%s",
|
|
date_opt);
|
|
if (debug) printf(_("Issuing date command: %s\n"), date_command);
|
|
|
|
date_child_fp = popen(date_command, "r");
|
|
if (date_child_fp == NULL) {
|
|
outsyserr(_("Unable to run 'date' program in /bin/sh shell. "
|
|
"popen() failed"));
|
|
retcode = 10;
|
|
} else {
|
|
date_resp[0] = '\0'; /* in case fgets fails */
|
|
fgets(date_resp, sizeof(date_resp), date_child_fp);
|
|
if (debug) printf(_("response from date command = %s\n"), date_resp);
|
|
if (strncmp(date_resp, magic, sizeof(magic)-1) != 0) {
|
|
fprintf(stderr, _("The date command issued by %s returned "
|
|
"unexpected results.\n"
|
|
"The command was:\n %s\nThe response was:\n %s\n"),
|
|
MYNAME, date_command, date_resp);
|
|
retcode = 8;
|
|
} else {
|
|
int seconds_since_epoch;
|
|
rc = sscanf(date_resp + sizeof(magic)-1, "%d", &seconds_since_epoch);
|
|
if (rc < 1) {
|
|
fprintf(stderr, _("The date command issued by %s returned"
|
|
"something other than an integer where the converted"
|
|
"time value was expected.\n"
|
|
"The command was:\n %s\nThe response was:\n %s\n"),
|
|
MYNAME, date_command, date_resp);
|
|
retcode = 6;
|
|
} else {
|
|
retcode = 0;
|
|
*time_p = seconds_since_epoch;
|
|
if (debug)
|
|
printf(_("date string %s equates to %d seconds since 1969.\n"),
|
|
date_opt, (int) *time_p);
|
|
}
|
|
}
|
|
fclose(date_child_fp);
|
|
}
|
|
}
|
|
return(retcode);
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
set_system_clock(const bool hclock_valid, const time_t newtime,
|
|
const bool testing) {
|
|
/*----------------------------------------------------------------------------
|
|
Set the System Clock to time 'newtime'.
|
|
|
|
Also set the kernel time zone value to the value indicated by the
|
|
TZ environment variable and/or /usr/lib/zoneinfo/, interpreted as
|
|
tzset() would interpret them. Except: do not consider Daylight
|
|
Savings Time to be a separate component of the time zone. Include
|
|
any effect of DST in the basic timezone value and set the kernel
|
|
DST value to 0.
|
|
|
|
EXCEPT: if hclock_valid is false, just issue an error message
|
|
saying there is no valid time in the Hardware Clock to which to set
|
|
the system time.
|
|
|
|
If 'testing' is true, don't actually update anything -- just say we
|
|
would have.
|
|
-----------------------------------------------------------------------------*/
|
|
int retcode; /* our eventual return code */
|
|
|
|
if (!hclock_valid) {
|
|
fprintf(stderr,_("The Hardware Clock does not contain a valid time, so "
|
|
"we cannot set the System Time from it.\n"));
|
|
retcode = 1;
|
|
} else {
|
|
struct timeval tv;
|
|
int rc; /* local return code */
|
|
|
|
tv.tv_sec = newtime;
|
|
tv.tv_usec = 0;
|
|
|
|
tzset(); /* init timezone, daylight from TZ or ...zoneinfo/localtime */
|
|
/* An undocumented function of tzset() is to set global variabales
|
|
'timezone' and 'daylight'
|
|
*/
|
|
|
|
if (debug) {
|
|
printf( _("Calling settimeofday:\n") );
|
|
printf( _("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"),
|
|
(long) tv.tv_sec, (long) tv.tv_usec );
|
|
printf( _("\ttz.tz_minuteswest = %ld\n"), timezone/60 - 60*daylight);
|
|
}
|
|
if (testing) {
|
|
printf(_("Not setting system clock because running in test mode.\n"));
|
|
retcode = 0;
|
|
} else {
|
|
/* For documentation of settimeofday(), in addition to its man page,
|
|
see kernel/time.c in the Linux source code.
|
|
*/
|
|
const struct timezone tz = { timezone/60 - 60*daylight, 0 };
|
|
/* put daylight in minuteswest rather than dsttime,
|
|
since the latter is mostly ignored ... */
|
|
rc = settimeofday(&tv, &tz);
|
|
if (rc != 0) {
|
|
if (errno == EPERM)
|
|
fprintf(stderr, _("Must be superuser to set system clock.\n"));
|
|
else
|
|
outsyserr(_("settimeofday() failed"));
|
|
retcode = 1;
|
|
} else retcode = 0;
|
|
}
|
|
}
|
|
return(retcode);
|
|
}
|
|
|
|
|
|
static void
|
|
adjust_drift_factor(struct adjtime *adjtime_p,
|
|
const time_t nowtime,
|
|
const bool hclock_valid, const time_t hclocktime ) {
|
|
/*---------------------------------------------------------------------------
|
|
Update the drift factor in <*adjtime_p> to reflect the fact that the
|
|
Hardware Clock was calibrated to <nowtime> and before that was set
|
|
to <hclocktime>.
|
|
|
|
We assume that the user has been doing regular drift adjustments
|
|
using the drift factor in the adjtime file, so if <nowtime> and
|
|
<clocktime> are different, that means the adjustment factor isn't
|
|
quite right.
|
|
|
|
We record in the adjtime file the time at which we last calibrated
|
|
the clock so we can compute the drift rate each time we calibrate.
|
|
|
|
EXCEPT: if <hclock_valid> is false, assume Hardware Clock was not set
|
|
before to anything meaningful and regular adjustments have not been
|
|
done, so don't adjust the drift factor.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
if (!hclock_valid) {
|
|
if (debug)
|
|
printf(_("Not adjusting drift factor because the Hardware Clock "
|
|
"previously contained garbage.\n"));
|
|
} else if ((hclocktime - adjtime_p->last_calib_time) < 23 * 60 * 60) {
|
|
if (debug)
|
|
printf(_("Not adjusting drift factor because it has been less than a "
|
|
"day since the last calibration.\n"));
|
|
} else {
|
|
const float factor_adjust =
|
|
((float) (nowtime - hclocktime)
|
|
/ (hclocktime - adjtime_p->last_calib_time))
|
|
* 24 * 60 * 60;
|
|
|
|
if (debug)
|
|
printf(_("Clock drifted %d seconds in the past %d seconds "
|
|
"in spite of a drift factor of %f seconds/day.\n"
|
|
"Adjusting drift factor by %f seconds/day\n"),
|
|
(int) (nowtime - hclocktime),
|
|
(int) (hclocktime - adjtime_p->last_calib_time),
|
|
adjtime_p->drift_factor,
|
|
factor_adjust );
|
|
|
|
adjtime_p->drift_factor += factor_adjust;
|
|
}
|
|
adjtime_p->last_calib_time = nowtime;
|
|
|
|
adjtime_p->last_adj_time = nowtime;
|
|
|
|
adjtime_p->not_adjusted = 0;
|
|
|
|
adjtime_p->dirty = TRUE;
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
calculate_adjustment(
|
|
const float factor,
|
|
const time_t last_time,
|
|
const float not_adjusted,
|
|
const time_t systime,
|
|
int *adjustment_p,
|
|
float *retro_p,
|
|
const int debug ) {
|
|
/*----------------------------------------------------------------------------
|
|
Do the drift adjustment calculation.
|
|
|
|
The way we have to set the clock, we need the adjustment in two parts:
|
|
|
|
1) an integer number of seconds (return as *adjustment_p)
|
|
|
|
2) a positive fraction of a second (less than 1) (return as *retro_p)
|
|
|
|
The sum of these two values is the adjustment needed. Positive means to
|
|
advance the clock or insert seconds. Negative means to retard the clock
|
|
or remove seconds.
|
|
----------------------------------------------------------------------------*/
|
|
float exact_adjustment;
|
|
|
|
exact_adjustment = ((float) (systime - last_time)) * factor / (24 * 60 * 60)
|
|
+ not_adjusted;
|
|
*adjustment_p = FLOOR(exact_adjustment);
|
|
|
|
*retro_p = exact_adjustment - (float) *adjustment_p;
|
|
if (debug) {
|
|
printf (_("Time since last adjustment is %d seconds\n"),
|
|
(int) (systime - last_time));
|
|
printf (_("Need to insert %d seconds and refer time back "
|
|
"%.6f seconds ago\n"),
|
|
*adjustment_p, *retro_p);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
save_adjtime(const struct adjtime adjtime, const bool testing) {
|
|
/*-----------------------------------------------------------------------------
|
|
Write the contents of the <adjtime> structure to its disk file.
|
|
|
|
But if the contents are clean (unchanged since read from disk), don't
|
|
bother.
|
|
-----------------------------------------------------------------------------*/
|
|
char newfile[405]; /* Stuff to write to disk file */
|
|
|
|
if (adjtime.dirty) {
|
|
/* snprintf is not always available, but this is safe
|
|
as long as libc does not use more than 100 positions for %ld or %f */
|
|
sprintf(newfile, "%f %ld %f\n%ld\n",
|
|
adjtime.drift_factor,
|
|
(long) adjtime.last_adj_time,
|
|
adjtime.not_adjusted,
|
|
(long) adjtime.last_calib_time );
|
|
|
|
if (testing) {
|
|
printf(_("Not updating adjtime file because of testing mode.\n"));
|
|
printf(_("Would have written the following to %s:\n%s"),
|
|
ADJPATH, newfile);
|
|
} else {
|
|
FILE *adjfile;
|
|
int err = 0;
|
|
|
|
adjfile = fopen(ADJPATH, "w");
|
|
if (adjfile == NULL) {
|
|
outsyserr("Could not open file with the clock adjustment parameters "
|
|
"in it (" ADJPATH ") for writing");
|
|
err = 1;
|
|
} else {
|
|
if (fprintf(adjfile, newfile) < 0) {
|
|
outsyserr("Could not update file with the clock adjustment "
|
|
"parameters (" ADJPATH ") in it");
|
|
err = 1;
|
|
}
|
|
if (fclose(adjfile) < 0) {
|
|
outsyserr("Could not update file with the clock adjustment "
|
|
"parameters (" ADJPATH ") in it");
|
|
err = 1;
|
|
}
|
|
}
|
|
if (err)
|
|
fprintf(stderr, _("Drift adjustment parameters not updated.\n"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
do_adjustment(struct adjtime *adjtime_p,
|
|
const bool hclock_valid, const time_t hclocktime,
|
|
const struct timeval read_time,
|
|
const bool universal, const bool testing) {
|
|
/*---------------------------------------------------------------------------
|
|
Do the adjustment requested, by 1) setting the Hardware Clock (if
|
|
necessary), and 2) updating the last-adjusted time in the adjtime
|
|
structure.
|
|
|
|
Do not update anything if the Hardware Clock does not currently present
|
|
a valid time.
|
|
|
|
arguments <factor> and <last_time> are current values from the adjtime
|
|
file.
|
|
|
|
<hclock_valid> means the Hardware Clock contains a valid time, and that
|
|
time is <hclocktime>.
|
|
|
|
<read_time> is the current system time (to be precise, it is the system
|
|
time at the time <hclocktime> was read, which due to computational delay
|
|
could be a short time ago).
|
|
|
|
<universal>: the Hardware Clock is kept in UTC.
|
|
|
|
<testing>: We are running in test mode (no updating of clock).
|
|
|
|
We do not bother to update the clock if the adjustment would be less than
|
|
one second. This is to avoid cumulative error and needless CPU hogging
|
|
(remember we use an infinite loop for some timing) if the user runs us
|
|
frequently.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
if (!hclock_valid) {
|
|
fprintf(stderr, _("The Hardware Clock does not contain a valid time, "
|
|
"so we cannot adjust it.\n"));
|
|
} else {
|
|
int adjustment;
|
|
/* Number of seconds we must insert in the Hardware Clock */
|
|
float retro;
|
|
/* Fraction of second we have to remove from clock after inserting
|
|
<adjustment> whole seconds.
|
|
*/
|
|
calculate_adjustment(adjtime_p->drift_factor,
|
|
adjtime_p->last_adj_time,
|
|
adjtime_p->not_adjusted,
|
|
hclocktime,
|
|
&adjustment, &retro,
|
|
debug );
|
|
if (adjustment > 0 || adjustment < -1) {
|
|
set_hardware_clock_exact(hclocktime + adjustment,
|
|
time_inc(read_time, -retro),
|
|
universal, testing);
|
|
adjtime_p->last_adj_time = hclocktime + adjustment;
|
|
adjtime_p->not_adjusted = 0;
|
|
adjtime_p->dirty = TRUE;
|
|
} else
|
|
if (debug)
|
|
printf(_("Needed adjustment is less than one second, "
|
|
"so not setting clock.\n"));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
determine_clock_access_method(const bool user_requests_ISA) {
|
|
|
|
ur = NULL;
|
|
|
|
if (user_requests_ISA)
|
|
ur = probe_for_cmos_clock();
|
|
|
|
if (!ur)
|
|
ur = probe_for_rtc_clock();
|
|
|
|
if (!ur)
|
|
ur = probe_for_kd_clock();
|
|
|
|
if (!ur && !user_requests_ISA)
|
|
ur = probe_for_cmos_clock();
|
|
|
|
if (debug) {
|
|
if (ur)
|
|
printf(_("Using %s.\n"), ur->interface_name);
|
|
else
|
|
printf(_("No usable clock interface found.\n"));
|
|
}
|
|
}
|
|
|
|
static void
|
|
manipulate_clock(const bool show, const bool adjust,
|
|
const bool set, const time_t set_time,
|
|
const bool hctosys, const bool systohc,
|
|
const struct timeval startup_time,
|
|
const bool universal, const bool testing,
|
|
int *retcode_p
|
|
) {
|
|
/*---------------------------------------------------------------------------
|
|
Do all the normal work of hwclock - read, set clock, etc.
|
|
|
|
Issue output to stdout and error message to stderr where appropriate.
|
|
|
|
Return rc == 0 if everything went OK, rc != 0 if not.
|
|
----------------------------------------------------------------------------*/
|
|
struct adjtime adjtime;
|
|
/* Contents of the adjtime file, or what they should be. */
|
|
int rc; /* local return code */
|
|
bool no_auth; /* User lacks necessary authorization to access the clock */
|
|
|
|
no_auth = ur->get_permissions();
|
|
|
|
if (no_auth) *retcode_p = 1;
|
|
else {
|
|
if (adjust || set || systohc)
|
|
read_adjtime(&adjtime, &rc);
|
|
else {
|
|
/* A little trick to avoid reading the file if we don't have to */
|
|
adjtime.dirty = FALSE;
|
|
rc = 0;
|
|
}
|
|
if (rc != 0) *retcode_p = 2;
|
|
else {
|
|
synchronize_to_clock_tick(retcode_p);
|
|
/* this takes up to 1 second */
|
|
if (*retcode_p == 0) {
|
|
struct timeval read_time;
|
|
/* The time at which we read the Hardware Clock */
|
|
|
|
bool hclock_valid;
|
|
/* The Hardware Clock gives us a valid time, or at least something
|
|
close enough to fool mktime().
|
|
*/
|
|
|
|
time_t hclocktime;
|
|
/* The time the hardware clock had just after we
|
|
synchronized to its next clock tick when we started up.
|
|
Defined only if hclock_valid is true.
|
|
*/
|
|
|
|
gettimeofday(&read_time, NULL);
|
|
read_hardware_clock(universal, &hclock_valid, &hclocktime);
|
|
|
|
if (show) {
|
|
display_time(hclock_valid, hclocktime,
|
|
time_diff(read_time, startup_time));
|
|
*retcode_p = 0;
|
|
} else if (set) {
|
|
set_hardware_clock_exact(set_time, startup_time,
|
|
universal, testing);
|
|
adjust_drift_factor(&adjtime, set_time, hclock_valid, hclocktime);
|
|
*retcode_p = 0;
|
|
} else if (adjust) {
|
|
do_adjustment(&adjtime, hclock_valid, hclocktime,
|
|
read_time, universal, testing);
|
|
*retcode_p = 0;
|
|
} else if (systohc) {
|
|
struct timeval nowtime, reftime;
|
|
/* We can only set_hardware_clock_exact to a whole seconds
|
|
time, so we set it with reference to the most recent
|
|
whole seconds time.
|
|
*/
|
|
gettimeofday(&nowtime, NULL);
|
|
reftime.tv_sec = nowtime.tv_sec;
|
|
reftime.tv_usec = 0;
|
|
|
|
set_hardware_clock_exact((time_t) reftime.tv_sec, reftime,
|
|
universal, testing);
|
|
*retcode_p = 0;
|
|
adjust_drift_factor(&adjtime, (time_t) reftime.tv_sec, hclock_valid,
|
|
hclocktime);
|
|
} else if (hctosys) {
|
|
rc = set_system_clock(hclock_valid, hclocktime, testing);
|
|
if (rc != 0) {
|
|
printf(_("Unable to set system clock.\n"));
|
|
*retcode_p = 1;
|
|
} else *retcode_p = 0;
|
|
}
|
|
save_adjtime(adjtime, testing);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
manipulate_epoch(const bool getepoch, const bool setepoch,
|
|
const int epoch_opt, const bool testing) {
|
|
/*----------------------------------------------------------------------------
|
|
Get or set the Hardware Clock epoch value in the kernel, as appropriate.
|
|
<getepoch>, <setepoch>, and <epoch> are hwclock invocation options.
|
|
|
|
<epoch> == -1 if the user did not specify an "epoch" option.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
/*
|
|
Maintenance note: This should work on non-Alpha machines, but the
|
|
evidence today (98.03.04) indicates that the kernel only keeps the
|
|
epoch value on Alphas. If that is ever fixed, this function should be
|
|
changed.
|
|
*/
|
|
|
|
#ifndef __alpha__
|
|
fprintf(stderr, _("The kernel keeps an epoch value for the Hardware Clock "
|
|
"only on an Alpha machine.\nThis copy of hwclock was built for "
|
|
"a machine other than Alpha\n(and thus is presumably not running "
|
|
"on an Alpha now). No action taken.\n"));
|
|
#else
|
|
if (getepoch) {
|
|
unsigned long epoch;
|
|
|
|
if (get_epoch_rtc(&epoch, 0))
|
|
fprintf(stderr, _("Unable to get the epoch value from the kernel.\n"));
|
|
else
|
|
printf(_("Kernel is assuming an epoch value of %lu\n"), epoch);
|
|
} else if (setepoch) {
|
|
if (epoch_opt == -1)
|
|
fprintf(stderr, _("To set the epoch value, you must use the 'epoch' "
|
|
"option to tell to what value to set it.\n"));
|
|
else if (testing)
|
|
printf(_("Not setting the epoch to %d - testing only.\n"),
|
|
epoch_opt);
|
|
else if (set_epoch_rtc(epoch_opt))
|
|
printf(_("Unable to set the epoch value in the kernel.\n"));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv, char **envp) {
|
|
|
|
struct timeval startup_time;
|
|
/* The time we started up, in seconds into the epoch, including fractions.
|
|
*/
|
|
time_t set_time; /* Time to which user said to set Hardware Clock */
|
|
|
|
bool permitted; /* User is permitted to do the function */
|
|
int retcode; /* Our eventual return code */
|
|
|
|
int rc; /* local return code */
|
|
|
|
/* option_def is the control table for the option parser. These other
|
|
variables are the results of parsing the options and their meanings
|
|
are given by the option_def. The only exception is <show>, which
|
|
may be modified after parsing is complete to effect an implied option.
|
|
*/
|
|
bool show, set, systohc, hctosys, adjust, getepoch, setepoch, version;
|
|
bool ARCconsole, universal, testing, directisa, Jensen, SRM, funky_toy;
|
|
char *date_opt;
|
|
int epoch_opt;
|
|
|
|
const optStruct option_def[] = {
|
|
{ 'r', (char *) "show", OPT_FLAG, &show, 0 },
|
|
{ 0, (char *) "set", OPT_FLAG, &set, 0 },
|
|
{ 'w', (char *) "systohc", OPT_FLAG, &systohc, 0 },
|
|
{ 's', (char *) "hctosys", OPT_FLAG, &hctosys, 0 },
|
|
{ 0, (char *) "getepoch", OPT_FLAG, &getepoch, 0 },
|
|
{ 0, (char *) "setepoch", OPT_FLAG, &setepoch, 0 },
|
|
{ 'a', (char *) "adjust", OPT_FLAG, &adjust, 0 },
|
|
{ 'v', (char *) "version", OPT_FLAG, &version, 0 },
|
|
{ 0, (char *) "date", OPT_STRING, &date_opt, 0 },
|
|
{ 0, (char *) "epoch", OPT_UINT, &epoch_opt, 0 },
|
|
{ 'u', (char *) "utc", OPT_FLAG, &universal, 0 },
|
|
{ 0, (char *) "badyear", OPT_FLAG, &badyear, 0 },
|
|
{ 0, (char *) "directisa", OPT_FLAG, &directisa, 0 },
|
|
{ 0, (char *) "test", OPT_FLAG, &testing, 0 },
|
|
{ 'D', (char *) "debug", OPT_FLAG, &debug, 0 },
|
|
#ifdef __alpha__
|
|
{ 'A', (char *) "ARC", OPT_FLAG, &ARCconsole,0 },
|
|
{ 'J', (char *) "Jensen", OPT_FLAG, &Jensen, 0 },
|
|
{ 'S', (char *) "SRM", OPT_FLAG, &SRM, 0 },
|
|
{ 'F', (char *) "funky-toy", OPT_FLAG, &funky_toy, 0 },
|
|
#endif
|
|
{ 0, (char *) NULL, OPT_END, NULL, 0 }
|
|
};
|
|
int argc_parse; /* argc, except we modify it as we parse */
|
|
char **argv_parse; /* argv, except we modify it as we parse */
|
|
|
|
gettimeofday(&startup_time, NULL); /* Remember what time we were invoked */
|
|
|
|
setlocale(LC_ALL, "");
|
|
bindtextdomain(PACKAGE, LOCALEDIR);
|
|
textdomain(PACKAGE);
|
|
|
|
/* set option defaults */
|
|
show = set = systohc = hctosys = adjust = getepoch = setepoch =
|
|
version = universal = ARCconsole = SRM = funky_toy =
|
|
directisa = badyear = Jensen = testing = debug = FALSE;
|
|
date_opt = NULL;
|
|
epoch_opt = -1;
|
|
|
|
argc_parse = argc; argv_parse = argv;
|
|
optParseOptions(&argc_parse, argv_parse, option_def, 0);
|
|
/* Uses and sets argc_parse, argv_parse.
|
|
Sets show, systohc, hctosys, adjust, universal, version, testing,
|
|
debug, set, date_opt, getepoch, setepoch, epoch_opt
|
|
*/
|
|
/* This is an ugly routine - for example, if I give an incorrect
|
|
option, it only says "unrecognized option" without telling
|
|
me what options are recognized. Rewrite with standard
|
|
getopt() and usage() and throw shhopt out. */
|
|
|
|
if (argc_parse - 1 > 0) {
|
|
fprintf(stderr, _("%s takes no non-option arguments. "
|
|
"You supplied %d.\n"),
|
|
MYNAME, argc_parse - 1);
|
|
exit(100);
|
|
}
|
|
|
|
if (show + set + systohc + hctosys + adjust +
|
|
getepoch + setepoch + version > 1) {
|
|
fprintf(stderr, _("You have specified multiple function options.\n"
|
|
"You can only perform one function at a time.\n"));
|
|
exit(100);
|
|
}
|
|
|
|
#ifdef __alpha__
|
|
set_cmos_epoch(ARCconsole, SRM);
|
|
set_cmos_access(Jensen, funky_toy);
|
|
#endif
|
|
|
|
if (set) {
|
|
rc = interpret_date_string(date_opt, &set_time); /* (time-consuming) */
|
|
if (rc != 0) {
|
|
fprintf(stderr, _("No usable set-to time. Cannot set clock.\n"));
|
|
exit(100);
|
|
}
|
|
}
|
|
|
|
if (!(show | set | systohc | hctosys | adjust | getepoch | setepoch |
|
|
version))
|
|
show = 1; /* default to show */
|
|
|
|
|
|
if (getuid() == 0) permitted = TRUE;
|
|
else {
|
|
/* program is designed to run setuid (in some situations) -- be secure! */
|
|
if (set || hctosys || systohc || adjust) {
|
|
fprintf(stderr,
|
|
_("Sorry, only the superuser can change the Hardware Clock.\n"));
|
|
permitted = FALSE;
|
|
} else if (setepoch) {
|
|
fprintf(stderr,
|
|
_("Sorry, only the superuser can change "
|
|
"the Hardware Clock epoch in the kernel.\n"));
|
|
permitted = FALSE;
|
|
} else permitted = TRUE;
|
|
}
|
|
|
|
if (!permitted) retcode = 2;
|
|
else {
|
|
retcode = 0;
|
|
if (version) {
|
|
printf(MYNAME " " VERSION "/%s\n",util_linux_version);
|
|
} else if (getepoch || setepoch) {
|
|
manipulate_epoch(getepoch, setepoch, epoch_opt, testing);
|
|
} else {
|
|
determine_clock_access_method(directisa);
|
|
if (!ur)
|
|
fprintf(stderr, _("Cannot access the Hardware Clock via any known "
|
|
"method. Use --debug option to see the details of our "
|
|
"search for an access method.\n"));
|
|
else
|
|
manipulate_clock(show, adjust, set, set_time, hctosys, systohc,
|
|
startup_time, universal, testing, &rc);
|
|
}
|
|
}
|
|
exit(retcode);
|
|
}
|
|
|
|
/* A single routine for greater uniformity */
|
|
void
|
|
outsyserr(char *msg) {
|
|
fprintf(stderr, _("%s: %s, errno=%d: %s.\n"),
|
|
progname, msg, errno, strerror(errno));
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
History of this program:
|
|
|
|
98.08.12 BJH Version 2.4
|
|
|
|
Don't use century byte from Hardware Clock. Add comments telling why.
|
|
|
|
|
|
98.06.20 BJH Version 2.3.
|
|
|
|
Make --hctosys set the kernel timezone from TZ environment variable
|
|
and/or /usr/lib/zoneinfo. From Klaus Ripke (klaus@ripke.com).
|
|
|
|
98.03.05 BJH. Version 2.2.
|
|
|
|
Add --getepoch and --setepoch.
|
|
|
|
Fix some word length things so it works on Alpha.
|
|
|
|
Make it work when /dev/rtc doesn't have the interrupt functions.
|
|
In this case, busywait for the top of a second instead of blocking and
|
|
waiting for the update complete interrupt.
|
|
|
|
Fix a bunch of bugs too numerous to mention.
|
|
|
|
97.06.01: BJH. Version 2.1. Read and write the century byte (Byte
|
|
50) of the ISA Hardware Clock when using direct ISA I/O. Problem
|
|
discovered by job (jei@iclnl.icl.nl).
|
|
|
|
Use the rtc clock access method in preference to the KDGHWCLK method.
|
|
Problem discovered by Andreas Schwab <schwab@LS5.informatik.uni-dortmund.de>.
|
|
|
|
November 1996: Version 2.0.1. Modifications by Nicolai Langfeldt
|
|
(janl@math.uio.no) to make it compile on linux 1.2 machines as well
|
|
as more recent versions of the kernel. Introduced the NO_CLOCK
|
|
access method and wrote feature test code to detect absense of rtc
|
|
headers.
|
|
|
|
|
|
**************************************************************************
|
|
Maintenance notes
|
|
|
|
To compile this, you must use GNU compiler optimization (-O option)
|
|
in order to make the "extern inline" functions from asm/io.h (inb(),
|
|
etc.) compile. If you don't optimize, which means the compiler
|
|
will generate no inline functions, the references to these functions
|
|
in this program will be compiled as external references. Since you
|
|
probably won't be linking with any functions by these names, you will
|
|
have unresolved external references when you link.
|
|
|
|
The program is designed to run setuid superuser, since we need to be
|
|
able to do direct I/O. (More to the point: we need permission to
|
|
execute the iopl() system call). (However, if you use one of the
|
|
methods other than direct ISA I/O to access the clock, no setuid is
|
|
required).
|
|
|
|
Here's some info on how we must deal with the time that elapses while
|
|
this program runs: There are two major delays as we run:
|
|
|
|
1) Waiting up to 1 second for a transition of the Hardware Clock so
|
|
we are synchronized to the Hardware Clock.
|
|
|
|
2) Running the "date" program to interpret the value of our --date
|
|
option.
|
|
|
|
Reading the /etc/adjtime file is the next biggest source of delay and
|
|
uncertainty.
|
|
|
|
The user wants to know what time it was at the moment he invoked us,
|
|
not some arbitrary time later. And in setting the clock, he is
|
|
giving us the time at the moment we are invoked, so if we set the
|
|
clock some time later, we have to add some time to that.
|
|
|
|
So we check the system time as soon as we start up, then run "date"
|
|
and do file I/O if necessary, then wait to synchronize with a
|
|
Hardware Clock edge, then check the system time again to see how
|
|
much time we spent. We immediately read the clock then and (if
|
|
appropriate) report that time, and additionally, the delay we measured.
|
|
|
|
If we're setting the clock to a time given by the user, we wait some
|
|
more so that the total delay is an integral number of seconds, then
|
|
set the Hardware Clock to the time the user requested plus that
|
|
integral number of seconds. N.B. The Hardware Clock can only be set
|
|
in integral seconds.
|
|
|
|
If we're setting the clock to the system clock value, we wait for
|
|
the system clock to reach the top of a second, and then set the
|
|
Hardware Clock to the system clock's value.
|
|
|
|
Here's an interesting point about setting the Hardware Clock: On my
|
|
machine, when you set it, it sets to that precise time. But one can
|
|
imagine another clock whose update oscillator marches on a steady one
|
|
second period, so updating the clock between any two oscillator ticks
|
|
is the same as updating it right at the earlier tick. To avoid any
|
|
complications that might cause, we set the clock as soon as possible
|
|
after an oscillator tick.
|
|
|
|
|
|
About synchronizing to the Hardware Clock when reading the time: The
|
|
precision of the Hardware Clock counters themselves is one second.
|
|
You can't read the counters and find out that is 12:01:02.5. But if
|
|
you consider the location in time of the counter's ticks as part of
|
|
its value, then its precision is as infinite as time is continuous!
|
|
What I'm saying is this: To find out the _exact_ time in the
|
|
hardware clock, we wait until the next clock tick (the next time the
|
|
second counter changes) and measure how long we had to wait. We
|
|
then read the value of the clock counters and subtract the wait time
|
|
and we know precisely what time it was when we set out to query the
|
|
time.
|
|
|
|
hwclock uses this method, and considers the Hardware Clock to have
|
|
infinite precision.
|
|
|
|
|
|
Enhancements needed:
|
|
|
|
- When waiting for whole second boundary in set_hardware_clock_exact,
|
|
fail if we miss the goal by more than .1 second, as could happen if
|
|
we get pre-empted (by the kernel dispatcher).
|
|
|
|
****************************************************************************/
|
|
|