Imported from util-linux-2.10s tarball.

[thirdparty/util-linux.git] / hwclock / hwclock.c

/*
 * hwclock.c
 *
 * clock.c was written by Charles Hedrick, hedrick@cs.rutgers.edu, Apr 1992
 * Modified for clock adjustments - Rob Hooft <hooft@chem.ruu.nl>, Nov 1992
 * Improvements by Harald Koenig <koenig@nova.tat.physik.uni-tuebingen.de>
 * and Alan Modra <alan@spri.levels.unisa.edu.au>.
 *
 * Major rewrite by Bryan Henderson <bryanh@giraffe-data.com>, 96.09.19.
 * The new program is called hwclock. New features:
 * - You can set the hardware clock without also modifying the system clock.
 * - You can read and set the clock with finer than 1 second precision.
 * - When you set the clock, hwclock automatically refigures the drift
 *   rate, based on how far off the clock was before you set it.
 *
 * Reshuffled things, added sparc code, and re-added alpha stuff
 * by David Mosberger <davidm@azstarnet.com>
 * and Jay Estabrook <jestabro@amt.tay1.dec.com> 
 * and Martin Ostermann <ost@coments.rwth-aachen.de>, aeb@cwi.nl, 990212.
 *
 * Fix for Award 2094 bug, Dave Coffin  (dcoffin@shore.net)  11/12/98
 * Change of local time handling, Stefan Ring <e9725446@stud3.tuwien.ac.at>
 *
 * Distributed under GPL
 */

/*
 * 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 <stdarg.h>

#include "shhopt.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. */

int epoch_option = -1;
  /* User-specified epoch, used when rtc fails to return epoch. */

/*
 * 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(LASTDATE,"w"))) {
    fprintf(fp,"%02d.%02d.%04d\n", tm->tm_mday, tm->tm_mon+1,
            tm->tm_year+1900);
    fclose(fp);
  } else
    perror(LASTDATE);
}

static 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: "
             "%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) 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: %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);
}


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 {
    struct tm *lt;
    char *format = "%c";
    char ctime_now[200];

    lt = localtime(&systime);
    strftime(ctime_now, sizeof(ctime_now), format, lt);
    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;
    struct tm *broken;
    int minuteswest;
    int rc;
    
    tv.tv_sec = newtime;
    tv.tv_usec = 0;
    
    broken = localtime(&newtime);
#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) 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 = { minuteswest, 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 (fputs(newfile, adjfile) < 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
}

#if __ia64__
#define RTC_DEV "/dev/efirtc"
#else
#define RTC_DEV "/dev/rtc"
#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 %s\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"
    ),RTC_DEV);
#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) {

  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;

  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_option,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, "");
#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);

  /* 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;

  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_option
       */
    /* 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 (hctosys) {
      fprintf(stderr,
              _("Sorry, only the superuser can change the System 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_option, 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.\n"));
        if (!debug)
                fprintf(stderr,
                        _("Use the --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, ...) {
        va_list args;
        int errsv = errno;
        
        fprintf(stderr, "%s: ", progname);
        va_start(args, msg);
        vfprintf(stderr, msg, args);
        va_end(args);
        fprintf(stderr, ", errno=%d: %s.\n",
                errsv, strerror(errsv));
}

/****************************************************************************

  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).

****************************************************************************/