diff options
Diffstat (limited to 'clockB/hwclock.c')
| -rw-r--r-- | clockB/hwclock.c | 1744 |
1 files changed, 0 insertions, 1744 deletions
diff --git a/clockB/hwclock.c b/clockB/hwclock.c deleted file mode 100644 index e7f1c919b..000000000 --- a/clockB/hwclock.c +++ /dev/null @@ -1,1744 +0,0 @@ -/************************************************************************** - hwclock -*************************************************************************** - - This is a program for reading and setting the Hardware Clock on an ISA - family computer. This is the clock that is also known as the RTC, - real time clock, or, unfortunately, the CMOS clock. - - See man page for details. - - By Bryan Henderson, 96.09.19. bryanh@giraffe-data.com - - Based on work by others; see history at end of source code. - -**************************************************************************/ -/************************************************************************** - 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. - - Definition of century: In this program, a century is a 100 year - period in which all the years' numbers in the Gregorian calendar - differ only in their last two decimal digits. E.g. 1900-1999 is - a century. The 20th Century (1901-2000), however, is not. - - - About the unusual situation of the Jensen variety of Alpha: - - Martin Ostermann writes: - - The problem with the Jensen is twofold: First, it has the clock at a - different address. Secondly, it has a distinction beween "local" and - normal bus addresses. The local ones pertain to the hardware integrated - into the chipset, like serial/parallel ports and of course, the RTC. - Those need to be addressed differently. This is handled fine in the kernel, - and it's not a problem, since this usually gets totally optimized by the - compile. But the i/o routines of (g)libc lack this support so far. - The result of this is, that the old clock program worked only on the - Jensen when USE_DEV_PORT was defined, but not with the normal inb/outb - functions. - - - - 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). - -****************************************************************************/ - -#include <string.h> -#include <stdio.h> -#include <fcntl.h> -#include <sys/ioctl.h> -#include <errno.h> -#include <stdlib.h> -#include <unistd.h> -#include <sys/time.h> -#include <sys/stat.h> -#include "shhopt.h" -#include "../version.h" /* Defines UTIL_LINUX, among other things */ -#include "hwclock.h" - -#define FLOOR(arg) ((arg >= 0 ? (int) arg : ((int) arg) - 1)); - -/* Here the information for time adjustments is kept. */ -#define ADJPATH "/etc/adjtime" - -/* Note that we must define the boolean type as int because we use the - shhopt option processing library which, unfortunately, returns flag - options as integers. It is customary to define bool as char, but - then we would have to do a lot of conversion in order to interface - with shhopt. -*/ - -/* The following are times, in unix standard format (seconds since 1969) */ -#define START_OF_1994 757411200 -#define END_OF_1995 820396800 - -struct adjtime { - /* This is information we keep in the adjtime file that tells us how - to do drift corrections, among other things. Elements are all - straight from the adjtime file, so see documentation of that file - for details. Exception is <dirty>, which is an indication that - what's in this structure is not what's in the disk file (because - it has been updated since read from the disk file). - */ - - bool dirty; - float drift_factor; - time_t last_adj_time; - float not_adjusted; - time_t last_calib_time; - /* The most recent time that we set the clock from an external - authority (as opposed to just doing a drift adjustment) - */ - enum a_local_utc {LOCAL, UTC} 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. Because of the pervasive and yet - background nature of this value, this is a global variable. */ - - - -/* We're going to assume that if the CPU is in the Intel x86 family, - this is an ISA family machine. For all practical purposes, this is - the case at the time of this writing, especially after we assume a - Linux kernel is running on it. - */ -const bool isa_machine = -#ifdef __i386__ -TRUE -#else -FALSE; -#endif -; - -const bool alpha_machine = -#ifdef __alpha__ -TRUE -#else -FALSE; -#endif -; - - - -static bool -hw_clock_is_utc(const bool utc, const bool local_opt, - const struct adjtime adjtime) { -/*---------------------------------------------------------------------------- - Return true iff the hardware clock keeps Coordinated Universal Time - rather than local time. - - 'utc' means the user told us in the invocation options that the - hardware clock is kept in UTC. ------------------------------------------------------------------------------*/ - - bool retval; /* our return value */ - - if (utc) retval = TRUE; - else if (local_opt) retval = FALSE; - else retval = (adjtime.local_utc == UTC); - if (debug) printf("Assuming hardware clock is kept in %s time.\n", - retval ? "UTC" : "LOCAL"); - return retval; -} - - - -static void -read_adjtime(struct adjtime *adjtime_p, int *rc_p) { -/*---------------------------------------------------------------------------- - Read the adjustment parameters and other persistent variables 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. - - Note: The default is LOCAL rather than UTC for historical reasons. - ------------------------------------------------------------------------------*/ - 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 = LOCAL; - - *rc_p = 0; - } else { - adjfile = fopen(ADJPATH, "r"); /* open file for reading */ - if (adjfile == NULL) { - const int fopen_errno = errno; - fprintf(stderr, MYNAME " is unable to open file " ADJPATH ". " - "fopen() errno=%d:%s", fopen_errno, strerror(fopen_errno)); - *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; - adjtime_p->local_utc = LOCAL; - - 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); - - { - char local_utc_string[sizeof(line3)]; - - local_utc_string[0] = '\0'; /* In case nothing in line3 */ - sscanf(line3, "%s", local_utc_string); - - *rc_p = 0; /* Initial assumption - local/utc token is valid */ - if (strlen(local_utc_string) == 0) - adjtime_p->local_utc = LOCAL; - else if (strcmp(local_utc_string, "UTC") == 0) - adjtime_p->local_utc = UTC; - else if (strcmp(local_utc_string, "LOCAL") == 0) - adjtime_p->local_utc = LOCAL; - else { - fprintf(stderr, "%s: The first token of the third line of the file " - ADJPATH " is invalid. It must be LOCAL or UTC, indicating " - "to which time zone the hardware clock is set. Its " - "present value is '%s'.\n", MYNAME, local_utc_string); - *rc_p = 5; - } - } - } - adjtime_p->dirty = FALSE; - - if (debug) { - printf("Last drift adjustment done %s (Time %d)\n", - ctime2(adjtime_p->last_adj_time), - (int) adjtime_p->last_adj_time); - printf("Last calibration done %s (Time %d)\n", - ctime2(adjtime_p->last_calib_time), - (int) adjtime_p->last_calib_time); - } - } -} - - - -static void -synchronize_to_clock_tick(enum clock_access_method clock_access, - const int dev_port, const bool use_uf_bit, - int *retcode_p) { -/*----------------------------------------------------------------------------- - Wait until the moment the Hardware Clock updates to the next second, - so we know the exact time. - - The clock only has 1 second precision, so it gives the exact time only - once per second. - - Return *retcode_p == 0 if it worked, nonzero if it didn't. ------------------------------------------------------------------------------*/ - if (debug) printf("Waiting for clock tick...\n"); - - switch (clock_access) { - case ISA: synchronize_to_clock_tick_ISA(retcode_p, -1, use_uf_bit); break; - case DEV_PORT: synchronize_to_clock_tick_ISA(retcode_p, dev_port, - use_uf_bit); break; - case RTC_IOCTL: synchronize_to_clock_tick_RTC(retcode_p); break; - case KD: synchronize_to_clock_tick_KD(retcode_p); break; - default: - fprintf(stderr, "%s: Internal error in synchronize_to_clock_tick. " - "Invalid value for clock_access argument: %d.\n", - MYNAME, clock_access); - *retcode_p = 1; - } - if (debug) printf("...got clock tick\n"); - return; -} - - -static struct tm -make_within_one_year(const struct tm base_tm, const time_t last_known_time) { -/*---------------------------------------------------------------------------- - Compute a time that is the same as the input base_tm, except for a - different year. The year shall be whatever year it takes to make the - output time within one year after last_known_time. - - The timezone for both the input and output values is the value of - the TZ environment variable. ------------------------------------------------------------------------------*/ - struct tm broken_last_known_time; - /* The input time last_known_time, in broken down format */ - struct tm test_time; - - if (debug) - printf("Ignoring clock year and assuming " - "it's within 1 year after %s\n", - ctime2(last_known_time)); - - broken_last_known_time = *localtime(&last_known_time); - - test_time = base_tm; - test_time.tm_year = broken_last_known_time.tm_year; - - if (mktime(&test_time) < last_known_time) - test_time.tm_year += 1; - - return(test_time); -} - - - -static void -mktime_tz(struct tm hw_tm, const bool universal, const bool badyear, - const time_t last_known_time, - bool *valid_p, time_t *systime_p) { -/*----------------------------------------------------------------------------- - Convert a time in broken down format (hours, minutes, etc.) as read - from the Hardware Clock 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. - - Argument 'badyear' true means the input time is from one of those - machines with the Award BIOS that is incapable of storing a year - value less than 94 or 95, which means we can't use the year value - from the clock (see documentation of hwclock's --badyear option). - In this case, we instead determine the year by assuming that it's - less than a year since the time <last_known_time>. - - - 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 */ - struct tm adjusted_tm; - /* The same as the value from our argument, except if we determine - the year in the argument is garbage, this value contains the year - computed from the ADJTIME file instead. - */ - 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", "UTC 0", TRUE); - /* Note: tzset() gets called implicitly by the time code, but only the - first time. When changing the environment variable, better call - tzset() explicitly. - - Also: documentation for tzset() says if TZ = "", that means UTC. - But practice shows that that only works if tzset() hasn't already - been called before. So we explicitly say "UTC 0". - */ - tzset(); - } - - if (badyear) - adjusted_tm = make_within_one_year(hw_tm, last_known_time); - else adjusted_tm = hw_tm; - - mktime_result = mktime(&adjusted_tm); - if (mktime_result == -1) { - /* This apparently (not specified in mktime() documentation) means - the 'adjusted_tm' structure does not contain valid values (however, not - containing valid values does _not_ imply mktime() returns -1). - */ - /* Note that we are assuming here that the invalidity came from the - hardware values and was not introduced by our adjustments! - */ - *valid_p = FALSE; - *systime_p = 0; - if (debug) - printf("Invalid values in hardware clock: " - "%2d/%.2d/%.2d %.2d:%.2d:%.2d\n", - hw_tm.tm_year, hw_tm.tm_mon+1, hw_tm.tm_mday, - hw_tm.tm_hour, hw_tm.tm_min, hw_tm.tm_sec - ); - } else { - *valid_p = TRUE; - *systime_p = mktime_result; - if (debug) - printf("Hw clock time : %s = %d seconds since 1969\n", - ctime2(*systime_p), (int) *systime_p); - } - /* now put back the original zone. */ - if (zone) setenv("TZ", zone, TRUE); - else unsetenv("TZ"); - tzset(); -} - - - -static void -read_hardware_clock(const enum clock_access_method method, - const int dev_port, - const bool universal, const int hc_zero_year, - const bool badyear, - const time_t last_known_time, - bool *valid_p, time_t *systime_p) { -/*---------------------------------------------------------------------------- - Read the hardware clock and return the current time via *systime_p - argument. - - If the hardware clock fails to tell us a time, return *valid_p == false - and undefined value as *systime_p. Otherwise *valid_p == true. - - Consider the hardware clock to be set in Coordinated Universal Time - (UTC) iff 'universal' == true. - - Consider the year value of the clock to be useless iff 'badyear' == true. - - Recognize that the present time is is after 'last_known_time', which - information may be necessary to interpret the value of some hardware - clocks. - - Use the method indicated by 'method' argument to access the hardware clock. ------------------------------------------------------------------------------*/ - struct tm tm; - - switch (method) { - case RTC_IOCTL: - read_hardware_clock_rtc_ioctl(&tm); - break; - case ISA: - read_hardware_clock_isa(&tm, -1, hc_zero_year); - break; - case DEV_PORT: - read_hardware_clock_isa(&tm, dev_port, hc_zero_year); - break; - case KD: - read_hardware_clock_kd(&tm); - break; - default: - fprintf(stderr, - "%s: Internal error: invalid value for clock access method.\n", - MYNAME); - exit(5); - } - if (debug) - printf ("Time read from Hardware Clock: Y=%d M=%d D=%d %02d:%02d:%02d\n", - tm.tm_year, tm.tm_mon+1, tm.tm_mday, - tm.tm_hour, tm.tm_min, tm.tm_sec); - mktime_tz(tm, universal, badyear, last_known_time, valid_p, systime_p); -} - - - -static void -set_hardware_clock(const enum clock_access_method method, - const int dev_port, - const time_t newtime, - const bool universal, - const int hc_zero_year, const bool badyear, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the Hardware Clock to the time 'newtime', in local time zone or UTC, - according to 'universal'. - - 'badyear' true means the clock is incapable of storing the proper - year value, so we instead store 95, 96, 97, or 98 so that it is at - least in the right place in the leap year cycle (and will remain so - for at least the next year). - - Use the method indicated by the 'method' argument. -----------------------------------------------------------------------------*/ - 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 the clock is incapable of storing the true year value, change - the year to a fictional stand-in year as described in the prolog. - */ - if (badyear) - new_broken_time.tm_year = 95 + ((new_broken_time.tm_year + 1) % 4); - - 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); - - switch (method) { - case RTC_IOCTL: - set_hardware_clock_rtc_ioctl(new_broken_time, testing); - break; - case ISA: - set_hardware_clock_isa(new_broken_time, hc_zero_year, -1, testing); - break; - case DEV_PORT: - set_hardware_clock_isa(new_broken_time, hc_zero_year, dev_port, testing); - break; - case KD: - set_hardware_clock_kd(new_broken_time, testing); - break; - default: - fprintf(stderr, - "%s: Internal error: invalid value for clock access method.\n", - MYNAME); - exit(5); - } -} - - - -static void -set_hardware_clock_exact(const time_t settime, - const struct timeval ref_time, - const enum clock_access_method clock_access, - const int dev_port, - const bool universal, - const int hc_zero_year, - const bool badyear, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the Hardware Clock to the time 'settime', in local time zone or UTC, - according to 'universal'. - - But iff 'badyear', use a fictional year as appropriate for the --badyear - option. - - 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(clock_access, dev_port, newtime, - universal, hc_zero_year, badyear, testing); -} - - - -static void -display_time(const bool hclock_valid, const time_t systime, - const float sync_duration, const bool badyear_warn) { -/*---------------------------------------------------------------------------- - 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 the year is 1994 or 1995 and 'badyear_warn' is true, warn the - user that he has a brain-damaged clock and needs to use --badyear. - Since we didn't exist in 1994 and 1995, we know the clock isn't - correct. - ------------------------------------------------------------------------------*/ - if (!hclock_valid) - fprintf(stderr, "%s: 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", MYNAME); - else { - if (badyear_warn && (systime > START_OF_1994 && systime < END_OF_1995)) { - printf("WARNING: The Hardware Clock shows a time in 1994 " - "or 1995. This probably means you have a Hardware Clock " - "that is incapable of tracking years after 1999, and you " - "must use the --badyear option to make hwclock work for " - "you. See hwclock documentation for details.\n"); - } - - printf("%s %.6f seconds\n", ctime2(systime), -(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, "%s: No --date option specified.\n", MYNAME); - retcode = 14; - } else if (strchr(date_opt, '"') != NULL) { - /* Quotation marks in date_opt would ruin the date command we construct. - */ - fprintf(stderr, "%s: The value of the --date option is not a valid date.\n" - "In particular, it contains quotation marks.\n", MYNAME); - 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) { - fprintf(stderr, "%s: Unable to run 'date' program in /bin/sh shell. " - "popen() failed with errno=%s (%d)\n", - MYNAME, strerror(errno), errno); - 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, "%s: The date command issued by " MYNAME " 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, "%s: The date command issued by " MYNAME " returned" - "something other than an integer where the converted" - "time value was expected.\n" - "The command was:\n %s\nThe response was:\n %s\n", - MYNAME, date_command, date_resp); - retcode = 6; - } else { - retcode = 0; - *time_p = seconds_since_epoch; - if (debug) - printf("date string %s equates to %d seconds since 1969.\n", - date_opt, (int) *time_p); - } - } - fclose(date_child_fp); - } - } - return(retcode); -} - - - -static int -set_system_clock(const bool hclock_valid, const time_t newtime, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the System Clock to time 'newtime'. - - Also set the kernel time zone value to the value indicated by the - TZ environment variable and/or /usr/lib/zoneinfo/, interpreted as - tzset() would interpret them. Except: do not consider Daylight - Savings Time to be a separate component of the time zone. Include - any effect of DST in the basic timezone value and set the kernel - DST value to 0. - - EXCEPT: if hclock_valid is false, just issue an error message - saying there is no valid time in the Hardware Clock to which to set - the system time. - - If 'testing' is true, don't actually update anything -- just say we - would have. ------------------------------------------------------------------------------*/ - int retcode; /* our eventual return code */ - - if (!hclock_valid) { - fprintf(stderr, "%s: The Hardware Clock does not contain a valid time, so " - "we cannot set the System Time from it.\n", MYNAME); - retcode = 1; - } else { - struct timeval tv; - int rc; /* local return code */ - - tv.tv_sec = newtime; - tv.tv_usec = 0; - - tzset(); /* init timezone, daylight from TZ or ...zoneinfo/localtime */ - /* An undocumented function of tzset() is to set global variabales - 'timezone' and 'daylight' - */ - - if (debug) { - printf( "Calling settimeofday:\n" ); - /* Note: tv_sec and tv_usec are declared variously on different - systems: int, long, time_t. Casting to long below makes it - compile everywhere. - */ - printf( "\ttv.tv_sec = %ld, tv.tv_usec = %ld\n", - (long) tv.tv_sec, (long) tv.tv_usec ); - } - if (testing) { - printf("Not setting system clock because running in test mode.\n"); - retcode = 0; - } else { - /* For documentation of settimeofday() see, in addition to its man page, - kernel/time.c in the Linux source code. - */ - const struct timezone tz = { timezone/60 - 60*daylight, 0 }; - /* put daylight in minuteswest rather than dsttime, - since the latter is mostly ignored ... */ - rc = settimeofday(&tv, &tz); - if (rc != 0) { - if (errno == EPERM) - fprintf(stderr, "%s: Must be superuser to set system clock.\n", - MYNAME); - else - fprintf(stderr, - "%s: settimeofday() failed, errno=%s (%d)\n", - MYNAME, strerror(errno), errno); - retcode = 1; - } else retcode = 0; - } - } - return(retcode); -} - - -static void -adjust_drift_factor(struct adjtime *adjtime_p, - const time_t actual_time, - const bool hclock_valid, - const struct timeval hclocktime ) { -/*--------------------------------------------------------------------------- - Update the drift factor and calibration parameters in '*adjtime_p' - to reflect the fact that at some recent instant when the actual time - was 'actual_time', the Hardware Clock said the time was - 'hclocktime', and that we have corrected the Hardware Clock - accordingly. Note that 'hclocktime' is a fractional time, taking - into consideration the Hardware Clock register contents and how long - those contents had been that. - - We assume that the only cause of error in the Hardware Clock is - systematic drift and that the user has been doing regular drift - adjustments using the drift factor in the adjtime file. Therefore, - if 'actual_time' and 'hclocktime' are different, that means the drift - factor isn't quite right. - - 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. - - Also, don't adjust if the error is more than 30 minutes, because that - kind of error probably isn't drift. - -----------------------------------------------------------------------------*/ - 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 there is no \n" - "previous calibration information (i.e. adjtime file is \n" - "nonexistent or has 0 in last calibration time field).\n"); - } else if (time_diff(hclocktime, t2tv(adjtime_p->last_calib_time)) - < 23.0 * 60.0 * 60.0) { - if (debug) - printf("Not adjusting drift factor because it has been less than a " - "day since the last calibration.\n"); - } else { - const float sec_per_day = 24.0 * 60.0 * 60.0; - float atime_per_htime; /* adjusted time units per hardware time unit */ - float adj_days; /* days since last adjustment (in hardware clock time) */ - float cal_days; /* days since last calibration (in hardware clock time) */ - float exp_drift; /* expected drift (sec) since last adjustment */ - float unc_drift; /* uncorrected drift (sec) since last calibration */ - float factor_adjust; /* amount to add to previous drift factor */ - atime_per_htime = 1.0 + adjtime_p->drift_factor / sec_per_day; - adj_days = time_diff(hclocktime, t2tv(adjtime_p->last_adj_time)) - / sec_per_day; - exp_drift = adj_days * adjtime_p->drift_factor + adjtime_p->not_adjusted; - unc_drift = time_diff(t2tv(actual_time), hclocktime) - exp_drift; - cal_days = ((float)(adjtime_p->last_adj_time - adjtime_p->last_calib_time) - + adjtime_p->not_adjusted) / (sec_per_day * atime_per_htime) - + adj_days; - factor_adjust = unc_drift / cal_days; - - if (unc_drift > 30*60.0) { - if (debug) - printf("Not adjusting drift factor because we calculated the \n" - "uncorrected drift as %.0f seconds, which is so large that \n" - "it probably is not drift at all, but rather some \n" - "clock setting anomaly.\n\n", unc_drift); - } else { - if (debug) - printf("Clock drifted %.1f 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", - unc_drift, - (int) (actual_time - adjtime_p->last_calib_time), - adjtime_p->drift_factor, - factor_adjust ); - - adjtime_p->drift_factor += factor_adjust; - } - } - adjtime_p->last_calib_time = actual_time; - - adjtime_p->last_adj_time = actual_time; - - 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[506]; /* Stuff to write to disk file */ - /* snprintf is not always available, but this is safe - as long as libc does not use more than 100 positions for %ld or %f - */ - - int rc; /* locally used: return code from a function */ - - if (adjtime.dirty) { - /* We'd use snprintf here, but apparently, it isn't always available. */ - 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; - - adjfile = fopen(ADJPATH, "w"); - if (adjfile == NULL) { - const int fopen_errno = errno; - printf("Could not open file with the clock adjustment parameters " - "in it (%s) for output.\n" - "fopen() returned errno %d: %s.\n" - "Drift adjustment parameters not updated.\n", - ADJPATH, fopen_errno, strerror(errno)); - } else { - rc = fprintf(adjfile, newfile); - if (rc < 0) { - const int fprintf_errno = errno; - printf("Could not update file (%s) " - "with the clock adjustment parameters in it.\n" - "fprintf() returned errno %d: %s.\n" - "Drift adjustment parameters not updated.\n", - ADJPATH, fprintf_errno, strerror(errno)); - } - rc = fclose(adjfile); - if (rc < 0) { - const int fclose_errno = errno; - printf("Could not update file (%s) " - "with the clock adjustment parameters in it.\n" - "fclose() returned errno %d: %s.\n" - "Drift adjustment parameters not updated.\n", - ADJPATH, fclose_errno, strerror(errno)); - } - } - } - } else if (debug) - printf("Skipping update of adjtime file because nothing has changed.\n"); -} - - - -static void -do_adjustment(struct adjtime *adjtime_p, - const bool hclock_valid, const time_t hclocktime, - const struct timeval read_time, - const enum clock_access_method clock_access, - const int dev_port, const bool universal, - const int hc_zero_year, - const bool badyear, 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. - - 'badyear': the Hardware Clock is incapable of storing years outside - the range 1994-1999. - - '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, "%s: The Hardware Clock does not contain a valid time, " - "so we cannot adjust it.\n", MYNAME); - /* Any previous calibration had to be before the clock got hosed, so - wipe out the record of it so it won't be used in the future. - */ - adjtime_p->last_calib_time = 0; - 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 adjusting clock because we have no information about \n" - "the previous calibration (i.e. the adjtime file is \n" - "nonexistent or contains zero in the last calibrated time \n" - "field).\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), - clock_access, dev_port, universal, - hc_zero_year, badyear, 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, - const bool user_says_jensen, - enum clock_access_method *clock_access_p) { -/*---------------------------------------------------------------------------- - Figure out how we're going to access the hardware clock, by seeing - what facilities are available, looking at invocation options, and - using compile-time constants. - - 'user_requests_ISA' means the user explicitly asked for the ISA method, - so we'll use that (even if we know it will fail because the machine - is incapable!). ------------------------------------------------------------------------------*/ - const bool jensen = - user_says_jensen || - (alpha_machine && is_in_cpuinfo("system type", "Jensen")); - /* See comments at top of program for how Jensen is a special case. */ - bool rtc_works; - /* The /dev/rtc method is available and seems to work on this machine */ - bool kdghwclk_works; - /* The KDHWCLK method is available and seems to work on this machine. */ - - see_if_rtc_works(&rtc_works); /* May issue error messages */ - see_if_kdghwclk_works(&kdghwclk_works); /* May issue error messages */ - - if (user_requests_ISA) *clock_access_p = ISA; - else if (rtc_works) *clock_access_p = RTC_IOCTL; - else if (kdghwclk_works) *clock_access_p = KD; - else if (got_kdghwclk) *clock_access_p = ISA; - /* I don't know on what machine the above line makes any sense, but the - code has always been this way. -BJH 99.03.31 - */ - else if (isa_machine) *clock_access_p = ISA; - else if (jensen) *clock_access_p = DEV_PORT; - else if (alpha_machine) *clock_access_p = ISA; - else *clock_access_p = NOCLOCK; - if (debug) { - switch (*clock_access_p) { - case ISA: printf("Using direct I/O instructions to ISA clock.\n"); break; - case KD: printf("Using KDGHWCLK interface to m68k clock.\n"); break; - case RTC_IOCTL: printf("Using /dev/rtc interface to clock.\n"); break; - case DEV_PORT: printf("Using /dev/port interface to clock.\n"); break; - case NOCLOCK: printf("Unable to find a usable clock access method.\n"); - break; - default: - printf("determine_clock_access_method() returned invalid value: %d.\n", - *clock_access_p); - } - } -} - - - -static void -do_systohc(const enum clock_access_method clock_access, - const int dev_port, - const time_t hclocktime, const bool hclock_valid, - const struct timeval read_time, - const bool universal, const int hc_zero_year, - const bool badyear, const bool testing, - struct adjtime * const adjtime_p) { -/*---------------------------------------------------------------------------- - Perform the specifics of the hwclock --systohc function. ------------------------------------------------------------------------------*/ - 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, - clock_access, dev_port, universal, - hc_zero_year, badyear, testing); - adjust_drift_factor(adjtime_p, (time_t) reftime.tv_sec, hclock_valid, - time_inc(t2tv(hclocktime), - - time_diff(read_time, reftime) - ) - ); -} - - -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 enum clock_access_method clock_access, - const bool utc, const bool local_opt, - const bool badyear, const bool arc_opt, const bool srm_opt, - const bool user_wants_uf, - 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 */ - int dev_port; - /* File descriptor for /dev/port, if we're using it. -1 if we - couldn't open it. 0 if we aren't using it. - */ - get_inb_outb_privilege(clock_access, &no_auth); - - if (no_auth) *retcode_p = 1; - else { - get_dev_port_access(clock_access, &dev_port); - - if (dev_port < 0) *retcode_p = 3; - else { - read_adjtime(&adjtime, &rc); - if (rc != 0) *retcode_p = 2; - else { - const bool use_uf_bit = uf_bit_needed(user_wants_uf); - const int hc_zero_year = zero_year(arc_opt, srm_opt); - /* year of century to which a value of zero corresponds in the - Hardware Clock's year register. - */ - const bool universal = hw_clock_is_utc(utc, local_opt, adjtime); - /* The hardware clock is kept in Coordinated Universal Time. */ - - if ((set || systohc || adjust) && - (adjtime.local_utc == UTC) != universal) { - adjtime.local_utc = universal ? UTC : LOCAL; - adjtime.dirty = TRUE; - } - - synchronize_to_clock_tick(clock_access, dev_port, use_uf_bit, - 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(clock_access, dev_port, universal, - hc_zero_year, badyear, - adjtime.last_calib_time, - &hclock_valid, &hclocktime); - - if (show) { - display_time(hclock_valid, hclocktime, - time_diff(read_time, startup_time), !badyear); - *retcode_p = 0; - } else if (set) { - set_hardware_clock_exact(set_time, startup_time, - clock_access, dev_port, universal, - hc_zero_year, - badyear, testing); - adjust_drift_factor(&adjtime, set_time, hclock_valid, - time_inc(t2tv(hclocktime), - - time_diff(read_time, startup_time) - ) - ); - *retcode_p = 0; - } else if (adjust) { - do_adjustment(&adjtime, hclock_valid, hclocktime, - read_time, clock_access, dev_port, - universal, hc_zero_year, - badyear, testing); - *retcode_p = 0; - } else if (systohc) { - do_systohc(clock_access, dev_port, - hclocktime, hclock_valid, read_time, - universal, hc_zero_year, badyear, testing, - &adjtime); - *retcode_p = 0; - } 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); - } - } - } - if (clock_access == DEV_PORT && dev_port >= 0) close(dev_port); - } -} - - - -static void -report_version(void) { - - char *additional_version; /* malloc'ed */ - /* Stuff to add on to the version report, after the basic version. - If this is hwclock packaged with util-linux, this is the - util-linux version. Otherwise, it's nothing. - */ - -#ifdef UTIL_LINUX - additional_version = malloc(strlen(util_linux_version) + 5); - sprintf(additional_version, "/%s", util_linux_version); -#else - additional_version = strdup(""); -#endif - printf(MYNAME " " VERSION "%s\n", additional_version); - free(additional_version); -} - - - -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. - */ - - if (!alpha_machine) - fprintf(stderr, - "%s: 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", MYNAME); - else { - if (getepoch) { - unsigned long epoch; - char *reason; /* malloc'ed */ - - get_epoch(&epoch, &reason); - if (reason != NULL) { - printf("Unable to get the epoch value from the kernel. %s\n", - reason); - free(reason); - } else - printf("Kernel is assuming an epoch value of %lu\n", epoch); - } else if (setepoch) { - if (epoch_opt == -1) - fprintf(stderr, "%s: To set the epoch value, you must use the 'epoch' " - "option to tell to what value to set it.\n", MYNAME); - else { - int rc; - set_epoch(epoch_opt, testing, &rc); - if (rc != 0) - printf("Unable to set the epoch value in the kernel.\n"); - } - } - } -} - - - -int -main(int argc, char **argv, char **envp) { -/*---------------------------------------------------------------------------- - MAIN ------------------------------------------------------------------------------*/ - 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 */ - - enum clock_access_method clock_access; - /* The method that we determine is best for accessing Hardware Clock - on this system. - */ - - bool permitted; /* User is permitted to do the function */ - int retcode; /* Our eventual return code */ - - int rc; /* local return code */ - - /* option_def is the control table for the option parser. These other - variables are the results of parsing the options and their meanings - are given by the option_def. The only exception is <show>, which - may be modified after parsing is complete to effect an implied option. - */ - bool show, set, systohc, hctosys, adjust, getepoch, setepoch, version; - bool utc, local_opt, badyear, testing, directisa; - bool arc_opt, jensen_opt, srm_opt, funky_opt; - char *date_opt; - int epoch_opt; - - const optStruct option_def[] = { - { 'r', (char *) "show", OPT_FLAG, &show, 0 }, - { 0, (char *) "set", OPT_FLAG, &set, 0 }, - { 'w', (char *) "systohc", OPT_FLAG, &systohc, 0 }, - { 's', (char *) "hctosys", OPT_FLAG, &hctosys, 0 }, - { 0, (char *) "getepoch", OPT_FLAG, &getepoch, 0 }, - { 0, (char *) "setepoch", OPT_FLAG, &setepoch, 0 }, - { 'a', (char *) "adjust", OPT_FLAG, &adjust, 0 }, - { 'v', (char *) "version", OPT_FLAG, &version, 0 }, - { 0, (char *) "date", OPT_STRING, &date_opt, 0 }, - { 0, (char *) "epoch", OPT_UINT, &epoch_opt, 0 }, - { 'u', (char *) "utc", OPT_FLAG, &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 }, - { 'A', (char *) "arc", OPT_FLAG, &arc_opt, 0 }, - { 'J', (char *) "jensen", OPT_FLAG, &jensen_opt,0 }, - { 'S', (char *) "srm", OPT_FLAG, &srm_opt, 0 }, - { 'F', (char *) "funky-toy", OPT_FLAG, &funky_opt, 0 }, - { 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 */ - - assume_interrupts_enabled(); /* Since we haven't messed with them yet */ - - gettimeofday(&startup_time, NULL); /* Remember what time we were invoked */ - - /* set option defaults */ - show = set = systohc = hctosys = adjust = getepoch = setepoch = - version = utc = local_opt = badyear = - directisa = testing = debug = - jensen_opt = arc_opt = srm_opt = funky_opt = FALSE; - date_opt = NULL; - epoch_opt = -1; - - argc_parse = argc; argv_parse = argv; - optParseOptions(&argc_parse, argv_parse, option_def, 0); - /* Uses and sets argc_parse, argv_parse. - Sets show, set, systohc, hctosys, adjust, getepoch, setepoch, - version, utc, localtime, badyear, - directisa, testing, debug, - date_opt, epoch_opt, - jensen_opt, arc_opt, srm_opt, funky_opt - */ - - if (argc_parse - 1 > 0) { - fprintf(stderr, MYNAME " takes no non-option arguments. " - "You supplied %d. See man page for complete syntax.\n", - argc_parse - 1); - exit(100); - } - - if (show + set + systohc + hctosys + adjust + - getepoch + setepoch + version > 1) { - fprintf(stderr, - "You have specified multiple function options to hwclock.\n" - "You can only perform one function at a time.\n"); - exit(100); - } - - if (set) { - rc = interpret_date_string(date_opt, &set_time); /* (time-consuming) */ - if (rc != 0) { - fprintf(stderr, "%s: No usable set-to time given. Cannot set clock.\n", - MYNAME); - exit(100); - } - } - - if (jensen_opt && !alpha_machine) { - fprintf(stderr, "%s: Your options indicate that this is a Jensen model of " - "DEC Alpha, but this is not an Alpha machine!\n", MYNAME); - exit(100); - } - - if (srm_opt && alpha_machine) { - fprintf(stderr, "%s: Your options indicate that this machine keeps SRM " - "console time, but only DEC Alphas have such a clock and this is " - "not an Alpha!\n", MYNAME); - exit(100); - } - if (arc_opt && alpha_machine) { - fprintf(stderr, "%s: Your options indicate that this machine's clock" - "keeps ARC console time, " - "but only DEC Alphas have such a clock and this is " - "not an Alpha!\n", MYNAME); - exit(100); - } - - if (directisa && !(isa_machine || alpha_machine)) { - fprintf(stderr, "%s: You have requested direct access to the ISA Hardware " - "Clock using machine instructions from the user process. " - "But this method only works on an ISA machine with an x86 " - "CPU, or a similar machine such as DEC Alpha. " - "This is not one.\n", MYNAME); - exit(100); - } - - if (utc && local_opt) { - fprintf(stderr, "%s: The --utc and --localtime options are mutually " - "exclusive. You specified both.\n", MYNAME); - exit(100); - } - - - if (!(show | set | systohc | hctosys | adjust | getepoch | setepoch | - version)) - show = TRUE; /* 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, - "%s: Sorry, only the superuser can change the " - "Hardware Clock.\n", MYNAME); - permitted = FALSE; - } else if (setepoch) { - fprintf(stderr, - "%s: Sorry, only the superuser can change " - "the Hardware Clock epoch in the kernel.\n", MYNAME); - permitted = FALSE; - } else permitted = TRUE; - } - - if (!permitted) retcode = 2; - else { - retcode = 0; - if (version) { - report_version(); - } else if (getepoch || setepoch) { - manipulate_epoch(getepoch, setepoch, epoch_opt, testing); - } else { - determine_clock_access_method(directisa, jensen_opt, &clock_access); - if (clock_access == NOCLOCK) - fprintf(stderr, "%s: Cannot access the Hardware Clock via any known " - "method. Use --debug option to see the details of our " - "search for an access method.\n", MYNAME); - else - manipulate_clock(show, adjust, set, set_time, hctosys, systohc, - startup_time, clock_access, utc, local_opt, badyear, - arc_opt, srm_opt, funky_opt, testing, &rc); - } - } - exit(retcode); -} - - -/**************************************************************************** - - History of this program: - - 99.04.08 BJH Version 2.5 - - Make it work on Alphas without /dev/rtc. Thanks to David Mosberger - <davidm@azstarnet.com>, Jay Estabrook <jestabro@amt.tay1.dec.com>, - Martin Ostermann <ost@coments.rwth-aachen.de>, Andries Brouwer - <aeb@cwi.nl>. Most of this code is lifted from another program - called "clock" (not the original ancestor of hwclock) that has - circulated for use on Alpha. - - Make it work on Sparc. - - Add --badyear option. Thanks to David J Coffin (dcoffin@shore.net) - for the design of this. - - Add --localtime option, local/UTC value in adjtime file, and defaults - for local/utc. - - Don't set CMOS memory Byte 50 (century byte). On some machines, - that byte not only isn't used as a century byte, but it is used for - something else. - - Don't update the drift factor if the variation is so huge that it - probably wasn't due to drift. - - Compute drift factor with better precision. - - 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. - - - Bryan Henderson based hwclock on the program "clock", in September - 1996. While remaining mostly backward compatible with clock, - hwclock added the following: - - - You can set the hardware clock without also modifying the Linux - 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. (This - is the drift rate that is used with the --adjust function to - automatically adjust the clock periodically to compensate for drift). - - - More mnemonic GNU-style command line options. - - - Comments describing how the clock and program work to improve - maintainability. - - - Removed the old dead I/O code that worked without the inb/outb - instructions and without the asm/io.h definitions. - - The first version of hwclock was Version 2. - - Here is the history section from the "clock" program at the time it was - used as a basis for hwclock: - - V1.0 - - - V1.0 by Charles Hedrick, hedrick@cs.rutgers.edu, April 1992. - - ******************** - V1.1 - Modified for clock adjustments - Rob Hooft, hooft@chem.ruu.nl, Nov 1992 - Also moved error messages to stderr. The program now uses getopt. - Changed some exit codes. Made 'gcc 2.3 -Wall' happy. - - ***** - V1.2 - - Applied patches by Harald Koenig (koenig@nova.tat.physik.uni-tuebingen.de) - Patched and indented by Rob Hooft (hooft@EMBL-Heidelberg.DE) - - A free quote from a MAIL-message (with spelling corrections): - - "I found the explanation and solution for the CMOS reading 0xff problem - in the 0.99pl13c (ALPHA) kernel: the RTC goes offline for a small amount - of time for updating. Solution is included in the kernel source - (linux/kernel/time.c)." - - "I modified clock.c to fix this problem and added an option (now default, - look for USE_INLINE_ASM_IO) that I/O instructions are used as inline - code and not via /dev/port (still possible via #undef ...)." - - With the new code, which is partially taken from the kernel sources, - the CMOS clock handling looks much more "official". - Thanks Harald (and Torsten for the kernel code)! - - ***** - V1.3 - Canges from alan@spri.levels.unisa.edu.au (Alan Modra): - a) Fix a few typos in comments and remove reference to making - clock -u a cron job. The kernel adjusts cmos time every 11 - minutes - see kernel/sched.c and kernel/time.c set_rtc_mmss(). - This means we should really have a cron job updating - /etc/adjtime every 11 mins (set last_time to the current time - and not_adjusted to ???). - b) Swapped arguments of outb() to agree with asm/io.h macro of the - same name. Use outb() from asm/io.h as it's slightly better. - c) Changed CMOS_READ and CMOS_WRITE to inline functions. Inserted - cli()..sti() pairs in appropriate places to prevent possible - errors, and changed ioperm() call to iopl() to allow cli. - d) Moved some variables around to localise them a bit. - e) Fixed bug with clock -ua or clock -us that cleared environment - variable TZ. This fix also cured the annoying display of bogus - day of week on a number of machines. (Use mktime(), ctime() - rather than asctime() ) - f) Use settimeofday() rather than stime(). This one is important - as it sets the kernel's timezone offset, which is returned by - gettimeofday(), and used for display of MSDOS and OS2 file - times. - g) faith@cs.unc.edu added -D flag for debugging - - V1.4: alan@SPRI.Levels.UniSA.Edu.Au (Alan Modra) - Wed Feb 8 12:29:08 1995, fix for years > 2000. - faith@cs.unc.edu added -v option to print version. */ - - |