X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=util-linux%2Fhwclock.c;h=416271b31561e78118d3dd4985d574e9bdb1eb23;hb=dc1fd2e52aa7d24fd609399e94b78c8c4dd79229;hp=5b990df0cb6b15f7b66165f89936d84ceb549178;hpb=f704b27b5bb8bd5acaed9464714db34ccef06cc8;p=oweals%2Fbusybox.git diff --git a/util-linux/hwclock.c b/util-linux/hwclock.c index 5b990df0c..416271b31 100644 --- a/util-linux/hwclock.c +++ b/util-linux/hwclock.c @@ -4,227 +4,273 @@ * * Copyright (C) 2002 Robert Griebl * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. */ - -#include -#include +#include "libbb.h" +/* After libbb.h, since it needs sys/types.h on some systems */ #include -#include -#include -#include -#include -#include -#include -#include -#include -#include "busybox.h" - -/* Copied from linux/rtc.h to eliminate the kernel dependency */ -struct linux_rtc_time { - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; -}; - -#define RTC_SET_TIME _IOW('p', 0x0a, struct linux_rtc_time) /* Set RTC time */ -#define RTC_RD_TIME _IOR('p', 0x09, struct linux_rtc_time) /* Read RTC time */ - -#ifdef CONFIG_FEATURE_HWCLOCK_LONGOPTIONS +#include "rtc_.h" + +#if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS # ifndef _GNU_SOURCE # define _GNU_SOURCE # endif #endif -static time_t read_rtc(int utc) -{ - int rtc; - struct tm tm; - char *oldtz = 0; - time_t t = 0; - if (( rtc = open ( "/dev/rtc", O_RDONLY )) < 0 ) { - if (( rtc = open ( "/dev/misc/rtc", O_RDONLY )) < 0 ) - bb_perror_msg_and_die ( "Could not access RTC" ); - } - memset ( &tm, 0, sizeof( struct tm )); - if ( ioctl ( rtc, RTC_RD_TIME, &tm ) < 0 ) - bb_perror_msg_and_die ( "Could not read time from RTC" ); - tm. tm_isdst = -1; // not known +/* diff code is disabled: it's not sys/hw clock diff, it's some useless + * "time between hwclock was started and we saw CMOS tick" quantity. + * It's useless since hwclock is started at a random moment, + * thus the quantity is also random, useless. Showing 0.000000 does not + * deprive us from any useful info. + * + * SHOW_HWCLOCK_DIFF code in this file shows the difference between system + * and hw clock. It is useful, but not compatible with standard hwclock. + * Thus disabled. + */ +#define SHOW_HWCLOCK_DIFF 0 - close ( rtc ); - if ( utc ) { - oldtz = getenv ( "TZ" ); - setenv ( "TZ", "UTC 0", 1 ); - tzset ( ); - } +#if !SHOW_HWCLOCK_DIFF +# define read_rtc(pp_rtcname, sys_tv, utc) read_rtc(pp_rtcname, utc) +#endif +static time_t read_rtc(const char **pp_rtcname, struct timeval *sys_tv, int utc) +{ + struct tm tm_time; + int fd; - t = mktime ( &tm ); + fd = rtc_xopen(pp_rtcname, O_RDONLY); - if ( utc ) { - if ( oldtz ) - setenv ( "TZ", oldtz, 1 ); - else - unsetenv ( "TZ" ); - tzset ( ); - } - return t; -} + rtc_read_tm(&tm_time, fd); -static void write_rtc(time_t t, int utc) -{ - int rtc; - struct tm tm; - - if (( rtc = open ( "/dev/rtc", O_WRONLY )) < 0 ) { - if (( rtc = open ( "/dev/misc/rtc", O_WRONLY )) < 0 ) - bb_perror_msg_and_die ( "Could not access RTC" ); +#if SHOW_HWCLOCK_DIFF + { + int before = tm_time.tm_sec; + while (1) { + rtc_read_tm(&tm_time, fd); + gettimeofday(sys_tv, NULL); + if (before != tm_time.tm_sec) + break; + } } +#endif - tm = *( utc ? gmtime ( &t ) : localtime ( &t )); - tm. tm_isdst = 0; - - if ( ioctl ( rtc, RTC_SET_TIME, &tm ) < 0 ) - bb_perror_msg_and_die ( "Could not set the RTC time" ); + if (ENABLE_FEATURE_CLEAN_UP) + close(fd); - close ( rtc ); + return rtc_tm2time(&tm_time, utc); } -static int show_clock(int utc) +static void show_clock(const char **pp_rtcname, int utc) { - struct tm *ptm; +#if SHOW_HWCLOCK_DIFF + struct timeval sys_tv; +#endif time_t t; - char buffer [64]; - - t = read_rtc ( utc ); - ptm = localtime ( &t ); /* Sets 'tzname[]' */ + char *cp; - safe_strncpy ( buffer, ctime ( &t ), sizeof( buffer )); - if ( buffer [0] ) - buffer [bb_strlen ( buffer ) - 1] = 0; - - //printf ( "%s %.6f seconds %s\n", buffer, 0.0, utc ? "" : ( ptm-> tm_isdst ? tzname [1] : tzname [0] )); - printf ( "%s %.6f seconds\n", buffer, 0.0 ); - - return 0; + t = read_rtc(pp_rtcname, &sys_tv, utc); + cp = ctime(&t); + strchrnul(cp, '\n')[0] = '\0'; +#if !SHOW_HWCLOCK_DIFF + printf("%s 0.000000 seconds\n", cp); +#else + { + long diff = sys_tv.tv_sec - t; + if (diff < 0 /*&& tv.tv_usec != 0*/) { + /* Why? */ + /* diff >= 0 is ok: diff < 0, can't just use tv.tv_usec: */ + /* 45.520820 43.520820 */ + /* - 44.000000 - 45.000000 */ + /* = 1.520820 = -1.479180, not -2.520820! */ + diff++; + /* should be 1000000 - tv.tv_usec, but then we must check tv.tv_usec != 0 */ + sys_tv.tv_usec = 999999 - sys_tv.tv_usec; + } + printf("%s %ld.%06lu seconds\n", cp, diff, (unsigned long)sys_tv.tv_usec); + } +#endif } -static int to_sys_clock(int utc) +static void to_sys_clock(const char **pp_rtcname, int utc) { - struct timeval tv = { 0, 0 }; - const struct timezone tz = { timezone/60 - 60*daylight, 0 }; + struct timeval tv; + struct timezone tz; - tv. tv_sec = read_rtc ( utc ); + tz.tz_minuteswest = timezone/60 - 60*daylight; + tz.tz_dsttime = 0; - if ( settimeofday ( &tv, &tz )) - bb_perror_msg_and_die ( "settimeofday() failed" ); - - return 0; + tv.tv_sec = read_rtc(pp_rtcname, NULL, utc); + tv.tv_usec = 0; + if (settimeofday(&tv, &tz)) + bb_perror_msg_and_die("settimeofday"); } -static int from_sys_clock(int utc) +static void from_sys_clock(const char **pp_rtcname, int utc) { - struct timeval tv = { 0, 0 }; - struct timezone tz = { 0, 0 }; - - if ( gettimeofday ( &tv, &tz )) - bb_perror_msg_and_die ( "gettimeofday() failed" ); - - write_rtc ( tv. tv_sec, utc ); - return 0; -} +#if 1 + struct timeval tv; + struct tm tm_time; + int rtc; -#ifdef CONFIG_FEATURE_HWCLOCK_ADJTIME_FHS -# define ADJTIME_PATH "/var/lib/hwclock/adjtime" + rtc = rtc_xopen(pp_rtcname, O_WRONLY); + gettimeofday(&tv, NULL); + /* Prepare tm_time */ + if (sizeof(time_t) == sizeof(tv.tv_sec)) { + if (utc) + gmtime_r((time_t*)&tv.tv_sec, &tm_time); + else + localtime_r((time_t*)&tv.tv_sec, &tm_time); + } else { + time_t t = tv.tv_sec; + if (utc) + gmtime_r(&t, &tm_time); + else + localtime_r(&t, &tm_time); + } #else -# define ADJTIME_PATH "/etc/adjtime" -#endif -static int check_utc(void) -{ - int utc = 0; - FILE *f = fopen ( ADJTIME_PATH, "r" ); +/* Bloated code which tries to set hw clock with better precision. + * On x86, even though code does set hw clock within <1ms of exact + * whole seconds, apparently hw clock (at least on some machines) + * doesn't reset internal fractional seconds to 0, + * making all this a pointless excercise. + */ + /* If we see that we are N usec away from whole second, + * we'll sleep for N-ADJ usecs. ADJ corrects for the fact + * that CPU is not infinitely fast. + * On infinitely fast CPU, next wakeup would be + * on (exactly_next_whole_second - ADJ). On real CPUs, + * this difference between current time and whole second + * is less than ADJ (assuming system isn't heavily loaded). + */ + /* Small value of 256us gives very precise sync for 2+ GHz CPUs. + * Slower CPUs will fail to sync and will go to bigger + * ADJ values. qemu-emulated armv4tl with ~100 MHz + * performance ends up using ADJ ~= 4*1024 and it takes + * 2+ secs (2 tries with successively larger ADJ) + * to sync. Even straced one on the same qemu (very slow) + * takes only 4 tries. + */ +#define TWEAK_USEC 256 + unsigned adj = TWEAK_USEC; + struct tm tm_time; + struct timeval tv; + int rtc = rtc_xopen(pp_rtcname, O_WRONLY); + + /* Try to catch the moment when whole second is close */ + while (1) { + unsigned rem_usec; + time_t t; + + gettimeofday(&tv, NULL); + + t = tv.tv_sec; + rem_usec = 1000000 - tv.tv_usec; + if (rem_usec < adj) { + /* Close enough */ + small_rem: + t++; + } + + /* Prepare tm_time from t */ + if (utc) + gmtime_r(&t, &tm_time); /* may read /etc/xxx (it takes time) */ + else + localtime_r(&t, &tm_time); /* same */ - if ( f ) { - char buffer [128]; + if (adj >= 32*1024) { + break; /* 32 ms diff and still no luck?? give up trying to sync */ + } - while ( fgets ( buffer, sizeof( buffer ), f )) { - int len = bb_strlen ( buffer ); + /* gmtime/localtime took some time, re-get cur time */ + gettimeofday(&tv, NULL); - while ( len && isspace ( buffer [len - 1] )) - len--; + if (tv.tv_sec < t /* we are still in old second */ + || (tv.tv_sec == t && tv.tv_usec < adj) /* not too far into next second */ + ) { + break; /* good, we are in sync! */ + } - buffer [len] = 0; + rem_usec = 1000000 - tv.tv_usec; + if (rem_usec < adj) { + t = tv.tv_sec; + goto small_rem; /* already close to next sec, don't sleep */ + } - if ( strncmp ( buffer, "UTC", 3 ) == 0 ) { - utc = 1; - break; - } + /* Try to sync up by sleeping */ + usleep(rem_usec - adj); + + /* Jump to 1ms diff, then increase fast (x2): EVERY loop + * takes ~1 sec, people won't like slowly converging code here! + */ + //bb_error_msg("adj:%d tv.tv_usec:%d", adj, (int)tv.tv_usec); + if (adj < 512) + adj = 512; + /* ... and if last "overshoot" does not look insanely big, + * just use it as adj increment. This makes convergence faster. + */ + if (tv.tv_usec < adj * 8) { + adj += tv.tv_usec; + continue; } - fclose ( f ); + adj *= 2; } - return utc; + /* Debug aid to find "optimal" TWEAK_USEC with nearly exact sync. + * Look for a value which makes tv_usec close to 999999 or 0. + * For 2.20GHz Intel Core 2: optimal TWEAK_USEC ~= 200 + */ + //bb_error_msg("tv.tv_usec:%d", (int)tv.tv_usec); +#endif + + tm_time.tm_isdst = 0; + xioctl(rtc, RTC_SET_TIME, &tm_time); + + if (ENABLE_FEATURE_CLEAN_UP) + close(rtc); } -#define HWCLOCK_OPT_LOCALTIME 0x01 -#define HWCLOCK_OPT_UTC 0x02 -#define HWCLOCK_OPT_SHOW 0x04 -#define HWCLOCK_OPT_HCTOSYS 0x08 -#define HWCLOCK_OPT_SYSTOHC 0x10 +#define HWCLOCK_OPT_LOCALTIME 0x01 +#define HWCLOCK_OPT_UTC 0x02 +#define HWCLOCK_OPT_SHOW 0x04 +#define HWCLOCK_OPT_HCTOSYS 0x08 +#define HWCLOCK_OPT_SYSTOHC 0x10 +#define HWCLOCK_OPT_RTCFILE 0x20 -extern int hwclock_main ( int argc, char **argv ) +int hwclock_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int hwclock_main(int argc UNUSED_PARAM, char **argv) { - unsigned long opt; + const char *rtcname = NULL; + unsigned opt; int utc; -#ifdef CONFIG_FEATURE_HWCLOCK_LONGOPTIONS -static const struct option hwclock_long_options[] = { - { "localtime", 0, 0, 'l' }, - { "utc", 0, 0, 'u' }, - { "show", 0, 0, 'r' }, - { "hctosys", 0, 0, 's' }, - { "systohc", 0, 0, 'w' }, - { 0, 0, 0, 0 } - }; - bb_applet_long_options = hwclock_long_options; +#if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS + static const char hwclock_longopts[] ALIGN1 = + "localtime\0" No_argument "l" + "utc\0" No_argument "u" + "show\0" No_argument "r" + "hctosys\0" No_argument "s" + "systohc\0" No_argument "w" + "file\0" Required_argument "f" + ; + applet_long_options = hwclock_longopts; #endif - - bb_opt_complementally = "?:r--ws:w--rs:s--wr:l--u:u--l"; - opt = bb_getopt_ulflags(argc, argv, "lursw"); + opt_complementary = "r--ws:w--rs:s--wr:l--u:u--l"; + opt = getopt32(argv, "lurswf:", &rtcname); /* If -u or -l wasn't given check if we are using utc */ if (opt & (HWCLOCK_OPT_UTC | HWCLOCK_OPT_LOCALTIME)) - utc = opt & HWCLOCK_OPT_UTC; + utc = (opt & HWCLOCK_OPT_UTC); else - utc = check_utc(); + utc = rtc_adjtime_is_utc(); - if (opt & HWCLOCK_OPT_HCTOSYS) { - return to_sys_clock ( utc ); - } - else if (opt & HWCLOCK_OPT_SYSTOHC) { - return from_sys_clock ( utc ); - } else { + if (opt & HWCLOCK_OPT_HCTOSYS) + to_sys_clock(&rtcname, utc); + else if (opt & HWCLOCK_OPT_SYSTOHC) + from_sys_clock(&rtcname, utc); + else /* default HWCLOCK_OPT_SHOW */ - return show_clock ( utc ); - } + show_clock(&rtcname, utc); + + return 0; }