/*
* 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 <stdarg.h>
#include "clock.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;
/* line 1 */
float drift_factor;
time_t last_adj_time;
float not_adjusted;
/* line 2 */
time_t last_calib_time;
/* The most recent time that we set the clock from an external
authority (as opposed to just doing a drift adjustment) */
/* line 3 */
enum a_local_utc {LOCAL, UTC, UNKNOWN} local_utc;
/* To which time zone, local or UTC, we most recently set the
hardware clock. */
};
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 bool
hw_clock_is_utc(const bool utc, const bool local_opt,
const struct adjtime adjtime) {
bool ret;
if (utc)
ret = TRUE; /* --utc explicitly given on command line */
else if (local_opt)
ret = FALSE; /* --localtime explicitly given */
else
/* get info from adjtime file - default is local */
ret = (adjtime.local_utc == UTC);
if (debug)
printf(_("Assuming hardware clock is kept in %s time.\n"),
ret ? _("UTC") : _("local"));
return ret;
}
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;
adjtime_p->local_utc = UNKNOWN;
*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 */
char line3[81]; /* String: third 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);
line3[0] = '\0'; /* In case fgets fails */
fgets(line3, sizeof(line3), 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);
if (!strcmp(line3, "UTC\n"))
adjtime_p->local_utc = UTC;
else if (!strcmp(line3, "LOCAL\n"))
adjtime_p->local_utc = LOCAL;
else {
adjtime_p->local_utc = UNKNOWN;
if (line3[0]) {
fprintf(stderr, _("%s: Warning: unrecognized third line in adjtime file\n"),
MYNAME);
fprintf(stderr, _("(Expected: `UTC' or `LOCAL' or nothing.)\n"));
}
}
*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);
printf(_("Hardware clock is on %s time\n"),
(adjtime_p->local_utc == LOCAL) ? _("local") :
(adjtime_p->local_utc == UTC) ? _("UTC") : _("unknown"));
}
}
}
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 */
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 %.2d:%.2d:%.2d = "
"%d seconds since 1969\n"),
tm.tm_year, tm.tm_mon+1, tm.tm_mday,
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: 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;
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;
tv.tv_sec = newtime;
tv.tv_usec = 0;
tzset(); /* init timezone from TZ or ...zoneinfo/localtime */
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);
}
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.
The code used to have `-60*daylight' here, but that is wrong.
The variable `daylight' does not specify whether it is DST now. */
const struct timezone tz = { timezone/60, 0 };
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[412]; /* 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%s\n",
adjtime.drift_factor,
(long) adjtime.last_adj_time,
adjtime.not_adjusted,
(long) adjtime.last_calib_time,
(adjtime.local_utc == UTC) ? "UTC" : "LOCAL");
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 utc, const bool local_opt,
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 || (!utc && !local_opt))
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 {
const bool universal = hw_clock_is_utc(utc, local_opt, adjtime);
if ((set || systohc || adjust) &&
(adjtime.local_utc == UTC) != universal) {
adjtime.local_utc = universal ? UTC : LOCAL;
adjtime.dirty = TRUE;
}
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
}
/*
usage - Output (error and) usage information
This function is called both directly from main to show usage
information and as fatal function from shhopt if some argument is
not understood. In case of normal usage info FMT should be NULL.
In that case the info is printed to stdout. If FMT is given
usage will act like fprintf( stderr, fmt, ... ), show a usage
information and terminate the program afterwards.
*/
static void
usage( const char *fmt, ... ) {
FILE *usageto;
va_list ap;
usageto = fmt ? stderr : stdout;
fprintf( usageto, _(
"hwclock - query and set the hardware clock (RTC)\n\n"
"Usage: hwclock [function] [options...]\n\n"
"Functions:\n"
" --help show this help\n"
" --show read hardware clock and print result\n"
" --set set the rtc to the time given with --date\n"
" --hctosys set the system time from the hardware clock\n"
" --systohc set the hardware clock to the current system time\n"
" --adjust adjust the rtc to account for systematic drift since \n"
" the clock was last set or adjusted\n"
" --getepoch print out the kernel's hardware clock epoch value\n"
" --setepoch set the kernel's hardware clock epoch value to the \n"
" value given with --epoch\n"
" --version print out the version of hwclock to stdout\n"
"\nOptions: \n"
" --utc the hardware clock is kept in coordinated universal time\n"
" --localtime the hardware clock is kept in local time\n"
" --directisa access the ISA bus directly instead of /dev/rtc\n"
" --badyear ignore rtc's year because the bios is broken\n"
" --date specifies the time to which to set the hardware clock\n"
" --epoch=year specifies the year which is the beginning of the \n"
" hardware clock's epoch value\n"
));
#ifdef __alpha__
fprintf( usageto, _(
" --jensen, --arc, --srm, --funky-toy\n"
" tell hwclock the type of alpha you have (see hwclock(8))\n"
) );
#endif
fflush(stdout);
if( fmt ) {
usageto = stderr;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
}
exit( fmt ? 99 : 0 );
}
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 help, show, set, systohc, hctosys, adjust, getepoch, setepoch, version;
bool ARCconsole, utc, testing, directisa, Jensen, SRM, funky_toy;
bool local_opt;
char *date_opt;
int epoch_opt;
const optStruct option_def[] = {
{ 'h', (char *) "help", OPT_FLAG, &help, 0 },
{ '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 },
{ '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, &utc, 0 },
{ 0, (char *) "localtime", OPT_FLAG, &local_opt, 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 */
help = show = set = systohc = hctosys = adjust = getepoch = setepoch =
version = utc = local_opt = 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, utc, local_opt, 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) {
usage( _("%s takes no non-option arguments. "
"You supplied %d.\n"),
MYNAME, argc_parse - 1);
}
if (help)
usage( NULL );
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);
}
if (utc && local_opt) {
fprintf(stderr, _("%s: The --utc and --localtime options are mutually "
"exclusive. You specified both.\n"), MYNAME);
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 {
if (debug)
printf(MYNAME " " VERSION "/%s\n",util_linux_version);
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, utc, local_opt, 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).
****************************************************************************/
