| /* |
| * 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 |
| * Change of local time handling, Stefan Ring <e9725446@stud3.tuwien.ac.at> |
| * Change of adjtime handling, James P. Rutledge <ao112@rgfn.epcc.edu>. |
| * |
| * Distributed under GPL |
| */ |
| /* |
| * 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 <errno.h> |
| #include <getopt.h> |
| #include <limits.h> |
| #include <math.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sysexits.h> |
| #include <sys/stat.h> |
| #include <sys/time.h> |
| #include <time.h> |
| #include <unistd.h> |
| |
| #define OPTUTILS_EXIT_CODE EX_USAGE |
| |
| #include "c.h" |
| #include "closestream.h" |
| #include "nls.h" |
| #include "optutils.h" |
| #include "pathnames.h" |
| #include "strutils.h" |
| #include "hwclock.h" |
| #include "timeutils.h" |
| #include "env.h" |
| |
| #ifdef HAVE_LIBAUDIT |
| #include <libaudit.h> |
| static int hwaudit_fd = -1; |
| static int hwaudit_on; |
| #endif |
| |
| /* The struct that holds our hardware access routines */ |
| struct clock_ops *ur; |
| |
| #define FLOOR(arg) ((arg >= 0 ? (int) arg : ((int) arg) - 1)); |
| |
| /* Maximal clock adjustment in seconds per day. |
| (adjtime() glibc call has 2145 seconds limit on i386, so it is good enough for us as well, |
| 43219 is a maximal safe value preventing exact_adjustment overflow.) */ |
| #define MAX_DRIFT 2145.0 |
| |
| const char *adj_file_name = NULL; |
| |
| 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 */ |
| double drift_factor; |
| time_t last_adj_time; |
| double 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. |
| */ |
| }; |
| |
| /* |
| * We are running in debug mode, wherein we put a lot of information about |
| * what we're doing to standard output. |
| */ |
| int debug; |
| |
| /* Workaround for Award 4.50g BIOS bug: keep the year in a file. */ |
| bool badyear; |
| |
| /* User-specified epoch, used when rtc fails to return epoch. */ |
| unsigned long epoch_option = ULONG_MAX; |
| |
| /* |
| * 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 |
| */ |
| static void write_date_to_file(struct tm *tm) |
| { |
| FILE *fp; |
| |
| if ((fp = fopen(_PATH_LASTDATE, "w"))) { |
| fprintf(fp, "%02d.%02d.%04d\n", tm->tm_mday, tm->tm_mon + 1, |
| tm->tm_year + 1900); |
| if (close_stream(fp) != 0) |
| warn(_("cannot write %s"), _PATH_LASTDATE); |
| } else |
| warn(_("cannot write %s"), _PATH_LASTDATE); |
| } |
| |
| static void read_date_from_file(struct tm *tm) |
| { |
| int last_mday, last_mon, last_year; |
| FILE *fp; |
| |
| if ((fp = fopen(_PATH_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); |
| } |
| |
| /* |
| * time_t to timeval conversion. |
| */ |
| static struct timeval t2tv(time_t timet) |
| { |
| struct timeval rettimeval; |
| |
| rettimeval.tv_sec = timet; |
| rettimeval.tv_usec = 0; |
| return rettimeval; |
| } |
| |
| /* |
| * The difference in seconds between two times in "timeval" format. |
| */ |
| double time_diff(struct timeval subtrahend, struct timeval subtractor) |
| { |
| return (subtrahend.tv_sec - subtractor.tv_sec) |
| + (subtrahend.tv_usec - subtractor.tv_usec) / 1E6; |
| } |
| |
| /* |
| * The time, in "timeval" format, which is <increment> seconds after the |
| * time <addend>. Of course, <increment> may be negative. |
| */ |
| static struct timeval time_inc(struct timeval addend, double increment) |
| { |
| 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 UTC */ |
| ret = (adjtime.local_utc != LOCAL); |
| if (debug) |
| printf(_("Assuming hardware clock is kept in %s time.\n"), |
| ret ? _("UTC") : _("local")); |
| return ret; |
| } |
| |
| /* |
| * 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 value 0 if all OK, !=0 otherwise. |
| */ |
| static int read_adjtime(struct adjtime *adjtime_p) |
| { |
| FILE *adjfile; |
| 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 */ |
| long timeval; |
| |
| if (access(adj_file_name, R_OK) != 0) { |
| /* 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 = UTC; |
| adjtime_p->dirty = FALSE; /* don't create a zero adjfile */ |
| |
| return 0; |
| } |
| |
| adjfile = fopen(adj_file_name, "r"); /* open file for reading */ |
| if (adjfile == NULL) { |
| warn(_("cannot open %s"), adj_file_name); |
| return EX_OSFILE; |
| } |
| |
| |
| if (!fgets(line1, sizeof(line1), adjfile)) |
| line1[0] = '\0'; /* In case fgets fails */ |
| if (!fgets(line2, sizeof(line2), adjfile)) |
| line2[0] = '\0'; /* In case fgets fails */ |
| if (!fgets(line3, sizeof(line3), adjfile)) |
| line3[0] = '\0'; /* In case fgets fails */ |
| |
| 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; |
| timeval = 0; |
| |
| sscanf(line1, "%lf %ld %lf", |
| &adjtime_p->drift_factor, |
| &timeval, &adjtime_p->not_adjusted); |
| adjtime_p->last_adj_time = timeval; |
| |
| sscanf(line2, "%ld", &timeval); |
| adjtime_p->last_calib_time = timeval; |
| |
| 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]) { |
| warnx(_("Warning: unrecognized third line in adjtime file\n" |
| "(Expected: `UTC' or `LOCAL' or nothing.)")); |
| } |
| } |
| |
| adjtime_p->dirty = FALSE; |
| |
| if (debug) { |
| printf(_ |
| ("Last drift adjustment done at %ld seconds after 1969\n"), |
| (long)adjtime_p->last_adj_time); |
| printf(_("Last calibration done at %ld seconds after 1969\n"), |
| (long)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")); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * 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 0 if it worked, nonzero if it didn't. |
| */ |
| static int synchronize_to_clock_tick(void) |
| { |
| int rc; |
| |
| if (debug) |
| printf(_("Waiting for clock tick...\n")); |
| |
| rc = ur->synchronize_to_clock_tick(); |
| |
| if (debug) { |
| if (rc) |
| printf(_("...synchronization failed\n")); |
| else |
| printf(_("...got clock tick\n")); |
| } |
| |
| return rc; |
| } |
| |
| /* |
| * 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. |
| */ |
| static void |
| mktime_tz(struct tm tm, const bool universal, |
| bool * valid_p, time_t * systime_p) |
| { |
| 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 = getenv("TZ"); /* remember original time zone */ |
| if (universal) { |
| /* Set timezone to UTC */ |
| xsetenv("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: " |
| "%4d/%.2d/%.2d %.2d:%.2d:%.2d\n"), |
| tm.tm_year + 1900, 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 : %4d/%.2d/%.2d %.2d:%.2d:%.2d = " |
| "%ld seconds since 1969\n"), tm.tm_year + 1900, |
| tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, |
| tm.tm_sec, (long)*systime_p); |
| } |
| /* now put back the original zone. */ |
| if (zone) |
| xsetenv("TZ", zone, TRUE); |
| else |
| unsetenv("TZ"); |
| tzset(); |
| } |
| |
| /* |
| * Read the hardware clock and return the current time via <tm> argument. |
| * |
| * Use the method indicated by <method> argument to access the hardware |
| * clock. |
| */ |
| static int |
| read_hardware_clock(const bool universal, bool * valid_p, time_t * systime_p) |
| { |
| struct tm tm; |
| int err; |
| |
| err = ur->read_hardware_clock(&tm); |
| if (err) |
| return err; |
| |
| if (badyear) |
| read_date_from_file(&tm); |
| |
| if (debug) |
| printf(_ |
| ("Time read from Hardware Clock: %4d/%.2d/%.2d %02d:%02d:%02d\n"), |
| tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, |
| tm.tm_min, tm.tm_sec); |
| mktime_tz(tm, universal, valid_p, systime_p); |
| |
| return 0; |
| } |
| |
| /* |
| * Set the Hardware Clock to the time <newtime>, in local time zone or UTC, |
| * according to <universal>. |
| */ |
| static void |
| set_hardware_clock(const time_t newtime, |
| const bool universal, const bool testing) |
| { |
| 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 " |
| "= %ld seconds since 1969\n"), |
| new_broken_time.tm_hour, new_broken_time.tm_min, |
| new_broken_time.tm_sec, (long)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); |
| } |
| ur->set_hardware_clock(&new_broken_time); |
| } |
| } |
| |
| /* |
| * Set the Hardware Clock to the time "sethwtime", in local time zone or |
| * UTC, according to "universal". |
| * |
| * Wait for a fraction of a second so that "sethwtime" is the value of the |
| * Hardware Clock as of system time "refsystime", which is in the past. For |
| * example, if "sethwtime" is 14:03:05 and "refsystime" is 12:10:04.5 and |
| * the current system time is 12:10:06.0: Wait .5 seconds (to make exactly 2 |
| * seconds since "refsystime") 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. |
| */ |
| static void |
| set_hardware_clock_exact(const time_t sethwtime, |
| const struct timeval refsystime, |
| const bool universal, const bool testing) |
| { |
| /* |
| * The Hardware Clock can only be set to any integer time plus one |
| * half second. The integer time is required because there is no |
| * interface to set or get a fractional second. The additional half |
| * second is because the Hardware Clock updates to the following |
| * second precisely 500 ms (not 1 second!) after you release the |
| * divider reset (after setting the new time) - see description of |
| * DV2, DV1, DV0 in Register A in the MC146818A data sheet (and note |
| * that although that document doesn't say so, real-world code seems |
| * to expect that the SET bit in Register B functions the same way). |
| * That means that, e.g., when you set the clock to 1:02:03, it |
| * effectively really sets it to 1:02:03.5, because it will update to |
| * 1:02:04 only half a second later. Our caller passes the desired |
| * integer Hardware Clock time in sethwtime, and the corresponding |
| * system time (which may have a fractional part, and which may or may |
| * not be the same!) in refsystime. In an ideal situation, we would |
| * then apply sethwtime to the Hardware Clock at refsystime+500ms, so |
| * that when the Hardware Clock ticks forward to sethwtime+1s half a |
| * second later at refsystime+1000ms, everything is in sync. So we |
| * spin, waiting for gettimeofday() to return a time at or after that |
| * time (refsystime+500ms) up to a tolerance value, initially 1ms. If |
| * we miss that time due to being preempted for some other process, |
| * then we increase the margin a little bit (initially 1ms, doubling |
| * each time), add 1 second (or more, if needed to get a time that is |
| * in the future) to both the time for which we are waiting and the |
| * time that we will apply to the Hardware Clock, and start waiting |
| * again. |
| * |
| * For example, the caller requests that we set the Hardware Clock to |
| * 1:02:03, with reference time (current system time) = 6:07:08.250. |
| * We want the Hardware Clock to update to 1:02:04 at 6:07:09.250 on |
| * the system clock, and the first such update will occur 0.500 |
| * seconds after we write to the Hardware Clock, so we spin until the |
| * system clock reads 6:07:08.750. If we get there, great, but let's |
| * imagine the system is so heavily loaded that our process is |
| * preempted and by the time we get to run again, the system clock |
| * reads 6:07:11.990. We now want to wait until the next xx:xx:xx.750 |
| * time, which is 6:07:12.750 (4.5 seconds after the reference time), |
| * at which point we will set the Hardware Clock to 1:02:07 (4 seconds |
| * after the originally requested time). If we do that successfully, |
| * then at 6:07:13.250 (5 seconds after the reference time), the |
| * Hardware Clock will update to 1:02:08 (5 seconds after the |
| * originally requested time), and all is well thereafter. |
| */ |
| |
| time_t newhwtime = sethwtime; |
| double target_time_tolerance_secs = 0.001; /* initial value */ |
| double tolerance_incr_secs = 0.001; /* initial value */ |
| const double RTC_SET_DELAY_SECS = 0.5; /* 500 ms */ |
| const struct timeval RTC_SET_DELAY_TV = { 0, RTC_SET_DELAY_SECS * 1E6 }; |
| |
| struct timeval targetsystime; |
| struct timeval nowsystime; |
| struct timeval prevsystime = refsystime; |
| double deltavstarget; |
| |
| timeradd(&refsystime, &RTC_SET_DELAY_TV, &targetsystime); |
| |
| while (1) { |
| double ticksize; |
| |
| /* FOR TESTING ONLY: inject random delays of up to 1000ms */ |
| if (debug >= 10) { |
| int usec = random() % 1000000; |
| printf(_("sleeping ~%d usec\n"), usec); |
| xusleep(usec); |
| } |
| |
| gettimeofday(&nowsystime, NULL); |
| deltavstarget = time_diff(nowsystime, targetsystime); |
| ticksize = time_diff(nowsystime, prevsystime); |
| prevsystime = nowsystime; |
| |
| if (ticksize < 0) { |
| if (debug) |
| printf(_("time jumped backward %.6f seconds " |
| "to %ld.%06ld - retargeting\n"), |
| ticksize, (long)nowsystime.tv_sec, |
| (long)nowsystime.tv_usec); |
| /* The retarget is handled at the end of the loop. */ |
| } else if (deltavstarget < 0) { |
| /* deltavstarget < 0 if current time < target time */ |
| if (debug >= 2) |
| printf(_("%ld.%06ld < %ld.%06ld (%.6f)\n"), |
| (long)nowsystime.tv_sec, |
| (long)nowsystime.tv_usec, |
| (long)targetsystime.tv_sec, |
| (long)targetsystime.tv_usec, |
| deltavstarget); |
| continue; /* not there yet - keep spinning */ |
| } else if (deltavstarget <= target_time_tolerance_secs) { |
| /* Close enough to the target time; done waiting. */ |
| break; |
| } else /* (deltavstarget > target_time_tolerance_secs) */ { |
| /* |
| * We missed our window. Increase the tolerance and |
| * aim for the next opportunity. |
| */ |
| if (debug) |
| printf(_("missed it - %ld.%06ld is too far " |
| "past %ld.%06ld (%.6f > %.6f)\n"), |
| (long)nowsystime.tv_sec, |
| (long)nowsystime.tv_usec, |
| (long)targetsystime.tv_sec, |
| (long)targetsystime.tv_usec, |
| deltavstarget, |
| target_time_tolerance_secs); |
| target_time_tolerance_secs += tolerance_incr_secs; |
| tolerance_incr_secs *= 2; |
| } |
| |
| /* |
| * Aim for the same offset (tv_usec) within the second in |
| * either the current second (if that offset hasn't arrived |
| * yet), or the next second. |
| */ |
| if (nowsystime.tv_usec < targetsystime.tv_usec) |
| targetsystime.tv_sec = nowsystime.tv_sec; |
| else |
| targetsystime.tv_sec = nowsystime.tv_sec + 1; |
| } |
| |
| newhwtime = sethwtime |
| + (int)(time_diff(nowsystime, refsystime) |
| - RTC_SET_DELAY_SECS /* don't count this */ |
| + 0.5 /* for rounding */); |
| if (debug) |
| printf(_("%ld.%06ld is close enough to %ld.%06ld (%.6f < %.6f)\n" |
| "Set RTC to %ld (%ld + %d; refsystime = %ld.%06ld)\n"), |
| (long)nowsystime.tv_sec, (long)nowsystime.tv_usec, |
| (long)targetsystime.tv_sec, (long)targetsystime.tv_usec, |
| deltavstarget, target_time_tolerance_secs, |
| (long)newhwtime, (long)sethwtime, |
| (int)(newhwtime - sethwtime), |
| (long)refsystime.tv_sec, (long)refsystime.tv_usec); |
| |
| set_hardware_clock(newhwtime, universal, testing); |
| } |
| |
| /* |
| * Put the time "hwctime" on standard output in display format. Except if |
| * hclock_valid == false, just tell standard output that we don't know what |
| * time it is. |
| */ |
| static void |
| display_time(const bool hclock_valid, struct timeval hwctime) |
| { |
| if (!hclock_valid) |
| warnx(_ |
| ("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).")); |
| else { |
| char buf[ISO_8601_BUFSIZ]; |
| |
| strtimeval_iso(&hwctime, ISO_8601_DATE|ISO_8601_TIME|ISO_8601_DOTUSEC| |
| ISO_8601_TIMEZONE|ISO_8601_SPACE, |
| buf, sizeof(buf)); |
| printf("%s\n", buf); |
| } |
| } |
| |
| /* |
| * 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. |
| */ |
| static int interpret_date_string(const char *date_opt, time_t * const time_p) |
| { |
| 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) { |
| warnx(_("No --date option specified.")); |
| return 14; |
| } |
| |
| /* prevent overflow - a security risk */ |
| if (strlen(date_opt) > sizeof(date_command) - 50) { |
| warnx(_("--date argument too long")); |
| return 13; |
| } |
| |
| /* Quotes in date_opt would ruin the date command we construct. */ |
| if (strchr(date_opt, '"') != NULL) { |
| warnx(_ |
| ("The value of the --date option is not a valid date.\n" |
| "In particular, it contains quotation marks.")); |
| return 12; |
| } |
| |
| 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) { |
| warn(_("Unable to run 'date' program in /bin/sh shell. " |
| "popen() failed")); |
| return 10; |
| } |
| |
| if (!fgets(date_resp, sizeof(date_resp), date_child_fp)) |
| date_resp[0] = '\0'; /* in case fgets fails */ |
| if (debug) |
| printf(_("response from date command = %s\n"), date_resp); |
| if (strncmp(date_resp, magic, sizeof(magic) - 1) != 0) { |
| warnx(_("The date command issued by %s returned " |
| "unexpected results.\n" |
| "The command was:\n %s\n" |
| "The response was:\n %s"), |
| program_invocation_short_name, date_command, date_resp); |
| retcode = 8; |
| } else { |
| long seconds_since_epoch; |
| rc = sscanf(date_resp + sizeof(magic) - 1, "%ld", |
| &seconds_since_epoch); |
| if (rc < 1) { |
| warnx(_("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\n" |
| "The response was:\n %s\n"), |
| program_invocation_short_name, date_command, |
| date_resp); |
| retcode = 6; |
| } else { |
| retcode = 0; |
| *time_p = seconds_since_epoch; |
| if (debug) |
| printf(_("date string %s equates to " |
| "%ld seconds since 1969.\n"), |
| date_opt, (long)*time_p); |
| } |
| } |
| pclose(date_child_fp); |
| |
| return retcode; |
| } |
| |
| /* |
| * 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. |
| * |
| * If this is the first call of settimeofday since boot, then this also sets |
| * the kernel variable persistent_clock_is_local so that NTP 11 minute mode |
| * will update the Hardware Clock with the proper timescale. If the Hardware |
| * Clock's timescale configuration is changed then a reboot is required for |
| * persistent_clock_is_local to be updated. |
| * |
| * 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. |
| */ |
| static int |
| set_system_clock(const bool hclock_valid, const struct timeval newtime, |
| const bool testing, const bool universal) |
| { |
| int retcode; |
| |
| if (!hclock_valid) { |
| warnx(_ |
| ("The Hardware Clock does not contain a valid time, so " |
| "we cannot set the System Time from it.")); |
| retcode = 1; |
| } else { |
| const struct timeval *tv_null = NULL; |
| struct tm *broken; |
| int minuteswest; |
| int rc = 0; |
| |
| broken = localtime(&newtime.tv_sec); |
| #ifdef HAVE_TM_GMTOFF |
| minuteswest = -broken->tm_gmtoff / 60; /* GNU extension */ |
| #else |
| minuteswest = timezone / 60; |
| if (broken->tm_isdst) |
| minuteswest -= 60; |
| #endif |
| |
| if (debug) { |
| printf(_("Calling settimeofday:\n")); |
| printf(_("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"), |
| (long)newtime.tv_sec, (long)newtime.tv_usec); |
| printf(_("\ttz.tz_minuteswest = %d\n"), minuteswest); |
| } |
| if (testing) { |
| printf(_ |
| ("Not setting system clock because running in test mode.\n")); |
| retcode = 0; |
| } else { |
| const struct timezone tz = { minuteswest, 0 }; |
| |
| /* Set kernel persistent_clock_is_local so that 11 minute |
| * mode does not clobber the Hardware Clock with UTC. This |
| * is only available on first call of settimeofday after boot. |
| */ |
| if (!universal) |
| rc = settimeofday(tv_null, &tz); |
| if (!rc) |
| rc = settimeofday(&newtime, &tz); |
| if (rc) { |
| if (errno == EPERM) { |
| warnx(_ |
| ("Must be superuser to set system clock.")); |
| retcode = EX_NOPERM; |
| } else { |
| warn(_("settimeofday() failed")); |
| retcode = 1; |
| } |
| } else |
| retcode = 0; |
| } |
| } |
| return retcode; |
| } |
| |
| /* |
| * Reset the System Clock from local time to UTC, based on its current value |
| * and the timezone unless universal is TRUE. |
| * |
| * 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. |
| * |
| * If 'testing' is true, don't actually update anything -- just say we would |
| * have. |
| */ |
| static int set_system_clock_timezone(const bool universal, const bool testing) |
| { |
| int retcode; |
| struct timeval tv; |
| struct tm *broken; |
| int minuteswest; |
| |
| gettimeofday(&tv, NULL); |
| if (debug) { |
| struct tm broken_time; |
| char ctime_now[200]; |
| |
| broken_time = *gmtime(&tv.tv_sec); |
| strftime(ctime_now, sizeof(ctime_now), "%Y/%m/%d %H:%M:%S", |
| &broken_time); |
| printf(_("Current system time: %ld = %s\n"), (long)tv.tv_sec, |
| ctime_now); |
| } |
| |
| broken = localtime(&tv.tv_sec); |
| #ifdef HAVE_TM_GMTOFF |
| minuteswest = -broken->tm_gmtoff / 60; /* GNU extension */ |
| #else |
| minuteswest = timezone / 60; |
| if (broken->tm_isdst) |
| minuteswest -= 60; |
| #endif |
| |
| if (debug) { |
| struct tm broken_time; |
| char ctime_now[200]; |
| |
| gettimeofday(&tv, NULL); |
| if (!universal) |
| tv.tv_sec += minuteswest * 60; |
| |
| broken_time = *gmtime(&tv.tv_sec); |
| strftime(ctime_now, sizeof(ctime_now), "%Y/%m/%d %H:%M:%S", |
| &broken_time); |
| |
| printf(_("Calling settimeofday:\n")); |
| printf(_("\tUTC: %s\n"), ctime_now); |
| printf(_("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"), |
| (long)tv.tv_sec, (long)tv.tv_usec); |
| printf(_("\ttz.tz_minuteswest = %d\n"), minuteswest); |
| } |
| if (testing) { |
| printf(_ |
| ("Not setting system clock because running in test mode.\n")); |
| retcode = 0; |
| } else { |
| const struct timezone tz_utc = { 0, 0 }; |
| const struct timezone tz = { minuteswest, 0 }; |
| const struct timeval *tv_null = NULL; |
| int rc = 0; |
| |
| /* The first call to settimeofday after boot will assume the systemtime |
| * is in localtime, and adjust it according to the given timezone to |
| * compensate. If the systemtime is in fact in UTC, then this is wrong |
| * so we first do a dummy call to make sure the time is not shifted. |
| */ |
| if (universal) |
| rc = settimeofday(tv_null, &tz_utc); |
| |
| /* Now we set the real timezone. Due to the above dummy call, this will |
| * only warp the systemtime if the RTC is not in UTC. */ |
| if (!rc) |
| rc = settimeofday(tv_null, &tz); |
| |
| if (rc) { |
| if (errno == EPERM) { |
| warnx(_ |
| ("Must be superuser to set system clock.")); |
| retcode = EX_NOPERM; |
| } else { |
| warn(_("settimeofday() failed")); |
| retcode = 1; |
| } |
| } else |
| retcode = 0; |
| } |
| return retcode; |
| } |
| |
| /* |
| * Refresh the last calibrated and last adjusted timestamps in <*adjtime_p> |
| * to facilitate future drift calculations based on this set point. |
| * |
| * With the --update-drift option: |
| * Update the drift factor in <*adjtime_p> based on the fact that the |
| * Hardware Clock was just calibrated to <nowtime> and before that was |
| * set to the <hclocktime> time scale. |
| * |
| * 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. |
| */ |
| static void |
| adjust_drift_factor(struct adjtime *adjtime_p, |
| const struct timeval nowtime, |
| const bool hclock_valid, |
| const struct timeval hclocktime, |
| const bool update) |
| { |
| if (!update) { |
| if (debug) |
| printf(_("Not adjusting drift factor because the " |
| "--update-drift option was not used.\n")); |
| } else if (!hclock_valid) { |
| if (debug) |
| printf(_("Not adjusting drift factor because the " |
| "Hardware Clock previously contained " |
| "garbage.\n")); |
| } else if (adjtime_p->last_calib_time == 0) { |
| if (debug) |
| printf(_("Not adjusting drift factor because last " |
| "calibration time is zero,\n" |
| "so history is bad and calibration startover " |
| "is necessary.\n")); |
| } else if ((hclocktime.tv_sec - adjtime_p->last_calib_time) < 4 * 60 * 60) { |
| if (debug) |
| printf(_("Not adjusting drift factor because it has " |
| "been less than four hours since the last " |
| "calibration.\n")); |
| } else if (adjtime_p->last_calib_time != 0) { |
| /* |
| * At adjustment time we drift correct the hardware clock |
| * according to the contents of the adjtime file and refresh |
| * its last adjusted timestamp. |
| * |
| * At calibration time we set the Hardware Clock and refresh |
| * both timestamps in <*adjtime_p>. |
| * |
| * Here, with the --update-drift option, we also update the |
| * drift factor in <*adjtime_p>. |
| * |
| * Let us do computation in doubles. (Floats almost suffice, |
| * but 195 days + 1 second equals 195 days in floats.) |
| */ |
| const double sec_per_day = 24.0 * 60.0 * 60.0; |
| double factor_adjust; |
| double drift_factor; |
| struct timeval last_calib; |
| |
| last_calib = t2tv(adjtime_p->last_calib_time); |
| /* |
| * Correction to apply to the current drift factor. |
| * |
| * Simplified: uncorrected_drift / days_since_calibration. |
| * |
| * hclocktime is fully corrected with the current drift factor. |
| * Its difference from nowtime is the missed drift correction. |
| */ |
| factor_adjust = time_diff(nowtime, hclocktime) / |
| (time_diff(nowtime, last_calib) / sec_per_day); |
| |
| drift_factor = adjtime_p->drift_factor + factor_adjust; |
| if (fabs(drift_factor) > MAX_DRIFT) { |
| if (debug) |
| printf(_("Clock drift factor was calculated as " |
| "%f seconds/day.\n" |
| "It is far too much. Resetting to zero.\n"), |
| drift_factor); |
| drift_factor = 0; |
| } else { |
| if (debug) |
| printf(_("Clock drifted %f seconds in the past " |
| "%f seconds\nin spite of a drift factor of " |
| "%f seconds/day.\n" |
| "Adjusting drift factor by %f seconds/day\n"), |
| time_diff(nowtime, hclocktime), |
| time_diff(nowtime, last_calib), |
| adjtime_p->drift_factor, factor_adjust); |
| } |
| |
| adjtime_p->drift_factor = drift_factor; |
| } |
| adjtime_p->last_calib_time = nowtime.tv_sec; |
| |
| adjtime_p->last_adj_time = nowtime.tv_sec; |
| |
| adjtime_p->not_adjusted = 0; |
| |
| adjtime_p->dirty = TRUE; |
| } |
| |
| /* |
| * Calculate the drift correction currently needed for the |
| * Hardware Clock based on the last time it was adjusted, |
| * and the current drift factor, as stored in the adjtime file. |
| * |
| * The total drift adjustment needed is stored at tdrift_p. |
| * |
| */ |
| static void |
| calculate_adjustment(const double factor, |
| const time_t last_time, |
| const double not_adjusted, |
| const time_t systime, struct timeval *tdrift_p) |
| { |
| double exact_adjustment; |
| |
| exact_adjustment = |
| ((double)(systime - last_time)) * factor / (24 * 60 * 60) |
| + not_adjusted; |
| tdrift_p->tv_sec = FLOOR(exact_adjustment); |
| tdrift_p->tv_usec = (exact_adjustment - |
| (double)tdrift_p->tv_sec) * 1E6; |
| if (debug) { |
| printf(P_("Time since last adjustment is %d second\n", |
| "Time since last adjustment is %d seconds\n", |
| (int)(systime - last_time)), |
| (int)(systime - last_time)); |
| printf(_("Calculated Hardware Clock drift is %ld.%06ld seconds\n"), |
| (long)tdrift_p->tv_sec, (long)tdrift_p->tv_usec); |
| } |
| } |
| |
| /* |
| * 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. |
| */ |
| static void save_adjtime(const struct adjtime adjtime, const bool testing) |
| { |
| 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 == LOCAL) ? "LOCAL" : "UTC"); |
| |
| if (testing) { |
| printf(_ |
| ("Not updating adjtime file because of testing mode.\n")); |
| printf(_("Would have written the following to %s:\n%s"), |
| adj_file_name, newfile); |
| } else { |
| FILE *adjfile; |
| int err = 0; |
| |
| adjfile = fopen(adj_file_name, "w"); |
| if (adjfile == NULL) { |
| warn(_ |
| ("Could not open file with the clock adjustment parameters " |
| "in it (%s) for writing"), adj_file_name); |
| err = 1; |
| } else { |
| if (fputs(newfile, adjfile) < 0) { |
| warn(_ |
| ("Could not update file with the clock adjustment " |
| "parameters (%s) in it"), |
| adj_file_name); |
| err = 1; |
| } |
| if (close_stream(adjfile) != 0) { |
| warn(_ |
| ("Could not update file with the clock adjustment " |
| "parameters (%s) in it"), |
| adj_file_name); |
| err = 1; |
| } |
| } |
| if (err) |
| warnx(_ |
| ("Drift adjustment parameters not updated.")); |
| } |
| } |
| } |
| |
| /* |
| * 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. |
| * |
| * <hclock_valid> means the Hardware Clock contains a valid time. |
| * |
| * <hclocktime> is the drift corrected time read from the Hardware Clock. |
| * |
| * <read_time> was the system time when the <hclocktime> was read, which due |
| * to computational delay could be a short time ago. It is used to define a |
| * trigger point for setting the Hardware Clock. The fractional part of the |
| * Hardware clock set time is subtracted from read_time to 'refer back', or |
| * delay, the trigger point. Fractional parts must be accounted for in this |
| * way, because the Hardware Clock can only be set to a whole second. |
| * |
| * <universal>: the Hardware Clock is kept in UTC. |
| * |
| * <testing>: We are running in test mode (no updating of clock). |
| * |
| */ |
| static void |
| do_adjustment(struct adjtime *adjtime_p, |
| const bool hclock_valid, const struct timeval hclocktime, |
| const struct timeval read_time, |
| const bool universal, const bool testing) |
| { |
| if (!hclock_valid) { |
| warnx(_("The Hardware Clock does not contain a valid time, " |
| "so we cannot adjust it.")); |
| adjtime_p->last_calib_time = 0; /* calibration startover is required */ |
| adjtime_p->last_adj_time = 0; |
| adjtime_p->not_adjusted = 0; |
| adjtime_p->dirty = TRUE; |
| } else if (adjtime_p->last_adj_time == 0) { |
| if (debug) |
| printf(_("Not setting clock because last adjustment time is zero, " |
| "so history is bad.\n")); |
| } else if (fabs(adjtime_p->drift_factor) > MAX_DRIFT) { |
| if (debug) |
| printf(_("Not setting clock because drift factor %f is far too high.\n"), |
| adjtime_p->drift_factor); |
| } else { |
| set_hardware_clock_exact(hclocktime.tv_sec, |
| time_inc(read_time, |
| -(hclocktime.tv_usec / 1E6)), |
| universal, testing); |
| adjtime_p->last_adj_time = hclocktime.tv_sec; |
| adjtime_p->not_adjusted = 0; |
| adjtime_p->dirty = TRUE; |
| } |
| } |
| |
| static void determine_clock_access_method(const bool user_requests_ISA) |
| { |
| ur = NULL; |
| |
| if (user_requests_ISA) |
| ur = probe_for_cmos_clock(); |
| |
| #ifdef __linux__ |
| if (!ur) |
| ur = probe_for_rtc_clock(); |
| #endif |
| |
| if (debug) { |
| if (ur) |
| puts(_(ur->interface_name)); |
| else |
| printf(_("No usable clock interface found.\n")); |
| } |
| } |
| |
| /* |
| * 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. |
| */ |
| static int |
| manipulate_clock(const bool show, const bool adjust, const bool noadjfile, |
| const bool set, const time_t set_time, |
| const bool hctosys, const bool systohc, const bool systz, |
| const struct timeval startup_time, |
| const bool utc, const bool local_opt, const bool update, |
| const bool testing, const bool predict, const bool get) |
| { |
| /* Contents of the adjtime file, or what they should be. */ |
| struct adjtime adjtime = { 0 }; |
| bool universal; |
| /* Set if user lacks necessary authorization to access the clock */ |
| bool no_auth; |
| /* The time at which we read the Hardware Clock */ |
| struct timeval read_time; |
| /* |
| * The Hardware Clock gives us a valid time, or at |
| * least something close enough to fool mktime(). |
| */ |
| bool hclock_valid = FALSE; |
| /* |
| * Tick synchronized time read from the Hardware Clock and |
| * then drift correct for all operations except --show. |
| */ |
| struct timeval hclocktime = { 0, 0 }; |
| /* Total Hardware Clock drift correction needed. */ |
| struct timeval tdrift; |
| /* local return code */ |
| int rc = 0; |
| |
| if (!systz && !predict) { |
| no_auth = ur->get_permissions(); |
| if (no_auth) |
| return EX_NOPERM; |
| } |
| |
| if (!noadjfile && !(systz && (utc || local_opt))) { |
| rc = read_adjtime(&adjtime); |
| if (rc) |
| return rc; |
| } else { |
| /* A little trick to avoid writing the file if we don't have to */ |
| adjtime.dirty = FALSE; |
| } |
| |
| 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; |
| } |
| |
| if (show || get || adjust || hctosys || (!noadjfile && !systz && !predict)) { |
| /* data from HW-clock are required */ |
| rc = synchronize_to_clock_tick(); |
| |
| /* |
| * 2 = synchronization timeout. We don't |
| * error out if the user is attempting to |
| * set the RTC - the RTC could be |
| * functioning but contain invalid time data |
| * so we still want to allow a user to set |
| * the RTC time. |
| */ |
| if (rc && rc != 2 && !set && !systohc) |
| return EX_IOERR; |
| gettimeofday(&read_time, NULL); |
| |
| /* |
| * If we can't synchronize to a clock tick, |
| * we likely can't read from the RTC so |
| * don't bother reading it again. |
| */ |
| if (!rc) { |
| rc = read_hardware_clock(universal, |
| &hclock_valid, &hclocktime.tv_sec); |
| if (rc && !set && !systohc) |
| return EX_IOERR; |
| } |
| } |
| /* |
| * Calculate Hardware Clock drift for --predict with the user |
| * supplied --date option time, and with the time read from the |
| * Hardware Clock for all other operations. Apply drift correction |
| * to the Hardware Clock time for everything except --show and |
| * --predict. For --predict negate the drift correction, because we |
| * want to 'predict' a future Hardware Clock time that includes drift. |
| */ |
| hclocktime = predict ? t2tv(set_time) : hclocktime; |
| calculate_adjustment(adjtime.drift_factor, |
| adjtime.last_adj_time, |
| adjtime.not_adjusted, |
| hclocktime.tv_sec, &tdrift); |
| if (!show && !predict) |
| hclocktime = time_inc(tdrift, hclocktime.tv_sec); |
| if (show || get) { |
| display_time(hclock_valid, |
| time_inc(hclocktime, -time_diff |
| (read_time, startup_time))); |
| } else if (set) { |
| set_hardware_clock_exact(set_time, startup_time, |
| universal, testing); |
| if (!noadjfile) |
| adjust_drift_factor(&adjtime, |
| time_inc(t2tv(set_time), time_diff |
| (read_time, startup_time)), |
| hclock_valid, hclocktime, update); |
| } else if (adjust) { |
| if (tdrift.tv_sec > 0 || tdrift.tv_sec < -1) |
| do_adjustment(&adjtime, hclock_valid, |
| hclocktime, read_time, universal, testing); |
| else |
| printf(_("Needed adjustment is less than one second, " |
| "so not setting clock.\n")); |
| } 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); |
| if (!noadjfile) |
| adjust_drift_factor(&adjtime, nowtime, |
| hclock_valid, hclocktime, update); |
| } else if (hctosys) { |
| rc = set_system_clock(hclock_valid, hclocktime, |
| testing, universal); |
| if (rc) { |
| printf(_("Unable to set system clock.\n")); |
| return rc; |
| } |
| } else if (systz) { |
| rc = set_system_clock_timezone(universal, testing); |
| if (rc) { |
| printf(_("Unable to set system clock.\n")); |
| return rc; |
| } |
| } else if (predict) { |
| hclocktime = time_inc(hclocktime, (double) |
| -(tdrift.tv_sec + tdrift.tv_usec / 1E6)); |
| if (debug) { |
| printf(_ |
| ("At %ld seconds after 1969, RTC is predicted to read %ld seconds after 1969.\n"), |
| set_time, (long)hclocktime.tv_sec); |
| } |
| display_time(TRUE, hclocktime); |
| } |
| if (!noadjfile) |
| save_adjtime(adjtime, testing); |
| return 0; |
| } |
| |
| /* |
| * 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. |
| */ |
| #ifdef __linux__ |
| /* |
| * 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__ |
| static void |
| manipulate_epoch(const bool getepoch __attribute__ ((__unused__)), |
| const bool setepoch __attribute__ ((__unused__)), |
| const unsigned long epoch_opt __attribute__ ((__unused__)), |
| const bool testing __attribute__ ((__unused__))) |
| { |
| warnx(_("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.")); |
| } |
| # else |
| static void |
| manipulate_epoch(const bool getepoch, |
| const bool setepoch, |
| const unsigned long epoch_opt, |
| const bool testing) |
| { |
| if (getepoch) { |
| unsigned long epoch; |
| |
| if (get_epoch_rtc(&epoch, 0)) |
| warnx(_ |
| ("Unable to get the epoch value from the kernel.")); |
| else |
| printf(_("Kernel is assuming an epoch value of %lu\n"), |
| epoch); |
| } else if (setepoch) { |
| if (epoch_opt == ULONG_MAX) |
| warnx(_ |
| ("To set the epoch value, you must use the 'epoch' " |
| "option to tell to what value to set it.")); |
| else if (testing) |
| printf(_ |
| ("Not setting the epoch to %lu - testing only.\n"), |
| epoch_opt); |
| else if (set_epoch_rtc(epoch_opt)) |
| printf(_ |
| ("Unable to set the epoch value in the kernel.\n")); |
| } |
| } |
| # endif /* __alpha__ */ |
| #endif /* __linux__ */ |
| |
| /* |
| * Compare the system and CMOS time and output the drift |
| * in 10 second intervals. |
| */ |
| static int compare_clock (const bool utc, const bool local_opt) |
| { |
| struct tm tm; |
| struct timeval tv; |
| struct adjtime adjtime; |
| double time1_sys, time2_sys; |
| time_t time1_hw, time2_hw; |
| bool hclock_valid = FALSE, universal, first_pass = TRUE; |
| int rc; |
| |
| if (ur->get_permissions()) |
| return EX_NOPERM; |
| |
| /* dummy call for increased precision */ |
| gettimeofday(&tv, NULL); |
| |
| rc = read_adjtime(&adjtime); |
| if (rc) |
| return rc; |
| |
| universal = hw_clock_is_utc(utc, local_opt, adjtime); |
| |
| synchronize_to_clock_tick(); |
| ur->read_hardware_clock(&tm); |
| |
| gettimeofday(&tv, NULL); |
| time1_sys = tv.tv_sec + tv.tv_usec / 1000000.0; |
| |
| mktime_tz(tm, universal, &hclock_valid, &time1_hw); |
| |
| while (1) { |
| double res; |
| |
| synchronize_to_clock_tick(); |
| ur->read_hardware_clock(&tm); |
| |
| gettimeofday(&tv, NULL); |
| time2_sys = tv.tv_sec + tv.tv_usec / 1000000.0; |
| |
| mktime_tz(tm, universal, &hclock_valid, &time2_hw); |
| |
| res = (((double) time1_hw - time1_sys) - |
| ((double) time2_hw - time2_sys)) |
| / (double) (time2_hw - time1_hw); |
| |
| if (!first_pass) |
| printf("%10.0f %10.6f %15.0f %4.0f\n", |
| (double) time2_hw, time2_sys, res * 1e6, res *1e4); |
| else { |
| first_pass = FALSE; |
| printf("hw-time system-time freq-offset-ppm tick\n"); |
| printf("%10.0f %10.6f\n", (double) time1_hw, time1_sys); |
| } |
| fflush(stdout); |
| sleep(10); |
| } |
| |
| return 0; |
| } |
| |
| static void out_version(void) |
| { |
| printf(UTIL_LINUX_VERSION); |
| } |
| |
| /* |
| * 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; |
| |
| fputs(USAGE_HEADER, usageto); |
| fputs(_(" hwclock [function] [option...]\n"), usageto); |
| |
| fputs(USAGE_SEPARATOR, usageto); |
| fputs(_("Query or set the hardware clock.\n"), usageto); |
| |
| fputs(_("\nFunctions:\n"), usageto); |
| fputs(_(" -h, --help show this help text and exit\n" |
| " -r, --show read hardware clock and print result\n" |
| " --get read hardware clock and print drift corrected result\n" |
| " --set set the RTC to the time given with --date\n"), usageto); |
| fputs(_(" -s, --hctosys set the system time from the hardware clock\n" |
| " -w, --systohc set the hardware clock from the current system time\n" |
| " --systz set the system time based on the current timezone\n" |
| " --adjust adjust the RTC to account for systematic drift since\n" |
| " the clock was last set or adjusted\n"), usageto); |
| fputs(_(" -c, --compare periodically compare the system clock with the CMOS clock\n"), usageto); |
| #ifdef __linux__ |
| fputs(_(" --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"), usageto); |
| #endif |
| fputs(_(" --predict predict RTC reading at time given with --date\n" |
| " -V, --version display version information and exit\n"), usageto); |
| |
| fputs(USAGE_OPTIONS, usageto); |
| fputs(_(" -u, --utc the hardware clock is kept in UTC\n" |
| " --localtime the hardware clock is kept in local time\n"), usageto); |
| #ifdef __linux__ |
| fputs(_(" -f, --rtc <file> special /dev/... file to use instead of default\n"), usageto); |
| #endif |
| fprintf(usageto, _( |
| " --directisa access the ISA bus directly instead of %s\n" |
| " --badyear ignore RTC's year because the BIOS is broken\n" |
| " --date <time> 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"), _PATH_RTC_DEV); |
| fprintf(usageto, _( |
| " --update-drift update drift factor in %1$s (requires\n" |
| " --set or --systohc)\n" |
| " --noadjfile do not access %1$s; this requires the use of\n" |
| " either --utc or --localtime\n" |
| " --adjfile <file> specifies the path to the adjust file;\n" |
| " the default is %1$s\n"), _PATH_ADJTIME); |
| fputs(_(" --test do not update anything, just show what would happen\n" |
| " -D, --debug debugging mode\n" "\n"), usageto); |
| #ifdef __alpha__ |
| fputs(_(" -J|--jensen, -A|--arc, -S|--srm, -F|--funky-toy\n" |
| " tell hwclock the type of Alpha you have (see hwclock(8))\n" |
| "\n"), usageto); |
| #endif |
| |
| if (fmt) { |
| va_start(ap, fmt); |
| vfprintf(usageto, fmt, ap); |
| va_end(ap); |
| } |
| |
| fflush(usageto); |
| hwclock_exit(fmt ? EX_USAGE : EX_OK); |
| } |
| |
| /* |
| * Returns: |
| * EX_USAGE: bad invocation |
| * EX_NOPERM: no permission |
| * EX_OSFILE: cannot open /dev/rtc or /etc/adjtime |
| * EX_IOERR: ioctl error getting or setting the time |
| * 0: OK (or not) |
| * 1: failure |
| */ |
| int main(int argc, char **argv) |
| { |
| struct timeval startup_time; |
| /* |
| * The time we started up, in seconds into the epoch, including |
| * fractions. |
| */ |
| time_t set_time = 0; /* Time to which user said to set Hardware Clock */ |
| int rc, c; |
| |
| /* Variables set by various options; show may also be set later */ |
| /* The options debug, badyear and epoch_option are global */ |
| bool show, set, systohc, hctosys, systz, adjust, getepoch, setepoch, |
| predict, compare, get; |
| bool utc, testing, local_opt, update, noadjfile, directisa; |
| char *date_opt; |
| #ifdef __alpha__ |
| bool ARCconsole, Jensen, SRM, funky_toy; |
| #endif |
| /* Long only options. */ |
| enum { |
| OPT_ADJFILE = CHAR_MAX + 1, |
| OPT_BADYEAR, |
| OPT_DATE, |
| OPT_DIRECTISA, |
| OPT_EPOCH, |
| OPT_GET, |
| OPT_GETEPOCH, |
| OPT_LOCALTIME, |
| OPT_NOADJFILE, |
| OPT_PREDICT_HC, |
| OPT_SET, |
| OPT_SETEPOCH, |
| OPT_SYSTZ, |
| OPT_TEST, |
| OPT_UPDATE |
| }; |
| |
| static const struct option longopts[] = { |
| {"adjust", 0, 0, 'a'}, |
| {"compare", 0, 0, 'c'}, |
| {"help", 0, 0, 'h'}, |
| {"show", 0, 0, 'r'}, |
| {"hctosys", 0, 0, 's'}, |
| {"utc", 0, 0, 'u'}, |
| {"version", 0, 0, 'v'}, |
| {"systohc", 0, 0, 'w'}, |
| {"debug", 0, 0, 'D'}, |
| #ifdef __alpha__ |
| {"ARC", 0, 0, 'A'}, |
| {"arc", 0, 0, 'A'}, |
| {"Jensen", 0, 0, 'J'}, |
| {"jensen", 0, 0, 'J'}, |
| {"SRM", 0, 0, 'S'}, |
| {"srm", 0, 0, 'S'}, |
| {"funky-toy", 0, 0, 'F'}, |
| #endif |
| {"set", 0, 0, OPT_SET}, |
| #ifdef __linux__ |
| {"getepoch", 0, 0, OPT_GETEPOCH}, |
| {"setepoch", 0, 0, OPT_SETEPOCH}, |
| #endif |
| {"noadjfile", 0, 0, OPT_NOADJFILE}, |
| {"localtime", 0, 0, OPT_LOCALTIME}, |
| {"badyear", 0, 0, OPT_BADYEAR}, |
| {"directisa", 0, 0, OPT_DIRECTISA}, |
| {"test", 0, 0, OPT_TEST}, |
| {"date", 1, 0, OPT_DATE}, |
| {"epoch", 1, 0, OPT_EPOCH}, |
| #ifdef __linux__ |
| {"rtc", 1, 0, 'f'}, |
| #endif |
| {"adjfile", 1, 0, OPT_ADJFILE}, |
| {"systz", 0, 0, OPT_SYSTZ}, |
| {"predict-hc", 0, 0, OPT_PREDICT_HC}, |
| {"get", 0, 0, OPT_GET}, |
| {"update-drift",0, 0, OPT_UPDATE}, |
| {NULL, 0, NULL, 0} |
| }; |
| |
| static const ul_excl_t excl[] = { /* rows and cols in in ASCII order */ |
| { 'a','r','s','w', |
| OPT_GET, OPT_GETEPOCH, OPT_PREDICT_HC, |
| OPT_SET, OPT_SETEPOCH, OPT_SYSTZ }, |
| { 'u', OPT_LOCALTIME}, |
| { OPT_ADJFILE, OPT_NOADJFILE }, |
| { OPT_NOADJFILE, OPT_UPDATE }, |
| { 0 } |
| }; |
| int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT; |
| |
| /* Remember what time we were invoked */ |
| gettimeofday(&startup_time, NULL); |
| |
| #ifdef HAVE_LIBAUDIT |
| hwaudit_fd = audit_open(); |
| if (hwaudit_fd < 0 && !(errno == EINVAL || errno == EPROTONOSUPPORT || |
| errno == EAFNOSUPPORT)) { |
| /* |
| * You get these error codes only when the kernel doesn't |
| * have audit compiled in. |
| */ |
| warnx(_("Unable to connect to audit system")); |
| return EX_NOPERM; |
| } |
| #endif |
| setlocale(LC_ALL, ""); |
| #ifdef LC_NUMERIC |
| /* |
| * We need LC_CTYPE and LC_TIME and LC_MESSAGES, but must avoid |
| * LC_NUMERIC since it gives problems when we write to /etc/adjtime. |
| * - gqueri@mail.dotcom.fr |
| */ |
| setlocale(LC_NUMERIC, "C"); |
| #endif |
| bindtextdomain(PACKAGE, LOCALEDIR); |
| textdomain(PACKAGE); |
| atexit(close_stdout); |
| |
| /* Set option defaults */ |
| show = set = systohc = hctosys = systz = adjust = noadjfile = predict = |
| compare = get = update = FALSE; |
| getepoch = setepoch = utc = local_opt = directisa = testing = debug = FALSE; |
| #ifdef __alpha__ |
| ARCconsole = Jensen = SRM = funky_toy = badyear = FALSE; |
| #endif |
| date_opt = NULL; |
| |
| while ((c = getopt_long(argc, argv, |
| "?hvVDacrsuwAJSFf:", longopts, NULL)) != -1) { |
| |
| err_exclusive_options(c, longopts, excl, excl_st); |
| |
| switch (c) { |
| case 'D': |
| ++debug; |
| break; |
| case 'a': |
| adjust = TRUE; |
| break; |
| case 'c': |
| compare = TRUE; |
| break; |
| case 'r': |
| show = TRUE; |
| break; |
| case 's': |
| hctosys = TRUE; |
| break; |
| case 'u': |
| utc = TRUE; |
| break; |
| case 'w': |
| systohc = TRUE; |
| break; |
| #ifdef __alpha__ |
| case 'A': |
| ARCconsole = TRUE; |
| break; |
| case 'J': |
| Jensen = TRUE; |
| break; |
| case 'S': |
| SRM = TRUE; |
| break; |
| case 'F': |
| funky_toy = TRUE; |
| break; |
| #endif |
| case OPT_SET: |
| set = TRUE; |
| break; |
| #ifdef __linux__ |
| case OPT_GETEPOCH: |
| getepoch = TRUE; |
| break; |
| case OPT_SETEPOCH: |
| setepoch = TRUE; |
| break; |
| #endif |
| case OPT_NOADJFILE: |
| noadjfile = TRUE; |
| break; |
| case OPT_LOCALTIME: |
| local_opt = TRUE; /* --localtime */ |
| break; |
| case OPT_BADYEAR: |
| badyear = TRUE; |
| break; |
| case OPT_DIRECTISA: |
| directisa = TRUE; |
| break; |
| case OPT_TEST: |
| testing = TRUE; /* --test */ |
| break; |
| case OPT_DATE: |
| date_opt = optarg; /* --date */ |
| break; |
| case OPT_EPOCH: |
| epoch_option = /* --epoch */ |
| strtoul_or_err(optarg, _("invalid epoch argument")); |
| break; |
| case OPT_ADJFILE: |
| adj_file_name = optarg; /* --adjfile */ |
| break; |
| case OPT_SYSTZ: |
| systz = TRUE; /* --systz */ |
| break; |
| case OPT_PREDICT_HC: |
| predict = TRUE; /* --predict-hc */ |
| break; |
| case OPT_GET: |
| get = TRUE; /* --get */ |
| break; |
| case OPT_UPDATE: |
| update = TRUE; /* --update-drift */ |
| break; |
| #ifdef __linux__ |
| case 'f': |
| rtc_dev_name = optarg; /* --rtc */ |
| break; |
| #endif |
| case 'v': /* --version */ |
| case 'V': |
| out_version(); |
| return 0; |
| case 'h': /* --help */ |
| case '?': |
| default: |
| usage(NULL); |
| } |
| } |
| |
| argc -= optind; |
| argv += optind; |
| |
| if (getuid() != 0) { |
| warnx(_("Sorry, only the superuser can use the Hardware Clock.")); |
| hwclock_exit(EX_NOPERM); |
| } |
| |
| #ifdef HAVE_LIBAUDIT |
| if (testing != TRUE) { |
| if (adjust == TRUE || hctosys == TRUE || systohc == TRUE || |
| set == TRUE || setepoch == TRUE) { |
| hwaudit_on = TRUE; |
| } |
| } |
| #endif |
| if (argc > 0) { |
| usage(_("%s takes no non-option arguments. " |
| "You supplied %d.\n"), program_invocation_short_name, |
| argc); |
| } |
| |
| if (!adj_file_name) |
| adj_file_name = _PATH_ADJTIME; |
| |
| if (noadjfile && !utc && !local_opt) { |
| warnx(_("With --noadjfile, you must specify " |
| "either --utc or --localtime")); |
| hwclock_exit(EX_USAGE); |
| } |
| #ifdef __alpha__ |
| set_cmos_epoch(ARCconsole, SRM); |
| set_cmos_access(Jensen, funky_toy); |
| #endif |
| |
| if (set || predict) { |
| rc = interpret_date_string(date_opt, &set_time); |
| /* (time-consuming) */ |
| if (rc != 0) { |
| warnx(_("No usable set-to time. " |
| "Cannot set clock.")); |
| hwclock_exit(EX_USAGE); |
| } |
| } |
| |
| if (!(show | set | systohc | hctosys | systz | adjust | getepoch |
| | setepoch | predict | compare | get)) |
| show = 1; /* default to show */ |
| |
| |
| #ifdef __linux__ |
| if (getepoch || setepoch) { |
| manipulate_epoch(getepoch, setepoch, epoch_option, testing); |
| hwclock_exit(EX_OK); |
| } |
| #endif |
| |
| if (debug) |
| out_version(); |
| |
| if (!systz && !predict) { |
| determine_clock_access_method(directisa); |
| if (!ur) { |
| warnx(_("Cannot access the Hardware Clock via " |
| "any known method.")); |
| if (!debug) |
| warnx(_("Use the --debug option to see the " |
| "details of our search for an access " |
| "method.")); |
| hwclock_exit(EX_SOFTWARE); |
| } |
| } |
| |
| if (compare) { |
| if (compare_clock(utc, local_opt)) |
| hwclock_exit(EX_NOPERM); |
| |
| rc = EX_OK; |
| } else |
| rc = manipulate_clock(show, adjust, noadjfile, set, set_time, |
| hctosys, systohc, systz, startup_time, utc, |
| local_opt, update, testing, predict, get); |
| |
| hwclock_exit(rc); |
| return rc; /* Not reached */ |
| } |
| |
| #ifdef HAVE_LIBAUDIT |
| /* |
| * hwclock_exit calls either this function or plain exit depending |
| * HAVE_LIBAUDIT see also clock.h |
| */ |
| void __attribute__((__noreturn__)) hwaudit_exit(int status) |
| { |
| if (hwaudit_on) { |
| audit_log_user_message(hwaudit_fd, AUDIT_USYS_CONFIG, |
| "op=change-system-time", NULL, NULL, NULL, |
| status ? 0 : 1); |
| close(hwaudit_fd); |
| } |
| exit(status); |
| } |
| #endif |
| |
| /* |
| * 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 absence 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. |
| * |
| * 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. |
| */ |