Commit | Line | Data |
---|---|---|
984263bc MD |
1 | /*********************************************************************** |
2 | * * | |
3 | * Copyright (c) David L. Mills 1993-2001 * | |
4 | * * | |
5 | * Permission to use, copy, modify, and distribute this software and * | |
6 | * its documentation for any purpose and without fee is hereby * | |
7 | * granted, provided that the above copyright notice appears in all * | |
8 | * copies and that both the copyright notice and this permission * | |
9 | * notice appear in supporting documentation, and that the name * | |
10 | * University of Delaware not be used in advertising or publicity * | |
11 | * pertaining to distribution of the software without specific, * | |
12 | * written prior permission. The University of Delaware makes no * | |
13 | * representations about the suitability this software for any * | |
14 | * purpose. It is provided "as is" without express or implied * | |
15 | * warranty. * | |
16 | * * | |
17 | **********************************************************************/ | |
18 | ||
19 | /* | |
20 | * Adapted from the original sources for FreeBSD and timecounters by: | |
21 | * Poul-Henning Kamp <phk@FreeBSD.org>. | |
22 | * | |
23 | * The 32bit version of the "LP" macros seems a bit past its "sell by" | |
24 | * date so I have retained only the 64bit version and included it directly | |
25 | * in this file. | |
26 | * | |
27 | * Only minor changes done to interface with the timecounters over in | |
28 | * sys/kern/kern_clock.c. Some of the comments below may be (even more) | |
29 | * confusing and/or plain wrong in that context. | |
30 | * | |
31 | * $FreeBSD: src/sys/kern/kern_ntptime.c,v 1.32.2.2 2001/04/22 11:19:46 jhay Exp $ | |
ba39e2e0 | 32 | * $DragonFly: src/sys/kern/kern_ntptime.c,v 1.13 2007/04/30 07:18:53 dillon Exp $ |
984263bc MD |
33 | */ |
34 | ||
35 | #include "opt_ntp.h" | |
36 | ||
37 | #include <sys/param.h> | |
38 | #include <sys/systm.h> | |
39 | #include <sys/sysproto.h> | |
40 | #include <sys/kernel.h> | |
41 | #include <sys/proc.h> | |
895c1f85 | 42 | #include <sys/priv.h> |
984263bc MD |
43 | #include <sys/time.h> |
44 | #include <sys/timex.h> | |
45 | #include <sys/timepps.h> | |
46 | #include <sys/sysctl.h> | |
88c4d2f6 | 47 | #include <sys/thread2.h> |
984263bc MD |
48 | |
49 | /* | |
50 | * Single-precision macros for 64-bit machines | |
51 | */ | |
52 | typedef long long l_fp; | |
53 | #define L_ADD(v, u) ((v) += (u)) | |
54 | #define L_SUB(v, u) ((v) -= (u)) | |
55 | #define L_ADDHI(v, a) ((v) += (long long)(a) << 32) | |
56 | #define L_NEG(v) ((v) = -(v)) | |
57 | #define L_RSHIFT(v, n) \ | |
58 | do { \ | |
59 | if ((v) < 0) \ | |
60 | (v) = -(-(v) >> (n)); \ | |
61 | else \ | |
62 | (v) = (v) >> (n); \ | |
63 | } while (0) | |
64 | #define L_MPY(v, a) ((v) *= (a)) | |
65 | #define L_CLR(v) ((v) = 0) | |
66 | #define L_ISNEG(v) ((v) < 0) | |
67 | #define L_LINT(v, a) ((v) = (long long)(a) << 32) | |
68 | #define L_GINT(v) ((v) < 0 ? -(-(v) >> 32) : (v) >> 32) | |
69 | ||
70 | /* | |
71 | * Generic NTP kernel interface | |
72 | * | |
73 | * These routines constitute the Network Time Protocol (NTP) interfaces | |
74 | * for user and daemon application programs. The ntp_gettime() routine | |
75 | * provides the time, maximum error (synch distance) and estimated error | |
76 | * (dispersion) to client user application programs. The ntp_adjtime() | |
77 | * routine is used by the NTP daemon to adjust the system clock to an | |
78 | * externally derived time. The time offset and related variables set by | |
79 | * this routine are used by other routines in this module to adjust the | |
80 | * phase and frequency of the clock discipline loop which controls the | |
81 | * system clock. | |
82 | * | |
83 | * When the kernel time is reckoned directly in nanoseconds (NTP_NANO | |
84 | * defined), the time at each tick interrupt is derived directly from | |
85 | * the kernel time variable. When the kernel time is reckoned in | |
86 | * microseconds, (NTP_NANO undefined), the time is derived from the | |
87 | * kernel time variable together with a variable representing the | |
88 | * leftover nanoseconds at the last tick interrupt. In either case, the | |
89 | * current nanosecond time is reckoned from these values plus an | |
90 | * interpolated value derived by the clock routines in another | |
91 | * architecture-specific module. The interpolation can use either a | |
92 | * dedicated counter or a processor cycle counter (PCC) implemented in | |
93 | * some architectures. | |
94 | * | |
95 | * Note that all routines must run at priority splclock or higher. | |
96 | */ | |
97 | /* | |
98 | * Phase/frequency-lock loop (PLL/FLL) definitions | |
99 | * | |
100 | * The nanosecond clock discipline uses two variable types, time | |
101 | * variables and frequency variables. Both types are represented as 64- | |
102 | * bit fixed-point quantities with the decimal point between two 32-bit | |
103 | * halves. On a 32-bit machine, each half is represented as a single | |
104 | * word and mathematical operations are done using multiple-precision | |
105 | * arithmetic. On a 64-bit machine, ordinary computer arithmetic is | |
106 | * used. | |
107 | * | |
108 | * A time variable is a signed 64-bit fixed-point number in ns and | |
109 | * fraction. It represents the remaining time offset to be amortized | |
110 | * over succeeding tick interrupts. The maximum time offset is about | |
111 | * 0.5 s and the resolution is about 2.3e-10 ns. | |
112 | * | |
113 | * 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 | |
114 | * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | |
115 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
116 | * |s s s| ns | | |
117 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
118 | * | fraction | | |
119 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
120 | * | |
121 | * A frequency variable is a signed 64-bit fixed-point number in ns/s | |
122 | * and fraction. It represents the ns and fraction to be added to the | |
123 | * kernel time variable at each second. The maximum frequency offset is | |
124 | * about +-500000 ns/s and the resolution is about 2.3e-10 ns/s. | |
125 | * | |
126 | * 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 | |
127 | * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | |
128 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
129 | * |s s s s s s s s s s s s s| ns/s | | |
130 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
131 | * | fraction | | |
132 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
133 | */ | |
134 | /* | |
135 | * The following variables establish the state of the PLL/FLL and the | |
136 | * residual time and frequency offset of the local clock. | |
137 | */ | |
138 | #define SHIFT_PLL 4 /* PLL loop gain (shift) */ | |
139 | #define SHIFT_FLL 2 /* FLL loop gain (shift) */ | |
140 | ||
141 | static int time_state = TIME_OK; /* clock state */ | |
142 | static int time_status = STA_UNSYNC; /* clock status bits */ | |
143 | static long time_tai; /* TAI offset (s) */ | |
144 | static long time_monitor; /* last time offset scaled (ns) */ | |
145 | static long time_constant; /* poll interval (shift) (s) */ | |
146 | static long time_precision = 1; /* clock precision (ns) */ | |
147 | static long time_maxerror = MAXPHASE / 1000; /* maximum error (us) */ | |
148 | static long time_esterror = MAXPHASE / 1000; /* estimated error (us) */ | |
149 | static long time_reftime; /* time at last adjustment (s) */ | |
150 | static long time_tick; /* nanoseconds per tick (ns) */ | |
151 | static l_fp time_offset; /* time offset (ns) */ | |
152 | static l_fp time_freq; /* frequency offset (ns/s) */ | |
153 | static l_fp time_adj; /* tick adjust (ns/s) */ | |
154 | ||
155 | #ifdef PPS_SYNC | |
156 | /* | |
157 | * The following variables are used when a pulse-per-second (PPS) signal | |
158 | * is available and connected via a modem control lead. They establish | |
159 | * the engineering parameters of the clock discipline loop when | |
160 | * controlled by the PPS signal. | |
161 | */ | |
162 | #define PPS_FAVG 2 /* min freq avg interval (s) (shift) */ | |
163 | #define PPS_FAVGDEF 8 /* default freq avg int (s) (shift) */ | |
164 | #define PPS_FAVGMAX 15 /* max freq avg interval (s) (shift) */ | |
165 | #define PPS_PAVG 4 /* phase avg interval (s) (shift) */ | |
166 | #define PPS_VALID 120 /* PPS signal watchdog max (s) */ | |
167 | #define PPS_MAXWANDER 100000 /* max PPS wander (ns/s) */ | |
168 | #define PPS_POPCORN 2 /* popcorn spike threshold (shift) */ | |
169 | ||
170 | static struct timespec pps_tf[3]; /* phase median filter */ | |
171 | static l_fp pps_freq; /* scaled frequency offset (ns/s) */ | |
172 | static long pps_fcount; /* frequency accumulator */ | |
173 | static long pps_jitter; /* nominal jitter (ns) */ | |
174 | static long pps_stabil; /* nominal stability (scaled ns/s) */ | |
175 | static long pps_lastsec; /* time at last calibration (s) */ | |
176 | static int pps_valid; /* signal watchdog counter */ | |
177 | static int pps_shift = PPS_FAVG; /* interval duration (s) (shift) */ | |
178 | static int pps_shiftmax = PPS_FAVGDEF; /* max interval duration (s) (shift) */ | |
179 | static int pps_intcnt; /* wander counter */ | |
180 | ||
181 | /* | |
182 | * PPS signal quality monitors | |
183 | */ | |
184 | static long pps_calcnt; /* calibration intervals */ | |
185 | static long pps_jitcnt; /* jitter limit exceeded */ | |
186 | static long pps_stbcnt; /* stability limit exceeded */ | |
187 | static long pps_errcnt; /* calibration errors */ | |
188 | #endif /* PPS_SYNC */ | |
189 | /* | |
190 | * End of phase/frequency-lock loop (PLL/FLL) definitions | |
191 | */ | |
192 | ||
193 | static void ntp_init(void); | |
194 | static void hardupdate(long offset); | |
195 | ||
196 | /* | |
197 | * ntp_gettime() - NTP user application interface | |
198 | * | |
199 | * See the timex.h header file for synopsis and API description. Note | |
200 | * that the TAI offset is returned in the ntvtimeval.tai structure | |
201 | * member. | |
202 | */ | |
203 | static int | |
204 | ntp_sysctl(SYSCTL_HANDLER_ARGS) | |
205 | { | |
206 | struct ntptimeval ntv; /* temporary structure */ | |
207 | struct timespec atv; /* nanosecond time */ | |
208 | ||
209 | nanotime(&atv); | |
210 | ntv.time.tv_sec = atv.tv_sec; | |
211 | ntv.time.tv_nsec = atv.tv_nsec; | |
212 | ntv.maxerror = time_maxerror; | |
213 | ntv.esterror = time_esterror; | |
214 | ntv.tai = time_tai; | |
215 | ntv.time_state = time_state; | |
216 | ||
217 | /* | |
218 | * Status word error decode. If any of these conditions occur, | |
219 | * an error is returned, instead of the status word. Most | |
220 | * applications will care only about the fact the system clock | |
221 | * may not be trusted, not about the details. | |
222 | * | |
223 | * Hardware or software error | |
224 | */ | |
225 | if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) || | |
226 | ||
227 | /* | |
228 | * PPS signal lost when either time or frequency synchronization | |
229 | * requested | |
230 | */ | |
231 | (time_status & (STA_PPSFREQ | STA_PPSTIME) && | |
232 | !(time_status & STA_PPSSIGNAL)) || | |
233 | ||
234 | /* | |
235 | * PPS jitter exceeded when time synchronization requested | |
236 | */ | |
237 | (time_status & STA_PPSTIME && | |
238 | time_status & STA_PPSJITTER) || | |
239 | ||
240 | /* | |
241 | * PPS wander exceeded or calibration error when frequency | |
242 | * synchronization requested | |
243 | */ | |
244 | (time_status & STA_PPSFREQ && | |
245 | time_status & (STA_PPSWANDER | STA_PPSERROR))) | |
246 | ntv.time_state = TIME_ERROR; | |
247 | return (sysctl_handle_opaque(oidp, &ntv, sizeof ntv, req)); | |
248 | } | |
249 | ||
250 | SYSCTL_NODE(_kern, OID_AUTO, ntp_pll, CTLFLAG_RW, 0, ""); | |
251 | SYSCTL_PROC(_kern_ntp_pll, OID_AUTO, gettime, CTLTYPE_OPAQUE|CTLFLAG_RD, | |
252 | 0, sizeof(struct ntptimeval) , ntp_sysctl, "S,ntptimeval", ""); | |
253 | ||
254 | #ifdef PPS_SYNC | |
255 | SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shiftmax, CTLFLAG_RW, &pps_shiftmax, 0, ""); | |
256 | SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shift, CTLFLAG_RW, &pps_shift, 0, ""); | |
257 | SYSCTL_INT(_kern_ntp_pll, OID_AUTO, time_monitor, CTLFLAG_RD, &time_monitor, 0, ""); | |
258 | ||
259 | SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, pps_freq, CTLFLAG_RD, &pps_freq, sizeof(pps_freq), "I", ""); | |
260 | SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, time_freq, CTLFLAG_RD, &time_freq, sizeof(time_freq), "I", ""); | |
261 | #endif | |
262 | /* | |
263 | * ntp_adjtime() - NTP daemon application interface | |
264 | * | |
265 | * See the timex.h header file for synopsis and API description. Note | |
266 | * that the timex.constant structure member has a dual purpose to set | |
267 | * the time constant and to set the TAI offset. | |
268 | */ | |
984263bc | 269 | int |
753fd850 | 270 | sys_ntp_adjtime(struct ntp_adjtime_args *uap) |
984263bc | 271 | { |
dadab5e9 | 272 | struct thread *td = curthread; |
984263bc MD |
273 | struct timex ntv; /* temporary structure */ |
274 | long freq; /* frequency ns/s) */ | |
275 | int modes; /* mode bits from structure */ | |
984263bc MD |
276 | int error; |
277 | ||
278 | error = copyin((caddr_t)uap->tp, (caddr_t)&ntv, sizeof(ntv)); | |
279 | if (error) | |
280 | return(error); | |
281 | ||
282 | /* | |
283 | * Update selected clock variables - only the superuser can | |
284 | * change anything. Note that there is no error checking here on | |
285 | * the assumption the superuser should know what it is doing. | |
286 | * Note that either the time constant or TAI offset are loaded | |
287 | * from the ntv.constant member, depending on the mode bits. If | |
288 | * the STA_PLL bit in the status word is cleared, the state and | |
289 | * status words are reset to the initial values at boot. | |
290 | */ | |
291 | modes = ntv.modes; | |
292 | if (modes) | |
1dad22bb | 293 | error = priv_check(td, PRIV_NTP_ADJTIME); |
984263bc MD |
294 | if (error) |
295 | return (error); | |
88c4d2f6 | 296 | crit_enter(); |
984263bc MD |
297 | if (modes & MOD_MAXERROR) |
298 | time_maxerror = ntv.maxerror; | |
299 | if (modes & MOD_ESTERROR) | |
300 | time_esterror = ntv.esterror; | |
301 | if (modes & MOD_STATUS) { | |
302 | if (time_status & STA_PLL && !(ntv.status & STA_PLL)) { | |
303 | time_state = TIME_OK; | |
304 | time_status = STA_UNSYNC; | |
305 | #ifdef PPS_SYNC | |
306 | pps_shift = PPS_FAVG; | |
307 | #endif /* PPS_SYNC */ | |
308 | } | |
309 | time_status &= STA_RONLY; | |
310 | time_status |= ntv.status & ~STA_RONLY; | |
311 | } | |
312 | if (modes & MOD_TIMECONST) { | |
313 | if (ntv.constant < 0) | |
314 | time_constant = 0; | |
315 | else if (ntv.constant > MAXTC) | |
316 | time_constant = MAXTC; | |
317 | else | |
318 | time_constant = ntv.constant; | |
319 | } | |
320 | if (modes & MOD_TAI) { | |
321 | if (ntv.constant > 0) /* XXX zero & negative numbers ? */ | |
322 | time_tai = ntv.constant; | |
323 | } | |
324 | #ifdef PPS_SYNC | |
325 | if (modes & MOD_PPSMAX) { | |
326 | if (ntv.shift < PPS_FAVG) | |
327 | pps_shiftmax = PPS_FAVG; | |
328 | else if (ntv.shift > PPS_FAVGMAX) | |
329 | pps_shiftmax = PPS_FAVGMAX; | |
330 | else | |
331 | pps_shiftmax = ntv.shift; | |
332 | } | |
333 | #endif /* PPS_SYNC */ | |
334 | if (modes & MOD_NANO) | |
335 | time_status |= STA_NANO; | |
336 | if (modes & MOD_MICRO) | |
337 | time_status &= ~STA_NANO; | |
338 | if (modes & MOD_CLKB) | |
339 | time_status |= STA_CLK; | |
340 | if (modes & MOD_CLKA) | |
341 | time_status &= ~STA_CLK; | |
342 | if (modes & MOD_OFFSET) { | |
343 | if (time_status & STA_NANO) | |
344 | hardupdate(ntv.offset); | |
345 | else | |
346 | hardupdate(ntv.offset * 1000); | |
347 | } | |
88c4d2f6 MD |
348 | /* |
349 | * Note: the userland specified frequency is in seconds per second | |
350 | * times 65536e+6. Multiply by a thousand and divide by 65336 to | |
351 | * get nanoseconds. | |
352 | */ | |
984263bc MD |
353 | if (modes & MOD_FREQUENCY) { |
354 | freq = (ntv.freq * 1000LL) >> 16; | |
355 | if (freq > MAXFREQ) | |
356 | L_LINT(time_freq, MAXFREQ); | |
357 | else if (freq < -MAXFREQ) | |
358 | L_LINT(time_freq, -MAXFREQ); | |
359 | else | |
360 | L_LINT(time_freq, freq); | |
361 | #ifdef PPS_SYNC | |
362 | pps_freq = time_freq; | |
363 | #endif /* PPS_SYNC */ | |
364 | } | |
365 | ||
366 | /* | |
367 | * Retrieve all clock variables. Note that the TAI offset is | |
368 | * returned only by ntp_gettime(); | |
369 | */ | |
370 | if (time_status & STA_NANO) | |
371 | ntv.offset = time_monitor; | |
372 | else | |
373 | ntv.offset = time_monitor / 1000; /* XXX rounding ? */ | |
374 | ntv.freq = L_GINT((time_freq / 1000LL) << 16); | |
375 | ntv.maxerror = time_maxerror; | |
376 | ntv.esterror = time_esterror; | |
377 | ntv.status = time_status; | |
378 | ntv.constant = time_constant; | |
379 | if (time_status & STA_NANO) | |
380 | ntv.precision = time_precision; | |
381 | else | |
382 | ntv.precision = time_precision / 1000; | |
383 | ntv.tolerance = MAXFREQ * SCALE_PPM; | |
384 | #ifdef PPS_SYNC | |
385 | ntv.shift = pps_shift; | |
386 | ntv.ppsfreq = L_GINT((pps_freq / 1000LL) << 16); | |
387 | if (time_status & STA_NANO) | |
388 | ntv.jitter = pps_jitter; | |
389 | else | |
390 | ntv.jitter = pps_jitter / 1000; | |
391 | ntv.stabil = pps_stabil; | |
392 | ntv.calcnt = pps_calcnt; | |
393 | ntv.errcnt = pps_errcnt; | |
394 | ntv.jitcnt = pps_jitcnt; | |
395 | ntv.stbcnt = pps_stbcnt; | |
396 | #endif /* PPS_SYNC */ | |
88c4d2f6 | 397 | crit_exit(); |
984263bc MD |
398 | |
399 | error = copyout((caddr_t)&ntv, (caddr_t)uap->tp, sizeof(ntv)); | |
400 | if (error) | |
401 | return (error); | |
402 | ||
403 | /* | |
404 | * Status word error decode. See comments in | |
405 | * ntp_gettime() routine. | |
406 | */ | |
407 | if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) || | |
408 | (time_status & (STA_PPSFREQ | STA_PPSTIME) && | |
409 | !(time_status & STA_PPSSIGNAL)) || | |
410 | (time_status & STA_PPSTIME && | |
411 | time_status & STA_PPSJITTER) || | |
412 | (time_status & STA_PPSFREQ && | |
90b9818c | 413 | time_status & (STA_PPSWANDER | STA_PPSERROR))) { |
c7114eea | 414 | uap->sysmsg_result = TIME_ERROR; |
90b9818c | 415 | } else { |
c7114eea | 416 | uap->sysmsg_result = time_state; |
90b9818c | 417 | } |
984263bc MD |
418 | return (error); |
419 | } | |
420 | ||
421 | /* | |
422 | * second_overflow() - called after ntp_tick_adjust() | |
423 | * | |
88c4d2f6 MD |
424 | * This routine is ordinarily called from hardclock() whenever the seconds |
425 | * hand rolls over. It returns leap seconds to add or drop, and sets nsec_adj | |
426 | * to the total adjustment to make over the next second in (ns << 32). | |
5eb5a6bc MD |
427 | * |
428 | * This routine is only called by cpu #0. | |
984263bc | 429 | */ |
88c4d2f6 MD |
430 | int |
431 | ntp_update_second(time_t newsec, int64_t *nsec_adj) | |
984263bc | 432 | { |
984263bc | 433 | l_fp ftemp; /* 32/64-bit temporary */ |
88c4d2f6 | 434 | int adjsec = 0; |
984263bc | 435 | |
984263bc MD |
436 | /* |
437 | * On rollover of the second both the nanosecond and microsecond | |
438 | * clocks are updated and the state machine cranked as | |
439 | * necessary. The phase adjustment to be used for the next | |
440 | * second is calculated and the maximum error is increased by | |
441 | * the tolerance. | |
442 | */ | |
443 | time_maxerror += MAXFREQ / 1000; | |
444 | ||
445 | /* | |
446 | * Leap second processing. If in leap-insert state at | |
447 | * the end of the day, the system clock is set back one | |
448 | * second; if in leap-delete state, the system clock is | |
449 | * set ahead one second. The nano_time() routine or | |
450 | * external clock driver will insure that reported time | |
451 | * is always monotonic. | |
452 | */ | |
453 | switch (time_state) { | |
454 | ||
455 | /* | |
456 | * No warning. | |
457 | */ | |
458 | case TIME_OK: | |
459 | if (time_status & STA_INS) | |
460 | time_state = TIME_INS; | |
461 | else if (time_status & STA_DEL) | |
462 | time_state = TIME_DEL; | |
463 | break; | |
464 | ||
465 | /* | |
466 | * Insert second 23:59:60 following second | |
467 | * 23:59:59. | |
468 | */ | |
469 | case TIME_INS: | |
470 | if (!(time_status & STA_INS)) | |
471 | time_state = TIME_OK; | |
88c4d2f6 MD |
472 | else if ((newsec) % 86400 == 0) { |
473 | --adjsec; | |
984263bc MD |
474 | time_state = TIME_OOP; |
475 | } | |
476 | break; | |
477 | ||
478 | /* | |
479 | * Delete second 23:59:59. | |
480 | */ | |
481 | case TIME_DEL: | |
482 | if (!(time_status & STA_DEL)) | |
483 | time_state = TIME_OK; | |
88c4d2f6 MD |
484 | else if (((newsec) + 1) % 86400 == 0) { |
485 | ++adjsec; | |
984263bc MD |
486 | time_tai--; |
487 | time_state = TIME_WAIT; | |
488 | } | |
489 | break; | |
490 | ||
491 | /* | |
492 | * Insert second in progress. | |
493 | */ | |
494 | case TIME_OOP: | |
495 | time_tai++; | |
496 | time_state = TIME_WAIT; | |
497 | break; | |
498 | ||
499 | /* | |
500 | * Wait for status bits to clear. | |
501 | */ | |
502 | case TIME_WAIT: | |
503 | if (!(time_status & (STA_INS | STA_DEL))) | |
504 | time_state = TIME_OK; | |
505 | } | |
506 | ||
507 | /* | |
88c4d2f6 MD |
508 | * time_offset represents the total time adjustment we wish to |
509 | * make (over no particular period of time). time_freq represents | |
510 | * the frequency compensation we wish to apply. | |
511 | * | |
512 | * time_adj represents the total adjustment we wish to make over | |
513 | * one full second. hardclock usually applies this adjustment in | |
514 | * time_adj / hz jumps, hz times a second. | |
984263bc MD |
515 | */ |
516 | ftemp = time_offset; | |
517 | #ifdef PPS_SYNC | |
518 | /* XXX even if PPS signal dies we should finish adjustment ? */ | |
581a9d18 | 519 | if ((time_status & STA_PPSTIME) && (time_status & STA_PPSSIGNAL)) |
984263bc MD |
520 | L_RSHIFT(ftemp, pps_shift); |
521 | else | |
522 | L_RSHIFT(ftemp, SHIFT_PLL + time_constant); | |
523 | #else | |
524 | L_RSHIFT(ftemp, SHIFT_PLL + time_constant); | |
525 | #endif /* PPS_SYNC */ | |
88c4d2f6 | 526 | time_adj = ftemp; /* adjustment for part of the offset */ |
984263bc | 527 | L_SUB(time_offset, ftemp); |
88c4d2f6 MD |
528 | L_ADD(time_adj, time_freq); /* add frequency correction */ |
529 | *nsec_adj = time_adj; | |
984263bc MD |
530 | #ifdef PPS_SYNC |
531 | if (pps_valid > 0) | |
532 | pps_valid--; | |
533 | else | |
534 | time_status &= ~STA_PPSSIGNAL; | |
535 | #endif /* PPS_SYNC */ | |
88c4d2f6 | 536 | return(adjsec); |
984263bc MD |
537 | } |
538 | ||
539 | /* | |
540 | * ntp_init() - initialize variables and structures | |
541 | * | |
542 | * This routine must be called after the kernel variables hz and tick | |
543 | * are set or changed and before the next tick interrupt. In this | |
544 | * particular implementation, these values are assumed set elsewhere in | |
545 | * the kernel. The design allows the clock frequency and tick interval | |
546 | * to be changed while the system is running. So, this routine should | |
547 | * probably be integrated with the code that does that. | |
548 | */ | |
549 | static void | |
77153250 | 550 | ntp_init(void) |
984263bc MD |
551 | { |
552 | ||
553 | /* | |
554 | * The following variable must be initialized any time the | |
555 | * kernel variable hz is changed. | |
556 | */ | |
557 | time_tick = NANOSECOND / hz; | |
558 | ||
559 | /* | |
560 | * The following variables are initialized only at startup. Only | |
561 | * those structures not cleared by the compiler need to be | |
562 | * initialized, and these only in the simulator. In the actual | |
563 | * kernel, any nonzero values here will quickly evaporate. | |
564 | */ | |
565 | L_CLR(time_offset); | |
566 | L_CLR(time_freq); | |
567 | #ifdef PPS_SYNC | |
568 | pps_tf[0].tv_sec = pps_tf[0].tv_nsec = 0; | |
569 | pps_tf[1].tv_sec = pps_tf[1].tv_nsec = 0; | |
570 | pps_tf[2].tv_sec = pps_tf[2].tv_nsec = 0; | |
571 | pps_fcount = 0; | |
572 | L_CLR(pps_freq); | |
573 | #endif /* PPS_SYNC */ | |
574 | } | |
575 | ||
ba39e2e0 | 576 | SYSINIT(ntpclocks, SI_BOOT2_CLOCKS, SI_ORDER_FIRST, ntp_init, NULL) |
984263bc MD |
577 | |
578 | /* | |
579 | * hardupdate() - local clock update | |
580 | * | |
581 | * This routine is called by ntp_adjtime() to update the local clock | |
582 | * phase and frequency. The implementation is of an adaptive-parameter, | |
583 | * hybrid phase/frequency-lock loop (PLL/FLL). The routine computes new | |
584 | * time and frequency offset estimates for each call. If the kernel PPS | |
585 | * discipline code is configured (PPS_SYNC), the PPS signal itself | |
586 | * determines the new time offset, instead of the calling argument. | |
587 | * Presumably, calls to ntp_adjtime() occur only when the caller | |
588 | * believes the local clock is valid within some bound (+-128 ms with | |
589 | * NTP). If the caller's time is far different than the PPS time, an | |
590 | * argument will ensue, and it's not clear who will lose. | |
591 | * | |
592 | * For uncompensated quartz crystal oscillators and nominal update | |
593 | * intervals less than 256 s, operation should be in phase-lock mode, | |
594 | * where the loop is disciplined to phase. For update intervals greater | |
595 | * than 1024 s, operation should be in frequency-lock mode, where the | |
596 | * loop is disciplined to frequency. Between 256 s and 1024 s, the mode | |
597 | * is selected by the STA_MODE status bit. | |
598 | */ | |
599 | static void | |
77153250 | 600 | hardupdate(long offset) |
984263bc MD |
601 | { |
602 | long mtemp; | |
603 | l_fp ftemp; | |
88c4d2f6 MD |
604 | globaldata_t gd; |
605 | ||
606 | gd = mycpu; | |
984263bc MD |
607 | |
608 | /* | |
609 | * Select how the phase is to be controlled and from which | |
610 | * source. If the PPS signal is present and enabled to | |
611 | * discipline the time, the PPS offset is used; otherwise, the | |
612 | * argument offset is used. | |
613 | */ | |
614 | if (!(time_status & STA_PLL)) | |
615 | return; | |
88c4d2f6 | 616 | if (!((time_status & STA_PPSTIME) && (time_status & STA_PPSSIGNAL))) { |
984263bc MD |
617 | if (offset > MAXPHASE) |
618 | time_monitor = MAXPHASE; | |
619 | else if (offset < -MAXPHASE) | |
620 | time_monitor = -MAXPHASE; | |
621 | else | |
622 | time_monitor = offset; | |
623 | L_LINT(time_offset, time_monitor); | |
624 | } | |
625 | ||
626 | /* | |
627 | * Select how the frequency is to be controlled and in which | |
628 | * mode (PLL or FLL). If the PPS signal is present and enabled | |
629 | * to discipline the frequency, the PPS frequency is used; | |
630 | * otherwise, the argument offset is used to compute it. | |
88c4d2f6 MD |
631 | * |
632 | * gd_time_seconds is basically an uncompensated uptime. We use | |
633 | * this for consistency. | |
984263bc MD |
634 | */ |
635 | if (time_status & STA_PPSFREQ && time_status & STA_PPSSIGNAL) { | |
636 | time_reftime = time_second; | |
637 | return; | |
638 | } | |
639 | if (time_status & STA_FREQHOLD || time_reftime == 0) | |
640 | time_reftime = time_second; | |
641 | mtemp = time_second - time_reftime; | |
642 | L_LINT(ftemp, time_monitor); | |
643 | L_RSHIFT(ftemp, (SHIFT_PLL + 2 + time_constant) << 1); | |
644 | L_MPY(ftemp, mtemp); | |
645 | L_ADD(time_freq, ftemp); | |
646 | time_status &= ~STA_MODE; | |
88c4d2f6 | 647 | if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) { |
984263bc MD |
648 | L_LINT(ftemp, (time_monitor << 4) / mtemp); |
649 | L_RSHIFT(ftemp, SHIFT_FLL + 4); | |
650 | L_ADD(time_freq, ftemp); | |
651 | time_status |= STA_MODE; | |
652 | } | |
653 | time_reftime = time_second; | |
654 | if (L_GINT(time_freq) > MAXFREQ) | |
655 | L_LINT(time_freq, MAXFREQ); | |
656 | else if (L_GINT(time_freq) < -MAXFREQ) | |
657 | L_LINT(time_freq, -MAXFREQ); | |
658 | } | |
659 | ||
660 | #ifdef PPS_SYNC | |
661 | /* | |
662 | * hardpps() - discipline CPU clock oscillator to external PPS signal | |
663 | * | |
664 | * This routine is called at each PPS interrupt in order to discipline | |
665 | * the CPU clock oscillator to the PPS signal. There are two independent | |
666 | * first-order feedback loops, one for the phase, the other for the | |
667 | * frequency. The phase loop measures and grooms the PPS phase offset | |
668 | * and leaves it in a handy spot for the seconds overflow routine. The | |
669 | * frequency loop averages successive PPS phase differences and | |
670 | * calculates the PPS frequency offset, which is also processed by the | |
671 | * seconds overflow routine. The code requires the caller to capture the | |
672 | * time and architecture-dependent hardware counter values in | |
673 | * nanoseconds at the on-time PPS signal transition. | |
674 | * | |
675 | * Note that, on some Unix systems this routine runs at an interrupt | |
676 | * priority level higher than the timer interrupt routine hardclock(). | |
677 | * Therefore, the variables used are distinct from the hardclock() | |
678 | * variables, except for the actual time and frequency variables, which | |
679 | * are determined by this routine and updated atomically. | |
680 | */ | |
681 | void | |
77153250 | 682 | hardpps(struct timespec *tsp, long nsec) |
984263bc MD |
683 | { |
684 | long u_sec, u_nsec, v_nsec; /* temps */ | |
685 | l_fp ftemp; | |
686 | ||
687 | /* | |
688 | * The signal is first processed by a range gate and frequency | |
689 | * discriminator. The range gate rejects noise spikes outside | |
690 | * the range +-500 us. The frequency discriminator rejects input | |
691 | * signals with apparent frequency outside the range 1 +-500 | |
692 | * PPM. If two hits occur in the same second, we ignore the | |
693 | * later hit; if not and a hit occurs outside the range gate, | |
694 | * keep the later hit for later comparison, but do not process | |
695 | * it. | |
696 | */ | |
697 | time_status |= STA_PPSSIGNAL | STA_PPSJITTER; | |
698 | time_status &= ~(STA_PPSWANDER | STA_PPSERROR); | |
699 | pps_valid = PPS_VALID; | |
700 | u_sec = tsp->tv_sec; | |
701 | u_nsec = tsp->tv_nsec; | |
702 | if (u_nsec >= (NANOSECOND >> 1)) { | |
703 | u_nsec -= NANOSECOND; | |
704 | u_sec++; | |
705 | } | |
706 | v_nsec = u_nsec - pps_tf[0].tv_nsec; | |
707 | if (u_sec == pps_tf[0].tv_sec && v_nsec < NANOSECOND - | |
708 | MAXFREQ) | |
709 | return; | |
710 | pps_tf[2] = pps_tf[1]; | |
711 | pps_tf[1] = pps_tf[0]; | |
712 | pps_tf[0].tv_sec = u_sec; | |
713 | pps_tf[0].tv_nsec = u_nsec; | |
714 | ||
715 | /* | |
716 | * Compute the difference between the current and previous | |
717 | * counter values. If the difference exceeds 0.5 s, assume it | |
718 | * has wrapped around, so correct 1.0 s. If the result exceeds | |
719 | * the tick interval, the sample point has crossed a tick | |
720 | * boundary during the last second, so correct the tick. Very | |
721 | * intricate. | |
722 | */ | |
723 | u_nsec = nsec; | |
724 | if (u_nsec > (NANOSECOND >> 1)) | |
725 | u_nsec -= NANOSECOND; | |
726 | else if (u_nsec < -(NANOSECOND >> 1)) | |
727 | u_nsec += NANOSECOND; | |
728 | pps_fcount += u_nsec; | |
729 | if (v_nsec > MAXFREQ || v_nsec < -MAXFREQ) | |
730 | return; | |
731 | time_status &= ~STA_PPSJITTER; | |
732 | ||
733 | /* | |
734 | * A three-stage median filter is used to help denoise the PPS | |
735 | * time. The median sample becomes the time offset estimate; the | |
736 | * difference between the other two samples becomes the time | |
737 | * dispersion (jitter) estimate. | |
738 | */ | |
739 | if (pps_tf[0].tv_nsec > pps_tf[1].tv_nsec) { | |
740 | if (pps_tf[1].tv_nsec > pps_tf[2].tv_nsec) { | |
741 | v_nsec = pps_tf[1].tv_nsec; /* 0 1 2 */ | |
742 | u_nsec = pps_tf[0].tv_nsec - pps_tf[2].tv_nsec; | |
743 | } else if (pps_tf[2].tv_nsec > pps_tf[0].tv_nsec) { | |
744 | v_nsec = pps_tf[0].tv_nsec; /* 2 0 1 */ | |
745 | u_nsec = pps_tf[2].tv_nsec - pps_tf[1].tv_nsec; | |
746 | } else { | |
747 | v_nsec = pps_tf[2].tv_nsec; /* 0 2 1 */ | |
748 | u_nsec = pps_tf[0].tv_nsec - pps_tf[1].tv_nsec; | |
749 | } | |
750 | } else { | |
751 | if (pps_tf[1].tv_nsec < pps_tf[2].tv_nsec) { | |
752 | v_nsec = pps_tf[1].tv_nsec; /* 2 1 0 */ | |
753 | u_nsec = pps_tf[2].tv_nsec - pps_tf[0].tv_nsec; | |
754 | } else if (pps_tf[2].tv_nsec < pps_tf[0].tv_nsec) { | |
755 | v_nsec = pps_tf[0].tv_nsec; /* 1 0 2 */ | |
756 | u_nsec = pps_tf[1].tv_nsec - pps_tf[2].tv_nsec; | |
757 | } else { | |
758 | v_nsec = pps_tf[2].tv_nsec; /* 1 2 0 */ | |
759 | u_nsec = pps_tf[1].tv_nsec - pps_tf[0].tv_nsec; | |
760 | } | |
761 | } | |
762 | ||
763 | /* | |
764 | * Nominal jitter is due to PPS signal noise and interrupt | |
765 | * latency. If it exceeds the popcorn threshold, the sample is | |
766 | * discarded. otherwise, if so enabled, the time offset is | |
767 | * updated. We can tolerate a modest loss of data here without | |
768 | * much degrading time accuracy. | |
769 | */ | |
770 | if (u_nsec > (pps_jitter << PPS_POPCORN)) { | |
771 | time_status |= STA_PPSJITTER; | |
772 | pps_jitcnt++; | |
773 | } else if (time_status & STA_PPSTIME) { | |
774 | time_monitor = -v_nsec; | |
775 | L_LINT(time_offset, time_monitor); | |
776 | } | |
777 | pps_jitter += (u_nsec - pps_jitter) >> PPS_FAVG; | |
778 | u_sec = pps_tf[0].tv_sec - pps_lastsec; | |
779 | if (u_sec < (1 << pps_shift)) | |
780 | return; | |
781 | ||
782 | /* | |
783 | * At the end of the calibration interval the difference between | |
784 | * the first and last counter values becomes the scaled | |
785 | * frequency. It will later be divided by the length of the | |
786 | * interval to determine the frequency update. If the frequency | |
787 | * exceeds a sanity threshold, or if the actual calibration | |
788 | * interval is not equal to the expected length, the data are | |
789 | * discarded. We can tolerate a modest loss of data here without | |
790 | * much degrading frequency accuracy. | |
791 | */ | |
792 | pps_calcnt++; | |
793 | v_nsec = -pps_fcount; | |
794 | pps_lastsec = pps_tf[0].tv_sec; | |
795 | pps_fcount = 0; | |
796 | u_nsec = MAXFREQ << pps_shift; | |
797 | if (v_nsec > u_nsec || v_nsec < -u_nsec || u_sec != (1 << | |
798 | pps_shift)) { | |
799 | time_status |= STA_PPSERROR; | |
800 | pps_errcnt++; | |
801 | return; | |
802 | } | |
803 | ||
804 | /* | |
805 | * Here the raw frequency offset and wander (stability) is | |
806 | * calculated. If the wander is less than the wander threshold | |
807 | * for four consecutive averaging intervals, the interval is | |
808 | * doubled; if it is greater than the threshold for four | |
809 | * consecutive intervals, the interval is halved. The scaled | |
810 | * frequency offset is converted to frequency offset. The | |
811 | * stability metric is calculated as the average of recent | |
812 | * frequency changes, but is used only for performance | |
813 | * monitoring. | |
814 | */ | |
815 | L_LINT(ftemp, v_nsec); | |
816 | L_RSHIFT(ftemp, pps_shift); | |
817 | L_SUB(ftemp, pps_freq); | |
818 | u_nsec = L_GINT(ftemp); | |
819 | if (u_nsec > PPS_MAXWANDER) { | |
820 | L_LINT(ftemp, PPS_MAXWANDER); | |
821 | pps_intcnt--; | |
822 | time_status |= STA_PPSWANDER; | |
823 | pps_stbcnt++; | |
824 | } else if (u_nsec < -PPS_MAXWANDER) { | |
825 | L_LINT(ftemp, -PPS_MAXWANDER); | |
826 | pps_intcnt--; | |
827 | time_status |= STA_PPSWANDER; | |
828 | pps_stbcnt++; | |
829 | } else { | |
830 | pps_intcnt++; | |
831 | } | |
832 | if (pps_intcnt >= 4) { | |
833 | pps_intcnt = 4; | |
834 | if (pps_shift < pps_shiftmax) { | |
835 | pps_shift++; | |
836 | pps_intcnt = 0; | |
837 | } | |
838 | } else if (pps_intcnt <= -4 || pps_shift > pps_shiftmax) { | |
839 | pps_intcnt = -4; | |
840 | if (pps_shift > PPS_FAVG) { | |
841 | pps_shift--; | |
842 | pps_intcnt = 0; | |
843 | } | |
844 | } | |
845 | if (u_nsec < 0) | |
846 | u_nsec = -u_nsec; | |
847 | pps_stabil += (u_nsec * SCALE_PPM - pps_stabil) >> PPS_FAVG; | |
848 | ||
849 | /* | |
850 | * The PPS frequency is recalculated and clamped to the maximum | |
851 | * MAXFREQ. If enabled, the system clock frequency is updated as | |
852 | * well. | |
853 | */ | |
854 | L_ADD(pps_freq, ftemp); | |
855 | u_nsec = L_GINT(pps_freq); | |
856 | if (u_nsec > MAXFREQ) | |
857 | L_LINT(pps_freq, MAXFREQ); | |
858 | else if (u_nsec < -MAXFREQ) | |
859 | L_LINT(pps_freq, -MAXFREQ); | |
860 | if (time_status & STA_PPSFREQ) | |
861 | time_freq = pps_freq; | |
862 | } | |
863 | #endif /* PPS_SYNC */ |