source: branches/3.2/mindi-busybox/util-linux/hwclock.c

Last change on this file was 3232, checked in by bruno, 5 years ago
  • Update mindi-busybox to 1.21.1
File size: 9.1 KB
Line 
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
31static 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
58static 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
95static 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
109static 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 */
242static 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
289int hwclock_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
290int 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}
Note: See TracBrowser for help on using the repository browser.