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 *
| 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: head/sys/kern/kern_ntptime.c 94740 2002-04-15 08:58:24Z phk $
| 31 * $FreeBSD: head/sys/kern/kern_ntptime.c 94754 2002-04-15 12:23:11Z phk $
|
32 */
33
34#include "opt_ntp.h"
35
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/sysproto.h>
39#include <sys/kernel.h>
40#include <sys/proc.h>
41#include <sys/lock.h>
42#include <sys/mutex.h>
43#include <sys/time.h>
44#include <sys/timex.h>
45#include <sys/timetc.h>
46#include <sys/timepps.h>
47#include <sys/sysctl.h>
48
49/*
50 * Single-precision macros for 64-bit machines
51 */
52typedef 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
141static int time_state = TIME_OK; /* clock state */
142static int time_status = STA_UNSYNC; /* clock status bits */
143static long time_tai; /* TAI offset (s) */
144static long time_monitor; /* last time offset scaled (ns) */
145static long time_constant; /* poll interval (shift) (s) */
146static long time_precision = 1; /* clock precision (ns) */
147static long time_maxerror = MAXPHASE / 1000; /* maximum error (us) */
148static long time_esterror = MAXPHASE / 1000; /* estimated error (us) */
149static long time_reftime; /* time at last adjustment (s) */
150static long time_tick; /* nanoseconds per tick (ns) */
151static l_fp time_offset; /* time offset (ns) */
152static l_fp time_freq; /* frequency offset (ns/s) */
153static l_fp time_adj; /* tick adjust (ns/s) */
154
| 32 */
33
34#include "opt_ntp.h"
35
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/sysproto.h>
39#include <sys/kernel.h>
40#include <sys/proc.h>
41#include <sys/lock.h>
42#include <sys/mutex.h>
43#include <sys/time.h>
44#include <sys/timex.h>
45#include <sys/timetc.h>
46#include <sys/timepps.h>
47#include <sys/sysctl.h>
48
49/*
50 * Single-precision macros for 64-bit machines
51 */
52typedef 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
141static int time_state = TIME_OK; /* clock state */
142static int time_status = STA_UNSYNC; /* clock status bits */
143static long time_tai; /* TAI offset (s) */
144static long time_monitor; /* last time offset scaled (ns) */
145static long time_constant; /* poll interval (shift) (s) */
146static long time_precision = 1; /* clock precision (ns) */
147static long time_maxerror = MAXPHASE / 1000; /* maximum error (us) */
148static long time_esterror = MAXPHASE / 1000; /* estimated error (us) */
149static long time_reftime; /* time at last adjustment (s) */
150static long time_tick; /* nanoseconds per tick (ns) */
151static l_fp time_offset; /* time offset (ns) */
152static l_fp time_freq; /* frequency offset (ns/s) */
153static l_fp time_adj; /* tick adjust (ns/s) */
154
|
| 155static int64_t time_adjtime; /* correction from adjtime(2) (usec) */
156
|
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
170static struct timespec pps_tf[3]; /* phase median filter */
171static l_fp pps_freq; /* scaled frequency offset (ns/s) */
172static long pps_fcount; /* frequency accumulator */
173static long pps_jitter; /* nominal jitter (ns) */
174static long pps_stabil; /* nominal stability (scaled ns/s) */
175static long pps_lastsec; /* time at last calibration (s) */
176static int pps_valid; /* signal watchdog counter */
177static int pps_shift = PPS_FAVG; /* interval duration (s) (shift) */
178static int pps_shiftmax = PPS_FAVGDEF; /* max interval duration (s) (shift) */
179static int pps_intcnt; /* wander counter */
180
181/*
182 * PPS signal quality monitors
183 */
184static long pps_calcnt; /* calibration intervals */
185static long pps_jitcnt; /* jitter limit exceeded */
186static long pps_stbcnt; /* stability limit exceeded */
187static long pps_errcnt; /* calibration errors */
188#endif /* PPS_SYNC */
189/*
190 * End of phase/frequency-lock loop (PLL/FLL) definitions
191 */
192
193static void ntp_init(void);
194static 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 */
203static int
204ntp_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
250SYSCTL_NODE(_kern, OID_AUTO, ntp_pll, CTLFLAG_RW, 0, "");
251SYSCTL_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
255SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shiftmax, CTLFLAG_RW, &pps_shiftmax, 0, "");
256SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shift, CTLFLAG_RW, &pps_shift, 0, "");
257SYSCTL_INT(_kern_ntp_pll, OID_AUTO, time_monitor, CTLFLAG_RD, &time_monitor, 0, "");
258
259SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, pps_freq, CTLFLAG_RD, &pps_freq, sizeof(pps_freq), "I", "");
260SYSCTL_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 */
269#ifndef _SYS_SYSPROTO_H_
270struct ntp_adjtime_args {
271 struct timex *tp;
272};
273#endif
274
275/*
276 * MPSAFE
277 */
278int
279ntp_adjtime(struct thread *td, struct ntp_adjtime_args *uap)
280{
281 struct timex ntv; /* temporary structure */
282 long freq; /* frequency ns/s) */
283 int modes; /* mode bits from structure */
284 int s; /* caller priority */
285 int error;
286
287 error = copyin((caddr_t)uap->tp, (caddr_t)&ntv, sizeof(ntv));
288 if (error)
289 return(error);
290
291 /*
292 * Update selected clock variables - only the superuser can
293 * change anything. Note that there is no error checking here on
294 * the assumption the superuser should know what it is doing.
295 * Note that either the time constant or TAI offset are loaded
296 * from the ntv.constant member, depending on the mode bits. If
297 * the STA_PLL bit in the status word is cleared, the state and
298 * status words are reset to the initial values at boot.
299 */
300 mtx_lock(&Giant);
301 modes = ntv.modes;
302 if (modes)
303 error = suser(td);
304 if (error)
305 goto done2;
306 s = splclock();
307 if (modes & MOD_MAXERROR)
308 time_maxerror = ntv.maxerror;
309 if (modes & MOD_ESTERROR)
310 time_esterror = ntv.esterror;
311 if (modes & MOD_STATUS) {
312 if (time_status & STA_PLL && !(ntv.status & STA_PLL)) {
313 time_state = TIME_OK;
314 time_status = STA_UNSYNC;
315#ifdef PPS_SYNC
316 pps_shift = PPS_FAVG;
317#endif /* PPS_SYNC */
318 }
319 time_status &= STA_RONLY;
320 time_status |= ntv.status & ~STA_RONLY;
321 }
322 if (modes & MOD_TIMECONST) {
323 if (ntv.constant < 0)
324 time_constant = 0;
325 else if (ntv.constant > MAXTC)
326 time_constant = MAXTC;
327 else
328 time_constant = ntv.constant;
329 }
330 if (modes & MOD_TAI) {
331 if (ntv.constant > 0) /* XXX zero & negative numbers ? */
332 time_tai = ntv.constant;
333 }
334#ifdef PPS_SYNC
335 if (modes & MOD_PPSMAX) {
336 if (ntv.shift < PPS_FAVG)
337 pps_shiftmax = PPS_FAVG;
338 else if (ntv.shift > PPS_FAVGMAX)
339 pps_shiftmax = PPS_FAVGMAX;
340 else
341 pps_shiftmax = ntv.shift;
342 }
343#endif /* PPS_SYNC */
344 if (modes & MOD_NANO)
345 time_status |= STA_NANO;
346 if (modes & MOD_MICRO)
347 time_status &= ~STA_NANO;
348 if (modes & MOD_CLKB)
349 time_status |= STA_CLK;
350 if (modes & MOD_CLKA)
351 time_status &= ~STA_CLK;
352 if (modes & MOD_OFFSET) {
353 if (time_status & STA_NANO)
354 hardupdate(ntv.offset);
355 else
356 hardupdate(ntv.offset * 1000);
357 }
358 if (modes & MOD_FREQUENCY) {
359 freq = (ntv.freq * 1000LL) >> 16;
360 if (freq > MAXFREQ)
361 L_LINT(time_freq, MAXFREQ);
362 else if (freq < -MAXFREQ)
363 L_LINT(time_freq, -MAXFREQ);
364 else
365 L_LINT(time_freq, freq);
366#ifdef PPS_SYNC
367 pps_freq = time_freq;
368#endif /* PPS_SYNC */
369 }
370
371 /*
372 * Retrieve all clock variables. Note that the TAI offset is
373 * returned only by ntp_gettime();
374 */
375 if (time_status & STA_NANO)
376 ntv.offset = L_GINT(time_offset);
377 else
378 ntv.offset = L_GINT(time_offset) / 1000; /* XXX rounding ? */
379 ntv.freq = L_GINT((time_freq / 1000LL) << 16);
380 ntv.maxerror = time_maxerror;
381 ntv.esterror = time_esterror;
382 ntv.status = time_status;
383 ntv.constant = time_constant;
384 if (time_status & STA_NANO)
385 ntv.precision = time_precision;
386 else
387 ntv.precision = time_precision / 1000;
388 ntv.tolerance = MAXFREQ * SCALE_PPM;
389#ifdef PPS_SYNC
390 ntv.shift = pps_shift;
391 ntv.ppsfreq = L_GINT((pps_freq / 1000LL) << 16);
392 if (time_status & STA_NANO)
393 ntv.jitter = pps_jitter;
394 else
395 ntv.jitter = pps_jitter / 1000;
396 ntv.stabil = pps_stabil;
397 ntv.calcnt = pps_calcnt;
398 ntv.errcnt = pps_errcnt;
399 ntv.jitcnt = pps_jitcnt;
400 ntv.stbcnt = pps_stbcnt;
401#endif /* PPS_SYNC */
402 splx(s);
403
404 error = copyout((caddr_t)&ntv, (caddr_t)uap->tp, sizeof(ntv));
405 if (error)
406 goto done2;
407
408 /*
409 * Status word error decode. See comments in
410 * ntp_gettime() routine.
411 */
412 if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) ||
413 (time_status & (STA_PPSFREQ | STA_PPSTIME) &&
414 !(time_status & STA_PPSSIGNAL)) ||
415 (time_status & STA_PPSTIME &&
416 time_status & STA_PPSJITTER) ||
417 (time_status & STA_PPSFREQ &&
418 time_status & (STA_PPSWANDER | STA_PPSERROR))) {
419 td->td_retval[0] = TIME_ERROR;
420 } else {
421 td->td_retval[0] = time_state;
422 }
423done2:
424 mtx_unlock(&Giant);
425 return (error);
426}
427
428/*
429 * second_overflow() - called after ntp_tick_adjust()
430 *
431 * This routine is ordinarily called immediately following the above
432 * routine ntp_tick_adjust(). While these two routines are normally
433 * combined, they are separated here only for the purposes of
434 * simulation.
435 */
436void
437ntp_update_second(struct timecounter *tcp)
438{
439 u_int32_t *newsec;
| 157#ifdef PPS_SYNC
158/*
159 * The following variables are used when a pulse-per-second (PPS) signal
160 * is available and connected via a modem control lead. They establish
161 * the engineering parameters of the clock discipline loop when
162 * controlled by the PPS signal.
163 */
164#define PPS_FAVG 2 /* min freq avg interval (s) (shift) */
165#define PPS_FAVGDEF 8 /* default freq avg int (s) (shift) */
166#define PPS_FAVGMAX 15 /* max freq avg interval (s) (shift) */
167#define PPS_PAVG 4 /* phase avg interval (s) (shift) */
168#define PPS_VALID 120 /* PPS signal watchdog max (s) */
169#define PPS_MAXWANDER 100000 /* max PPS wander (ns/s) */
170#define PPS_POPCORN 2 /* popcorn spike threshold (shift) */
171
172static struct timespec pps_tf[3]; /* phase median filter */
173static l_fp pps_freq; /* scaled frequency offset (ns/s) */
174static long pps_fcount; /* frequency accumulator */
175static long pps_jitter; /* nominal jitter (ns) */
176static long pps_stabil; /* nominal stability (scaled ns/s) */
177static long pps_lastsec; /* time at last calibration (s) */
178static int pps_valid; /* signal watchdog counter */
179static int pps_shift = PPS_FAVG; /* interval duration (s) (shift) */
180static int pps_shiftmax = PPS_FAVGDEF; /* max interval duration (s) (shift) */
181static int pps_intcnt; /* wander counter */
182
183/*
184 * PPS signal quality monitors
185 */
186static long pps_calcnt; /* calibration intervals */
187static long pps_jitcnt; /* jitter limit exceeded */
188static long pps_stbcnt; /* stability limit exceeded */
189static long pps_errcnt; /* calibration errors */
190#endif /* PPS_SYNC */
191/*
192 * End of phase/frequency-lock loop (PLL/FLL) definitions
193 */
194
195static void ntp_init(void);
196static void hardupdate(long offset);
197
198/*
199 * ntp_gettime() - NTP user application interface
200 *
201 * See the timex.h header file for synopsis and API description. Note
202 * that the TAI offset is returned in the ntvtimeval.tai structure
203 * member.
204 */
205static int
206ntp_sysctl(SYSCTL_HANDLER_ARGS)
207{
208 struct ntptimeval ntv; /* temporary structure */
209 struct timespec atv; /* nanosecond time */
210
211 nanotime(&atv);
212 ntv.time.tv_sec = atv.tv_sec;
213 ntv.time.tv_nsec = atv.tv_nsec;
214 ntv.maxerror = time_maxerror;
215 ntv.esterror = time_esterror;
216 ntv.tai = time_tai;
217 ntv.time_state = time_state;
218
219 /*
220 * Status word error decode. If any of these conditions occur,
221 * an error is returned, instead of the status word. Most
222 * applications will care only about the fact the system clock
223 * may not be trusted, not about the details.
224 *
225 * Hardware or software error
226 */
227 if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) ||
228
229 /*
230 * PPS signal lost when either time or frequency synchronization
231 * requested
232 */
233 (time_status & (STA_PPSFREQ | STA_PPSTIME) &&
234 !(time_status & STA_PPSSIGNAL)) ||
235
236 /*
237 * PPS jitter exceeded when time synchronization requested
238 */
239 (time_status & STA_PPSTIME &&
240 time_status & STA_PPSJITTER) ||
241
242 /*
243 * PPS wander exceeded or calibration error when frequency
244 * synchronization requested
245 */
246 (time_status & STA_PPSFREQ &&
247 time_status & (STA_PPSWANDER | STA_PPSERROR)))
248 ntv.time_state = TIME_ERROR;
249 return (sysctl_handle_opaque(oidp, &ntv, sizeof ntv, req));
250}
251
252SYSCTL_NODE(_kern, OID_AUTO, ntp_pll, CTLFLAG_RW, 0, "");
253SYSCTL_PROC(_kern_ntp_pll, OID_AUTO, gettime, CTLTYPE_OPAQUE|CTLFLAG_RD,
254 0, sizeof(struct ntptimeval) , ntp_sysctl, "S,ntptimeval", "");
255
256#ifdef PPS_SYNC
257SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shiftmax, CTLFLAG_RW, &pps_shiftmax, 0, "");
258SYSCTL_INT(_kern_ntp_pll, OID_AUTO, pps_shift, CTLFLAG_RW, &pps_shift, 0, "");
259SYSCTL_INT(_kern_ntp_pll, OID_AUTO, time_monitor, CTLFLAG_RD, &time_monitor, 0, "");
260
261SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, pps_freq, CTLFLAG_RD, &pps_freq, sizeof(pps_freq), "I", "");
262SYSCTL_OPAQUE(_kern_ntp_pll, OID_AUTO, time_freq, CTLFLAG_RD, &time_freq, sizeof(time_freq), "I", "");
263#endif
264/*
265 * ntp_adjtime() - NTP daemon application interface
266 *
267 * See the timex.h header file for synopsis and API description. Note
268 * that the timex.constant structure member has a dual purpose to set
269 * the time constant and to set the TAI offset.
270 */
271#ifndef _SYS_SYSPROTO_H_
272struct ntp_adjtime_args {
273 struct timex *tp;
274};
275#endif
276
277/*
278 * MPSAFE
279 */
280int
281ntp_adjtime(struct thread *td, struct ntp_adjtime_args *uap)
282{
283 struct timex ntv; /* temporary structure */
284 long freq; /* frequency ns/s) */
285 int modes; /* mode bits from structure */
286 int s; /* caller priority */
287 int error;
288
289 error = copyin((caddr_t)uap->tp, (caddr_t)&ntv, sizeof(ntv));
290 if (error)
291 return(error);
292
293 /*
294 * Update selected clock variables - only the superuser can
295 * change anything. Note that there is no error checking here on
296 * the assumption the superuser should know what it is doing.
297 * Note that either the time constant or TAI offset are loaded
298 * from the ntv.constant member, depending on the mode bits. If
299 * the STA_PLL bit in the status word is cleared, the state and
300 * status words are reset to the initial values at boot.
301 */
302 mtx_lock(&Giant);
303 modes = ntv.modes;
304 if (modes)
305 error = suser(td);
306 if (error)
307 goto done2;
308 s = splclock();
309 if (modes & MOD_MAXERROR)
310 time_maxerror = ntv.maxerror;
311 if (modes & MOD_ESTERROR)
312 time_esterror = ntv.esterror;
313 if (modes & MOD_STATUS) {
314 if (time_status & STA_PLL && !(ntv.status & STA_PLL)) {
315 time_state = TIME_OK;
316 time_status = STA_UNSYNC;
317#ifdef PPS_SYNC
318 pps_shift = PPS_FAVG;
319#endif /* PPS_SYNC */
320 }
321 time_status &= STA_RONLY;
322 time_status |= ntv.status & ~STA_RONLY;
323 }
324 if (modes & MOD_TIMECONST) {
325 if (ntv.constant < 0)
326 time_constant = 0;
327 else if (ntv.constant > MAXTC)
328 time_constant = MAXTC;
329 else
330 time_constant = ntv.constant;
331 }
332 if (modes & MOD_TAI) {
333 if (ntv.constant > 0) /* XXX zero & negative numbers ? */
334 time_tai = ntv.constant;
335 }
336#ifdef PPS_SYNC
337 if (modes & MOD_PPSMAX) {
338 if (ntv.shift < PPS_FAVG)
339 pps_shiftmax = PPS_FAVG;
340 else if (ntv.shift > PPS_FAVGMAX)
341 pps_shiftmax = PPS_FAVGMAX;
342 else
343 pps_shiftmax = ntv.shift;
344 }
345#endif /* PPS_SYNC */
346 if (modes & MOD_NANO)
347 time_status |= STA_NANO;
348 if (modes & MOD_MICRO)
349 time_status &= ~STA_NANO;
350 if (modes & MOD_CLKB)
351 time_status |= STA_CLK;
352 if (modes & MOD_CLKA)
353 time_status &= ~STA_CLK;
354 if (modes & MOD_OFFSET) {
355 if (time_status & STA_NANO)
356 hardupdate(ntv.offset);
357 else
358 hardupdate(ntv.offset * 1000);
359 }
360 if (modes & MOD_FREQUENCY) {
361 freq = (ntv.freq * 1000LL) >> 16;
362 if (freq > MAXFREQ)
363 L_LINT(time_freq, MAXFREQ);
364 else if (freq < -MAXFREQ)
365 L_LINT(time_freq, -MAXFREQ);
366 else
367 L_LINT(time_freq, freq);
368#ifdef PPS_SYNC
369 pps_freq = time_freq;
370#endif /* PPS_SYNC */
371 }
372
373 /*
374 * Retrieve all clock variables. Note that the TAI offset is
375 * returned only by ntp_gettime();
376 */
377 if (time_status & STA_NANO)
378 ntv.offset = L_GINT(time_offset);
379 else
380 ntv.offset = L_GINT(time_offset) / 1000; /* XXX rounding ? */
381 ntv.freq = L_GINT((time_freq / 1000LL) << 16);
382 ntv.maxerror = time_maxerror;
383 ntv.esterror = time_esterror;
384 ntv.status = time_status;
385 ntv.constant = time_constant;
386 if (time_status & STA_NANO)
387 ntv.precision = time_precision;
388 else
389 ntv.precision = time_precision / 1000;
390 ntv.tolerance = MAXFREQ * SCALE_PPM;
391#ifdef PPS_SYNC
392 ntv.shift = pps_shift;
393 ntv.ppsfreq = L_GINT((pps_freq / 1000LL) << 16);
394 if (time_status & STA_NANO)
395 ntv.jitter = pps_jitter;
396 else
397 ntv.jitter = pps_jitter / 1000;
398 ntv.stabil = pps_stabil;
399 ntv.calcnt = pps_calcnt;
400 ntv.errcnt = pps_errcnt;
401 ntv.jitcnt = pps_jitcnt;
402 ntv.stbcnt = pps_stbcnt;
403#endif /* PPS_SYNC */
404 splx(s);
405
406 error = copyout((caddr_t)&ntv, (caddr_t)uap->tp, sizeof(ntv));
407 if (error)
408 goto done2;
409
410 /*
411 * Status word error decode. See comments in
412 * ntp_gettime() routine.
413 */
414 if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) ||
415 (time_status & (STA_PPSFREQ | STA_PPSTIME) &&
416 !(time_status & STA_PPSSIGNAL)) ||
417 (time_status & STA_PPSTIME &&
418 time_status & STA_PPSJITTER) ||
419 (time_status & STA_PPSFREQ &&
420 time_status & (STA_PPSWANDER | STA_PPSERROR))) {
421 td->td_retval[0] = TIME_ERROR;
422 } else {
423 td->td_retval[0] = time_state;
424 }
425done2:
426 mtx_unlock(&Giant);
427 return (error);
428}
429
430/*
431 * second_overflow() - called after ntp_tick_adjust()
432 *
433 * This routine is ordinarily called immediately following the above
434 * routine ntp_tick_adjust(). While these two routines are normally
435 * combined, they are separated here only for the purposes of
436 * simulation.
437 */
438void
439ntp_update_second(struct timecounter *tcp)
440{
441 u_int32_t *newsec;
|
| 442 int tickrate;
|
440 l_fp ftemp; /* 32/64-bit temporary */
441
442 newsec = &tcp->tc_offset.sec;
443 /*
444 * On rollover of the second both the nanosecond and microsecond
445 * clocks are updated and the state machine cranked as
446 * necessary. The phase adjustment to be used for the next
447 * second is calculated and the maximum error is increased by
448 * the tolerance.
449 */
450 time_maxerror += MAXFREQ / 1000;
451
452 /*
453 * Leap second processing. If in leap-insert state at
454 * the end of the day, the system clock is set back one
455 * second; if in leap-delete state, the system clock is
456 * set ahead one second. The nano_time() routine or
457 * external clock driver will insure that reported time
458 * is always monotonic.
459 */
460 switch (time_state) {
461
462 /*
463 * No warning.
464 */
465 case TIME_OK:
466 if (time_status & STA_INS)
467 time_state = TIME_INS;
468 else if (time_status & STA_DEL)
469 time_state = TIME_DEL;
470 break;
471
472 /*
473 * Insert second 23:59:60 following second
474 * 23:59:59.
475 */
476 case TIME_INS:
477 if (!(time_status & STA_INS))
478 time_state = TIME_OK;
479 else if ((*newsec) % 86400 == 0) {
480 (*newsec)--;
481 time_state = TIME_OOP;
482 }
483 break;
484
485 /*
486 * Delete second 23:59:59.
487 */
488 case TIME_DEL:
489 if (!(time_status & STA_DEL))
490 time_state = TIME_OK;
491 else if (((*newsec) + 1) % 86400 == 0) {
492 (*newsec)++;
493 time_tai--;
494 time_state = TIME_WAIT;
495 }
496 break;
497
498 /*
499 * Insert second in progress.
500 */
501 case TIME_OOP:
502 time_tai++;
503 time_state = TIME_WAIT;
504 break;
505
506 /*
507 * Wait for status bits to clear.
508 */
509 case TIME_WAIT:
510 if (!(time_status & (STA_INS | STA_DEL)))
511 time_state = TIME_OK;
512 }
513
514 /*
515 * Compute the total time adjustment for the next second
516 * in ns. The offset is reduced by a factor depending on
517 * whether the PPS signal is operating. Note that the
518 * value is in effect scaled by the clock frequency,
519 * since the adjustment is added at each tick interrupt.
520 */
521 ftemp = time_offset;
522#ifdef PPS_SYNC
523 /* XXX even if PPS signal dies we should finish adjustment ? */
524 if (time_status & STA_PPSTIME && time_status &
525 STA_PPSSIGNAL)
526 L_RSHIFT(ftemp, pps_shift);
527 else
528 L_RSHIFT(ftemp, SHIFT_PLL + time_constant);
529#else
530 L_RSHIFT(ftemp, SHIFT_PLL + time_constant);
531#endif /* PPS_SYNC */
532 time_adj = ftemp;
533 L_SUB(time_offset, ftemp);
534 L_ADD(time_adj, time_freq);
| 443 l_fp ftemp; /* 32/64-bit temporary */
444
445 newsec = &tcp->tc_offset.sec;
446 /*
447 * On rollover of the second both the nanosecond and microsecond
448 * clocks are updated and the state machine cranked as
449 * necessary. The phase adjustment to be used for the next
450 * second is calculated and the maximum error is increased by
451 * the tolerance.
452 */
453 time_maxerror += MAXFREQ / 1000;
454
455 /*
456 * Leap second processing. If in leap-insert state at
457 * the end of the day, the system clock is set back one
458 * second; if in leap-delete state, the system clock is
459 * set ahead one second. The nano_time() routine or
460 * external clock driver will insure that reported time
461 * is always monotonic.
462 */
463 switch (time_state) {
464
465 /*
466 * No warning.
467 */
468 case TIME_OK:
469 if (time_status & STA_INS)
470 time_state = TIME_INS;
471 else if (time_status & STA_DEL)
472 time_state = TIME_DEL;
473 break;
474
475 /*
476 * Insert second 23:59:60 following second
477 * 23:59:59.
478 */
479 case TIME_INS:
480 if (!(time_status & STA_INS))
481 time_state = TIME_OK;
482 else if ((*newsec) % 86400 == 0) {
483 (*newsec)--;
484 time_state = TIME_OOP;
485 }
486 break;
487
488 /*
489 * Delete second 23:59:59.
490 */
491 case TIME_DEL:
492 if (!(time_status & STA_DEL))
493 time_state = TIME_OK;
494 else if (((*newsec) + 1) % 86400 == 0) {
495 (*newsec)++;
496 time_tai--;
497 time_state = TIME_WAIT;
498 }
499 break;
500
501 /*
502 * Insert second in progress.
503 */
504 case TIME_OOP:
505 time_tai++;
506 time_state = TIME_WAIT;
507 break;
508
509 /*
510 * Wait for status bits to clear.
511 */
512 case TIME_WAIT:
513 if (!(time_status & (STA_INS | STA_DEL)))
514 time_state = TIME_OK;
515 }
516
517 /*
518 * Compute the total time adjustment for the next second
519 * in ns. The offset is reduced by a factor depending on
520 * whether the PPS signal is operating. Note that the
521 * value is in effect scaled by the clock frequency,
522 * since the adjustment is added at each tick interrupt.
523 */
524 ftemp = time_offset;
525#ifdef PPS_SYNC
526 /* XXX even if PPS signal dies we should finish adjustment ? */
527 if (time_status & STA_PPSTIME && time_status &
528 STA_PPSSIGNAL)
529 L_RSHIFT(ftemp, pps_shift);
530 else
531 L_RSHIFT(ftemp, SHIFT_PLL + time_constant);
532#else
533 L_RSHIFT(ftemp, SHIFT_PLL + time_constant);
534#endif /* PPS_SYNC */
535 time_adj = ftemp;
536 L_SUB(time_offset, ftemp);
537 L_ADD(time_adj, time_freq);
|
| 538
539 /*
540 * Apply any correction from adjtime(2). If more than one second
541 * off we slew at a rate of 5ms/s (5000 PPM) else 500us/s (500PPM)
542 * until the last second is slewed the final < 500 usecs.
543 */
544 if (time_adjtime != 0) {
545 if (time_adjtime > 1000000)
546 tickrate = 5000;
547 else if (time_adjtime < -1000000)
548 tickrate = -5000;
549 else if (time_adjtime > 500)
550 tickrate = 500;
551 else if (time_adjtime < -500)
552 tickrate = -500;
553 else if (time_adjtime != 0)
554 tickrate = time_adjtime;
555 else
556 tickrate = 0; /* GCC sucks! */
557 time_adjtime -= tickrate;
558 L_LINT(ftemp, tickrate * 1000);
559 L_ADD(time_adj, ftemp);
560 }
|
535 tcp->tc_adjustment = time_adj;
| 561 tcp->tc_adjustment = time_adj;
|
| 562
|
536#ifdef PPS_SYNC
537 if (pps_valid > 0)
538 pps_valid--;
539 else
540 time_status &= ~STA_PPSSIGNAL;
541#endif /* PPS_SYNC */
542}
543
544/*
545 * ntp_init() - initialize variables and structures
546 *
547 * This routine must be called after the kernel variables hz and tick
548 * are set or changed and before the next tick interrupt. In this
549 * particular implementation, these values are assumed set elsewhere in
550 * the kernel. The design allows the clock frequency and tick interval
551 * to be changed while the system is running. So, this routine should
552 * probably be integrated with the code that does that.
553 */
554static void
555ntp_init()
556{
557
558 /*
559 * The following variable must be initialized any time the
560 * kernel variable hz is changed.
561 */
562 time_tick = NANOSECOND / hz;
563
564 /*
565 * The following variables are initialized only at startup. Only
566 * those structures not cleared by the compiler need to be
567 * initialized, and these only in the simulator. In the actual
568 * kernel, any nonzero values here will quickly evaporate.
569 */
570 L_CLR(time_offset);
571 L_CLR(time_freq);
572#ifdef PPS_SYNC
573 pps_tf[0].tv_sec = pps_tf[0].tv_nsec = 0;
574 pps_tf[1].tv_sec = pps_tf[1].tv_nsec = 0;
575 pps_tf[2].tv_sec = pps_tf[2].tv_nsec = 0;
576 pps_fcount = 0;
577 L_CLR(pps_freq);
578#endif /* PPS_SYNC */
579}
580
581SYSINIT(ntpclocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, ntp_init, NULL)
582
583/*
584 * hardupdate() - local clock update
585 *
586 * This routine is called by ntp_adjtime() to update the local clock
587 * phase and frequency. The implementation is of an adaptive-parameter,
588 * hybrid phase/frequency-lock loop (PLL/FLL). The routine computes new
589 * time and frequency offset estimates for each call. If the kernel PPS
590 * discipline code is configured (PPS_SYNC), the PPS signal itself
591 * determines the new time offset, instead of the calling argument.
592 * Presumably, calls to ntp_adjtime() occur only when the caller
593 * believes the local clock is valid within some bound (+-128 ms with
594 * NTP). If the caller's time is far different than the PPS time, an
595 * argument will ensue, and it's not clear who will lose.
596 *
597 * For uncompensated quartz crystal oscillators and nominal update
598 * intervals less than 256 s, operation should be in phase-lock mode,
599 * where the loop is disciplined to phase. For update intervals greater
600 * than 1024 s, operation should be in frequency-lock mode, where the
601 * loop is disciplined to frequency. Between 256 s and 1024 s, the mode
602 * is selected by the STA_MODE status bit.
603 */
604static void
605hardupdate(offset)
606 long offset; /* clock offset (ns) */
607{
608 long mtemp;
609 l_fp ftemp;
610
611 /*
612 * Select how the phase is to be controlled and from which
613 * source. If the PPS signal is present and enabled to
614 * discipline the time, the PPS offset is used; otherwise, the
615 * argument offset is used.
616 */
617 if (!(time_status & STA_PLL))
618 return;
619 if (!(time_status & STA_PPSTIME && time_status &
620 STA_PPSSIGNAL)) {
621 if (offset > MAXPHASE)
622 time_monitor = MAXPHASE;
623 else if (offset < -MAXPHASE)
624 time_monitor = -MAXPHASE;
625 else
626 time_monitor = offset;
627 L_LINT(time_offset, time_monitor);
628 }
629
630 /*
631 * Select how the frequency is to be controlled and in which
632 * mode (PLL or FLL). If the PPS signal is present and enabled
633 * to discipline the frequency, the PPS frequency is used;
634 * otherwise, the argument offset is used to compute it.
635 */
636 if (time_status & STA_PPSFREQ && time_status & STA_PPSSIGNAL) {
637 time_reftime = time_second;
638 return;
639 }
640 if (time_status & STA_FREQHOLD || time_reftime == 0)
641 time_reftime = time_second;
642 mtemp = time_second - time_reftime;
643 L_LINT(ftemp, time_monitor);
644 L_RSHIFT(ftemp, (SHIFT_PLL + 2 + time_constant) << 1);
645 L_MPY(ftemp, mtemp);
646 L_ADD(time_freq, ftemp);
647 time_status &= ~STA_MODE;
648 if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp >
649 MAXSEC)) {
650 L_LINT(ftemp, (time_monitor << 4) / mtemp);
651 L_RSHIFT(ftemp, SHIFT_FLL + 4);
652 L_ADD(time_freq, ftemp);
653 time_status |= STA_MODE;
654 }
655 time_reftime = time_second;
656 if (L_GINT(time_freq) > MAXFREQ)
657 L_LINT(time_freq, MAXFREQ);
658 else if (L_GINT(time_freq) < -MAXFREQ)
659 L_LINT(time_freq, -MAXFREQ);
660}
661
662#ifdef PPS_SYNC
663/*
664 * hardpps() - discipline CPU clock oscillator to external PPS signal
665 *
666 * This routine is called at each PPS interrupt in order to discipline
667 * the CPU clock oscillator to the PPS signal. There are two independent
668 * first-order feedback loops, one for the phase, the other for the
669 * frequency. The phase loop measures and grooms the PPS phase offset
670 * and leaves it in a handy spot for the seconds overflow routine. The
671 * frequency loop averages successive PPS phase differences and
672 * calculates the PPS frequency offset, which is also processed by the
673 * seconds overflow routine. The code requires the caller to capture the
674 * time and architecture-dependent hardware counter values in
675 * nanoseconds at the on-time PPS signal transition.
676 *
677 * Note that, on some Unix systems this routine runs at an interrupt
678 * priority level higher than the timer interrupt routine hardclock().
679 * Therefore, the variables used are distinct from the hardclock()
680 * variables, except for the actual time and frequency variables, which
681 * are determined by this routine and updated atomically.
682 */
683void
684hardpps(tsp, nsec)
685 struct timespec *tsp; /* time at PPS */
686 long nsec; /* hardware counter at PPS */
687{
688 long u_sec, u_nsec, v_nsec; /* temps */
689 l_fp ftemp;
690
691 /*
692 * The signal is first processed by a range gate and frequency
693 * discriminator. The range gate rejects noise spikes outside
694 * the range +-500 us. The frequency discriminator rejects input
695 * signals with apparent frequency outside the range 1 +-500
696 * PPM. If two hits occur in the same second, we ignore the
697 * later hit; if not and a hit occurs outside the range gate,
698 * keep the later hit for later comparison, but do not process
699 * it.
700 */
701 time_status |= STA_PPSSIGNAL | STA_PPSJITTER;
702 time_status &= ~(STA_PPSWANDER | STA_PPSERROR);
703 pps_valid = PPS_VALID;
704 u_sec = tsp->tv_sec;
705 u_nsec = tsp->tv_nsec;
706 if (u_nsec >= (NANOSECOND >> 1)) {
707 u_nsec -= NANOSECOND;
708 u_sec++;
709 }
710 v_nsec = u_nsec - pps_tf[0].tv_nsec;
711 if (u_sec == pps_tf[0].tv_sec && v_nsec < NANOSECOND -
712 MAXFREQ)
713 return;
714 pps_tf[2] = pps_tf[1];
715 pps_tf[1] = pps_tf[0];
716 pps_tf[0].tv_sec = u_sec;
717 pps_tf[0].tv_nsec = u_nsec;
718
719 /*
720 * Compute the difference between the current and previous
721 * counter values. If the difference exceeds 0.5 s, assume it
722 * has wrapped around, so correct 1.0 s. If the result exceeds
723 * the tick interval, the sample point has crossed a tick
724 * boundary during the last second, so correct the tick. Very
725 * intricate.
726 */
727 u_nsec = nsec;
728 if (u_nsec > (NANOSECOND >> 1))
729 u_nsec -= NANOSECOND;
730 else if (u_nsec < -(NANOSECOND >> 1))
731 u_nsec += NANOSECOND;
732 pps_fcount += u_nsec;
733 if (v_nsec > MAXFREQ || v_nsec < -MAXFREQ)
734 return;
735 time_status &= ~STA_PPSJITTER;
736
737 /*
738 * A three-stage median filter is used to help denoise the PPS
739 * time. The median sample becomes the time offset estimate; the
740 * difference between the other two samples becomes the time
741 * dispersion (jitter) estimate.
742 */
743 if (pps_tf[0].tv_nsec > pps_tf[1].tv_nsec) {
744 if (pps_tf[1].tv_nsec > pps_tf[2].tv_nsec) {
745 v_nsec = pps_tf[1].tv_nsec; /* 0 1 2 */
746 u_nsec = pps_tf[0].tv_nsec - pps_tf[2].tv_nsec;
747 } else if (pps_tf[2].tv_nsec > pps_tf[0].tv_nsec) {
748 v_nsec = pps_tf[0].tv_nsec; /* 2 0 1 */
749 u_nsec = pps_tf[2].tv_nsec - pps_tf[1].tv_nsec;
750 } else {
751 v_nsec = pps_tf[2].tv_nsec; /* 0 2 1 */
752 u_nsec = pps_tf[0].tv_nsec - pps_tf[1].tv_nsec;
753 }
754 } else {
755 if (pps_tf[1].tv_nsec < pps_tf[2].tv_nsec) {
756 v_nsec = pps_tf[1].tv_nsec; /* 2 1 0 */
757 u_nsec = pps_tf[2].tv_nsec - pps_tf[0].tv_nsec;
758 } else if (pps_tf[2].tv_nsec < pps_tf[0].tv_nsec) {
759 v_nsec = pps_tf[0].tv_nsec; /* 1 0 2 */
760 u_nsec = pps_tf[1].tv_nsec - pps_tf[2].tv_nsec;
761 } else {
762 v_nsec = pps_tf[2].tv_nsec; /* 1 2 0 */
763 u_nsec = pps_tf[1].tv_nsec - pps_tf[0].tv_nsec;
764 }
765 }
766
767 /*
768 * Nominal jitter is due to PPS signal noise and interrupt
769 * latency. If it exceeds the popcorn threshold, the sample is
770 * discarded. otherwise, if so enabled, the time offset is
771 * updated. We can tolerate a modest loss of data here without
772 * much degrading time accuracy.
773 */
774 if (u_nsec > (pps_jitter << PPS_POPCORN)) {
775 time_status |= STA_PPSJITTER;
776 pps_jitcnt++;
777 } else if (time_status & STA_PPSTIME) {
778 time_monitor = -v_nsec;
779 L_LINT(time_offset, time_monitor);
780 }
781 pps_jitter += (u_nsec - pps_jitter) >> PPS_FAVG;
782 u_sec = pps_tf[0].tv_sec - pps_lastsec;
783 if (u_sec < (1 << pps_shift))
784 return;
785
786 /*
787 * At the end of the calibration interval the difference between
788 * the first and last counter values becomes the scaled
789 * frequency. It will later be divided by the length of the
790 * interval to determine the frequency update. If the frequency
791 * exceeds a sanity threshold, or if the actual calibration
792 * interval is not equal to the expected length, the data are
793 * discarded. We can tolerate a modest loss of data here without
794 * much degrading frequency accuracy.
795 */
796 pps_calcnt++;
797 v_nsec = -pps_fcount;
798 pps_lastsec = pps_tf[0].tv_sec;
799 pps_fcount = 0;
800 u_nsec = MAXFREQ << pps_shift;
801 if (v_nsec > u_nsec || v_nsec < -u_nsec || u_sec != (1 <<
802 pps_shift)) {
803 time_status |= STA_PPSERROR;
804 pps_errcnt++;
805 return;
806 }
807
808 /*
809 * Here the raw frequency offset and wander (stability) is
810 * calculated. If the wander is less than the wander threshold
811 * for four consecutive averaging intervals, the interval is
812 * doubled; if it is greater than the threshold for four
813 * consecutive intervals, the interval is halved. The scaled
814 * frequency offset is converted to frequency offset. The
815 * stability metric is calculated as the average of recent
816 * frequency changes, but is used only for performance
817 * monitoring.
818 */
819 L_LINT(ftemp, v_nsec);
820 L_RSHIFT(ftemp, pps_shift);
821 L_SUB(ftemp, pps_freq);
822 u_nsec = L_GINT(ftemp);
823 if (u_nsec > PPS_MAXWANDER) {
824 L_LINT(ftemp, PPS_MAXWANDER);
825 pps_intcnt--;
826 time_status |= STA_PPSWANDER;
827 pps_stbcnt++;
828 } else if (u_nsec < -PPS_MAXWANDER) {
829 L_LINT(ftemp, -PPS_MAXWANDER);
830 pps_intcnt--;
831 time_status |= STA_PPSWANDER;
832 pps_stbcnt++;
833 } else {
834 pps_intcnt++;
835 }
836 if (pps_intcnt >= 4) {
837 pps_intcnt = 4;
838 if (pps_shift < pps_shiftmax) {
839 pps_shift++;
840 pps_intcnt = 0;
841 }
842 } else if (pps_intcnt <= -4 || pps_shift > pps_shiftmax) {
843 pps_intcnt = -4;
844 if (pps_shift > PPS_FAVG) {
845 pps_shift--;
846 pps_intcnt = 0;
847 }
848 }
849 if (u_nsec < 0)
850 u_nsec = -u_nsec;
851 pps_stabil += (u_nsec * SCALE_PPM - pps_stabil) >> PPS_FAVG;
852
853 /*
854 * The PPS frequency is recalculated and clamped to the maximum
855 * MAXFREQ. If enabled, the system clock frequency is updated as
856 * well.
857 */
858 L_ADD(pps_freq, ftemp);
859 u_nsec = L_GINT(pps_freq);
860 if (u_nsec > MAXFREQ)
861 L_LINT(pps_freq, MAXFREQ);
862 else if (u_nsec < -MAXFREQ)
863 L_LINT(pps_freq, -MAXFREQ);
864 if (time_status & STA_PPSFREQ)
865 time_freq = pps_freq;
866}
867#endif /* PPS_SYNC */
| 563#ifdef PPS_SYNC
564 if (pps_valid > 0)
565 pps_valid--;
566 else
567 time_status &= ~STA_PPSSIGNAL;
568#endif /* PPS_SYNC */
569}
570
571/*
572 * ntp_init() - initialize variables and structures
573 *
574 * This routine must be called after the kernel variables hz and tick
575 * are set or changed and before the next tick interrupt. In this
576 * particular implementation, these values are assumed set elsewhere in
577 * the kernel. The design allows the clock frequency and tick interval
578 * to be changed while the system is running. So, this routine should
579 * probably be integrated with the code that does that.
580 */
581static void
582ntp_init()
583{
584
585 /*
586 * The following variable must be initialized any time the
587 * kernel variable hz is changed.
588 */
589 time_tick = NANOSECOND / hz;
590
591 /*
592 * The following variables are initialized only at startup. Only
593 * those structures not cleared by the compiler need to be
594 * initialized, and these only in the simulator. In the actual
595 * kernel, any nonzero values here will quickly evaporate.
596 */
597 L_CLR(time_offset);
598 L_CLR(time_freq);
599#ifdef PPS_SYNC
600 pps_tf[0].tv_sec = pps_tf[0].tv_nsec = 0;
601 pps_tf[1].tv_sec = pps_tf[1].tv_nsec = 0;
602 pps_tf[2].tv_sec = pps_tf[2].tv_nsec = 0;
603 pps_fcount = 0;
604 L_CLR(pps_freq);
605#endif /* PPS_SYNC */
606}
607
608SYSINIT(ntpclocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, ntp_init, NULL)
609
610/*
611 * hardupdate() - local clock update
612 *
613 * This routine is called by ntp_adjtime() to update the local clock
614 * phase and frequency. The implementation is of an adaptive-parameter,
615 * hybrid phase/frequency-lock loop (PLL/FLL). The routine computes new
616 * time and frequency offset estimates for each call. If the kernel PPS
617 * discipline code is configured (PPS_SYNC), the PPS signal itself
618 * determines the new time offset, instead of the calling argument.
619 * Presumably, calls to ntp_adjtime() occur only when the caller
620 * believes the local clock is valid within some bound (+-128 ms with
621 * NTP). If the caller's time is far different than the PPS time, an
622 * argument will ensue, and it's not clear who will lose.
623 *
624 * For uncompensated quartz crystal oscillators and nominal update
625 * intervals less than 256 s, operation should be in phase-lock mode,
626 * where the loop is disciplined to phase. For update intervals greater
627 * than 1024 s, operation should be in frequency-lock mode, where the
628 * loop is disciplined to frequency. Between 256 s and 1024 s, the mode
629 * is selected by the STA_MODE status bit.
630 */
631static void
632hardupdate(offset)
633 long offset; /* clock offset (ns) */
634{
635 long mtemp;
636 l_fp ftemp;
637
638 /*
639 * Select how the phase is to be controlled and from which
640 * source. If the PPS signal is present and enabled to
641 * discipline the time, the PPS offset is used; otherwise, the
642 * argument offset is used.
643 */
644 if (!(time_status & STA_PLL))
645 return;
646 if (!(time_status & STA_PPSTIME && time_status &
647 STA_PPSSIGNAL)) {
648 if (offset > MAXPHASE)
649 time_monitor = MAXPHASE;
650 else if (offset < -MAXPHASE)
651 time_monitor = -MAXPHASE;
652 else
653 time_monitor = offset;
654 L_LINT(time_offset, time_monitor);
655 }
656
657 /*
658 * Select how the frequency is to be controlled and in which
659 * mode (PLL or FLL). If the PPS signal is present and enabled
660 * to discipline the frequency, the PPS frequency is used;
661 * otherwise, the argument offset is used to compute it.
662 */
663 if (time_status & STA_PPSFREQ && time_status & STA_PPSSIGNAL) {
664 time_reftime = time_second;
665 return;
666 }
667 if (time_status & STA_FREQHOLD || time_reftime == 0)
668 time_reftime = time_second;
669 mtemp = time_second - time_reftime;
670 L_LINT(ftemp, time_monitor);
671 L_RSHIFT(ftemp, (SHIFT_PLL + 2 + time_constant) << 1);
672 L_MPY(ftemp, mtemp);
673 L_ADD(time_freq, ftemp);
674 time_status &= ~STA_MODE;
675 if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp >
676 MAXSEC)) {
677 L_LINT(ftemp, (time_monitor << 4) / mtemp);
678 L_RSHIFT(ftemp, SHIFT_FLL + 4);
679 L_ADD(time_freq, ftemp);
680 time_status |= STA_MODE;
681 }
682 time_reftime = time_second;
683 if (L_GINT(time_freq) > MAXFREQ)
684 L_LINT(time_freq, MAXFREQ);
685 else if (L_GINT(time_freq) < -MAXFREQ)
686 L_LINT(time_freq, -MAXFREQ);
687}
688
689#ifdef PPS_SYNC
690/*
691 * hardpps() - discipline CPU clock oscillator to external PPS signal
692 *
693 * This routine is called at each PPS interrupt in order to discipline
694 * the CPU clock oscillator to the PPS signal. There are two independent
695 * first-order feedback loops, one for the phase, the other for the
696 * frequency. The phase loop measures and grooms the PPS phase offset
697 * and leaves it in a handy spot for the seconds overflow routine. The
698 * frequency loop averages successive PPS phase differences and
699 * calculates the PPS frequency offset, which is also processed by the
700 * seconds overflow routine. The code requires the caller to capture the
701 * time and architecture-dependent hardware counter values in
702 * nanoseconds at the on-time PPS signal transition.
703 *
704 * Note that, on some Unix systems this routine runs at an interrupt
705 * priority level higher than the timer interrupt routine hardclock().
706 * Therefore, the variables used are distinct from the hardclock()
707 * variables, except for the actual time and frequency variables, which
708 * are determined by this routine and updated atomically.
709 */
710void
711hardpps(tsp, nsec)
712 struct timespec *tsp; /* time at PPS */
713 long nsec; /* hardware counter at PPS */
714{
715 long u_sec, u_nsec, v_nsec; /* temps */
716 l_fp ftemp;
717
718 /*
719 * The signal is first processed by a range gate and frequency
720 * discriminator. The range gate rejects noise spikes outside
721 * the range +-500 us. The frequency discriminator rejects input
722 * signals with apparent frequency outside the range 1 +-500
723 * PPM. If two hits occur in the same second, we ignore the
724 * later hit; if not and a hit occurs outside the range gate,
725 * keep the later hit for later comparison, but do not process
726 * it.
727 */
728 time_status |= STA_PPSSIGNAL | STA_PPSJITTER;
729 time_status &= ~(STA_PPSWANDER | STA_PPSERROR);
730 pps_valid = PPS_VALID;
731 u_sec = tsp->tv_sec;
732 u_nsec = tsp->tv_nsec;
733 if (u_nsec >= (NANOSECOND >> 1)) {
734 u_nsec -= NANOSECOND;
735 u_sec++;
736 }
737 v_nsec = u_nsec - pps_tf[0].tv_nsec;
738 if (u_sec == pps_tf[0].tv_sec && v_nsec < NANOSECOND -
739 MAXFREQ)
740 return;
741 pps_tf[2] = pps_tf[1];
742 pps_tf[1] = pps_tf[0];
743 pps_tf[0].tv_sec = u_sec;
744 pps_tf[0].tv_nsec = u_nsec;
745
746 /*
747 * Compute the difference between the current and previous
748 * counter values. If the difference exceeds 0.5 s, assume it
749 * has wrapped around, so correct 1.0 s. If the result exceeds
750 * the tick interval, the sample point has crossed a tick
751 * boundary during the last second, so correct the tick. Very
752 * intricate.
753 */
754 u_nsec = nsec;
755 if (u_nsec > (NANOSECOND >> 1))
756 u_nsec -= NANOSECOND;
757 else if (u_nsec < -(NANOSECOND >> 1))
758 u_nsec += NANOSECOND;
759 pps_fcount += u_nsec;
760 if (v_nsec > MAXFREQ || v_nsec < -MAXFREQ)
761 return;
762 time_status &= ~STA_PPSJITTER;
763
764 /*
765 * A three-stage median filter is used to help denoise the PPS
766 * time. The median sample becomes the time offset estimate; the
767 * difference between the other two samples becomes the time
768 * dispersion (jitter) estimate.
769 */
770 if (pps_tf[0].tv_nsec > pps_tf[1].tv_nsec) {
771 if (pps_tf[1].tv_nsec > pps_tf[2].tv_nsec) {
772 v_nsec = pps_tf[1].tv_nsec; /* 0 1 2 */
773 u_nsec = pps_tf[0].tv_nsec - pps_tf[2].tv_nsec;
774 } else if (pps_tf[2].tv_nsec > pps_tf[0].tv_nsec) {
775 v_nsec = pps_tf[0].tv_nsec; /* 2 0 1 */
776 u_nsec = pps_tf[2].tv_nsec - pps_tf[1].tv_nsec;
777 } else {
778 v_nsec = pps_tf[2].tv_nsec; /* 0 2 1 */
779 u_nsec = pps_tf[0].tv_nsec - pps_tf[1].tv_nsec;
780 }
781 } else {
782 if (pps_tf[1].tv_nsec < pps_tf[2].tv_nsec) {
783 v_nsec = pps_tf[1].tv_nsec; /* 2 1 0 */
784 u_nsec = pps_tf[2].tv_nsec - pps_tf[0].tv_nsec;
785 } else if (pps_tf[2].tv_nsec < pps_tf[0].tv_nsec) {
786 v_nsec = pps_tf[0].tv_nsec; /* 1 0 2 */
787 u_nsec = pps_tf[1].tv_nsec - pps_tf[2].tv_nsec;
788 } else {
789 v_nsec = pps_tf[2].tv_nsec; /* 1 2 0 */
790 u_nsec = pps_tf[1].tv_nsec - pps_tf[0].tv_nsec;
791 }
792 }
793
794 /*
795 * Nominal jitter is due to PPS signal noise and interrupt
796 * latency. If it exceeds the popcorn threshold, the sample is
797 * discarded. otherwise, if so enabled, the time offset is
798 * updated. We can tolerate a modest loss of data here without
799 * much degrading time accuracy.
800 */
801 if (u_nsec > (pps_jitter << PPS_POPCORN)) {
802 time_status |= STA_PPSJITTER;
803 pps_jitcnt++;
804 } else if (time_status & STA_PPSTIME) {
805 time_monitor = -v_nsec;
806 L_LINT(time_offset, time_monitor);
807 }
808 pps_jitter += (u_nsec - pps_jitter) >> PPS_FAVG;
809 u_sec = pps_tf[0].tv_sec - pps_lastsec;
810 if (u_sec < (1 << pps_shift))
811 return;
812
813 /*
814 * At the end of the calibration interval the difference between
815 * the first and last counter values becomes the scaled
816 * frequency. It will later be divided by the length of the
817 * interval to determine the frequency update. If the frequency
818 * exceeds a sanity threshold, or if the actual calibration
819 * interval is not equal to the expected length, the data are
820 * discarded. We can tolerate a modest loss of data here without
821 * much degrading frequency accuracy.
822 */
823 pps_calcnt++;
824 v_nsec = -pps_fcount;
825 pps_lastsec = pps_tf[0].tv_sec;
826 pps_fcount = 0;
827 u_nsec = MAXFREQ << pps_shift;
828 if (v_nsec > u_nsec || v_nsec < -u_nsec || u_sec != (1 <<
829 pps_shift)) {
830 time_status |= STA_PPSERROR;
831 pps_errcnt++;
832 return;
833 }
834
835 /*
836 * Here the raw frequency offset and wander (stability) is
837 * calculated. If the wander is less than the wander threshold
838 * for four consecutive averaging intervals, the interval is
839 * doubled; if it is greater than the threshold for four
840 * consecutive intervals, the interval is halved. The scaled
841 * frequency offset is converted to frequency offset. The
842 * stability metric is calculated as the average of recent
843 * frequency changes, but is used only for performance
844 * monitoring.
845 */
846 L_LINT(ftemp, v_nsec);
847 L_RSHIFT(ftemp, pps_shift);
848 L_SUB(ftemp, pps_freq);
849 u_nsec = L_GINT(ftemp);
850 if (u_nsec > PPS_MAXWANDER) {
851 L_LINT(ftemp, PPS_MAXWANDER);
852 pps_intcnt--;
853 time_status |= STA_PPSWANDER;
854 pps_stbcnt++;
855 } else if (u_nsec < -PPS_MAXWANDER) {
856 L_LINT(ftemp, -PPS_MAXWANDER);
857 pps_intcnt--;
858 time_status |= STA_PPSWANDER;
859 pps_stbcnt++;
860 } else {
861 pps_intcnt++;
862 }
863 if (pps_intcnt >= 4) {
864 pps_intcnt = 4;
865 if (pps_shift < pps_shiftmax) {
866 pps_shift++;
867 pps_intcnt = 0;
868 }
869 } else if (pps_intcnt <= -4 || pps_shift > pps_shiftmax) {
870 pps_intcnt = -4;
871 if (pps_shift > PPS_FAVG) {
872 pps_shift--;
873 pps_intcnt = 0;
874 }
875 }
876 if (u_nsec < 0)
877 u_nsec = -u_nsec;
878 pps_stabil += (u_nsec * SCALE_PPM - pps_stabil) >> PPS_FAVG;
879
880 /*
881 * The PPS frequency is recalculated and clamped to the maximum
882 * MAXFREQ. If enabled, the system clock frequency is updated as
883 * well.
884 */
885 L_ADD(pps_freq, ftemp);
886 u_nsec = L_GINT(pps_freq);
887 if (u_nsec > MAXFREQ)
888 L_LINT(pps_freq, MAXFREQ);
889 else if (u_nsec < -MAXFREQ)
890 L_LINT(pps_freq, -MAXFREQ);
891 if (time_status & STA_PPSFREQ)
892 time_freq = pps_freq;
893}
894#endif /* PPS_SYNC */
|
| 895
896#ifndef _SYS_SYSPROTO_H_
897struct adjtime_args {
898 struct timeval *delta;
899 struct timeval *olddelta;
900};
901#endif
902/*
903 * MPSAFE
904 */
905/* ARGSUSED */
906int
907adjtime(struct thread *td, struct adjtime_args *uap)
908{
909 struct timeval atv;
910 int error;
911
912 mtx_lock(&Giant);
913
914 if ((error = suser(td)))
915 goto done2;
916 if (uap->olddelta) {
917 atv.tv_sec = time_adjtime / 1000000;
918 atv.tv_usec = time_adjtime % 1000000;
919 if (atv.tv_usec < 0) {
920 atv.tv_usec += 1000000;
921 atv.tv_sec--;
922 }
923 printf("Old: time_adjtime = %ld.%06ld %lld\n",
924 atv.tv_sec, atv.tv_usec, time_adjtime);
925 error = copyout(&atv, uap->olddelta, sizeof(atv));
926 if (error)
927 goto done2;
928 }
929 if (uap->delta) {
930 error = copyin(uap->delta, &atv, sizeof(atv));
931 if (error)
932 goto done2;
933 time_adjtime = (int64_t)atv.tv_sec * 1000000 + atv.tv_usec;
934 printf("New: time_adjtime = %ld.%06ld %lld\n",
935 atv.tv_sec, atv.tv_usec, time_adjtime);
936 }
937done2:
938 mtx_unlock(&Giant);
939 return (error);
940}
941
|
| |