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 != 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;
|
---|
64 | char *cp;
|
---|
65 |
|
---|
66 | t = read_rtc(pp_rtcname, &sys_tv, utc);
|
---|
67 | cp = ctime(&t);
|
---|
68 | strchrnul(cp, '\n')[0] = '\0';
|
---|
69 | #if !SHOW_HWCLOCK_DIFF
|
---|
70 | printf("%s 0.000000 seconds\n", cp);
|
---|
71 | #else
|
---|
72 | {
|
---|
73 | long diff = sys_tv.tv_sec - t;
|
---|
74 | if (diff < 0 /*&& tv.tv_usec != 0*/) {
|
---|
75 | /* Why? */
|
---|
76 | /* diff >= 0 is ok: diff < 0, can't just use tv.tv_usec: */
|
---|
77 | /* 45.520820 43.520820 */
|
---|
78 | /* - 44.000000 - 45.000000 */
|
---|
79 | /* = 1.520820 = -1.479180, not -2.520820! */
|
---|
80 | diff++;
|
---|
81 | /* should be 1000000 - tv.tv_usec, but then we must check tv.tv_usec != 0 */
|
---|
82 | sys_tv.tv_usec = 999999 - sys_tv.tv_usec;
|
---|
83 | }
|
---|
84 | printf("%s %ld.%06lu seconds\n", cp, diff, (unsigned long)sys_tv.tv_usec);
|
---|
85 | }
|
---|
86 | #endif
|
---|
87 | }
|
---|
88 |
|
---|
89 | static void to_sys_clock(const char **pp_rtcname, int utc)
|
---|
90 | {
|
---|
91 | struct timeval tv;
|
---|
92 | struct timezone tz;
|
---|
93 |
|
---|
94 | tz.tz_minuteswest = timezone/60 - 60*daylight;
|
---|
95 | tz.tz_dsttime = 0;
|
---|
96 |
|
---|
97 | tv.tv_sec = read_rtc(pp_rtcname, NULL, utc);
|
---|
98 | tv.tv_usec = 0;
|
---|
99 | if (settimeofday(&tv, &tz))
|
---|
100 | bb_perror_msg_and_die("settimeofday");
|
---|
101 | }
|
---|
102 |
|
---|
103 | static void from_sys_clock(const char **pp_rtcname, int utc)
|
---|
104 | {
|
---|
105 | #if 1
|
---|
106 | struct timeval tv;
|
---|
107 | struct tm tm_time;
|
---|
108 | int rtc;
|
---|
109 |
|
---|
110 | rtc = rtc_xopen(pp_rtcname, O_WRONLY);
|
---|
111 | gettimeofday(&tv, NULL);
|
---|
112 | /* Prepare tm_time */
|
---|
113 | if (sizeof(time_t) == sizeof(tv.tv_sec)) {
|
---|
114 | if (utc)
|
---|
115 | gmtime_r((time_t*)&tv.tv_sec, &tm_time);
|
---|
116 | else
|
---|
117 | localtime_r((time_t*)&tv.tv_sec, &tm_time);
|
---|
118 | } else {
|
---|
119 | time_t t = tv.tv_sec;
|
---|
120 | if (utc)
|
---|
121 | gmtime_r(&t, &tm_time);
|
---|
122 | else
|
---|
123 | localtime_r(&t, &tm_time);
|
---|
124 | }
|
---|
125 | #else
|
---|
126 | /* Bloated code which tries to set hw clock with better precision.
|
---|
127 | * On x86, even though code does set hw clock within <1ms of exact
|
---|
128 | * whole seconds, apparently hw clock (at least on some machines)
|
---|
129 | * doesn't reset internal fractional seconds to 0,
|
---|
130 | * making all this a pointless excercise.
|
---|
131 | */
|
---|
132 | /* If we see that we are N usec away from whole second,
|
---|
133 | * we'll sleep for N-ADJ usecs. ADJ corrects for the fact
|
---|
134 | * that CPU is not infinitely fast.
|
---|
135 | * On infinitely fast CPU, next wakeup would be
|
---|
136 | * on (exactly_next_whole_second - ADJ). On real CPUs,
|
---|
137 | * this difference between current time and whole second
|
---|
138 | * is less than ADJ (assuming system isn't heavily loaded).
|
---|
139 | */
|
---|
140 | /* Small value of 256us gives very precise sync for 2+ GHz CPUs.
|
---|
141 | * Slower CPUs will fail to sync and will go to bigger
|
---|
142 | * ADJ values. qemu-emulated armv4tl with ~100 MHz
|
---|
143 | * performance ends up using ADJ ~= 4*1024 and it takes
|
---|
144 | * 2+ secs (2 tries with successively larger ADJ)
|
---|
145 | * to sync. Even straced one on the same qemu (very slow)
|
---|
146 | * takes only 4 tries.
|
---|
147 | */
|
---|
148 | #define TWEAK_USEC 256
|
---|
149 | unsigned adj = TWEAK_USEC;
|
---|
150 | struct tm tm_time;
|
---|
151 | struct timeval tv;
|
---|
152 | int rtc = rtc_xopen(pp_rtcname, O_WRONLY);
|
---|
153 |
|
---|
154 | /* Try to catch the moment when whole second is close */
|
---|
155 | while (1) {
|
---|
156 | unsigned rem_usec;
|
---|
157 | time_t t;
|
---|
158 |
|
---|
159 | gettimeofday(&tv, NULL);
|
---|
160 |
|
---|
161 | t = tv.tv_sec;
|
---|
162 | rem_usec = 1000000 - tv.tv_usec;
|
---|
163 | if (rem_usec < adj) {
|
---|
164 | /* Close enough */
|
---|
165 | small_rem:
|
---|
166 | t++;
|
---|
167 | }
|
---|
168 |
|
---|
169 | /* Prepare tm_time from t */
|
---|
170 | if (utc)
|
---|
171 | gmtime_r(&t, &tm_time); /* may read /etc/xxx (it takes time) */
|
---|
172 | else
|
---|
173 | localtime_r(&t, &tm_time); /* same */
|
---|
174 |
|
---|
175 | if (adj >= 32*1024) {
|
---|
176 | break; /* 32 ms diff and still no luck?? give up trying to sync */
|
---|
177 | }
|
---|
178 |
|
---|
179 | /* gmtime/localtime took some time, re-get cur time */
|
---|
180 | gettimeofday(&tv, NULL);
|
---|
181 |
|
---|
182 | if (tv.tv_sec < t /* we are still in old second */
|
---|
183 | || (tv.tv_sec == t && tv.tv_usec < adj) /* not too far into next second */
|
---|
184 | ) {
|
---|
185 | break; /* good, we are in sync! */
|
---|
186 | }
|
---|
187 |
|
---|
188 | rem_usec = 1000000 - tv.tv_usec;
|
---|
189 | if (rem_usec < adj) {
|
---|
190 | t = tv.tv_sec;
|
---|
191 | goto small_rem; /* already close to next sec, don't sleep */
|
---|
192 | }
|
---|
193 |
|
---|
194 | /* Try to sync up by sleeping */
|
---|
195 | usleep(rem_usec - adj);
|
---|
196 |
|
---|
197 | /* Jump to 1ms diff, then increase fast (x2): EVERY loop
|
---|
198 | * takes ~1 sec, people won't like slowly converging code here!
|
---|
199 | */
|
---|
200 | //bb_error_msg("adj:%d tv.tv_usec:%d", adj, (int)tv.tv_usec);
|
---|
201 | if (adj < 512)
|
---|
202 | adj = 512;
|
---|
203 | /* ... and if last "overshoot" does not look insanely big,
|
---|
204 | * just use it as adj increment. This makes convergence faster.
|
---|
205 | */
|
---|
206 | if (tv.tv_usec < adj * 8) {
|
---|
207 | adj += tv.tv_usec;
|
---|
208 | continue;
|
---|
209 | }
|
---|
210 | adj *= 2;
|
---|
211 | }
|
---|
212 | /* Debug aid to find "optimal" TWEAK_USEC with nearly exact sync.
|
---|
213 | * Look for a value which makes tv_usec close to 999999 or 0.
|
---|
214 | * For 2.20GHz Intel Core 2: optimal TWEAK_USEC ~= 200
|
---|
215 | */
|
---|
216 | //bb_error_msg("tv.tv_usec:%d", (int)tv.tv_usec);
|
---|
217 | #endif
|
---|
218 |
|
---|
219 | tm_time.tm_isdst = 0;
|
---|
220 | xioctl(rtc, RTC_SET_TIME, &tm_time);
|
---|
221 |
|
---|
222 | if (ENABLE_FEATURE_CLEAN_UP)
|
---|
223 | close(rtc);
|
---|
224 | }
|
---|
225 |
|
---|
226 | #define HWCLOCK_OPT_LOCALTIME 0x01
|
---|
227 | #define HWCLOCK_OPT_UTC 0x02
|
---|
228 | #define HWCLOCK_OPT_SHOW 0x04
|
---|
229 | #define HWCLOCK_OPT_HCTOSYS 0x08
|
---|
230 | #define HWCLOCK_OPT_SYSTOHC 0x10
|
---|
231 | #define HWCLOCK_OPT_RTCFILE 0x20
|
---|
232 |
|
---|
233 | int hwclock_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
234 | int hwclock_main(int argc UNUSED_PARAM, char **argv)
|
---|
235 | {
|
---|
236 | const char *rtcname = NULL;
|
---|
237 | unsigned opt;
|
---|
238 | int utc;
|
---|
239 |
|
---|
240 | #if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS
|
---|
241 | static const char hwclock_longopts[] ALIGN1 =
|
---|
242 | "localtime\0" No_argument "l"
|
---|
243 | "utc\0" No_argument "u"
|
---|
244 | "show\0" No_argument "r"
|
---|
245 | "hctosys\0" No_argument "s"
|
---|
246 | "systohc\0" No_argument "w"
|
---|
247 | "file\0" Required_argument "f"
|
---|
248 | ;
|
---|
249 | applet_long_options = hwclock_longopts;
|
---|
250 | #endif
|
---|
251 | opt_complementary = "r--ws:w--rs:s--wr:l--u:u--l";
|
---|
252 | opt = getopt32(argv, "lurswf:", &rtcname);
|
---|
253 |
|
---|
254 | /* If -u or -l wasn't given check if we are using utc */
|
---|
255 | if (opt & (HWCLOCK_OPT_UTC | HWCLOCK_OPT_LOCALTIME))
|
---|
256 | utc = (opt & HWCLOCK_OPT_UTC);
|
---|
257 | else
|
---|
258 | utc = rtc_adjtime_is_utc();
|
---|
259 |
|
---|
260 | if (opt & HWCLOCK_OPT_HCTOSYS)
|
---|
261 | to_sys_clock(&rtcname, utc);
|
---|
262 | else if (opt & HWCLOCK_OPT_SYSTOHC)
|
---|
263 | from_sys_clock(&rtcname, utc);
|
---|
264 | else
|
---|
265 | /* default HWCLOCK_OPT_SHOW */
|
---|
266 | show_clock(&rtcname, utc);
|
---|
267 |
|
---|
268 | return 0;
|
---|
269 | }
|
---|