Annotation of embedaddon/ntp/libntp/systime.c, revision 1.1.1.1
1.1 misho 1: /*
2: * systime -- routines to fiddle a UNIX clock.
3: *
4: * ATTENTION: Get approval from Dave Mills on all changes to this file!
5: *
6: */
7: #include "ntp_machine.h"
8: #include "ntp_fp.h"
9: #include "ntp_syslog.h"
10: #include "ntp_unixtime.h"
11: #include "ntp_stdlib.h"
12: #include "ntp_random.h"
13: #include "ntpd.h" /* for sys_precision */
14:
15: #ifdef HAVE_SYS_PARAM_H
16: # include <sys/param.h>
17: #endif
18: #ifdef HAVE_UTMP_H
19: # include <utmp.h>
20: #endif /* HAVE_UTMP_H */
21: #ifdef HAVE_UTMPX_H
22: # include <utmpx.h>
23: #endif /* HAVE_UTMPX_H */
24:
25:
26: #define FUZZ 500e-6 /* fuzz pivot */
27:
28: /*
29: * These routines (get_systime, step_systime, adj_systime) implement an
30: * interface between the system independent NTP clock and the Unix
31: * system clock in various architectures and operating systems. Time is
32: * a precious quantity in these routines and every effort is made to
33: * minimize errors by unbiased rounding and amortizing adjustment
34: * residues.
35: *
36: * In order to improve the apparent resolution, provide unbiased
37: * rounding and insure that the readings cannot be predicted, the low-
38: * order unused portion of the time below the resolution limit is filled
39: * with an unbiased random fuzz.
40: *
41: * The sys_tick variable secifies the system clock tick interval in
42: * seconds. For systems that can interpolate between timer interrupts,
43: * the resolution is presumed much less than the time to read the system
44: * clock, which is the value of sys_tick after the precision has been
45: * determined. For those systems that cannot interpolate between timer
46: * interrupts, sys_tick will be much larger in the order of 10 ms, so the
47: * fuzz should be that value. For Sunses the tick is not interpolated, but
48: * the system clock is derived from a 2-MHz oscillator, so the resolution
49: * is 500 ns and sys_tick is 500 ns.
50: */
51: double sys_tick = 0; /* precision (time to read the clock) */
52: double sys_residual = 0; /* adjustment residue (s) */
53:
54: #ifndef SIM
55:
56: /*
57: * get_systime - return system time in NTP timestamp format.
58: */
59: void
60: get_systime(
61: l_fp *now /* system time */
62: )
63: {
64: double dtemp;
65:
66: #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_GETCLOCK)
67: struct timespec ts; /* seconds and nanoseconds */
68:
69: /*
70: * Convert Unix timespec from seconds and nanoseconds to NTP
71: * seconds and fraction.
72: */
73: # ifdef HAVE_CLOCK_GETTIME
74: clock_gettime(CLOCK_REALTIME, &ts);
75: # else
76: getclock(TIMEOFDAY, &ts);
77: # endif
78: now->l_i = (int32)ts.tv_sec + JAN_1970;
79: dtemp = 0;
80: if (sys_tick > FUZZ)
81: dtemp = ntp_random() * 2. / FRAC * sys_tick * 1e9;
82: else if (sys_tick > 0)
83: dtemp = ntp_random() * 2. / FRAC;
84: dtemp = (ts.tv_nsec + dtemp) * 1e-9;
85: if (dtemp >= 1.) {
86: dtemp -= 1.;
87: now->l_i++;
88: } else if (dtemp < 0) {
89: dtemp += 1.;
90: now->l_i--;
91: }
92: now->l_uf = (u_int32)(dtemp * FRAC);
93:
94: #else /* HAVE_CLOCK_GETTIME || HAVE_GETCLOCK */
95: struct timeval tv; /* seconds and microseconds */
96:
97: /*
98: * Convert Unix timeval from seconds and microseconds to NTP
99: * seconds and fraction.
100: */
101: GETTIMEOFDAY(&tv, NULL);
102: now->l_i = tv.tv_sec + JAN_1970;
103: dtemp = 0;
104: if (sys_tick > FUZZ)
105: dtemp = ntp_random() * 2. / FRAC * sys_tick * 1e6;
106: else if (sys_tick > 0)
107: dtemp = ntp_random() * 2. / FRAC;
108: dtemp = (tv.tv_usec + dtemp) * 1e-6;
109: if (dtemp >= 1.) {
110: dtemp -= 1.;
111: now->l_i++;
112: } else if (dtemp < 0) {
113: dtemp += 1.;
114: now->l_i--;
115: }
116: now->l_uf = (u_int32)(dtemp * FRAC);
117:
118: #endif /* HAVE_CLOCK_GETTIME || HAVE_GETCLOCK */
119: }
120:
121:
122: /*
123: * adj_systime - adjust system time by the argument.
124: */
125: #if !defined SYS_WINNT
126: int /* 0 okay, 1 error */
127: adj_systime(
128: double now /* adjustment (s) */
129: )
130: {
131: struct timeval adjtv; /* new adjustment */
132: struct timeval oadjtv; /* residual adjustment */
133: double dtemp;
134: long ticks;
135: int isneg = 0;
136:
137: /*
138: * Most Unix adjtime() implementations adjust the system clock
139: * in microsecond quanta, but some adjust in 10-ms quanta. We
140: * carefully round the adjustment to the nearest quantum, then
141: * adjust in quanta and keep the residue for later.
142: */
143: dtemp = now + sys_residual;
144: if (dtemp < 0) {
145: isneg = 1;
146: dtemp = -dtemp;
147: }
148: adjtv.tv_sec = (long)dtemp;
149: dtemp -= adjtv.tv_sec;
150: ticks = (long)(dtemp / sys_tick + .5);
151: adjtv.tv_usec = (long)(ticks * sys_tick * 1e6);
152: dtemp -= adjtv.tv_usec / 1e6;
153: sys_residual = dtemp;
154:
155: /*
156: * Convert to signed seconds and microseconds for the Unix
157: * adjtime() system call. Note we purposely lose the adjtime()
158: * leftover.
159: */
160: if (isneg) {
161: adjtv.tv_sec = -adjtv.tv_sec;
162: adjtv.tv_usec = -adjtv.tv_usec;
163: sys_residual = -sys_residual;
164: }
165: if (adjtv.tv_sec != 0 || adjtv.tv_usec != 0) {
166: if (adjtime(&adjtv, &oadjtv) < 0) {
167: msyslog(LOG_ERR, "adj_systime: %m");
168: return (0);
169: }
170: }
171: return (1);
172: }
173: #endif
174:
175:
176: /*
177: * step_systime - step the system clock.
178: */
179: int
180: step_systime(
181: double now
182: )
183: {
184: struct timeval timetv, adjtv, oldtimetv;
185: int isneg = 0;
186: double dtemp;
187: #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_GETCLOCK)
188: struct timespec ts;
189: #endif
190:
191: dtemp = sys_residual + now;
192: if (dtemp < 0) {
193: isneg = 1;
194: dtemp = - dtemp;
195: adjtv.tv_sec = (int32)dtemp;
196: adjtv.tv_usec = (u_int32)((dtemp -
197: (double)adjtv.tv_sec) * 1e6 + .5);
198: } else {
199: adjtv.tv_sec = (int32)dtemp;
200: adjtv.tv_usec = (u_int32)((dtemp -
201: (double)adjtv.tv_sec) * 1e6 + .5);
202: }
203: #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_GETCLOCK)
204: # ifdef HAVE_CLOCK_GETTIME
205: (void) clock_gettime(CLOCK_REALTIME, &ts);
206: # else
207: (void) getclock(TIMEOFDAY, &ts);
208: # endif
209: timetv.tv_sec = ts.tv_sec;
210: timetv.tv_usec = ts.tv_nsec / 1000;
211: #else /* not HAVE_GETCLOCK */
212: (void) GETTIMEOFDAY(&timetv, (struct timezone *)0);
213: #endif /* not HAVE_GETCLOCK */
214:
215: oldtimetv = timetv;
216:
217: #ifdef DEBUG
218: if (debug)
219: printf("step_systime: step %.6f residual %.6f\n", now, sys_residual);
220: #endif
221: if (isneg) {
222: timetv.tv_sec -= adjtv.tv_sec;
223: timetv.tv_usec -= adjtv.tv_usec;
224: if (timetv.tv_usec < 0) {
225: timetv.tv_sec--;
226: timetv.tv_usec += 1000000;
227: }
228: } else {
229: timetv.tv_sec += adjtv.tv_sec;
230: timetv.tv_usec += adjtv.tv_usec;
231: if (timetv.tv_usec >= 1000000) {
232: timetv.tv_sec++;
233: timetv.tv_usec -= 1000000;
234: }
235: }
236: if (ntp_set_tod(&timetv, NULL) != 0) {
237: msyslog(LOG_ERR, "step-systime: %m");
238: return (0);
239: }
240: sys_residual = 0;
241:
242: #ifdef NEED_HPUX_ADJTIME
243: /*
244: * CHECKME: is this correct when called by ntpdate?????
245: */
246: _clear_adjtime();
247: #endif
248:
249: /*
250: * FreeBSD, for example, has:
251: * struct utmp {
252: * char ut_line[UT_LINESIZE];
253: * char ut_name[UT_NAMESIZE];
254: * char ut_host[UT_HOSTSIZE];
255: * long ut_time;
256: * };
257: * and appends line="|", name="date", host="", time for the OLD
258: * and appends line="{", name="date", host="", time for the NEW
259: * to _PATH_WTMP .
260: *
261: * Some OSes have utmp, some have utmpx.
262: */
263:
264: /*
265: * Write old and new time entries in utmp and wtmp if step
266: * adjustment is greater than one second.
267: *
268: * This might become even Uglier...
269: */
270: if (oldtimetv.tv_sec != timetv.tv_sec)
271: {
272: #ifdef HAVE_UTMP_H
273: struct utmp ut;
274: #endif
275: #ifdef HAVE_UTMPX_H
276: struct utmpx utx;
277: #endif
278:
279: #ifdef HAVE_UTMP_H
280: memset((char *)&ut, 0, sizeof(ut));
281: #endif
282: #ifdef HAVE_UTMPX_H
283: memset((char *)&utx, 0, sizeof(utx));
284: #endif
285:
286: /* UTMP */
287:
288: #ifdef UPDATE_UTMP
289: # ifdef HAVE_PUTUTLINE
290: ut.ut_type = OLD_TIME;
291: (void)strcpy(ut.ut_line, OTIME_MSG);
292: ut.ut_time = oldtimetv.tv_sec;
293: pututline(&ut);
294: setutent();
295: ut.ut_type = NEW_TIME;
296: (void)strcpy(ut.ut_line, NTIME_MSG);
297: ut.ut_time = timetv.tv_sec;
298: pututline(&ut);
299: endutent();
300: # else /* not HAVE_PUTUTLINE */
301: # endif /* not HAVE_PUTUTLINE */
302: #endif /* UPDATE_UTMP */
303:
304: /* UTMPX */
305:
306: #ifdef UPDATE_UTMPX
307: # ifdef HAVE_PUTUTXLINE
308: utx.ut_type = OLD_TIME;
309: (void)strcpy(utx.ut_line, OTIME_MSG);
310: utx.ut_tv = oldtimetv;
311: pututxline(&utx);
312: setutxent();
313: utx.ut_type = NEW_TIME;
314: (void)strcpy(utx.ut_line, NTIME_MSG);
315: utx.ut_tv = timetv;
316: pututxline(&utx);
317: endutxent();
318: # else /* not HAVE_PUTUTXLINE */
319: # endif /* not HAVE_PUTUTXLINE */
320: #endif /* UPDATE_UTMPX */
321:
322: /* WTMP */
323:
324: #ifdef UPDATE_WTMP
325: # ifdef HAVE_PUTUTLINE
326: utmpname(WTMP_FILE);
327: ut.ut_type = OLD_TIME;
328: (void)strcpy(ut.ut_line, OTIME_MSG);
329: ut.ut_time = oldtimetv.tv_sec;
330: pututline(&ut);
331: ut.ut_type = NEW_TIME;
332: (void)strcpy(ut.ut_line, NTIME_MSG);
333: ut.ut_time = timetv.tv_sec;
334: pututline(&ut);
335: endutent();
336: # else /* not HAVE_PUTUTLINE */
337: # endif /* not HAVE_PUTUTLINE */
338: #endif /* UPDATE_WTMP */
339:
340: /* WTMPX */
341:
342: #ifdef UPDATE_WTMPX
343: # ifdef HAVE_PUTUTXLINE
344: utx.ut_type = OLD_TIME;
345: utx.ut_tv = oldtimetv;
346: (void)strcpy(utx.ut_line, OTIME_MSG);
347: # ifdef HAVE_UPDWTMPX
348: updwtmpx(WTMPX_FILE, &utx);
349: # else /* not HAVE_UPDWTMPX */
350: # endif /* not HAVE_UPDWTMPX */
351: # else /* not HAVE_PUTUTXLINE */
352: # endif /* not HAVE_PUTUTXLINE */
353: # ifdef HAVE_PUTUTXLINE
354: utx.ut_type = NEW_TIME;
355: utx.ut_tv = timetv;
356: (void)strcpy(utx.ut_line, NTIME_MSG);
357: # ifdef HAVE_UPDWTMPX
358: updwtmpx(WTMPX_FILE, &utx);
359: # else /* not HAVE_UPDWTMPX */
360: # endif /* not HAVE_UPDWTMPX */
361: # else /* not HAVE_PUTUTXLINE */
362: # endif /* not HAVE_PUTUTXLINE */
363: #endif /* UPDATE_WTMPX */
364:
365: }
366: return (1);
367: }
368:
369: #else /* SIM */
370: /*
371: * Clock routines for the simulator - Harish Nair, with help
372: */
373:
374:
375: /* SK:
376: * The code that used to be here has been moved to ntpsim.c,
377: * where, IMHO, it rightfully belonged.
378: */
379:
380: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to systime.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp