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         strchrnul(cp, '\n')[0] = '\0';
  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 - 60*daylight;
 101         tz.tz_dsttime = 0;
 102
 103         tv.tv_sec = read_rtc(pp_rtcname, NULL, utc);
 104         tv.tv_usec = 0;
 105         if (settimeofday(&tv, &tz))
 106                 bb_perror_msg_and_die("settimeofday");
 107 }
 108
 109 static void from_sys_clock(const char **pp_rtcname, int utc)
 110 {
 111 #if 1
 112         struct timeval tv;
 113         struct tm tm_time;
 114         int rtc;
 115
 116         rtc = rtc_xopen(pp_rtcname, O_WRONLY);
 117         gettimeofday(&tv, NULL);
 118         /* Prepare tm_time */
 119         if (sizeof(time_t) == sizeof(tv.tv_sec)) {
 120                 if (utc)
 121                         gmtime_r((time_t*)&tv.tv_sec, &tm_time);
 122                 else
 123                         localtime_r((time_t*)&tv.tv_sec, &tm_time);
 124         } else {
 125                 time_t t = tv.tv_sec;
 126                 if (utc)
 127                         gmtime_r(&t, &tm_time);
 128                 else
 129                         localtime_r(&t, &tm_time);
 130         }
 131 #else
 132 /* Bloated code which tries to set hw clock with better precision.
 133  * On x86, even though code does set hw clock within <1ms of exact
 134  * whole seconds, apparently hw clock (at least on some machines)
 135  * doesn't reset internal fractional seconds to 0,
 136  * making all this a pointless excercise.
 137  */
 138         /* If we see that we are N usec away from whole second,
 139          * we'll sleep for N-ADJ usecs. ADJ corrects for the fact
 140          * that CPU is not infinitely fast.
 141          * On infinitely fast CPU, next wakeup would be
 142          * on (exactly_next_whole_second - ADJ). On real CPUs,
 143          * this difference between current time and whole second
 144          * is less than ADJ (assuming system isn't heavily loaded).
 145          */
 146         /* Small value of 256us gives very precise sync for 2+ GHz CPUs.
 147          * Slower CPUs will fail to sync and will go to bigger
 148          * ADJ values. qemu-emulated armv4tl with ~100 MHz
 149          * performance ends up using ADJ ~= 4*1024 and it takes
 150          * 2+ secs (2 tries with successively larger ADJ)
 151          * to sync. Even straced one on the same qemu (very slow)
 152          * takes only 4 tries.
 153          */
 154 #define TWEAK_USEC 256
 155         unsigned adj = TWEAK_USEC;
 156         struct tm tm_time;
 157         struct timeval tv;
 158         int rtc = rtc_xopen(pp_rtcname, O_WRONLY);
 159
 160         /* Try to catch the moment when whole second is close */
 161         while (1) {
 162                 unsigned rem_usec;
 163                 time_t t;
 164
 165                 gettimeofday(&tv, NULL);
 166
 167                 t = tv.tv_sec;
 168                 rem_usec = 1000000 - tv.tv_usec;
 169                 if (rem_usec < adj) {
 170                         /* Close enough */
 171  small_rem:
 172                         t++;
 173                 }
 174
 175                 /* Prepare tm_time from t */
 176                 if (utc)
 177                         gmtime_r(&t, &tm_time); /* may read /etc/xxx (it takes time) */
 178                 else
 179                         localtime_r(&t, &tm_time); /* same */
 180
 181                 if (adj >= 32*1024) {
 182                         break; /* 32 ms diff and still no luck?? give up trying to sync */
 183                 }
 184
 185                 /* gmtime/localtime took some time, re-get cur time */
 186                 gettimeofday(&tv, NULL);
 187
 188                 if (tv.tv_sec < t /* we are still in old second */
 189                  || (tv.tv_sec == t && tv.tv_usec < adj) /* not too far into next second */
 190                 ) {
 191                         break; /* good, we are in sync! */
 192                 }
 193
 194                 rem_usec = 1000000 - tv.tv_usec;
 195                 if (rem_usec < adj) {
 196                         t = tv.tv_sec;
 197                         goto small_rem; /* already close to next sec, don't sleep */
 198                 }
 199
 200                 /* Try to sync up by sleeping */
 201                 usleep(rem_usec - adj);
 202
 203                 /* Jump to 1ms diff, then increase fast (x2): EVERY loop
 204                  * takes ~1 sec, people won't like slowly converging code here!
 205                  */
 206         //bb_error_msg("adj:%d tv.tv_usec:%d", adj, (int)tv.tv_usec);
 207                 if (adj < 512)
 208                         adj = 512;
 209                 /* ... and if last "overshoot" does not look insanely big,
 210                  * just use it as adj increment. This makes convergence faster.
 211                  */
 212                 if (tv.tv_usec < adj * 8) {
 213                         adj += tv.tv_usec;
 214                         continue;
 215                 }
 216                 adj *= 2;
 217         }
 218         /* Debug aid to find "optimal" TWEAK_USEC with nearly exact sync.
 219          * Look for a value which makes tv_usec close to 999999 or 0.
 220          * For 2.20GHz Intel Core 2: optimal TWEAK_USEC ~= 200
 221          */
 222         //bb_error_msg("tv.tv_usec:%d", (int)tv.tv_usec);
 223 #endif
 224
 225         tm_time.tm_isdst = 0;
 226         xioctl(rtc, RTC_SET_TIME, &tm_time);
 227
 228         if (ENABLE_FEATURE_CLEAN_UP)
 229                 close(rtc);
 230 }
 231
 232 /*
 233  * At system boot, kernel may set system time from RTC,
 234  * but it knows nothing about timezones. If RTC is in local time,
 235  * then system time is wrong - it is offset by timezone.
 236  * This option corrects system time if RTC is in local time,
 237  * and (always) sets in-kernel timezone.
 238  *
 239  * This is an alternate option to --hctosys that does not read the
 240  * hardware clock.
 241  */
 242 static void set_system_clock_timezone(int utc)
 243 {
 244         struct timeval tv;
 245         struct tm *broken;
 246         struct timezone tz;
 247
 248         gettimeofday(&tv, NULL);
 249         broken = localtime(&tv.tv_sec);
 250         tz.tz_minuteswest = timezone / 60;
 251         if (broken->tm_isdst)
 252                 tz.tz_minuteswest -= 60;
 253         tz.tz_dsttime = 0;
 254         gettimeofday(&tv, NULL);
 255         if (!utc)
 256                 tv.tv_sec += tz.tz_minuteswest * 60;
 257         if (settimeofday(&tv, &tz))
 258                 bb_perror_msg_and_die("settimeofday");
 259 }
 260
 261 //usage:#define hwclock_trivial_usage
 262 //usage:        IF_FEATURE_HWCLOCK_LONG_OPTIONS(
 263 //usage:       "[-r|--show] [-s|--hctosys] [-w|--systohc] [-t|--systz]"
 264 //usage:       " [-l|--localtime] [-u|--utc]"
 265 //usage:       " [-f|--rtc FILE]"
 266 //usage:        )
 267 //usage:        IF_NOT_FEATURE_HWCLOCK_LONG_OPTIONS(
 268 //usage:       "[-r] [-s] [-w] [-t] [-l] [-u] [-f FILE]"
 269 //usage:        )
 270 //usage:#define hwclock_full_usage "\n\n"
 271 //usage:       "Query and set hardware clock (RTC)\n"
 272 //usage:     "\n        -r      Show hardware clock time"
 273 //usage:     "\n        -s      Set system time from hardware clock"
 274 //usage:     "\n        -w      Set hardware clock from system time"
 275 //usage:     "\n        -t      Set in-kernel timezone, correct system time"
 276 //usage:     "\n                if hardware clock is in local time"
 277 //usage:     "\n        -u      Assume hardware clock is kept in UTC"
 278 //usage:     "\n        -l      Assume hardware clock is kept in local time"
 279 //usage:     "\n        -f FILE Use specified device (e.g. /dev/rtc2)"
 280
 281 #define HWCLOCK_OPT_LOCALTIME   0x01
 282 #define HWCLOCK_OPT_UTC         0x02
 283 #define HWCLOCK_OPT_SHOW        0x04
 284 #define HWCLOCK_OPT_HCTOSYS     0x08
 285 #define HWCLOCK_OPT_SYSTOHC     0x10
 286 #define HWCLOCK_OPT_SYSTZ       0x20
 287 #define HWCLOCK_OPT_RTCFILE     0x40
 288
 289 int hwclock_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 290 int hwclock_main(int argc UNUSED_PARAM, char **argv)
 291 {
 292         const char *rtcname = NULL;
 293         unsigned opt;
 294         int utc;
 295
 296 #if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS
 297         static const char hwclock_longopts[] ALIGN1 =
 298                 "localtime\0" No_argument "l" /* short opt is non-standard */
 299                 "utc\0"       No_argument "u"
 300                 "show\0"      No_argument "r"
 301                 "hctosys\0"   No_argument "s"
 302                 "systohc\0"   No_argument "w"
 303                 "systz\0"     No_argument "t" /* short opt is non-standard */
 304                 "rtc\0"       Required_argument "f"
 305                 ;
 306         applet_long_options = hwclock_longopts;
 307 #endif
 308         opt_complementary = "r--wst:w--rst:s--wrt:t--rsw:l--u:u--l";
 309         opt = getopt32(argv, "lurswtf:", &rtcname);
 310
 311         /* If -u or -l wasn't given check if we are using utc */
 312         if (opt & (HWCLOCK_OPT_UTC | HWCLOCK_OPT_LOCALTIME))
 313                 utc = (opt & HWCLOCK_OPT_UTC);
 314         else
 315                 utc = rtc_adjtime_is_utc();
 316
 317         if (opt & HWCLOCK_OPT_HCTOSYS)
 318                 to_sys_clock(&rtcname, utc);
 319         else if (opt & HWCLOCK_OPT_SYSTOHC)
 320                 from_sys_clock(&rtcname, utc);
 321         else if (opt & HWCLOCK_OPT_SYSTZ)
 322                 set_system_clock_timezone(utc);
 323         else
 324                 /* default HWCLOCK_OPT_SHOW */
 325                 show_clock(&rtcname, utc);
 326
 327         return 0;
 328 }