util-linux/hwclock.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini hwclock implementation for busybox
   4  *
   5  * Copyright (C) 2002 Robert Griebl <griebl@gmx.de>
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8 */
   9
  10 #include "libbb.h"
  11 /* After libbb.h, since it needs sys/types.h on some systems */
  12 #include <sys/utsname.h>
  13 #include "rtc_.h"
  14
  15 /* diff code is disabled: it's not sys/hw clock diff, it's some useless
  16  * "time between hwclock was started and we saw CMOS tick" quantity.
  17  * It's useless since hwclock is started at a random moment,
  18  * thus the quantity is also random, useless. Showing 0.000000 does not
  19  * deprive us from any useful info.
  20  *
  21  * SHOW_HWCLOCK_DIFF code in this file shows the difference between system
  22  * and hw clock. It is useful, but not compatible with standard hwclock.
  23  * Thus disabled.
  24  */
  25 #define SHOW_HWCLOCK_DIFF 0
  26
  27
  28 #if !SHOW_HWCLOCK_DIFF
  29 # define read_rtc(pp_rtcname, sys_tv, utc) read_rtc(pp_rtcname, utc)
  30 #endif
  31 static time_t read_rtc(const char **pp_rtcname, struct timeval *sys_tv, int utc)
  32 {
  33         struct tm tm_time;
  34         int fd;
  35
  36         fd = rtc_xopen(pp_rtcname, O_RDONLY);
  37
  38         rtc_read_tm(&tm_time, fd);
  39
  40 #if SHOW_HWCLOCK_DIFF
  41         {
  42                 int before = tm_time.tm_sec;
  43                 while (1) {
  44                         rtc_read_tm(&tm_time, fd);
  45                         gettimeofday(sys_tv, NULL);
  46                         if (before != (int)tm_time.tm_sec)
  47                                 break;
  48                 }
  49         }
  50 #endif
  51
  52         if (ENABLE_FEATURE_CLEAN_UP)
  53                 close(fd);
  54
  55         return rtc_tm2time(&tm_time, utc);
  56 }
  57
  58 static void show_clock(const char **pp_rtcname, int utc)
  59 {
  60 #if SHOW_HWCLOCK_DIFF
  61         struct timeval sys_tv;
  62 #endif
  63         time_t t = read_rtc(pp_rtcname, &sys_tv, utc);
  64
  65 #if ENABLE_LOCALE_SUPPORT
  66         /* Standard hwclock uses locale-specific output format */
  67         char cp[64];
  68         struct tm *ptm = localtime(&t);
  69         strftime(cp, sizeof(cp), "%c", ptm);
  70 #else
  71         char *cp = ctime(&t);
  72         chomp(cp);
  73 #endif
  74
  75 #if !SHOW_HWCLOCK_DIFF
  76         printf("%s  0.000000 seconds\n", cp);
  77 #else
  78         {
  79                 long diff = sys_tv.tv_sec - t;
  80                 if (diff < 0 /*&& tv.tv_usec != 0*/) {
  81                         /* Why we need diff++? */
  82                         /* diff >= 0 is ok: | diff < 0, can't just use tv.tv_usec: */
  83                         /*   45.520820      |   43.520820 */
  84                         /* - 44.000000      | - 45.000000 */
  85                         /* =  1.520820      | = -1.479180, not -2.520820! */
  86                         diff++;
  87                         /* Should be 1000000 - tv.tv_usec, but then we must check tv.tv_usec != 0 */
  88                         sys_tv.tv_usec = 999999 - sys_tv.tv_usec;
  89                 }
  90                 printf("%s  %ld.%06lu seconds\n", cp, diff, (unsigned long)sys_tv.tv_usec);
  91         }
  92 #endif
  93 }
  94
  95 static void to_sys_clock(const char **pp_rtcname, int utc)
  96 {
  97         struct timeval tv;
  98         struct timezone tz;
  99
 100         tz.tz_minuteswest = timezone/60;
 101         /* ^^^ used to also subtract 60*daylight, but it's wrong:
 102          * daylight!=0 means "this timezone has some DST
 103          * during the year", not "DST is in effect now".
 104          */
 105         tz.tz_dsttime = 0;
 106
 107         tv.tv_sec = read_rtc(pp_rtcname, NULL, utc);
 108         tv.tv_usec = 0;
 109         if (settimeofday(&tv, &tz))
 110                 bb_perror_msg_and_die("settimeofday");
 111 }
 112
 113 static void from_sys_clock(const char **pp_rtcname, int utc)
 114 {
 115 #if 1
 116         struct timeval tv;
 117         struct tm tm_time;
 118         int rtc;
 119
 120         rtc = rtc_xopen(pp_rtcname, O_WRONLY);
 121         gettimeofday(&tv, NULL);
 122         /* Prepare tm_time */
 123         if (sizeof(time_t) == sizeof(tv.tv_sec)) {
 124                 if (utc)
 125                         gmtime_r((time_t*)&tv.tv_sec, &tm_time);
 126                 else
 127                         localtime_r((time_t*)&tv.tv_sec, &tm_time);
 128         } else {
 129                 time_t t = tv.tv_sec;
 130                 if (utc)
 131                         gmtime_r(&t, &tm_time);
 132                 else
 133                         localtime_r(&t, &tm_time);
 134         }
 135 #else
 136 /* Bloated code which tries to set hw clock with better precision.
 137  * On x86, even though code does set hw clock within <1ms of exact
 138  * whole seconds, apparently hw clock (at least on some machines)
 139  * doesn't reset internal fractional seconds to 0,
 140  * making all this a pointless excercise.
 141  */
 142         /* If we see that we are N usec away from whole second,
 143          * we'll sleep for N-ADJ usecs. ADJ corrects for the fact
 144          * that CPU is not infinitely fast.
 145          * On infinitely fast CPU, next wakeup would be
 146          * on (exactly_next_whole_second - ADJ). On real CPUs,
 147          * this difference between current time and whole second
 148          * is less than ADJ (assuming system isn't heavily loaded).
 149          */
 150         /* Small value of 256us gives very precise sync for 2+ GHz CPUs.
 151          * Slower CPUs will fail to sync and will go to bigger
 152          * ADJ values. qemu-emulated armv4tl with ~100 MHz
 153          * performance ends up using ADJ ~= 4*1024 and it takes
 154          * 2+ secs (2 tries with successively larger ADJ)
 155          * to sync. Even straced one on the same qemu (very slow)
 156          * takes only 4 tries.
 157          */
 158 #define TWEAK_USEC 256
 159         unsigned adj = TWEAK_USEC;
 160         struct tm tm_time;
 161         struct timeval tv;
 162         int rtc = rtc_xopen(pp_rtcname, O_WRONLY);
 163
 164         /* Try to catch the moment when whole second is close */
 165         while (1) {
 166                 unsigned rem_usec;
 167                 time_t t;
 168
 169                 gettimeofday(&tv, NULL);
 170
 171                 t = tv.tv_sec;
 172                 rem_usec = 1000000 - tv.tv_usec;
 173                 if (rem_usec < adj) {
 174                         /* Close enough */
 175  small_rem:
 176                         t++;
 177                 }
 178
 179                 /* Prepare tm_time from t */
 180                 if (utc)
 181                         gmtime_r(&t, &tm_time); /* may read /etc/xxx (it takes time) */
 182                 else
 183                         localtime_r(&t, &tm_time); /* same */
 184
 185                 if (adj >= 32*1024) {
 186                         break; /* 32 ms diff and still no luck?? give up trying to sync */
 187                 }
 188
 189                 /* gmtime/localtime took some time, re-get cur time */
 190                 gettimeofday(&tv, NULL);
 191
 192                 if (tv.tv_sec < t /* we are still in old second */
 193                  || (tv.tv_sec == t && tv.tv_usec < adj) /* not too far into next second */
 194                 ) {
 195                         break; /* good, we are in sync! */
 196                 }
 197
 198                 rem_usec = 1000000 - tv.tv_usec;
 199                 if (rem_usec < adj) {
 200                         t = tv.tv_sec;
 201                         goto small_rem; /* already close to next sec, don't sleep */
 202                 }
 203
 204                 /* Try to sync up by sleeping */
 205                 usleep(rem_usec - adj);
 206
 207                 /* Jump to 1ms diff, then increase fast (x2): EVERY loop
 208                  * takes ~1 sec, people won't like slowly converging code here!
 209                  */
 210         //bb_error_msg("adj:%d tv.tv_usec:%d", adj, (int)tv.tv_usec);
 211                 if (adj < 512)
 212                         adj = 512;
 213                 /* ... and if last "overshoot" does not look insanely big,
 214                  * just use it as adj increment. This makes convergence faster.
 215                  */
 216                 if (tv.tv_usec < adj * 8) {
 217                         adj += tv.tv_usec;
 218                         continue;
 219                 }
 220                 adj *= 2;
 221         }
 222         /* Debug aid to find "optimal" TWEAK_USEC with nearly exact sync.
 223          * Look for a value which makes tv_usec close to 999999 or 0.
 224          * For 2.20GHz Intel Core 2: optimal TWEAK_USEC ~= 200
 225          */
 226         //bb_error_msg("tv.tv_usec:%d", (int)tv.tv_usec);
 227 #endif
 228
 229         tm_time.tm_isdst = 0;
 230         xioctl(rtc, RTC_SET_TIME, &tm_time);
 231
 232         if (ENABLE_FEATURE_CLEAN_UP)
 233                 close(rtc);
 234 }
 235
 236 /*
 237  * At system boot, kernel may set system time from RTC,
 238  * but it knows nothing about timezones. If RTC is in local time,
 239  * then system time is wrong - it is offset by timezone.
 240  * This option corrects system time if RTC is in local time,
 241  * and (always) sets in-kernel timezone.
 242  *
 243  * This is an alternate option to --hctosys that does not read the
 244  * hardware clock.
 245  */
 246 static void set_system_clock_timezone(int utc)
 247 {
 248         struct timeval tv;
 249         struct tm *broken;
 250         struct timezone tz;
 251
 252         gettimeofday(&tv, NULL);
 253         broken = localtime(&tv.tv_sec);
 254         tz.tz_minuteswest = timezone / 60;
 255         if (broken->tm_isdst > 0)
 256                 tz.tz_minuteswest -= 60;
 257         tz.tz_dsttime = 0;
 258         gettimeofday(&tv, NULL);
 259         if (!utc)
 260                 tv.tv_sec += tz.tz_minuteswest * 60;
 261         if (settimeofday(&tv, &tz))
 262                 bb_perror_msg_and_die("settimeofday");
 263 }
 264
 265 //usage:#define hwclock_trivial_usage
 266 //usage:        IF_FEATURE_HWCLOCK_LONG_OPTIONS(
 267 //usage:       "[-r|--show] [-s|--hctosys] [-w|--systohc] [-t|--systz]"
 268 //usage:       " [-l|--localtime] [-u|--utc]"
 269 //usage:       " [-f|--rtc FILE]"
 270 //usage:        )
 271 //usage:        IF_NOT_FEATURE_HWCLOCK_LONG_OPTIONS(
 272 //usage:       "[-r] [-s] [-w] [-t] [-l] [-u] [-f FILE]"
 273 //usage:        )
 274 //usage:#define hwclock_full_usage "\n\n"
 275 //usage:       "Query and set hardware clock (RTC)\n"
 276 //usage:     "\n        -r      Show hardware clock time"
 277 //usage:     "\n        -s      Set system time from hardware clock"
 278 //usage:     "\n        -w      Set hardware clock from system time"
 279 //usage:     "\n        -t      Set in-kernel timezone, correct system time"
 280 //usage:     "\n                if hardware clock is in local time"
 281 //usage:     "\n        -u      Assume hardware clock is kept in UTC"
 282 //usage:     "\n        -l      Assume hardware clock is kept in local time"
 283 //usage:     "\n        -f FILE Use specified device (e.g. /dev/rtc2)"
 284
 285 #define HWCLOCK_OPT_LOCALTIME   0x01
 286 #define HWCLOCK_OPT_UTC         0x02
 287 #define HWCLOCK_OPT_SHOW        0x04
 288 #define HWCLOCK_OPT_HCTOSYS     0x08
 289 #define HWCLOCK_OPT_SYSTOHC     0x10
 290 #define HWCLOCK_OPT_SYSTZ       0x20
 291 #define HWCLOCK_OPT_RTCFILE     0x40
 292
 293 int hwclock_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 294 int hwclock_main(int argc UNUSED_PARAM, char **argv)
 295 {
 296         const char *rtcname = NULL;
 297         unsigned opt;
 298         int utc;
 299
 300 #if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS
 301         static const char hwclock_longopts[] ALIGN1 =
 302                 "localtime\0" No_argument "l" /* short opt is non-standard */
 303                 "utc\0"       No_argument "u"
 304                 "show\0"      No_argument "r"
 305                 "hctosys\0"   No_argument "s"
 306                 "systohc\0"   No_argument "w"
 307                 "systz\0"     No_argument "t" /* short opt is non-standard */
 308                 "rtc\0"       Required_argument "f"
 309                 ;
 310         applet_long_options = hwclock_longopts;
 311 #endif
 312
 313         /* Initialize "timezone" (libc global variable) */
 314         tzset();
 315
 316         opt_complementary = "r--wst:w--rst:s--wrt:t--rsw:l--u:u--l";
 317         opt = getopt32(argv, "lurswtf:", &rtcname);
 318
 319         /* If -u or -l wasn't given check if we are using utc */
 320         if (opt & (HWCLOCK_OPT_UTC | HWCLOCK_OPT_LOCALTIME))
 321                 utc = (opt & HWCLOCK_OPT_UTC);
 322         else
 323                 utc = rtc_adjtime_is_utc();
 324
 325         if (opt & HWCLOCK_OPT_HCTOSYS)
 326                 to_sys_clock(&rtcname, utc);
 327         else if (opt & HWCLOCK_OPT_SYSTOHC)
 328                 from_sys_clock(&rtcname, utc);
 329         else if (opt & HWCLOCK_OPT_SYSTZ)
 330                 set_system_clock_timezone(utc);
 331         else
 332                 /* default HWCLOCK_OPT_SHOW */
 333                 show_clock(&rtcname, utc);
 334
 335         return 0;
 336 }