| /* vi: set sw=4 ts=4: */ |
| /* |
| * Mini hwclock implementation for busybox |
| * |
| * Copyright (C) 2002 Robert Griebl <griebl@gmx.de> |
| * |
| * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
| */ |
| //config:config HWCLOCK |
| //config: bool "hwclock (5.8 kb)" |
| //config: default y |
| //config: help |
| //config: The hwclock utility is used to read and set the hardware clock |
| //config: on a system. This is primarily used to set the current time on |
| //config: shutdown in the hardware clock, so the hardware will keep the |
| //config: correct time when Linux is _not_ running. |
| //config: |
| //config:config FEATURE_HWCLOCK_ADJTIME_FHS |
| //config: bool "Use FHS /var/lib/hwclock/adjtime" |
| //config: default n # util-linux-ng in Fedora 13 still uses /etc/adjtime |
| //config: depends on HWCLOCK |
| //config: help |
| //config: Starting with FHS 2.3, the adjtime state file is supposed to exist |
| //config: at /var/lib/hwclock/adjtime instead of /etc/adjtime. If you wish |
| //config: to use the FHS behavior, answer Y here, otherwise answer N for the |
| //config: classic /etc/adjtime path. |
| //config: |
| //config: pathname.com/fhs/pub/fhs-2.3.html#VARLIBHWCLOCKSTATEDIRECTORYFORHWCLO |
| |
| //applet:IF_HWCLOCK(APPLET(hwclock, BB_DIR_SBIN, BB_SUID_DROP)) |
| |
| //kbuild:lib-$(CONFIG_HWCLOCK) += hwclock.o |
| |
| #include "libbb.h" |
| /* After libbb.h, since it needs sys/types.h on some systems */ |
| #include <sys/utsname.h> |
| #include "rtc_.h" |
| |
| /* 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 |
| |
| |
| #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; |
| |
| fd = rtc_xopen(pp_rtcname, O_RDONLY); |
| |
| rtc_read_tm(&tm_time, fd); |
| |
| #if SHOW_HWCLOCK_DIFF |
| { |
| int before = tm_time.tm_sec; |
| while (1) { |
| rtc_read_tm(&tm_time, fd); |
| gettimeofday(sys_tv, NULL); |
| if (before != (int)tm_time.tm_sec) |
| break; |
| } |
| } |
| #endif |
| |
| if (ENABLE_FEATURE_CLEAN_UP) |
| close(fd); |
| |
| return rtc_tm2time(&tm_time, utc); |
| } |
| |
| static void show_clock(const char **pp_rtcname, int utc) |
| { |
| #if SHOW_HWCLOCK_DIFF |
| struct timeval sys_tv; |
| #endif |
| time_t t = read_rtc(pp_rtcname, &sys_tv, utc); |
| |
| #if ENABLE_LOCALE_SUPPORT |
| /* Standard hwclock uses locale-specific output format */ |
| char cp[64]; |
| struct tm *ptm = localtime(&t); |
| strftime(cp, sizeof(cp), "%c", ptm); |
| #else |
| char *cp = ctime(&t); |
| chomp(cp); |
| #endif |
| |
| #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 we need diff++? */ |
| /* 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 void to_sys_clock(const char **pp_rtcname, int utc) |
| { |
| struct timeval tv; |
| struct timezone tz; |
| |
| tz.tz_minuteswest = timezone / 60; |
| /* ^^^ used to also subtract 60*daylight, but it's wrong: |
| * daylight!=0 means "this timezone has some DST |
| * during the year", not "DST is in effect now". |
| */ |
| tz.tz_dsttime = 0; |
| |
| /* glibc v2.31+ returns an error if both args are non-NULL */ |
| if (settimeofday(NULL, &tz)) |
| bb_simple_perror_msg_and_die("settimeofday"); |
| |
| tv.tv_sec = read_rtc(pp_rtcname, NULL, utc); |
| tv.tv_usec = 0; |
| if (settimeofday(&tv, NULL)) |
| bb_simple_perror_msg_and_die("settimeofday"); |
| } |
| |
| static void from_sys_clock(const char **pp_rtcname, int utc) |
| { |
| #if 1 |
| struct timeval tv; |
| struct tm tm_time; |
| int rtc; |
| |
| 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 |
| /* 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 exercise. |
| */ |
| /* 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 (adj >= 32*1024) { |
| break; /* 32 ms diff and still no luck?? give up trying to sync */ |
| } |
| |
| /* gmtime/localtime took some time, re-get cur time */ |
| gettimeofday(&tv, NULL); |
| |
| 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! */ |
| } |
| |
| 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 */ |
| } |
| |
| /* 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; |
| } |
| adj *= 2; |
| } |
| /* 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); |
| } |
| |
| /* |
| * At system boot, kernel may set system time from RTC, |
| * but it knows nothing about timezones. If RTC is in local time, |
| * then system time is wrong - it is offset by timezone. |
| * This option corrects system time if RTC is in local time, |
| * and (always) sets in-kernel timezone. |
| * |
| * This is an alternate option to --hctosys that does not read the |
| * hardware clock. |
| */ |
| static void set_system_clock_timezone(int utc) |
| { |
| struct timeval tv; |
| struct tm *broken; |
| struct timezone tz; |
| |
| gettimeofday(&tv, NULL); |
| broken = localtime(&tv.tv_sec); |
| tz.tz_minuteswest = timezone / 60; |
| if (broken->tm_isdst > 0) |
| tz.tz_minuteswest -= 60; |
| tz.tz_dsttime = 0; |
| gettimeofday(&tv, NULL); |
| if (!utc) |
| tv.tv_sec += tz.tz_minuteswest * 60; |
| |
| /* glibc v2.31+ returns an error if both args are non-NULL */ |
| if (settimeofday(NULL, &tz)) |
| bb_simple_perror_msg_and_die("settimeofday"); |
| if (settimeofday(&tv, NULL)) |
| bb_simple_perror_msg_and_die("settimeofday"); |
| } |
| |
| //usage:#define hwclock_trivial_usage |
| //usage: IF_LONG_OPTS( |
| //usage: "[-swu] [--systz] [--localtime] [-f FILE]" |
| //usage: ) |
| //usage: IF_NOT_LONG_OPTS( |
| //usage: "[-swtlu] [-f FILE]" |
| //usage: ) |
| //usage:#define hwclock_full_usage "\n\n" |
| //usage: "Show or set hardware clock (RTC)\n" |
| ///////: "\n -r Show hardware clock time" |
| ///////-r is default, don't bother showing it in help |
| //usage: "\n -s Set system time from hardware clock" |
| //usage: "\n -w Set hardware clock from system time" |
| //usage: IF_LONG_OPTS( |
| //usage: "\n --systz Set in-kernel timezone, correct system time" |
| //usage: ) |
| //usage: "\n if hardware clock is in local time" |
| //usage: "\n -u Assume hardware clock is kept in UTC" |
| //usage: IF_LONG_OPTS( |
| //usage: "\n --localtime Assume hardware clock is kept in local time" |
| //usage: ) |
| //usage: "\n -f FILE Use specified device (e.g. /dev/rtc2)" |
| |
| //TODO: get rid of incompatible -t and -l aliases to --systz and --localtime |
| |
| #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_SYSTZ 0x20 |
| #define HWCLOCK_OPT_RTCFILE 0x40 |
| |
| int hwclock_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
| int hwclock_main(int argc UNUSED_PARAM, char **argv) |
| { |
| const char *rtcname = NULL; |
| unsigned opt; |
| int utc; |
| |
| #if ENABLE_LONG_OPTS |
| static const char hwclock_longopts[] ALIGN1 = |
| "localtime\0" No_argument "l" /* short opt is non-standard */ |
| "utc\0" No_argument "u" |
| "show\0" No_argument "r" |
| "hctosys\0" No_argument "s" |
| "systohc\0" No_argument "w" |
| "systz\0" No_argument "t" /* short opt is non-standard */ |
| "rtc\0" Required_argument "f" |
| ; |
| #endif |
| |
| /* Initialize "timezone" (libc global variable) */ |
| tzset(); |
| |
| opt = getopt32long(argv, |
| "^lurswtf:" "\0" "r--wst:w--rst:s--wrt:t--rsw:l--u:u--l", |
| hwclock_longopts, |
| &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); |
| else |
| utc = rtc_adjtime_is_utc(); |
| |
| if (opt & HWCLOCK_OPT_HCTOSYS) |
| to_sys_clock(&rtcname, utc); |
| else if (opt & HWCLOCK_OPT_SYSTOHC) |
| from_sys_clock(&rtcname, utc); |
| else if (opt & HWCLOCK_OPT_SYSTZ) |
| set_system_clock_timezone(utc); |
| else |
| /* default HWCLOCK_OPT_SHOW */ |
| show_clock(&rtcname, utc); |
| |
| return 0; |
| } |