diff options
Diffstat (limited to 'sys-utils/hwclock.c')
| -rw-r--r-- | sys-utils/hwclock.c | 2151 |
1 files changed, 0 insertions, 2151 deletions
diff --git a/sys-utils/hwclock.c b/sys-utils/hwclock.c deleted file mode 100644 index 02302da29..000000000 --- a/sys-utils/hwclock.c +++ /dev/null @@ -1,2151 +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. - - - 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 <time.h> -#include <sys/time.h> -#include <sys/stat.h> -#ifdef __i386__ -#include <asm/io.h> /* for inb, outb */ -#endif -#include <shhopt.h> -#include "../version.h" - -#define MYNAME "hwclock" -#define VERSION "2.4" - -#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. -*/ -typedef int bool; -#define TRUE 1 -#define FALSE 0 - -struct adjtime { - /* This is information we keep in the adjtime file that tells us how - to do drift corrections. Elements are all straight from the - adjtime file, so see documentation of that file for details. - Exception is <dirty>, which is an indication that what's in this - structure is not what's in the disk file (because it has been - updated since read from the disk file). - */ - bool dirty; - float drift_factor; - time_t last_adj_time; - float not_adjusted; - time_t last_calib_time; -}; - - -enum clock_access_method {ISA, RTC_IOCTL, KD, NOCLOCK}; - /* A method for accessing (reading, writing) the hardware clock: - - ISA: - via direct CPU I/O instructions that work on an ISA family - machine (IBM PC compatible). - - RTC_IOCTL: - via the rtc device driver, using device special file /dev/rtc. - - KD: - via the console driver, using device special file /dev/tty1. - This is the m68k ioctl interface, known as KDGHWCLK. - - NO_CLOCK: - Unable to determine a usable access method for the system clock. - */ - -#ifdef __i386__ -/* The following are just constants. Oddly, this program will not - compile if the inb() and outb() functions use something even - slightly different from these variables. This is probably at least - partially related to the fact that __builtin_constant_p() doesn't - work (is never true) in an inline function. See comment to this - effect in asm/io.h. -*/ -static unsigned short clock_ctl_addr = 0x70; -static unsigned short clock_data_addr = 0x71; -#endif - -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. */ - -bool interrupts_enabled; - /* Interrupts are enabled as normal. We, unfortunately, turn interrupts - on the machine off in some places where we do the direct ISA accesses - to the Hardware Clock. It is in extremely poor form for a user space - program to do this, but that's the price we have to pay to run on an - ISA machine without the rtc driver in the kernel. - - Code which turns interrupts off uses this value to determine if they - need to be turned back on. - */ - -#include <linux/version.h> -/* Check if the /dev/rtc interface is available in this version of - the system headers. 131072 is linux 2.0.0. Might need to make - it conditional on i386 or something too -janl */ -#if LINUX_VERSION_CODE >= 131072 -#include <linux/mc146818rtc.h> -#include <linux/kd.h> -static const bool got_rtc = TRUE; -#else -static const bool got_rtc = FALSE; -/* Dummy definitions to make it compile. If any lines containing these - macros ever execute, there is a bug in the code. - */ -#define RTC_SET_TIME -1 -#define RTC_RD_TIME -1 -#define RTC_UIE_ON -1 -#define RTC_UIE_OFF -1 -#endif - -/* The RTC_EPOCH_READ and RTC_EPOCH_SET macros are supposed to be - defined by linux/mc146818rtc.h, included above. However, these are - recent inventions and at the time of this writing, not in any - official Linux. Since these values aren't even necessary for most - uses of hwclock, we don't want compilation to depend on the user - having some arcane version of this header file on his system. Thus, - we define the macros ourselves if the header file failed to do so. - 98.03.03. -*/ - -#ifndef RTC_EPOCH_READ -#define RTC_EPOCH_READ _IOR('p', 0x0d, unsigned long) /* Read epoch */ - /* Not all kernels have this ioctl */ -#endif - -#ifndef RTC_EPOCH_SET -#define RTC_EPOCH_SET _IOW('p', 0x0e, unsigned long) /* Set epoch */ - /* Not all kernels have this ioctl */ -#endif - - -#if defined(KDGHWCLK) -static const bool got_kdghwclk = TRUE; -static const int kdghwclk_ioctl = KDGHWCLK; -static const int kdshwclk_ioctl = KDSHWCLK; -#else -static const bool got_kdghwclk = FALSE; -static const int kdghwclk_ioctl; /* Never used; just to make compile work */ -struct hwclk_time {int sec;}; - /* Never used; just to make compile work */ -#endif - - -/* 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 int -i386_iopl(const int level) { -/*---------------------------------------------------------------------------- - When compiled for an Intel target, this is just the iopl() kernel call. - When compiled for any other target, this is a dummy function. - - We do it this way in order to keep the conditional compilation stuff - out of the way so it doesn't mess up readability of the code. ------------------------------------------------------------------------------*/ -#ifdef __i386__ - extern int iopl(const int level); - return iopl(level); -#else - return -1; -#endif -} - - - -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 inline unsigned char -hclock_read(unsigned char reg) { -/*--------------------------------------------------------------------------- - Relative byte <reg> of the Hardware Clock value. - - On non-ISA machine, just return 0. ----------------------------------------------------------------------------*/ - register unsigned char ret; -#ifdef __i386__ - const bool interrupts_were_enabled = interrupts_enabled; - - __asm__ volatile ("cli"); - interrupts_enabled = FALSE; - /* & 0x7f ensures that we are not disabling NMI while we read. - Setting on Bit 7 here would disable NMI - */ - outb(reg & 0x7f, clock_ctl_addr); - ret = inb(clock_data_addr); - if (interrupts_were_enabled) { - __asm__ volatile ("sti"); - interrupts_enabled = TRUE; - } -#else - ret = 0; -#endif - return ret; -} - - - -static inline void -hclock_write(unsigned char reg, unsigned char val) { -/*---------------------------------------------------------------------------- - Set relative byte <reg> of the Hardware Clock value to <val>. - - On non-ISA machine, do nothing. -----------------------------------------------------------------------------*/ -#ifdef __i386__ - /* & 0x7f ensures that we are not disabling NMI while we read. - Setting on Bit 7 here would disable NMI - */ - outb(reg & 0x7f, clock_ctl_addr); - outb(val, clock_data_addr); -#endif -} - - - -static inline int -hclock_read_bcd (int addr) { - int b; - b = hclock_read(addr); - return (b & 15) + (b >> 4) * 10; -} - -static inline void -hclock_write_bcd(int addr, int value) { - hclock_write(addr, ((value / 10) << 4) + value % 10); -} - - -static void -read_adjtime(struct adjtime *adjtime_p, int *rc_p) { -/*---------------------------------------------------------------------------- - Read the adjustment parameters out of the /etc/adjtime file. - - Return them as the adjtime structure <*adjtime_p>. - - If there is no /etc/adjtime file, return defaults. - If values are missing from the file, return defaults for them. - - return *rc_p = 0 if all OK, !=0 otherwise. - ------------------------------------------------------------------------------*/ - FILE *adjfile; - int rc; /* local return code */ - struct stat statbuf; /* We don't even use the contents of this. */ - - rc = stat(ADJPATH, &statbuf); - if (rc < 0 && errno == ENOENT) { - /* He doesn't have a adjtime file, so we'll use defaults. */ - adjtime_p->drift_factor = 0; - adjtime_p->last_adj_time = 0; - adjtime_p->not_adjusted = 0; - adjtime_p->last_calib_time = 0; - - *rc_p = 0; - } else { - adjfile = fopen(ADJPATH, "r"); /* open file for reading */ - if (adjfile == NULL) { - 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 */ - - line1[0] = '\0'; /* In case fgets fails */ - fgets(line1, sizeof(line1), adjfile); - line2[0] = '\0'; /* In case fgets fails */ - fgets(line2, sizeof(line2), adjfile); - - fclose(adjfile); - - /* Set defaults in case values are missing from file */ - adjtime_p->drift_factor = 0; - adjtime_p->last_adj_time = 0; - adjtime_p->not_adjusted = 0; - adjtime_p->last_calib_time = 0; - - sscanf(line1, "%f %d %f", - &adjtime_p->drift_factor, - (int *) &adjtime_p->last_adj_time, - &adjtime_p->not_adjusted); - - sscanf(line2, "%d", (int *) &adjtime_p->last_calib_time); - - *rc_p = 0; - } - adjtime_p->dirty = FALSE; - - if (debug) { - printf("Last drift adjustment done at %d seconds after 1969\n", - (int) adjtime_p->last_adj_time); - printf("Last calibration done at %d seconds after 1969\n", - (int) adjtime_p->last_calib_time); - } - } -} - - - -static void -synchronize_to_clock_tick_ISA(int *retcode_p) { -/*---------------------------------------------------------------------------- - Same as synchronize_to_clock_tick(), but just for ISA. ------------------------------------------------------------------------------*/ - int i; /* local loop index */ - - /* Wait for rise. Should be within a second, but in case something - weird happens, we have a limit on this loop to reduce the impact - of this failure. - */ - for (i = 0; !(hclock_read(10) & 0x80) && (i < 10000000); i++); - if (i >= 10000000) *retcode_p = 1; - else { - /* Wait for fall. Should be within 2.228 ms. */ - for (i = 0; (hclock_read(10) & 0x80) && (i < 1000000); i++); - if (i >= 10000000) *retcode_p = 1; - else *retcode_p = 0; - } -} - - - -static void -busywait_for_rtc_clock_tick(const int rtc_fd, int *retcode_p) { -/*---------------------------------------------------------------------------- - Wait for the top of a clock tick by reading /dev/rtc in a busy loop until - we see it. ------------------------------------------------------------------------------*/ - struct tm start_time; - /* The time when we were called (and started waiting) */ - int rc; - - if (debug) - printf("Waiting in loop for time from /dev/rtc to change\n"); - - rc = ioctl(rtc_fd, RTC_RD_TIME, &start_time); - if (rc == -1) { - fprintf(stderr, "ioctl() to /dev/rtc to read time failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 1; - } else { - /* Wait for change. Should be within a second, but in case something - weird happens, we have a limit on this loop to reduce the impact - of this failure. - */ - struct tm nowtime; - int i; /* local loop index */ - int rc; /* Return code from ioctl */ - - for (i = 0; - (rc = ioctl(rtc_fd, RTC_RD_TIME, &nowtime)) != -1 - && start_time.tm_sec == nowtime.tm_sec && i < 1000000; - i++); - if (i >= 1000000) { - fprintf(stderr, "Timed out waiting for time change.\n"); - *retcode_p = 2; - } else if (rc == -1) { - fprintf(stderr, "ioctl() to /dev/rtc to read time failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 3; - } else *retcode_p = 0; - } -} - - - -static void -synchronize_to_clock_tick_RTC(int *retcode_p) { -/*---------------------------------------------------------------------------- - Same as synchronize_to_clock_tick(), but just for /dev/rtc. ------------------------------------------------------------------------------*/ -int rtc_fd; /* File descriptor of /dev/rtc */ - - rtc_fd = open("/dev/rtc",O_RDONLY); - if (rtc_fd == -1) { - fprintf(stderr, "open() of /dev/rtc failed, errno = %s (%d).\n", - strerror(errno), errno); - *retcode_p = 1; - } else { - int rc; /* Return code from ioctl */ - /* Turn on update interrupts (one per second) */ - rc = ioctl(rtc_fd, RTC_UIE_ON, 0); - if (rc == -1 && errno == EINVAL) { - /* This rtc device doesn't have interrupt functions. This is typical - on an Alpha, where the Hardware Clock interrupts are used by the - kernel for the system clock, so aren't at the user's disposal. - */ - if (debug) printf("/dev/rtc does not have interrupt functions. "); - busywait_for_rtc_clock_tick(rtc_fd, retcode_p); - } else if (rc != -1) { - int rc; /* return code from ioctl */ - unsigned long dummy; - - /* this blocks until the next update interrupt */ - rc = read(rtc_fd, &dummy, sizeof(dummy)); - if (rc == -1) { - fprintf(stderr, "read() to /dev/rtc to wait for clock tick failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 1; - } else { - *retcode_p = 0; - } - /* Turn off update interrupts */ - rc = ioctl(rtc_fd, RTC_UIE_OFF, 0); - if (rc == -1) { - fprintf(stderr, "ioctl() to /dev/rtc to turn off update interrupts " - "failed, errno = %s (%d).\n", strerror(errno), errno); - } - } else { - fprintf(stderr, "ioctl() to /dev/rtc to turn on update interrupts " - "failed unexpectedly, errno = %s (%d).\n", - strerror(errno), errno); - *retcode_p = 1; - } - close(rtc_fd); - } -} - - - -static void -synchronize_to_clock_tick_KD(int *retcode_p) { -/*---------------------------------------------------------------------------- - Wait for the top of a clock tick by calling KDGHWCLK in a busy loop until - we see it. ------------------------------------------------------------------------------*/ - int con_fd; - - if (debug) - printf("Waiting in loop for time from KDGHWCLK to change\n"); - - con_fd = open("/dev/tty1", O_RDONLY); - if (con_fd < 0) { - fprintf(stderr, "open() failed to open /dev/tty1, errno = %s (%d).\n", - strerror(errno), errno); - *retcode_p = 1; - } else { - int rc; /* return code from ioctl() */ - int i; /* local loop index */ - /* The time when we were called (and started waiting) */ - struct hwclk_time start_time, nowtime; - - rc = ioctl(con_fd, kdghwclk_ioctl, &start_time); - if (rc == -1) { - fprintf(stderr, "KDGHWCLK to read time failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 3; - } - - for (i = 0; - (rc = ioctl(con_fd, kdghwclk_ioctl, &nowtime)) != -1 - && start_time.sec == nowtime.sec && i < 1000000; - i++); - if (i >= 1000000) { - fprintf(stderr, "Timed out waiting for time change.\n"); - *retcode_p = 2; - } else if (rc == -1) { - fprintf(stderr, "KDGHWCLK to read time failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 3; - } else *retcode_p = 0; - close(con_fd); - } -} - - - -static void -synchronize_to_clock_tick(enum clock_access_method clock_access, - 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. - - For the KD clock access method, we have no way to synchronize, so we - just return immediately. This will mess some things up, but it's the - best we can do. - - 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); 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, "Internal error in synchronize_to_clock_tick. Invalid " - "value for clock_access argument.\n"); - *retcode_p = 1; - } - if (debug) printf("...got clock tick\n"); - return; -} - - - -static void -mktime_tz(struct tm tm, const bool universal, - bool *valid_p, time_t *systime_p) { -/*----------------------------------------------------------------------------- - Convert a time in broken down format (hours, minutes, etc.) into standard - unix time (seconds into epoch). Return it as *systime_p. - - The broken down time is argument <tm>. This broken down time is either in - local time zone or UTC, depending on value of logical argument "universal". - True means it is in UTC. - - If the argument contains values that do not constitute a valid time, - and mktime() recognizes this, return *valid_p == false and - *systime_p undefined. However, mktime() sometimes goes ahead and - computes a fictional time "as if" the input values were valid, - e.g. if they indicate the 31st day of April, mktime() may compute - the time of May 1. In such a case, we return the same fictional - value mktime() does as *systime_p and return *valid_p == true. - ------------------------------------------------------------------------------*/ - time_t mktime_result; /* The value returned by our mktime() call */ - char *zone; /* Local time zone name */ - - /* We use the C library function mktime(), but since it only works on - local time zone input, we may have to fake it out by temporarily - changing the local time zone to UTC. - */ - zone = (char *) getenv("TZ"); /* remember original time zone */ - - if (universal) { - /* Set timezone to UTC */ - setenv("TZ", "", TRUE); - /* Note: tzset() gets called implicitly by the time code, but only the - first time. When changing the environment variable, better call - tzset() explicitly. - */ - tzset(); - } - mktime_result = mktime(&tm); - if (mktime_result == -1) { - /* This apparently (not specified in mktime() documentation) means - the 'tm' structure does not contain valid values (however, not - containing valid values does _not_ imply mktime() returns -1). - */ - *valid_p = FALSE; - *systime_p = 0; - if (debug) - printf("Invalid values in hardware clock: " - "%2d/%.2d/%.2d %.2d:%.2d:%.2d\n", - tm.tm_year, tm.tm_mon+1, tm.tm_mday, - tm.tm_hour, tm.tm_min, tm.tm_sec - ); - } else { - *valid_p = TRUE; - *systime_p = mktime_result; - if (debug) - printf("Hw clock time : %.2d:%.2d:%.2d = %d seconds since 1969\n", - tm.tm_hour, tm.tm_min, tm.tm_sec, (int) *systime_p); - } - /* now put back the original zone. */ - if (zone) setenv("TZ", zone, TRUE); - else unsetenv("TZ"); - tzset(); -} - - - -static void -read_hardware_clock_kd(struct tm *tm) { -/*---------------------------------------------------------------------------- - Read the hardware clock and return the current time via <tm> - argument. Use ioctls to /dev/tty1 on what we assume is an m68k - machine. - - Note that we don't use /dev/console here. That might be a serial - console. ------------------------------------------------------------------------------*/ -#ifdef KDGHWCLK - int con_fd; - struct hwclk_time t; - - con_fd = open("/dev/tty1", O_RDONLY); - if (con_fd < 0) { - fprintf(stderr, "open() failed to open /dev/tty1, errno = %s (%d).\n", - strerror(errno), errno); - exit(5); - } else { - int rc; /* return code from ioctl() */ - - rc = ioctl(con_fd, kdghwclk_ioctl, &t); - if (rc == -1) { - fprintf(stderr, "ioctl() failed to read time from /dev/tty1, " - "errno = %s (%d).\n", - strerror(errno), errno); - exit(5); - } - close(con_fd); - } - - tm->tm_sec = t.sec; - tm->tm_min = t.min; - tm->tm_hour = t.hour; - tm->tm_mday = t.day; - tm->tm_mon = t.mon; - tm->tm_year = t.year; - tm->tm_wday = t.wday; - tm->tm_isdst = -1; /* Don't know if it's Daylight Savings Time */ -#else - /* This routine should never be invoked. It is here just to make the - program compile. - */ -#endif -} - - - -static void -read_hardware_clock_rtc_ioctl(struct tm *tm) { -/*---------------------------------------------------------------------------- - Read the hardware clock and return the current time via <tm> - argument. Use ioctls to "rtc" device /dev/rtc. ------------------------------------------------------------------------------*/ -#if defined(_MC146818RTC_H) - int rc; /* Local return code */ - int rtc_fd; /* File descriptor of /dev/rtc */ - - rtc_fd = open("/dev/rtc",O_RDONLY); - if (rtc_fd == -1) { - fprintf(stderr, "open() of /dev/rtc failed, errno = %s (%d).\n", - strerror(errno), errno); - exit(5); - } else { - /* Read the RTC time/date */ - rc = ioctl(rtc_fd, RTC_RD_TIME, tm); - if (rc == -1) { - fprintf(stderr, "ioctl() to /dev/rtc to read the time failed, " - "errno = %s (%d).\n", strerror(errno), errno); - exit(5); - } - close(rtc_fd); - } - tm->tm_isdst = -1; /* don't know whether it's daylight */ -#else - /* This function should never be called. It exists just to make the - program compile. - */ -#endif -} - - - -static void -read_hardware_clock_isa(struct tm *tm) { -/*---------------------------------------------------------------------------- - Read the hardware clock and return the current time via <tm> argument. - Assume we have an ISA machine and read the clock directly with CPU I/O - instructions. - - This function is not totally reliable. It takes a finite and - unpredictable amount of time to execute the code below. During that - time, the clock may change and we may even read an invalid value in - the middle of an update. We do a few checks to minimize this - possibility, but only the kernel can actually read the clock - properly, since it can execute code in a short and predictable - amount of time (by turning of interrupts). - - In practice, the chance of this function returning the wrong time is - extremely remote. - ------------------------------------------------------------------------------*/ - bool got_time; - /* We've successfully read a time from the Hardware Clock */ - - got_time = FALSE; - while (!got_time) { - /* Bit 7 of Byte 10 of the Hardware Clock value is the Update In Progress - (UIP) bit, which is on while and 244 uS before the Hardware Clock - updates itself. It updates the counters individually, so reading - them during an update would produce garbage. The update takes 2mS, - so we could be spinning here that long waiting for this bit to turn - off. - - Furthermore, it is pathologically possible for us to be in this - code so long that even if the UIP bit is not on at first, the - clock has changed while we were running. We check for that too, - and if it happens, we start over. - */ - - if ((hclock_read(10) & 0x80) == 0) { - /* No clock update in progress, go ahead and read */ - tm->tm_sec = hclock_read_bcd(0); - tm->tm_min = hclock_read_bcd(2); - tm->tm_hour = hclock_read_bcd(4); - tm->tm_wday = hclock_read_bcd(6) - 3; - tm->tm_mday = hclock_read_bcd(7); - tm->tm_mon = hclock_read_bcd(8) - 1; - tm->tm_year = hclock_read_bcd(9); - /* We don't use the century byte (Byte 50) of the Hardware Clock. - Here's why: On older machines, it isn't defined. In at least - one reported case, a machine puts some arbitrary value in that - byte. Furthermore, the Linux standard time data structure doesn't - allow for times beyond about 2037 and no Linux systems were - running before 1937. Therefore, all the century byte could tell - us is that the clock is wrong or this whole program is obsolete! - - So we just say if the year of century is less than 37, it's the - 21st century, otherwise it's the 20th. - */ - - if (hclock_read_bcd(9) >= 37) tm->tm_year = hclock_read_bcd(9); - else tm->tm_year = hclock_read_bcd(9) + 100; - } - /* Unless the clock changed while we were reading, consider this - a good clock read . - */ - if (tm->tm_sec == hclock_read_bcd (0)) got_time = TRUE; - /* Yes, in theory we could have been running for 60 seconds and - the above test wouldn't work! - */ - } - tm->tm_isdst = -1; /* don't know whether it's daylight */ -} - - - -static void -read_hardware_clock(const enum clock_access_method method, - 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; - - - switch (method) { - case ISA: - read_hardware_clock_isa(&tm); - break; - case RTC_IOCTL: - read_hardware_clock_rtc_ioctl(&tm); - break; - case KD: - read_hardware_clock_kd(&tm); - break; - default: - fprintf(stderr, - "Internal error: invalid value for clock access method.\n"); - exit(5); - } - if (debug) - printf ("Time read from Hardware Clock: %02d:%02d:%02d\n", - tm.tm_hour, tm.tm_min, tm.tm_sec); - mktime_tz(tm, universal, valid_p, systime_p); -} - - - -static void -set_hardware_clock_kd(const struct tm new_broken_time, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the Hardware Clock to the time <new_broken_time>. Use ioctls to - /dev/tty1 on what we assume is an m68k machine. - - Note that we don't use /dev/console here. That might be a serial console. -----------------------------------------------------------------------------*/ -#ifdef KDGHWCLK - int con_fd; /* File descriptor of /dev/tty1 */ - struct hwclk_time t; - - con_fd = open("/dev/tty1", O_RDONLY); - if (con_fd < 0) { - fprintf(stderr, "Error opening /dev/tty1. Errno: %s (%d)\n", - strerror(errno), errno); - exit(1); - } else { - int rc; /* locally used return code */ - - t.sec = new_broken_time.tm_sec; - t.min = new_broken_time.tm_min; - t.hour = new_broken_time.tm_hour; - t.day = new_broken_time.tm_mday; - t.mon = new_broken_time.tm_mon; - t.year = new_broken_time.tm_year; - t.wday = new_broken_time.tm_wday; - - if (testing) - printf("Not setting Hardware Clock because running in test mode.\n"); - else { - rc = ioctl(con_fd, kdshwclk_ioctl, &t ); - if (rc < 0) { - fprintf(stderr, "ioctl() to open /dev/tty1 failed. " - "Errno: %s (%d)\n", - strerror(errno), errno); - exit(1); - } - } - close(con_fd); - } -#else - /* This function should never be invoked. It is here just to make the - program compile. - */ -#endif -} - - - -static void -set_hardware_clock_rtc_ioctl(const struct tm new_broken_time, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the Hardware Clock to the broken down time <new_broken_time>. - Use ioctls to "rtc" device /dev/rtc. -----------------------------------------------------------------------------*/ - int rc; - int rtc_fd; - - rtc_fd = open("/dev/rtc", O_RDONLY); - if (rtc_fd < 0) { - fprintf(stderr, "Unable to open /dev/rtc, open() errno = %s (%d)\n", - strerror(errno), errno); - exit(5); - } else { - if (testing) - printf("Not setting Hardware Clock because running in test mode.\n"); - else { - rc = ioctl(rtc_fd, RTC_SET_TIME, &new_broken_time); - if (rc == -1) { - fprintf(stderr, - "ioctl() (RTC_SET_TIME) to /dev/rtc to set time failed, " - "errno = %s (%d).\n", strerror(errno), errno); - exit(5); - } else { - if (debug) - printf("ioctl(RTC_SET_TIME) was successful.\n"); - } - } - close(rtc_fd); - } -} - - - -static void -set_hardware_clock_isa(const struct tm new_broken_time, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the Hardware Clock to the time (in broken down format) - new_broken_time. Use direct I/O instructions to what we assume is - an ISA Hardware Clock. -----------------------------------------------------------------------------*/ - unsigned char save_control, save_freq_select; - - if (testing) - printf("Not setting Hardware Clock because running in test mode.\n"); - else { -#ifdef __i386__ - const bool interrupts_were_enabled = interrupts_enabled; - - __asm__ volatile ("cli"); - interrupts_enabled = FALSE; -#endif - save_control = hclock_read(11); /* tell the clock it's being set */ - hclock_write(11, (save_control | 0x80)); - save_freq_select = hclock_read(10); /* stop and reset prescaler */ - hclock_write (10, (save_freq_select | 0x70)); - - hclock_write_bcd(0, new_broken_time.tm_sec); - hclock_write_bcd(2, new_broken_time.tm_min); - hclock_write_bcd(4, new_broken_time.tm_hour); - hclock_write_bcd(6, new_broken_time.tm_wday + 3); - hclock_write_bcd(7, new_broken_time.tm_mday); - hclock_write_bcd(8, new_broken_time.tm_mon + 1); - hclock_write_bcd(9, new_broken_time.tm_year%100); - hclock_write_bcd(50, (1900+new_broken_time.tm_year)/100); - - /* The kernel sources, linux/arch/i386/kernel/time.c, have the - following comment: - - The following flags have to be released exactly in this order, - otherwise the DS12887 (popular MC146818A clone with integrated - battery and quartz) will not reset the oscillator and will not - update precisely 500 ms later. You won't find this mentioned - in the Dallas Semiconductor data sheets, but who believes data - sheets anyway ... -- Markus Kuhn - - Hence, they will also be done in this order here. - faith@cs.unc.edu, Thu Nov 9 08:26:37 1995 - */ - - hclock_write (11, save_control); - hclock_write (10, save_freq_select); -#ifdef __i386__ - if (interrupts_were_enabled) { - __asm__ volatile ("sti"); - interrupts_enabled = TRUE; - } -#endif - } -} - - -static void -set_hardware_clock(const enum clock_access_method method, - 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>. - - 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 (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 ISA: - set_hardware_clock_isa(new_broken_time, testing); - break; - case RTC_IOCTL: - set_hardware_clock_rtc_ioctl(new_broken_time, testing); - break; - case KD: - set_hardware_clock_kd(new_broken_time, testing); - break; - default: - fprintf(stderr, - "Internal error: invalid value for clock access method.\n"); - 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 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(clock_access, newtime, universal, testing); -} - - - -static void -get_epoch(unsigned long *epoch_p, int *retcode_p) { -/*---------------------------------------------------------------------------- - Get the Hardware Clock epoch setting from the kernel. -----------------------------------------------------------------------------*/ - int rtc_fd; - - rtc_fd = open("/dev/rtc", O_RDONLY); - if (rtc_fd < 0) { - if (errno == ENOENT) - fprintf(stderr, "To manipulate the epoch value in the kernel, we must " - "access the Linux 'rtc' device driver via the device special " - "file /dev/rtc. This file does not exist on this system.\n"); - else - fprintf(stderr, "Unable to open /dev/rtc, open() errno = %s (%d)\n", - strerror(errno), errno); - *retcode_p = 1; - } else { - int rc; /* return code from ioctl */ - rc = ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p); - if (rc == -1) { - fprintf(stderr, "ioctl(RTC_EPOCH_READ) to /dev/rtc failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 1; - } else { - *retcode_p = 0; - if (debug) printf("we have read epoch %ld from /dev/rtc " - "with RTC_EPOCH_READ ioctl.\n", *epoch_p); - } - close(rtc_fd); - } - return; -} - - - -static void -set_epoch(unsigned long epoch, const bool testing, int *retcode_p) { -/*---------------------------------------------------------------------------- - Set the Hardware Clock epoch in the kernel. -----------------------------------------------------------------------------*/ - if (epoch < 1900) - /* kernel would not accept this epoch value */ - fprintf(stderr, "The epoch value may not be less than 1900. " - "You requested %ld\n", epoch); - else { - int rtc_fd; - - rtc_fd = open("/dev/rtc", O_RDONLY); - if (rtc_fd < 0) { - if (errno == ENOENT) - fprintf(stderr, "To manipulate the epoch value in the kernel, we must " - "access the Linux 'rtc' device driver via the device special " - "file /dev/rtc. This file does not exist on this system.\n"); - fprintf(stderr, "Unable to open /dev/rtc, open() errno = %s (%d)\n", - strerror(errno), errno); - *retcode_p = 1; - } else { - if (debug) printf("setting epoch to %ld " - "with RTC_EPOCH_SET ioctl to /dev/rtc.\n", epoch); - if (testing) { - printf("Not setting epoch because running in test mode.\n"); - *retcode_p = 0; - } else { - int rc; /* return code from ioctl */ - rc = ioctl(rtc_fd, RTC_EPOCH_SET, epoch); - if (rc == -1) { - if (errno == EINVAL) - fprintf(stderr, "The kernel (specifically, the device driver " - "for /dev/rtc) does not have the RTC_EPOCH_SET ioctl. " - "Get a newer driver.\n"); - else - fprintf(stderr, "ioctl(RTC_EPOCH_SET) to /dev/rtc failed, " - "errno = %s (%d).\n", strerror(errno), errno); - *retcode_p = 1; - } else *retcode_p = 0; - } - close(rtc_fd); - } - } -} - - - -static void -display_time(const bool hclock_valid, const time_t systime, - const float sync_duration) { -/*---------------------------------------------------------------------------- - Put the time "systime" on standard output in display format. - Except if hclock_valid == false, just tell standard output that we don't - know what time it is. - - Include in the output the adjustment "sync_duration". ------------------------------------------------------------------------------*/ - if (!hclock_valid) - fprintf(stderr, "The Hardware Clock registers contain values that are " - "either invalid (e.g. 50th day of month) or beyond the range " - "we can handle (e.g. Year 2095).\n"); - else { - char *ctime_now; /* Address of static storage containing time string */ - - /* For some strange reason, ctime() is designed to include a newline - character at the end. We have to remove that. - */ - ctime_now = ctime(&systime); /* Compute display value for time */ - *(ctime_now+strlen(ctime_now)-1) = '\0'; /* Cut off trailing newline */ - - printf("%s %.6f seconds\n", ctime_now, -(sync_duration)); - } -} - - - -static int -interpret_date_string(const char *date_opt, time_t * const time_p) { -/*---------------------------------------------------------------------------- - Interpret the value of the --date option, which is something like - "13:05:01". In fact, it can be any of the myriad ASCII strings that specify - a time which the "date" program can understand. The date option value in - question is our "dateopt" argument. - - The specified time is in the local time zone. - - Our output, "*time_p", is a seconds-into-epoch time. - - We use the "date" program to interpret the date string. "date" must be - runnable by issuing the command "date" to the /bin/sh shell. That means - in must be in the current PATH. - - If anything goes wrong (and many things can), we return return code - 10 and arbitrary *time_p. Otherwise, return code is 0 and *time_p - is valid. -----------------------------------------------------------------------------*/ - FILE *date_child_fp; - char date_resp[100]; - const char magic[]="seconds-into-epoch="; - char date_command[100]; - int retcode; /* our eventual return code */ - int rc; /* local return code */ - - if (date_opt == NULL) { - fprintf(stderr, "No --date option specified.\n"); - retcode = 14; - } else if (strchr(date_opt, '"') != NULL) { - /* Quotation marks in date_opt would ruin the date command we construct. - */ - fprintf(stderr, "The value of the --date option is not a valid date.\n" - "In particular, it contains quotation marks.\n"); - retcode = 12; - } else { - sprintf(date_command, "date --date=\"%s\" +seconds-into-epoch=%%s", - date_opt); - if (debug) printf("Issuing date command: %s\n", date_command); - - date_child_fp = popen(date_command, "r"); - if (date_child_fp == NULL) { - fprintf(stderr, "Unable to run 'date' program in /bin/sh shell. " - "popen() failed with errno=%d:%s\n", errno, strerror(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, "The date command issued by " MYNAME " returned " - "unexpected results.\n" - "The command was:\n %s\nThe response was:\n %s\n", - 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 " 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", - date_command, date_resp); - retcode = 6; - } else { - retcode = 0; - *time_p = seconds_since_epoch; - if (debug) - printf("date string %s equates to %d seconds since 1969.\n", - date_opt, (int) *time_p); - } - } - fclose(date_child_fp); - } - } - return(retcode); -} - - - -static int -set_system_clock(const bool hclock_valid, const time_t newtime, - const bool testing) { -/*---------------------------------------------------------------------------- - Set the System Clock to time 'newtime'. - - Also set the kernel time zone value to the value indicated by the - TZ environment variable and/or /usr/lib/zoneinfo/, interpreted as - tzset() would interpret them. Except: do not consider Daylight - Savings Time to be a separate component of the time zone. Include - any effect of DST in the basic timezone value and set the kernel - DST value to 0. - - EXCEPT: if hclock_valid is false, just issue an error message - saying there is no valid time in the Hardware Clock to which to set - the system time. - - If 'testing' is true, don't actually update anything -- just say we - would have. ------------------------------------------------------------------------------*/ - int retcode; /* our eventual return code */ - - if (!hclock_valid) { - fprintf(stderr,"The Hardware Clock does not contain a valid time, so " - "we cannot set the System Time from it.\n"); - retcode = 1; - } else { - struct timeval tv; - int rc; /* local return code */ - - tv.tv_sec = newtime; - tv.tv_usec = 0; - - tzset(); /* init timezone, daylight from TZ or ...zoneinfo/localtime */ - /* An undocumented function of tzset() is to set global variabales - 'timezone' and 'daylight' - */ - - if (debug) { - printf( "Calling settimeofday:\n" ); - printf( "\ttv.tv_sec = %ld, tv.tv_usec = %ld\n", - (long) tv.tv_sec, (long) tv.tv_usec ); - } - if (testing) { - printf("Not setting system clock because running in test mode.\n"); - retcode = 0; - } else { - /* For documentation of settimeofday(), in addition to its man page, - see kernel/time.c in the Linux source code. - */ - const struct timezone tz = { timezone/60 - 60*daylight, 0 }; - /* put daylight in minuteswest rather than dsttime, - since the latter is mostly ignored ... */ - rc = settimeofday(&tv, &tz); - if (rc != 0) { - if (errno == EPERM) - fprintf(stderr, "Must be superuser to set system clock.\n"); - else - fprintf(stderr, - "settimeofday() failed, errno=%d:%s\n", - errno, strerror(errno)); - 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. ------------------------------------------------------------------------------*/ - FILE *adjfile; - char newfile[405]; /* Stuff to write to disk file */ - - int rc; /* locally used: return code from a function */ - - if (adjtime.dirty) { - /* snprintf is not always available, but this is safe - as long as libc does not use more than 100 positions for %ld or %f */ - sprintf(newfile, "%f %ld %f\n%ld\n", - adjtime.drift_factor, - (long) adjtime.last_adj_time, - adjtime.not_adjusted, - (long) adjtime.last_calib_time ); - - if (testing) { - printf("Not updating adjtime file because of testing mode.\n"); - printf("Would have written the following to %s:\n%s", - ADJPATH, newfile); - } else { - 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 with the clock adjustment parameters " - "(%s) 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 with the clock adjustment parameters " - "(%s) in it.\n" - "fclose() returned errno %d: %s.\n" - "Drift adjustment parameters not updated.\n", - ADJPATH, fclose_errno, strerror(errno)); - } - } - } - } -} - - - -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 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), - clock_access, 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, - 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. - Even if he did, we will not select the ISA method if this is not an - ISA machine. ------------------------------------------------------------------------------*/ - bool rtc_works; - /* The /dev/rtc method is available and seems to work on this machine */ - - if (got_rtc) { - int rtc_fd = open("/dev/rtc", O_RDONLY); - if (rtc_fd > 0) { - rtc_works = TRUE; - close(rtc_fd); - } else { - rtc_works = FALSE; - if (debug) - printf("Open of /dev/rtc failed, errno = %s (%d). " - "falling back to more primitive clock access method.\n", - strerror(errno), errno); - } - } else { - if (debug) - printf("The Linux kernel for which this copy of hwclock() was built " - "is too old to have /dev/rtc\n"); - rtc_works = FALSE; - } - - if (user_requests_ISA && isa_machine) *clock_access_p = ISA; - else if (rtc_works) *clock_access_p = RTC_IOCTL; - else if (got_kdghwclk) { - int con_fd; - struct hwclk_time t; - - con_fd = open("/dev/tty1", O_RDONLY); - if (con_fd >= 0) { - if (ioctl( con_fd, kdghwclk_ioctl, &t ) >= 0) - *clock_access_p = KD; - else { - if (errno == EINVAL) { - /* KDGHWCLK not implemented in this kernel... */ - *clock_access_p = ISA; - } else { - *clock_access_p = KD; - fprintf(stderr, - "KDGHWCLK ioctl failed, errno = %s (%d).\n", - strerror(errno), errno); - } - } - } else { - *clock_access_p = KD; - fprintf(stderr, - "Can't open /dev/tty1. open() errno = %s (%d).\n", - strerror(errno), errno); - } - close(con_fd); - } else if (isa_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; - default: - printf("determine_clock_access_method() returned invalid value: %d.\n", - *clock_access_p); - } - } -} - - - -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 universal, const bool testing, - int *retcode_p - ) { -/*--------------------------------------------------------------------------- - Do all the normal work of hwclock - read, set clock, etc. - - Issue output to stdout and error message to stderr where appropriate. - - Return rc == 0 if everything went OK, rc != 0 if not. -----------------------------------------------------------------------------*/ - struct adjtime adjtime; - /* Contents of the adjtime file, or what they should be. */ - int rc; /* local return code */ - bool no_auth; /* User lacks necessary authorization to access the clock */ - - if (clock_access == ISA) { - rc = i386_iopl(3); - if (rc != 0) { - fprintf(stderr, MYNAME " is unable to get I/O port access. " - "I.e. iopl(3) returned nonzero return code %d.\n" - "This is often because the program isn't running " - "with superuser privilege, which it needs.\n", - rc); - no_auth = TRUE; - } else no_auth = FALSE; - } else no_auth = FALSE; - - if (no_auth) *retcode_p = 1; - else { - if (adjust || set || systohc) - read_adjtime(&adjtime, &rc); - else { - /* A little trick to avoid reading the file if we don't have to */ - adjtime.dirty = FALSE; - rc = 0; - } - if (rc != 0) *retcode_p = 2; - else { - synchronize_to_clock_tick(clock_access, 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, 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, - clock_access, 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, clock_access, - 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, - clock_access, 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. - */ - - if (!alpha_machine) - 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; - int retcode; - - get_epoch(&epoch, &retcode); - if (retcode != 0) - printf("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 { - 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 universal, testing, directisa; - char *date_opt; - int epoch_opt; - - const optStruct option_def[] = { - { 'r', (char *) "show", OPT_FLAG, &show, 0 }, - { 0, (char *) "set", OPT_FLAG, &set, 0 }, - { 'w', (char *) "systohc", OPT_FLAG, &systohc, 0 }, - { 's', (char *) "hctosys", OPT_FLAG, &hctosys, 0 }, - { 0, (char *) "getepoch", OPT_FLAG, &getepoch, 0 }, - { 0, (char *) "setepoch", OPT_FLAG, &setepoch, 0 }, - { 'a', (char *) "adjust", OPT_FLAG, &adjust, 0 }, - { 'v', (char *) "version", OPT_FLAG, &version, 0 }, - { 0, (char *) "date", OPT_STRING, &date_opt, 0 }, - { 0, (char *) "epoch", OPT_UINT, &epoch_opt, 0 }, - { 'u', (char *) "utc", OPT_FLAG, &universal, 0 }, - { 0, (char *) "directisa", OPT_FLAG, &directisa, 0 }, - { 0, (char *) "test", OPT_FLAG, &testing, 0 }, - { 'D', (char *) "debug", OPT_FLAG, &debug, 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 */ - - interrupts_enabled = TRUE; /* 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 = universal = - directisa = testing = debug = FALSE; - date_opt = NULL; - epoch_opt = -1; - - argc_parse = argc; argv_parse = argv; - optParseOptions(&argc_parse, argv_parse, option_def, 0); - /* Uses and sets argc_parse, argv_parse. - Sets show, systohc, hctosys, adjust, universal, version, testing, - debug, set, date_opt, getepoch, setepoch, epoch_opt - */ - - if (argc_parse - 1 > 0) { - fprintf(stderr, MYNAME " takes no non-option arguments. " - "You supplied %d.\n", - argc_parse - 1); - exit(100); - } - - if (show + set + systohc + hctosys + adjust + - getepoch + setepoch + version > 1) { - fprintf(stderr, "You have specified multiple function options.\n" - "You can only perform one function at a time.\n"); - exit(100); - } - - 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 (directisa && !isa_machine) { - fprintf(stderr, "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, and this is not one!\n"); - exit(100); - } - - if (!(show | set | systohc | hctosys | adjust | getepoch | setepoch | - version)) - show = 1; /* default to show */ - - - if (getuid() == 0) permitted = TRUE; - else { - /* program is designed to run setuid (in some situations) -- be secure! */ - if (set || hctosys || systohc || adjust) { - fprintf(stderr, - "Sorry, only the superuser can change the Hardware Clock.\n"); - permitted = FALSE; - } else if (setepoch) { - fprintf(stderr, - "Sorry, only the superuser can change " - "the Hardware Clock epoch in the kernel.\n"); - permitted = FALSE; - } else permitted = TRUE; - } - - if (!permitted) retcode = 2; - else { - retcode = 0; - if (version) { - printf(MYNAME " " VERSION "/%s\n",util_linux_version); - } else if (getepoch || setepoch) { - manipulate_epoch(getepoch, setepoch, epoch_opt, testing); - } else { - determine_clock_access_method(directisa, &clock_access); - if (clock_access == NOCLOCK) - fprintf(stderr, "Cannot access the Hardware Clock via any known " - "method. Use --debug option to see the details of our " - "search for an access method.\n"); - else - manipulate_clock(show, adjust, set, set_time, hctosys, systohc, - startup_time, clock_access, universal, testing, &rc); - } - } - exit(retcode); -} - - -/**************************************************************************** - - 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. - - - 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. */ - - |