kern_clock.c revision 1.109 1 1.109 ad /* $NetBSD: kern_clock.c,v 1.109 2007/07/09 21:10:51 ad Exp $ */
2 1.52 thorpej
3 1.52 thorpej /*-
4 1.106 ad * Copyright (c) 2000, 2004, 2006, 2007 The NetBSD Foundation, Inc.
5 1.52 thorpej * All rights reserved.
6 1.52 thorpej *
7 1.52 thorpej * This code is derived from software contributed to The NetBSD Foundation
8 1.52 thorpej * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 1.52 thorpej * NASA Ames Research Center.
10 1.94 mycroft * This code is derived from software contributed to The NetBSD Foundation
11 1.94 mycroft * by Charles M. Hannum.
12 1.52 thorpej *
13 1.52 thorpej * Redistribution and use in source and binary forms, with or without
14 1.52 thorpej * modification, are permitted provided that the following conditions
15 1.52 thorpej * are met:
16 1.52 thorpej * 1. Redistributions of source code must retain the above copyright
17 1.52 thorpej * notice, this list of conditions and the following disclaimer.
18 1.52 thorpej * 2. Redistributions in binary form must reproduce the above copyright
19 1.52 thorpej * notice, this list of conditions and the following disclaimer in the
20 1.52 thorpej * documentation and/or other materials provided with the distribution.
21 1.52 thorpej * 3. All advertising materials mentioning features or use of this software
22 1.52 thorpej * must display the following acknowledgement:
23 1.52 thorpej * This product includes software developed by the NetBSD
24 1.52 thorpej * Foundation, Inc. and its contributors.
25 1.52 thorpej * 4. Neither the name of The NetBSD Foundation nor the names of its
26 1.52 thorpej * contributors may be used to endorse or promote products derived
27 1.52 thorpej * from this software without specific prior written permission.
28 1.52 thorpej *
29 1.52 thorpej * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
30 1.52 thorpej * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
31 1.52 thorpej * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32 1.52 thorpej * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
33 1.52 thorpej * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34 1.52 thorpej * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35 1.52 thorpej * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36 1.52 thorpej * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37 1.52 thorpej * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38 1.52 thorpej * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39 1.52 thorpej * POSSIBILITY OF SUCH DAMAGE.
40 1.52 thorpej */
41 1.19 cgd
42 1.19 cgd /*-
43 1.19 cgd * Copyright (c) 1982, 1986, 1991, 1993
44 1.19 cgd * The Regents of the University of California. All rights reserved.
45 1.19 cgd * (c) UNIX System Laboratories, Inc.
46 1.19 cgd * All or some portions of this file are derived from material licensed
47 1.19 cgd * to the University of California by American Telephone and Telegraph
48 1.19 cgd * Co. or Unix System Laboratories, Inc. and are reproduced herein with
49 1.19 cgd * the permission of UNIX System Laboratories, Inc.
50 1.19 cgd *
51 1.19 cgd * Redistribution and use in source and binary forms, with or without
52 1.19 cgd * modification, are permitted provided that the following conditions
53 1.19 cgd * are met:
54 1.19 cgd * 1. Redistributions of source code must retain the above copyright
55 1.19 cgd * notice, this list of conditions and the following disclaimer.
56 1.19 cgd * 2. Redistributions in binary form must reproduce the above copyright
57 1.19 cgd * notice, this list of conditions and the following disclaimer in the
58 1.19 cgd * documentation and/or other materials provided with the distribution.
59 1.87 agc * 3. Neither the name of the University nor the names of its contributors
60 1.19 cgd * may be used to endorse or promote products derived from this software
61 1.19 cgd * without specific prior written permission.
62 1.19 cgd *
63 1.19 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
64 1.19 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
65 1.19 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
66 1.19 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
67 1.19 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
68 1.19 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
69 1.19 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
70 1.19 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
71 1.19 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
72 1.19 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
73 1.19 cgd * SUCH DAMAGE.
74 1.19 cgd *
75 1.19 cgd * @(#)kern_clock.c 8.5 (Berkeley) 1/21/94
76 1.19 cgd */
77 1.78 lukem
78 1.78 lukem #include <sys/cdefs.h>
79 1.109 ad __KERNEL_RCSID(0, "$NetBSD: kern_clock.c,v 1.109 2007/07/09 21:10:51 ad Exp $");
80 1.44 jonathan
81 1.44 jonathan #include "opt_ntp.h"
82 1.86 martin #include "opt_multiprocessor.h"
83 1.80 briggs #include "opt_perfctrs.h"
84 1.19 cgd
85 1.19 cgd #include <sys/param.h>
86 1.19 cgd #include <sys/systm.h>
87 1.19 cgd #include <sys/callout.h>
88 1.19 cgd #include <sys/kernel.h>
89 1.19 cgd #include <sys/proc.h>
90 1.19 cgd #include <sys/resourcevar.h>
91 1.25 christos #include <sys/signalvar.h>
92 1.26 christos #include <sys/sysctl.h>
93 1.27 jonathan #include <sys/timex.h>
94 1.45 ross #include <sys/sched.h>
95 1.82 thorpej #include <sys/time.h>
96 1.99 kardel #include <sys/timetc.h>
97 1.109 ad #include <sys/cpu.h>
98 1.25 christos
99 1.19 cgd #ifdef GPROF
100 1.19 cgd #include <sys/gmon.h>
101 1.19 cgd #endif
102 1.19 cgd
103 1.19 cgd /*
104 1.19 cgd * Clock handling routines.
105 1.19 cgd *
106 1.19 cgd * This code is written to operate with two timers that run independently of
107 1.19 cgd * each other. The main clock, running hz times per second, is used to keep
108 1.19 cgd * track of real time. The second timer handles kernel and user profiling,
109 1.19 cgd * and does resource use estimation. If the second timer is programmable,
110 1.19 cgd * it is randomized to avoid aliasing between the two clocks. For example,
111 1.90 wiz * the randomization prevents an adversary from always giving up the CPU
112 1.19 cgd * just before its quantum expires. Otherwise, it would never accumulate
113 1.90 wiz * CPU ticks. The mean frequency of the second timer is stathz.
114 1.19 cgd *
115 1.19 cgd * If no second timer exists, stathz will be zero; in this case we drive
116 1.19 cgd * profiling and statistics off the main clock. This WILL NOT be accurate;
117 1.19 cgd * do not do it unless absolutely necessary.
118 1.19 cgd *
119 1.19 cgd * The statistics clock may (or may not) be run at a higher rate while
120 1.19 cgd * profiling. This profile clock runs at profhz. We require that profhz
121 1.19 cgd * be an integral multiple of stathz.
122 1.19 cgd *
123 1.19 cgd * If the statistics clock is running fast, it must be divided by the ratio
124 1.19 cgd * profhz/stathz for statistics. (For profiling, every tick counts.)
125 1.19 cgd */
126 1.19 cgd
127 1.99 kardel #ifndef __HAVE_TIMECOUNTER
128 1.27 jonathan #ifdef NTP /* NTP phase-locked loop in kernel */
129 1.27 jonathan /*
130 1.27 jonathan * Phase/frequency-lock loop (PLL/FLL) definitions
131 1.27 jonathan *
132 1.27 jonathan * The following variables are read and set by the ntp_adjtime() system
133 1.27 jonathan * call.
134 1.27 jonathan *
135 1.27 jonathan * time_state shows the state of the system clock, with values defined
136 1.27 jonathan * in the timex.h header file.
137 1.27 jonathan *
138 1.27 jonathan * time_status shows the status of the system clock, with bits defined
139 1.27 jonathan * in the timex.h header file.
140 1.27 jonathan *
141 1.27 jonathan * time_offset is used by the PLL/FLL to adjust the system time in small
142 1.27 jonathan * increments.
143 1.27 jonathan *
144 1.27 jonathan * time_constant determines the bandwidth or "stiffness" of the PLL.
145 1.27 jonathan *
146 1.27 jonathan * time_tolerance determines maximum frequency error or tolerance of the
147 1.27 jonathan * CPU clock oscillator and is a property of the architecture; however,
148 1.27 jonathan * in principle it could change as result of the presence of external
149 1.27 jonathan * discipline signals, for instance.
150 1.27 jonathan *
151 1.27 jonathan * time_precision is usually equal to the kernel tick variable; however,
152 1.27 jonathan * in cases where a precision clock counter or external clock is
153 1.27 jonathan * available, the resolution can be much less than this and depend on
154 1.27 jonathan * whether the external clock is working or not.
155 1.27 jonathan *
156 1.27 jonathan * time_maxerror is initialized by a ntp_adjtime() call and increased by
157 1.27 jonathan * the kernel once each second to reflect the maximum error bound
158 1.27 jonathan * growth.
159 1.27 jonathan *
160 1.27 jonathan * time_esterror is set and read by the ntp_adjtime() call, but
161 1.27 jonathan * otherwise not used by the kernel.
162 1.27 jonathan */
163 1.27 jonathan int time_state = TIME_OK; /* clock state */
164 1.27 jonathan int time_status = STA_UNSYNC; /* clock status bits */
165 1.27 jonathan long time_offset = 0; /* time offset (us) */
166 1.27 jonathan long time_constant = 0; /* pll time constant */
167 1.27 jonathan long time_tolerance = MAXFREQ; /* frequency tolerance (scaled ppm) */
168 1.27 jonathan long time_precision = 1; /* clock precision (us) */
169 1.27 jonathan long time_maxerror = MAXPHASE; /* maximum error (us) */
170 1.27 jonathan long time_esterror = MAXPHASE; /* estimated error (us) */
171 1.27 jonathan
172 1.27 jonathan /*
173 1.27 jonathan * The following variables establish the state of the PLL/FLL and the
174 1.27 jonathan * residual time and frequency offset of the local clock. The scale
175 1.27 jonathan * factors are defined in the timex.h header file.
176 1.27 jonathan *
177 1.27 jonathan * time_phase and time_freq are the phase increment and the frequency
178 1.27 jonathan * increment, respectively, of the kernel time variable.
179 1.27 jonathan *
180 1.27 jonathan * time_freq is set via ntp_adjtime() from a value stored in a file when
181 1.27 jonathan * the synchronization daemon is first started. Its value is retrieved
182 1.27 jonathan * via ntp_adjtime() and written to the file about once per hour by the
183 1.27 jonathan * daemon.
184 1.27 jonathan *
185 1.27 jonathan * time_adj is the adjustment added to the value of tick at each timer
186 1.27 jonathan * interrupt and is recomputed from time_phase and time_freq at each
187 1.27 jonathan * seconds rollover.
188 1.27 jonathan *
189 1.27 jonathan * time_reftime is the second's portion of the system time at the last
190 1.27 jonathan * call to ntp_adjtime(). It is used to adjust the time_freq variable
191 1.27 jonathan * and to increase the time_maxerror as the time since last update
192 1.27 jonathan * increases.
193 1.27 jonathan */
194 1.27 jonathan long time_phase = 0; /* phase offset (scaled us) */
195 1.27 jonathan long time_freq = 0; /* frequency offset (scaled ppm) */
196 1.27 jonathan long time_adj = 0; /* tick adjust (scaled 1 / hz) */
197 1.27 jonathan long time_reftime = 0; /* time at last adjustment (s) */
198 1.27 jonathan
199 1.27 jonathan #ifdef PPS_SYNC
200 1.27 jonathan /*
201 1.27 jonathan * The following variables are used only if the kernel PPS discipline
202 1.27 jonathan * code is configured (PPS_SYNC). The scale factors are defined in the
203 1.27 jonathan * timex.h header file.
204 1.27 jonathan *
205 1.27 jonathan * pps_time contains the time at each calibration interval, as read by
206 1.27 jonathan * microtime(). pps_count counts the seconds of the calibration
207 1.27 jonathan * interval, the duration of which is nominally pps_shift in powers of
208 1.27 jonathan * two.
209 1.27 jonathan *
210 1.27 jonathan * pps_offset is the time offset produced by the time median filter
211 1.27 jonathan * pps_tf[], while pps_jitter is the dispersion (jitter) measured by
212 1.27 jonathan * this filter.
213 1.27 jonathan *
214 1.27 jonathan * pps_freq is the frequency offset produced by the frequency median
215 1.27 jonathan * filter pps_ff[], while pps_stabil is the dispersion (wander) measured
216 1.27 jonathan * by this filter.
217 1.27 jonathan *
218 1.27 jonathan * pps_usec is latched from a high resolution counter or external clock
219 1.27 jonathan * at pps_time. Here we want the hardware counter contents only, not the
220 1.27 jonathan * contents plus the time_tv.usec as usual.
221 1.27 jonathan *
222 1.27 jonathan * pps_valid counts the number of seconds since the last PPS update. It
223 1.27 jonathan * is used as a watchdog timer to disable the PPS discipline should the
224 1.27 jonathan * PPS signal be lost.
225 1.27 jonathan *
226 1.27 jonathan * pps_glitch counts the number of seconds since the beginning of an
227 1.27 jonathan * offset burst more than tick/2 from current nominal offset. It is used
228 1.27 jonathan * mainly to suppress error bursts due to priority conflicts between the
229 1.27 jonathan * PPS interrupt and timer interrupt.
230 1.27 jonathan *
231 1.27 jonathan * pps_intcnt counts the calibration intervals for use in the interval-
232 1.27 jonathan * adaptation algorithm. It's just too complicated for words.
233 1.89 simonb *
234 1.89 simonb * pps_kc_hardpps_source contains an arbitrary value that uniquely
235 1.89 simonb * identifies the currently bound source of the PPS signal, or NULL
236 1.89 simonb * if no source is bound.
237 1.89 simonb *
238 1.89 simonb * pps_kc_hardpps_mode indicates which transitions, if any, of the PPS
239 1.89 simonb * signal should be reported.
240 1.27 jonathan */
241 1.27 jonathan struct timeval pps_time; /* kernel time at last interval */
242 1.27 jonathan long pps_tf[] = {0, 0, 0}; /* pps time offset median filter (us) */
243 1.27 jonathan long pps_offset = 0; /* pps time offset (us) */
244 1.27 jonathan long pps_jitter = MAXTIME; /* time dispersion (jitter) (us) */
245 1.27 jonathan long pps_ff[] = {0, 0, 0}; /* pps frequency offset median filter */
246 1.27 jonathan long pps_freq = 0; /* frequency offset (scaled ppm) */
247 1.27 jonathan long pps_stabil = MAXFREQ; /* frequency dispersion (scaled ppm) */
248 1.27 jonathan long pps_usec = 0; /* microsec counter at last interval */
249 1.27 jonathan long pps_valid = PPS_VALID; /* pps signal watchdog counter */
250 1.27 jonathan int pps_glitch = 0; /* pps signal glitch counter */
251 1.27 jonathan int pps_count = 0; /* calibration interval counter (s) */
252 1.27 jonathan int pps_shift = PPS_SHIFT; /* interval duration (s) (shift) */
253 1.27 jonathan int pps_intcnt = 0; /* intervals at current duration */
254 1.89 simonb void *pps_kc_hardpps_source = NULL; /* current PPS supplier's identifier */
255 1.89 simonb int pps_kc_hardpps_mode = 0; /* interesting edges of PPS signal */
256 1.27 jonathan
257 1.27 jonathan /*
258 1.27 jonathan * PPS signal quality monitors
259 1.27 jonathan *
260 1.27 jonathan * pps_jitcnt counts the seconds that have been discarded because the
261 1.27 jonathan * jitter measured by the time median filter exceeds the limit MAXTIME
262 1.27 jonathan * (100 us).
263 1.27 jonathan *
264 1.27 jonathan * pps_calcnt counts the frequency calibration intervals, which are
265 1.27 jonathan * variable from 4 s to 256 s.
266 1.27 jonathan *
267 1.27 jonathan * pps_errcnt counts the calibration intervals which have been discarded
268 1.27 jonathan * because the wander exceeds the limit MAXFREQ (100 ppm) or where the
269 1.27 jonathan * calibration interval jitter exceeds two ticks.
270 1.27 jonathan *
271 1.27 jonathan * pps_stbcnt counts the calibration intervals that have been discarded
272 1.27 jonathan * because the frequency wander exceeds the limit MAXFREQ / 4 (25 us).
273 1.27 jonathan */
274 1.27 jonathan long pps_jitcnt = 0; /* jitter limit exceeded */
275 1.27 jonathan long pps_calcnt = 0; /* calibration intervals */
276 1.27 jonathan long pps_errcnt = 0; /* calibration errors */
277 1.27 jonathan long pps_stbcnt = 0; /* stability limit exceeded */
278 1.27 jonathan #endif /* PPS_SYNC */
279 1.27 jonathan
280 1.27 jonathan #ifdef EXT_CLOCK
281 1.27 jonathan /*
282 1.27 jonathan * External clock definitions
283 1.27 jonathan *
284 1.27 jonathan * The following definitions and declarations are used only if an
285 1.27 jonathan * external clock is configured on the system.
286 1.27 jonathan */
287 1.27 jonathan #define CLOCK_INTERVAL 30 /* CPU clock update interval (s) */
288 1.27 jonathan
289 1.27 jonathan /*
290 1.27 jonathan * The clock_count variable is set to CLOCK_INTERVAL at each PPS
291 1.27 jonathan * interrupt and decremented once each second.
292 1.27 jonathan */
293 1.27 jonathan int clock_count = 0; /* CPU clock counter */
294 1.27 jonathan
295 1.27 jonathan #ifdef HIGHBALL
296 1.27 jonathan /*
297 1.27 jonathan * The clock_offset and clock_cpu variables are used by the HIGHBALL
298 1.27 jonathan * interface. The clock_offset variable defines the offset between
299 1.27 jonathan * system time and the HIGBALL counters. The clock_cpu variable contains
300 1.27 jonathan * the offset between the system clock and the HIGHBALL clock for use in
301 1.27 jonathan * disciplining the kernel time variable.
302 1.27 jonathan */
303 1.27 jonathan extern struct timeval clock_offset; /* Highball clock offset */
304 1.27 jonathan long clock_cpu = 0; /* CPU clock adjust */
305 1.27 jonathan #endif /* HIGHBALL */
306 1.27 jonathan #endif /* EXT_CLOCK */
307 1.27 jonathan #endif /* NTP */
308 1.27 jonathan
309 1.19 cgd /*
310 1.19 cgd * Bump a timeval by a small number of usec's.
311 1.19 cgd */
312 1.19 cgd #define BUMPTIME(t, usec) { \
313 1.55 augustss volatile struct timeval *tp = (t); \
314 1.55 augustss long us; \
315 1.19 cgd \
316 1.19 cgd tp->tv_usec = us = tp->tv_usec + (usec); \
317 1.19 cgd if (us >= 1000000) { \
318 1.19 cgd tp->tv_usec = us - 1000000; \
319 1.19 cgd tp->tv_sec++; \
320 1.19 cgd } \
321 1.19 cgd }
322 1.99 kardel #endif /* !__HAVE_TIMECOUNTER */
323 1.19 cgd
324 1.19 cgd int stathz;
325 1.19 cgd int profhz;
326 1.80 briggs int profsrc;
327 1.75 simonb int schedhz;
328 1.19 cgd int profprocs;
329 1.100 drochner int hardclock_ticks;
330 1.91 yamt static int statscheddiv; /* stat => sched divider (used if schedhz == 0) */
331 1.70 sommerfe static int psdiv; /* prof => stat divider */
332 1.22 cgd int psratio; /* ratio: prof / stat */
333 1.99 kardel #ifndef __HAVE_TIMECOUNTER
334 1.22 cgd int tickfix, tickfixinterval; /* used if tick not really integral */
335 1.34 briggs #ifndef NTP
336 1.39 cgd static int tickfixcnt; /* accumulated fractional error */
337 1.34 briggs #else
338 1.27 jonathan int fixtick; /* used by NTP for same */
339 1.31 mycroft int shifthz;
340 1.31 mycroft #endif
341 1.19 cgd
342 1.48 christos /*
343 1.48 christos * We might want ldd to load the both words from time at once.
344 1.48 christos * To succeed we need to be quadword aligned.
345 1.48 christos * The sparc already does that, and that it has worked so far is a fluke.
346 1.48 christos */
347 1.48 christos volatile struct timeval time __attribute__((__aligned__(__alignof__(quad_t))));
348 1.19 cgd volatile struct timeval mono_time;
349 1.99 kardel #endif /* !__HAVE_TIMECOUNTER */
350 1.19 cgd
351 1.99 kardel #ifdef __HAVE_TIMECOUNTER
352 1.99 kardel static u_int get_intr_timecount(struct timecounter *);
353 1.99 kardel
354 1.99 kardel static struct timecounter intr_timecounter = {
355 1.99 kardel get_intr_timecount, /* get_timecount */
356 1.99 kardel 0, /* no poll_pps */
357 1.99 kardel ~0u, /* counter_mask */
358 1.99 kardel 0, /* frequency */
359 1.99 kardel "clockinterrupt", /* name */
360 1.102 christos 0, /* quality - minimum implementation level for a clock */
361 1.102 christos NULL, /* prev */
362 1.102 christos NULL, /* next */
363 1.99 kardel };
364 1.99 kardel
365 1.99 kardel static u_int
366 1.104 yamt get_intr_timecount(struct timecounter *tc)
367 1.99 kardel {
368 1.104 yamt
369 1.100 drochner return (u_int)hardclock_ticks;
370 1.99 kardel }
371 1.99 kardel #endif
372 1.73 thorpej
373 1.66 thorpej /*
374 1.19 cgd * Initialize clock frequencies and start both clocks running.
375 1.19 cgd */
376 1.19 cgd void
377 1.63 thorpej initclocks(void)
378 1.19 cgd {
379 1.55 augustss int i;
380 1.19 cgd
381 1.19 cgd /*
382 1.19 cgd * Set divisors to 1 (normal case) and let the machine-specific
383 1.19 cgd * code do its bit.
384 1.19 cgd */
385 1.70 sommerfe psdiv = 1;
386 1.99 kardel #ifdef __HAVE_TIMECOUNTER
387 1.99 kardel /*
388 1.99 kardel * provide minimum default time counter
389 1.99 kardel * will only run at interrupt resolution
390 1.99 kardel */
391 1.99 kardel intr_timecounter.tc_frequency = hz;
392 1.99 kardel tc_init(&intr_timecounter);
393 1.99 kardel #endif
394 1.19 cgd cpu_initclocks();
395 1.19 cgd
396 1.19 cgd /*
397 1.108 yamt * Compute profhz and stathz, fix profhz if needed.
398 1.19 cgd */
399 1.19 cgd i = stathz ? stathz : hz;
400 1.19 cgd if (profhz == 0)
401 1.19 cgd profhz = i;
402 1.19 cgd psratio = profhz / i;
403 1.91 yamt if (schedhz == 0) {
404 1.91 yamt /* 16Hz is best */
405 1.91 yamt statscheddiv = i / 16;
406 1.91 yamt if (statscheddiv <= 0)
407 1.91 yamt panic("statscheddiv");
408 1.91 yamt }
409 1.31 mycroft
410 1.99 kardel #ifndef __HAVE_TIMECOUNTER
411 1.31 mycroft #ifdef NTP
412 1.31 mycroft switch (hz) {
413 1.57 mycroft case 1:
414 1.57 mycroft shifthz = SHIFT_SCALE - 0;
415 1.57 mycroft break;
416 1.57 mycroft case 2:
417 1.57 mycroft shifthz = SHIFT_SCALE - 1;
418 1.57 mycroft break;
419 1.57 mycroft case 4:
420 1.57 mycroft shifthz = SHIFT_SCALE - 2;
421 1.57 mycroft break;
422 1.57 mycroft case 8:
423 1.57 mycroft shifthz = SHIFT_SCALE - 3;
424 1.57 mycroft break;
425 1.57 mycroft case 16:
426 1.57 mycroft shifthz = SHIFT_SCALE - 4;
427 1.57 mycroft break;
428 1.57 mycroft case 32:
429 1.57 mycroft shifthz = SHIFT_SCALE - 5;
430 1.57 mycroft break;
431 1.92 tls case 50:
432 1.31 mycroft case 60:
433 1.31 mycroft case 64:
434 1.31 mycroft shifthz = SHIFT_SCALE - 6;
435 1.31 mycroft break;
436 1.31 mycroft case 96:
437 1.31 mycroft case 100:
438 1.31 mycroft case 128:
439 1.31 mycroft shifthz = SHIFT_SCALE - 7;
440 1.31 mycroft break;
441 1.31 mycroft case 256:
442 1.31 mycroft shifthz = SHIFT_SCALE - 8;
443 1.41 tls break;
444 1.41 tls case 512:
445 1.41 tls shifthz = SHIFT_SCALE - 9;
446 1.31 mycroft break;
447 1.43 ross case 1000:
448 1.31 mycroft case 1024:
449 1.31 mycroft shifthz = SHIFT_SCALE - 10;
450 1.31 mycroft break;
451 1.57 mycroft case 1200:
452 1.57 mycroft case 2048:
453 1.57 mycroft shifthz = SHIFT_SCALE - 11;
454 1.57 mycroft break;
455 1.57 mycroft case 4096:
456 1.57 mycroft shifthz = SHIFT_SCALE - 12;
457 1.57 mycroft break;
458 1.57 mycroft case 8192:
459 1.57 mycroft shifthz = SHIFT_SCALE - 13;
460 1.57 mycroft break;
461 1.57 mycroft case 16384:
462 1.57 mycroft shifthz = SHIFT_SCALE - 14;
463 1.57 mycroft break;
464 1.57 mycroft case 32768:
465 1.57 mycroft shifthz = SHIFT_SCALE - 15;
466 1.57 mycroft break;
467 1.57 mycroft case 65536:
468 1.57 mycroft shifthz = SHIFT_SCALE - 16;
469 1.57 mycroft break;
470 1.31 mycroft default:
471 1.31 mycroft panic("weird hz");
472 1.50 sommerfe }
473 1.50 sommerfe if (fixtick == 0) {
474 1.52 thorpej /*
475 1.52 thorpej * Give MD code a chance to set this to a better
476 1.52 thorpej * value; but, if it doesn't, we should.
477 1.52 thorpej */
478 1.50 sommerfe fixtick = (1000000 - (hz*tick));
479 1.31 mycroft }
480 1.99 kardel #endif /* NTP */
481 1.99 kardel #endif /* !__HAVE_TIMECOUNTER */
482 1.19 cgd }
483 1.19 cgd
484 1.19 cgd /*
485 1.19 cgd * The real-time timer, interrupting hz times per second.
486 1.19 cgd */
487 1.19 cgd void
488 1.63 thorpej hardclock(struct clockframe *frame)
489 1.19 cgd {
490 1.82 thorpej struct lwp *l;
491 1.55 augustss struct proc *p;
492 1.99 kardel struct cpu_info *ci = curcpu();
493 1.99 kardel struct ptimer *pt;
494 1.99 kardel #ifndef __HAVE_TIMECOUNTER
495 1.55 augustss int delta;
496 1.19 cgd extern int tickdelta;
497 1.19 cgd extern long timedelta;
498 1.30 mycroft #ifdef NTP
499 1.55 augustss int time_update;
500 1.55 augustss int ltemp;
501 1.99 kardel #endif /* NTP */
502 1.99 kardel #endif /* __HAVE_TIMECOUNTER */
503 1.19 cgd
504 1.82 thorpej l = curlwp;
505 1.108 yamt if (!CURCPU_IDLE_P()) {
506 1.82 thorpej p = l->l_proc;
507 1.19 cgd /*
508 1.19 cgd * Run current process's virtual and profile time, as needed.
509 1.19 cgd */
510 1.82 thorpej if (CLKF_USERMODE(frame) && p->p_timers &&
511 1.82 thorpej (pt = LIST_FIRST(&p->p_timers->pts_virtual)) != NULL)
512 1.82 thorpej if (itimerdecr(pt, tick) == 0)
513 1.82 thorpej itimerfire(pt);
514 1.82 thorpej if (p->p_timers &&
515 1.82 thorpej (pt = LIST_FIRST(&p->p_timers->pts_prof)) != NULL)
516 1.82 thorpej if (itimerdecr(pt, tick) == 0)
517 1.82 thorpej itimerfire(pt);
518 1.19 cgd }
519 1.19 cgd
520 1.19 cgd /*
521 1.19 cgd * If no separate statistics clock is available, run it from here.
522 1.19 cgd */
523 1.19 cgd if (stathz == 0)
524 1.19 cgd statclock(frame);
525 1.108 yamt if ((--ci->ci_schedstate.spc_ticks) <= 0)
526 1.108 yamt sched_tick(ci);
527 1.93 perry
528 1.60 thorpej #if defined(MULTIPROCESSOR)
529 1.60 thorpej /*
530 1.60 thorpej * If we are not the primary CPU, we're not allowed to do
531 1.60 thorpej * any more work.
532 1.60 thorpej */
533 1.70 sommerfe if (CPU_IS_PRIMARY(ci) == 0)
534 1.60 thorpej return;
535 1.60 thorpej #endif
536 1.60 thorpej
537 1.99 kardel hardclock_ticks++;
538 1.99 kardel
539 1.99 kardel #ifdef __HAVE_TIMECOUNTER
540 1.99 kardel tc_ticktock();
541 1.99 kardel #else /* __HAVE_TIMECOUNTER */
542 1.19 cgd /*
543 1.22 cgd * Increment the time-of-day. The increment is normally just
544 1.22 cgd * ``tick''. If the machine is one which has a clock frequency
545 1.22 cgd * such that ``hz'' would not divide the second evenly into
546 1.22 cgd * milliseconds, a periodic adjustment must be applied. Finally,
547 1.22 cgd * if we are still adjusting the time (see adjtime()),
548 1.22 cgd * ``tickdelta'' may also be added in.
549 1.19 cgd */
550 1.22 cgd delta = tick;
551 1.27 jonathan
552 1.27 jonathan #ifndef NTP
553 1.22 cgd if (tickfix) {
554 1.39 cgd tickfixcnt += tickfix;
555 1.24 cgd if (tickfixcnt >= tickfixinterval) {
556 1.39 cgd delta++;
557 1.39 cgd tickfixcnt -= tickfixinterval;
558 1.22 cgd }
559 1.22 cgd }
560 1.27 jonathan #endif /* !NTP */
561 1.27 jonathan /* Imprecise 4bsd adjtime() handling */
562 1.22 cgd if (timedelta != 0) {
563 1.38 cgd delta += tickdelta;
564 1.19 cgd timedelta -= tickdelta;
565 1.19 cgd }
566 1.27 jonathan
567 1.27 jonathan #ifdef notyet
568 1.27 jonathan microset();
569 1.27 jonathan #endif
570 1.27 jonathan
571 1.27 jonathan #ifndef NTP
572 1.27 jonathan BUMPTIME(&time, delta); /* XXX Now done using NTP code below */
573 1.27 jonathan #endif
574 1.19 cgd BUMPTIME(&mono_time, delta);
575 1.27 jonathan
576 1.31 mycroft #ifdef NTP
577 1.30 mycroft time_update = delta;
578 1.27 jonathan
579 1.27 jonathan /*
580 1.27 jonathan * Compute the phase adjustment. If the low-order bits
581 1.27 jonathan * (time_phase) of the update overflow, bump the high-order bits
582 1.27 jonathan * (time_update).
583 1.27 jonathan */
584 1.27 jonathan time_phase += time_adj;
585 1.27 jonathan if (time_phase <= -FINEUSEC) {
586 1.27 jonathan ltemp = -time_phase >> SHIFT_SCALE;
587 1.27 jonathan time_phase += ltemp << SHIFT_SCALE;
588 1.27 jonathan time_update -= ltemp;
589 1.31 mycroft } else if (time_phase >= FINEUSEC) {
590 1.27 jonathan ltemp = time_phase >> SHIFT_SCALE;
591 1.27 jonathan time_phase -= ltemp << SHIFT_SCALE;
592 1.27 jonathan time_update += ltemp;
593 1.27 jonathan }
594 1.27 jonathan
595 1.27 jonathan #ifdef HIGHBALL
596 1.27 jonathan /*
597 1.27 jonathan * If the HIGHBALL board is installed, we need to adjust the
598 1.27 jonathan * external clock offset in order to close the hardware feedback
599 1.27 jonathan * loop. This will adjust the external clock phase and frequency
600 1.27 jonathan * in small amounts. The additional phase noise and frequency
601 1.27 jonathan * wander this causes should be minimal. We also need to
602 1.27 jonathan * discipline the kernel time variable, since the PLL is used to
603 1.27 jonathan * discipline the external clock. If the Highball board is not
604 1.27 jonathan * present, we discipline kernel time with the PLL as usual. We
605 1.27 jonathan * assume that the external clock phase adjustment (time_update)
606 1.27 jonathan * and kernel phase adjustment (clock_cpu) are less than the
607 1.27 jonathan * value of tick.
608 1.27 jonathan */
609 1.27 jonathan clock_offset.tv_usec += time_update;
610 1.27 jonathan if (clock_offset.tv_usec >= 1000000) {
611 1.27 jonathan clock_offset.tv_sec++;
612 1.27 jonathan clock_offset.tv_usec -= 1000000;
613 1.27 jonathan }
614 1.27 jonathan if (clock_offset.tv_usec < 0) {
615 1.27 jonathan clock_offset.tv_sec--;
616 1.27 jonathan clock_offset.tv_usec += 1000000;
617 1.27 jonathan }
618 1.27 jonathan time.tv_usec += clock_cpu;
619 1.27 jonathan clock_cpu = 0;
620 1.27 jonathan #else
621 1.27 jonathan time.tv_usec += time_update;
622 1.27 jonathan #endif /* HIGHBALL */
623 1.27 jonathan
624 1.27 jonathan /*
625 1.27 jonathan * On rollover of the second the phase adjustment to be used for
626 1.27 jonathan * the next second is calculated. Also, the maximum error is
627 1.27 jonathan * increased by the tolerance. If the PPS frequency discipline
628 1.27 jonathan * code is present, the phase is increased to compensate for the
629 1.27 jonathan * CPU clock oscillator frequency error.
630 1.27 jonathan *
631 1.27 jonathan * On a 32-bit machine and given parameters in the timex.h
632 1.27 jonathan * header file, the maximum phase adjustment is +-512 ms and
633 1.27 jonathan * maximum frequency offset is a tad less than) +-512 ppm. On a
634 1.27 jonathan * 64-bit machine, you shouldn't need to ask.
635 1.27 jonathan */
636 1.27 jonathan if (time.tv_usec >= 1000000) {
637 1.27 jonathan time.tv_usec -= 1000000;
638 1.27 jonathan time.tv_sec++;
639 1.27 jonathan time_maxerror += time_tolerance >> SHIFT_USEC;
640 1.27 jonathan
641 1.27 jonathan /*
642 1.27 jonathan * Leap second processing. If in leap-insert state at
643 1.27 jonathan * the end of the day, the system clock is set back one
644 1.27 jonathan * second; if in leap-delete state, the system clock is
645 1.27 jonathan * set ahead one second. The microtime() routine or
646 1.27 jonathan * external clock driver will insure that reported time
647 1.27 jonathan * is always monotonic. The ugly divides should be
648 1.27 jonathan * replaced.
649 1.27 jonathan */
650 1.27 jonathan switch (time_state) {
651 1.31 mycroft case TIME_OK:
652 1.27 jonathan if (time_status & STA_INS)
653 1.27 jonathan time_state = TIME_INS;
654 1.27 jonathan else if (time_status & STA_DEL)
655 1.27 jonathan time_state = TIME_DEL;
656 1.27 jonathan break;
657 1.27 jonathan
658 1.31 mycroft case TIME_INS:
659 1.27 jonathan if (time.tv_sec % 86400 == 0) {
660 1.27 jonathan time.tv_sec--;
661 1.27 jonathan time_state = TIME_OOP;
662 1.27 jonathan }
663 1.27 jonathan break;
664 1.27 jonathan
665 1.31 mycroft case TIME_DEL:
666 1.27 jonathan if ((time.tv_sec + 1) % 86400 == 0) {
667 1.27 jonathan time.tv_sec++;
668 1.27 jonathan time_state = TIME_WAIT;
669 1.27 jonathan }
670 1.27 jonathan break;
671 1.27 jonathan
672 1.31 mycroft case TIME_OOP:
673 1.27 jonathan time_state = TIME_WAIT;
674 1.27 jonathan break;
675 1.27 jonathan
676 1.31 mycroft case TIME_WAIT:
677 1.27 jonathan if (!(time_status & (STA_INS | STA_DEL)))
678 1.27 jonathan time_state = TIME_OK;
679 1.31 mycroft break;
680 1.27 jonathan }
681 1.27 jonathan
682 1.27 jonathan /*
683 1.27 jonathan * Compute the phase adjustment for the next second. In
684 1.27 jonathan * PLL mode, the offset is reduced by a fixed factor
685 1.27 jonathan * times the time constant. In FLL mode the offset is
686 1.27 jonathan * used directly. In either mode, the maximum phase
687 1.27 jonathan * adjustment for each second is clamped so as to spread
688 1.27 jonathan * the adjustment over not more than the number of
689 1.27 jonathan * seconds between updates.
690 1.27 jonathan */
691 1.27 jonathan if (time_offset < 0) {
692 1.27 jonathan ltemp = -time_offset;
693 1.27 jonathan if (!(time_status & STA_FLL))
694 1.27 jonathan ltemp >>= SHIFT_KG + time_constant;
695 1.27 jonathan if (ltemp > (MAXPHASE / MINSEC) << SHIFT_UPDATE)
696 1.27 jonathan ltemp = (MAXPHASE / MINSEC) <<
697 1.27 jonathan SHIFT_UPDATE;
698 1.27 jonathan time_offset += ltemp;
699 1.31 mycroft time_adj = -ltemp << (shifthz - SHIFT_UPDATE);
700 1.31 mycroft } else if (time_offset > 0) {
701 1.27 jonathan ltemp = time_offset;
702 1.27 jonathan if (!(time_status & STA_FLL))
703 1.27 jonathan ltemp >>= SHIFT_KG + time_constant;
704 1.27 jonathan if (ltemp > (MAXPHASE / MINSEC) << SHIFT_UPDATE)
705 1.27 jonathan ltemp = (MAXPHASE / MINSEC) <<
706 1.27 jonathan SHIFT_UPDATE;
707 1.27 jonathan time_offset -= ltemp;
708 1.31 mycroft time_adj = ltemp << (shifthz - SHIFT_UPDATE);
709 1.31 mycroft } else
710 1.31 mycroft time_adj = 0;
711 1.27 jonathan
712 1.27 jonathan /*
713 1.27 jonathan * Compute the frequency estimate and additional phase
714 1.27 jonathan * adjustment due to frequency error for the next
715 1.27 jonathan * second. When the PPS signal is engaged, gnaw on the
716 1.27 jonathan * watchdog counter and update the frequency computed by
717 1.27 jonathan * the pll and the PPS signal.
718 1.27 jonathan */
719 1.27 jonathan #ifdef PPS_SYNC
720 1.27 jonathan pps_valid++;
721 1.27 jonathan if (pps_valid == PPS_VALID) {
722 1.27 jonathan pps_jitter = MAXTIME;
723 1.27 jonathan pps_stabil = MAXFREQ;
724 1.27 jonathan time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
725 1.27 jonathan STA_PPSWANDER | STA_PPSERROR);
726 1.27 jonathan }
727 1.27 jonathan ltemp = time_freq + pps_freq;
728 1.27 jonathan #else
729 1.27 jonathan ltemp = time_freq;
730 1.27 jonathan #endif /* PPS_SYNC */
731 1.27 jonathan
732 1.27 jonathan if (ltemp < 0)
733 1.31 mycroft time_adj -= -ltemp >> (SHIFT_USEC - shifthz);
734 1.27 jonathan else
735 1.31 mycroft time_adj += ltemp >> (SHIFT_USEC - shifthz);
736 1.31 mycroft time_adj += (long)fixtick << shifthz;
737 1.27 jonathan
738 1.27 jonathan /*
739 1.27 jonathan * When the CPU clock oscillator frequency is not a
740 1.31 mycroft * power of 2 in Hz, shifthz is only an approximate
741 1.31 mycroft * scale factor.
742 1.46 mycroft *
743 1.46 mycroft * To determine the adjustment, you can do the following:
744 1.46 mycroft * bc -q
745 1.46 mycroft * scale=24
746 1.46 mycroft * obase=2
747 1.46 mycroft * idealhz/realhz
748 1.46 mycroft * where `idealhz' is the next higher power of 2, and `realhz'
749 1.57 mycroft * is the actual value. You may need to factor this result
750 1.57 mycroft * into a sequence of 2 multipliers to get better precision.
751 1.46 mycroft *
752 1.46 mycroft * Likewise, the error can be calculated with (e.g. for 100Hz):
753 1.46 mycroft * bc -q
754 1.46 mycroft * scale=24
755 1.57 mycroft * ((1+2^-2+2^-5)*(1-2^-10)*realhz-idealhz)/idealhz
756 1.57 mycroft * (and then multiply by 1000000 to get ppm).
757 1.27 jonathan */
758 1.31 mycroft switch (hz) {
759 1.58 mycroft case 60:
760 1.58 mycroft /* A factor of 1.000100010001 gives about 15ppm
761 1.58 mycroft error. */
762 1.58 mycroft if (time_adj < 0) {
763 1.58 mycroft time_adj -= (-time_adj >> 4);
764 1.58 mycroft time_adj -= (-time_adj >> 8);
765 1.58 mycroft } else {
766 1.58 mycroft time_adj += (time_adj >> 4);
767 1.58 mycroft time_adj += (time_adj >> 8);
768 1.58 mycroft }
769 1.58 mycroft break;
770 1.58 mycroft
771 1.31 mycroft case 96:
772 1.56 mycroft /* A factor of 1.0101010101 gives about 244ppm error. */
773 1.46 mycroft if (time_adj < 0) {
774 1.46 mycroft time_adj -= (-time_adj >> 2);
775 1.46 mycroft time_adj -= (-time_adj >> 4) + (-time_adj >> 8);
776 1.46 mycroft } else {
777 1.46 mycroft time_adj += (time_adj >> 2);
778 1.46 mycroft time_adj += (time_adj >> 4) + (time_adj >> 8);
779 1.46 mycroft }
780 1.46 mycroft break;
781 1.46 mycroft
782 1.92 tls case 50:
783 1.31 mycroft case 100:
784 1.56 mycroft /* A factor of 1.010001111010111 gives about 1ppm
785 1.56 mycroft error. */
786 1.56 mycroft if (time_adj < 0) {
787 1.46 mycroft time_adj -= (-time_adj >> 2) + (-time_adj >> 5);
788 1.56 mycroft time_adj += (-time_adj >> 10);
789 1.56 mycroft } else {
790 1.46 mycroft time_adj += (time_adj >> 2) + (time_adj >> 5);
791 1.56 mycroft time_adj -= (time_adj >> 10);
792 1.56 mycroft }
793 1.43 ross break;
794 1.46 mycroft
795 1.43 ross case 1000:
796 1.56 mycroft /* A factor of 1.000001100010100001 gives about 50ppm
797 1.56 mycroft error. */
798 1.56 mycroft if (time_adj < 0) {
799 1.56 mycroft time_adj -= (-time_adj >> 6) + (-time_adj >> 11);
800 1.56 mycroft time_adj -= (-time_adj >> 7);
801 1.56 mycroft } else {
802 1.56 mycroft time_adj += (time_adj >> 6) + (time_adj >> 11);
803 1.56 mycroft time_adj += (time_adj >> 7);
804 1.56 mycroft }
805 1.56 mycroft break;
806 1.56 mycroft
807 1.56 mycroft case 1200:
808 1.56 mycroft /* A factor of 1.1011010011100001 gives about 64ppm
809 1.56 mycroft error. */
810 1.56 mycroft if (time_adj < 0) {
811 1.56 mycroft time_adj -= (-time_adj >> 1) + (-time_adj >> 6);
812 1.56 mycroft time_adj -= (-time_adj >> 3) + (-time_adj >> 10);
813 1.56 mycroft } else {
814 1.56 mycroft time_adj += (time_adj >> 1) + (time_adj >> 6);
815 1.56 mycroft time_adj += (time_adj >> 3) + (time_adj >> 10);
816 1.56 mycroft }
817 1.31 mycroft break;
818 1.27 jonathan }
819 1.27 jonathan
820 1.27 jonathan #ifdef EXT_CLOCK
821 1.27 jonathan /*
822 1.27 jonathan * If an external clock is present, it is necessary to
823 1.27 jonathan * discipline the kernel time variable anyway, since not
824 1.27 jonathan * all system components use the microtime() interface.
825 1.27 jonathan * Here, the time offset between the external clock and
826 1.27 jonathan * kernel time variable is computed every so often.
827 1.27 jonathan */
828 1.27 jonathan clock_count++;
829 1.27 jonathan if (clock_count > CLOCK_INTERVAL) {
830 1.27 jonathan clock_count = 0;
831 1.27 jonathan microtime(&clock_ext);
832 1.27 jonathan delta.tv_sec = clock_ext.tv_sec - time.tv_sec;
833 1.27 jonathan delta.tv_usec = clock_ext.tv_usec -
834 1.27 jonathan time.tv_usec;
835 1.27 jonathan if (delta.tv_usec < 0)
836 1.27 jonathan delta.tv_sec--;
837 1.27 jonathan if (delta.tv_usec >= 500000) {
838 1.27 jonathan delta.tv_usec -= 1000000;
839 1.27 jonathan delta.tv_sec++;
840 1.27 jonathan }
841 1.27 jonathan if (delta.tv_usec < -500000) {
842 1.27 jonathan delta.tv_usec += 1000000;
843 1.27 jonathan delta.tv_sec--;
844 1.27 jonathan }
845 1.27 jonathan if (delta.tv_sec > 0 || (delta.tv_sec == 0 &&
846 1.27 jonathan delta.tv_usec > MAXPHASE) ||
847 1.27 jonathan delta.tv_sec < -1 || (delta.tv_sec == -1 &&
848 1.27 jonathan delta.tv_usec < -MAXPHASE)) {
849 1.27 jonathan time = clock_ext;
850 1.27 jonathan delta.tv_sec = 0;
851 1.27 jonathan delta.tv_usec = 0;
852 1.27 jonathan }
853 1.27 jonathan #ifdef HIGHBALL
854 1.27 jonathan clock_cpu = delta.tv_usec;
855 1.27 jonathan #else /* HIGHBALL */
856 1.27 jonathan hardupdate(delta.tv_usec);
857 1.27 jonathan #endif /* HIGHBALL */
858 1.27 jonathan }
859 1.27 jonathan #endif /* EXT_CLOCK */
860 1.27 jonathan }
861 1.27 jonathan
862 1.31 mycroft #endif /* NTP */
863 1.99 kardel #endif /* !__HAVE_TIMECOUNTER */
864 1.19 cgd
865 1.19 cgd /*
866 1.106 ad * Update real-time timeout queue. Callouts are processed at a
867 1.106 ad * very low CPU priority, so we don't keep the relatively high
868 1.106 ad * clock interrupt priority any longer than necessary.
869 1.106 ad */
870 1.109 ad callout_hardclock();
871 1.19 cgd }
872 1.19 cgd
873 1.99 kardel #ifdef __HAVE_TIMECOUNTER
874 1.99 kardel /*
875 1.99 kardel * Compute number of hz until specified time. Used to compute second
876 1.99 kardel * argument to callout_reset() from an absolute time.
877 1.99 kardel */
878 1.99 kardel int
879 1.99 kardel hzto(struct timeval *tvp)
880 1.99 kardel {
881 1.99 kardel struct timeval now, tv;
882 1.99 kardel
883 1.99 kardel tv = *tvp; /* Don't modify original tvp. */
884 1.99 kardel getmicrotime(&now);
885 1.99 kardel timersub(&tv, &now, &tv);
886 1.99 kardel return tvtohz(&tv);
887 1.99 kardel }
888 1.99 kardel #endif /* __HAVE_TIMECOUNTER */
889 1.99 kardel
890 1.99 kardel /*
891 1.99 kardel * Compute number of ticks in the specified amount of time.
892 1.99 kardel */
893 1.99 kardel int
894 1.99 kardel tvtohz(struct timeval *tv)
895 1.99 kardel {
896 1.99 kardel unsigned long ticks;
897 1.99 kardel long sec, usec;
898 1.99 kardel
899 1.99 kardel /*
900 1.99 kardel * If the number of usecs in the whole seconds part of the time
901 1.99 kardel * difference fits in a long, then the total number of usecs will
902 1.99 kardel * fit in an unsigned long. Compute the total and convert it to
903 1.99 kardel * ticks, rounding up and adding 1 to allow for the current tick
904 1.99 kardel * to expire. Rounding also depends on unsigned long arithmetic
905 1.99 kardel * to avoid overflow.
906 1.99 kardel *
907 1.99 kardel * Otherwise, if the number of ticks in the whole seconds part of
908 1.99 kardel * the time difference fits in a long, then convert the parts to
909 1.99 kardel * ticks separately and add, using similar rounding methods and
910 1.99 kardel * overflow avoidance. This method would work in the previous
911 1.99 kardel * case, but it is slightly slower and assumes that hz is integral.
912 1.99 kardel *
913 1.99 kardel * Otherwise, round the time difference down to the maximum
914 1.99 kardel * representable value.
915 1.99 kardel *
916 1.99 kardel * If ints are 32-bit, then the maximum value for any timeout in
917 1.99 kardel * 10ms ticks is 248 days.
918 1.99 kardel */
919 1.99 kardel sec = tv->tv_sec;
920 1.99 kardel usec = tv->tv_usec;
921 1.99 kardel
922 1.99 kardel if (usec < 0) {
923 1.99 kardel sec--;
924 1.99 kardel usec += 1000000;
925 1.99 kardel }
926 1.99 kardel
927 1.99 kardel if (sec < 0 || (sec == 0 && usec <= 0)) {
928 1.99 kardel /*
929 1.99 kardel * Would expire now or in the past. Return 0 ticks.
930 1.99 kardel * This is different from the legacy hzto() interface,
931 1.99 kardel * and callers need to check for it.
932 1.99 kardel */
933 1.99 kardel ticks = 0;
934 1.99 kardel } else if (sec <= (LONG_MAX / 1000000))
935 1.99 kardel ticks = (((sec * 1000000) + (unsigned long)usec + (tick - 1))
936 1.99 kardel / tick) + 1;
937 1.99 kardel else if (sec <= (LONG_MAX / hz))
938 1.99 kardel ticks = (sec * hz) +
939 1.99 kardel (((unsigned long)usec + (tick - 1)) / tick) + 1;
940 1.99 kardel else
941 1.99 kardel ticks = LONG_MAX;
942 1.99 kardel
943 1.99 kardel if (ticks > INT_MAX)
944 1.99 kardel ticks = INT_MAX;
945 1.99 kardel
946 1.99 kardel return ((int)ticks);
947 1.99 kardel }
948 1.99 kardel
949 1.99 kardel #ifndef __HAVE_TIMECOUNTER
950 1.19 cgd /*
951 1.52 thorpej * Compute number of hz until specified time. Used to compute second
952 1.52 thorpej * argument to callout_reset() from an absolute time.
953 1.19 cgd */
954 1.19 cgd int
955 1.63 thorpej hzto(struct timeval *tv)
956 1.19 cgd {
957 1.62 thorpej unsigned long ticks;
958 1.62 thorpej long sec, usec;
959 1.19 cgd int s;
960 1.19 cgd
961 1.19 cgd /*
962 1.62 thorpej * If the number of usecs in the whole seconds part of the time
963 1.62 thorpej * difference fits in a long, then the total number of usecs will
964 1.62 thorpej * fit in an unsigned long. Compute the total and convert it to
965 1.62 thorpej * ticks, rounding up and adding 1 to allow for the current tick
966 1.62 thorpej * to expire. Rounding also depends on unsigned long arithmetic
967 1.62 thorpej * to avoid overflow.
968 1.19 cgd *
969 1.62 thorpej * Otherwise, if the number of ticks in the whole seconds part of
970 1.62 thorpej * the time difference fits in a long, then convert the parts to
971 1.62 thorpej * ticks separately and add, using similar rounding methods and
972 1.62 thorpej * overflow avoidance. This method would work in the previous
973 1.62 thorpej * case, but it is slightly slower and assume that hz is integral.
974 1.62 thorpej *
975 1.62 thorpej * Otherwise, round the time difference down to the maximum
976 1.62 thorpej * representable value.
977 1.62 thorpej *
978 1.62 thorpej * If ints are 32-bit, then the maximum value for any timeout in
979 1.62 thorpej * 10ms ticks is 248 days.
980 1.19 cgd */
981 1.40 mycroft s = splclock();
982 1.19 cgd sec = tv->tv_sec - time.tv_sec;
983 1.62 thorpej usec = tv->tv_usec - time.tv_usec;
984 1.62 thorpej splx(s);
985 1.62 thorpej
986 1.62 thorpej if (usec < 0) {
987 1.62 thorpej sec--;
988 1.62 thorpej usec += 1000000;
989 1.62 thorpej }
990 1.62 thorpej
991 1.62 thorpej if (sec < 0 || (sec == 0 && usec <= 0)) {
992 1.62 thorpej /*
993 1.62 thorpej * Would expire now or in the past. Return 0 ticks.
994 1.62 thorpej * This is different from the legacy hzto() interface,
995 1.62 thorpej * and callers need to check for it.
996 1.62 thorpej */
997 1.62 thorpej ticks = 0;
998 1.62 thorpej } else if (sec <= (LONG_MAX / 1000000))
999 1.62 thorpej ticks = (((sec * 1000000) + (unsigned long)usec + (tick - 1))
1000 1.62 thorpej / tick) + 1;
1001 1.62 thorpej else if (sec <= (LONG_MAX / hz))
1002 1.62 thorpej ticks = (sec * hz) +
1003 1.62 thorpej (((unsigned long)usec + (tick - 1)) / tick) + 1;
1004 1.19 cgd else
1005 1.62 thorpej ticks = LONG_MAX;
1006 1.62 thorpej
1007 1.62 thorpej if (ticks > INT_MAX)
1008 1.62 thorpej ticks = INT_MAX;
1009 1.62 thorpej
1010 1.62 thorpej return ((int)ticks);
1011 1.19 cgd }
1012 1.99 kardel #endif /* !__HAVE_TIMECOUNTER */
1013 1.99 kardel
1014 1.99 kardel /*
1015 1.99 kardel * Compute number of ticks in the specified amount of time.
1016 1.99 kardel */
1017 1.99 kardel int
1018 1.99 kardel tstohz(struct timespec *ts)
1019 1.99 kardel {
1020 1.99 kardel struct timeval tv;
1021 1.99 kardel
1022 1.99 kardel /*
1023 1.99 kardel * usec has great enough resolution for hz, so convert to a
1024 1.99 kardel * timeval and use tvtohz() above.
1025 1.99 kardel */
1026 1.99 kardel TIMESPEC_TO_TIMEVAL(&tv, ts);
1027 1.99 kardel return tvtohz(&tv);
1028 1.99 kardel }
1029 1.19 cgd
1030 1.19 cgd /*
1031 1.19 cgd * Start profiling on a process.
1032 1.19 cgd *
1033 1.19 cgd * Kernel profiling passes proc0 which never exits and hence
1034 1.19 cgd * keeps the profile clock running constantly.
1035 1.19 cgd */
1036 1.19 cgd void
1037 1.63 thorpej startprofclock(struct proc *p)
1038 1.19 cgd {
1039 1.19 cgd
1040 1.109 ad KASSERT(mutex_owned(&p->p_stmutex));
1041 1.105 ad
1042 1.105 ad if ((p->p_stflag & PST_PROFIL) == 0) {
1043 1.105 ad p->p_stflag |= PST_PROFIL;
1044 1.80 briggs /*
1045 1.80 briggs * This is only necessary if using the clock as the
1046 1.80 briggs * profiling source.
1047 1.80 briggs */
1048 1.70 sommerfe if (++profprocs == 1 && stathz != 0)
1049 1.70 sommerfe psdiv = psratio;
1050 1.19 cgd }
1051 1.19 cgd }
1052 1.19 cgd
1053 1.19 cgd /*
1054 1.19 cgd * Stop profiling on a process.
1055 1.19 cgd */
1056 1.19 cgd void
1057 1.63 thorpej stopprofclock(struct proc *p)
1058 1.19 cgd {
1059 1.19 cgd
1060 1.109 ad KASSERT(mutex_owned(&p->p_stmutex));
1061 1.105 ad
1062 1.105 ad if (p->p_stflag & PST_PROFIL) {
1063 1.105 ad p->p_stflag &= ~PST_PROFIL;
1064 1.80 briggs /*
1065 1.80 briggs * This is only necessary if using the clock as the
1066 1.80 briggs * profiling source.
1067 1.80 briggs */
1068 1.70 sommerfe if (--profprocs == 0 && stathz != 0)
1069 1.70 sommerfe psdiv = 1;
1070 1.19 cgd }
1071 1.19 cgd }
1072 1.19 cgd
1073 1.80 briggs #if defined(PERFCTRS)
1074 1.80 briggs /*
1075 1.80 briggs * Independent profiling "tick" in case we're using a separate
1076 1.80 briggs * clock or profiling event source. Currently, that's just
1077 1.80 briggs * performance counters--hence the wrapper.
1078 1.80 briggs */
1079 1.80 briggs void
1080 1.80 briggs proftick(struct clockframe *frame)
1081 1.80 briggs {
1082 1.80 briggs #ifdef GPROF
1083 1.93 perry struct gmonparam *g;
1084 1.93 perry intptr_t i;
1085 1.80 briggs #endif
1086 1.105 ad struct lwp *l;
1087 1.80 briggs struct proc *p;
1088 1.80 briggs
1089 1.105 ad l = curlwp;
1090 1.105 ad p = (l ? l->l_proc : NULL);
1091 1.80 briggs if (CLKF_USERMODE(frame)) {
1092 1.105 ad mutex_spin_enter(&p->p_stmutex);
1093 1.105 ad if (p->p_stflag & PST_PROFIL)
1094 1.105 ad addupc_intr(l, CLKF_PC(frame));
1095 1.105 ad mutex_spin_exit(&p->p_stmutex);
1096 1.80 briggs } else {
1097 1.80 briggs #ifdef GPROF
1098 1.80 briggs g = &_gmonparam;
1099 1.80 briggs if (g->state == GMON_PROF_ON) {
1100 1.80 briggs i = CLKF_PC(frame) - g->lowpc;
1101 1.80 briggs if (i < g->textsize) {
1102 1.80 briggs i /= HISTFRACTION * sizeof(*g->kcount);
1103 1.80 briggs g->kcount[i]++;
1104 1.80 briggs }
1105 1.80 briggs }
1106 1.80 briggs #endif
1107 1.93 perry #ifdef PROC_PC
1108 1.105 ad if (p != NULL) {
1109 1.105 ad mutex_spin_enter(&p->p_stmutex);
1110 1.105 ad if (p->p_stflag & PST_PROFIL))
1111 1.105 ad addupc_intr(l, PROC_PC(p));
1112 1.105 ad mutex_spin_exit(&p->p_stmutex);
1113 1.105 ad }
1114 1.93 perry #endif
1115 1.80 briggs }
1116 1.80 briggs }
1117 1.80 briggs #endif
1118 1.80 briggs
1119 1.108 yamt void
1120 1.108 yamt schedclock(struct lwp *l)
1121 1.108 yamt {
1122 1.108 yamt
1123 1.108 yamt if ((l->l_flag & LW_IDLE) != 0)
1124 1.108 yamt return;
1125 1.108 yamt
1126 1.108 yamt sched_schedclock(l);
1127 1.108 yamt }
1128 1.108 yamt
1129 1.19 cgd /*
1130 1.19 cgd * Statistics clock. Grab profile sample, and if divider reaches 0,
1131 1.19 cgd * do process and kernel statistics.
1132 1.19 cgd */
1133 1.19 cgd void
1134 1.63 thorpej statclock(struct clockframe *frame)
1135 1.19 cgd {
1136 1.19 cgd #ifdef GPROF
1137 1.55 augustss struct gmonparam *g;
1138 1.68 eeh intptr_t i;
1139 1.19 cgd #endif
1140 1.60 thorpej struct cpu_info *ci = curcpu();
1141 1.60 thorpej struct schedstate_percpu *spc = &ci->ci_schedstate;
1142 1.55 augustss struct proc *p;
1143 1.98 christos struct lwp *l;
1144 1.19 cgd
1145 1.70 sommerfe /*
1146 1.70 sommerfe * Notice changes in divisor frequency, and adjust clock
1147 1.70 sommerfe * frequency accordingly.
1148 1.70 sommerfe */
1149 1.70 sommerfe if (spc->spc_psdiv != psdiv) {
1150 1.70 sommerfe spc->spc_psdiv = psdiv;
1151 1.70 sommerfe spc->spc_pscnt = psdiv;
1152 1.70 sommerfe if (psdiv == 1) {
1153 1.70 sommerfe setstatclockrate(stathz);
1154 1.70 sommerfe } else {
1155 1.93 perry setstatclockrate(profhz);
1156 1.70 sommerfe }
1157 1.70 sommerfe }
1158 1.98 christos l = curlwp;
1159 1.108 yamt if ((l->l_flag & LW_IDLE) != 0) {
1160 1.108 yamt /*
1161 1.108 yamt * don't account idle lwps as swapper.
1162 1.108 yamt */
1163 1.108 yamt p = NULL;
1164 1.108 yamt } else {
1165 1.108 yamt p = l->l_proc;
1166 1.105 ad mutex_spin_enter(&p->p_stmutex);
1167 1.108 yamt }
1168 1.108 yamt
1169 1.19 cgd if (CLKF_USERMODE(frame)) {
1170 1.105 ad if ((p->p_stflag & PST_PROFIL) && profsrc == PROFSRC_CLOCK)
1171 1.105 ad addupc_intr(l, CLKF_PC(frame));
1172 1.105 ad if (--spc->spc_pscnt > 0) {
1173 1.105 ad mutex_spin_exit(&p->p_stmutex);
1174 1.19 cgd return;
1175 1.105 ad }
1176 1.105 ad
1177 1.19 cgd /*
1178 1.19 cgd * Came from user mode; CPU was in user state.
1179 1.19 cgd * If this process is being profiled record the tick.
1180 1.19 cgd */
1181 1.19 cgd p->p_uticks++;
1182 1.19 cgd if (p->p_nice > NZERO)
1183 1.60 thorpej spc->spc_cp_time[CP_NICE]++;
1184 1.19 cgd else
1185 1.60 thorpej spc->spc_cp_time[CP_USER]++;
1186 1.19 cgd } else {
1187 1.19 cgd #ifdef GPROF
1188 1.19 cgd /*
1189 1.19 cgd * Kernel statistics are just like addupc_intr, only easier.
1190 1.19 cgd */
1191 1.19 cgd g = &_gmonparam;
1192 1.80 briggs if (profsrc == PROFSRC_CLOCK && g->state == GMON_PROF_ON) {
1193 1.19 cgd i = CLKF_PC(frame) - g->lowpc;
1194 1.19 cgd if (i < g->textsize) {
1195 1.19 cgd i /= HISTFRACTION * sizeof(*g->kcount);
1196 1.19 cgd g->kcount[i]++;
1197 1.19 cgd }
1198 1.19 cgd }
1199 1.19 cgd #endif
1200 1.82 thorpej #ifdef LWP_PC
1201 1.108 yamt if (p != NULL && profsrc == PROFSRC_CLOCK &&
1202 1.108 yamt (p->p_stflag & PST_PROFIL)) {
1203 1.105 ad addupc_intr(l, LWP_PC(l));
1204 1.108 yamt }
1205 1.72 mycroft #endif
1206 1.105 ad if (--spc->spc_pscnt > 0) {
1207 1.105 ad if (p != NULL)
1208 1.105 ad mutex_spin_exit(&p->p_stmutex);
1209 1.19 cgd return;
1210 1.105 ad }
1211 1.19 cgd /*
1212 1.19 cgd * Came from kernel mode, so we were:
1213 1.19 cgd * - handling an interrupt,
1214 1.19 cgd * - doing syscall or trap work on behalf of the current
1215 1.19 cgd * user process, or
1216 1.19 cgd * - spinning in the idle loop.
1217 1.19 cgd * Whichever it is, charge the time as appropriate.
1218 1.19 cgd * Note that we charge interrupts to the current process,
1219 1.19 cgd * regardless of whether they are ``for'' that process,
1220 1.19 cgd * so that we know how much of its real time was spent
1221 1.19 cgd * in ``non-process'' (i.e., interrupt) work.
1222 1.19 cgd */
1223 1.109 ad if (CLKF_INTR(frame) || (l->l_flag & LW_INTR) != 0) {
1224 1.108 yamt if (p != NULL) {
1225 1.19 cgd p->p_iticks++;
1226 1.108 yamt }
1227 1.60 thorpej spc->spc_cp_time[CP_INTR]++;
1228 1.19 cgd } else if (p != NULL) {
1229 1.19 cgd p->p_sticks++;
1230 1.60 thorpej spc->spc_cp_time[CP_SYS]++;
1231 1.108 yamt } else {
1232 1.60 thorpej spc->spc_cp_time[CP_IDLE]++;
1233 1.108 yamt }
1234 1.19 cgd }
1235 1.70 sommerfe spc->spc_pscnt = psdiv;
1236 1.19 cgd
1237 1.97 elad if (p != NULL) {
1238 1.108 yamt ++l->l_cpticks;
1239 1.105 ad mutex_spin_exit(&p->p_stmutex);
1240 1.108 yamt }
1241 1.105 ad
1242 1.108 yamt /*
1243 1.108 yamt * If no separate schedclock is provided, call it here
1244 1.108 yamt * at about 16 Hz.
1245 1.108 yamt */
1246 1.108 yamt if (schedhz == 0) {
1247 1.108 yamt if ((int)(--ci->ci_schedstate.spc_schedticks) <= 0) {
1248 1.108 yamt schedclock(l);
1249 1.108 yamt ci->ci_schedstate.spc_schedticks = statscheddiv;
1250 1.108 yamt }
1251 1.19 cgd }
1252 1.19 cgd }
1253 1.27 jonathan
1254 1.99 kardel #ifndef __HAVE_TIMECOUNTER
1255 1.27 jonathan #ifdef NTP /* NTP phase-locked loop in kernel */
1256 1.27 jonathan /*
1257 1.27 jonathan * hardupdate() - local clock update
1258 1.27 jonathan *
1259 1.27 jonathan * This routine is called by ntp_adjtime() to update the local clock
1260 1.27 jonathan * phase and frequency. The implementation is of an adaptive-parameter,
1261 1.27 jonathan * hybrid phase/frequency-lock loop (PLL/FLL). The routine computes new
1262 1.27 jonathan * time and frequency offset estimates for each call. If the kernel PPS
1263 1.27 jonathan * discipline code is configured (PPS_SYNC), the PPS signal itself
1264 1.27 jonathan * determines the new time offset, instead of the calling argument.
1265 1.27 jonathan * Presumably, calls to ntp_adjtime() occur only when the caller
1266 1.27 jonathan * believes the local clock is valid within some bound (+-128 ms with
1267 1.27 jonathan * NTP). If the caller's time is far different than the PPS time, an
1268 1.27 jonathan * argument will ensue, and it's not clear who will lose.
1269 1.27 jonathan *
1270 1.27 jonathan * For uncompensated quartz crystal oscillatores and nominal update
1271 1.27 jonathan * intervals less than 1024 s, operation should be in phase-lock mode
1272 1.27 jonathan * (STA_FLL = 0), where the loop is disciplined to phase. For update
1273 1.27 jonathan * intervals greater than thiss, operation should be in frequency-lock
1274 1.27 jonathan * mode (STA_FLL = 1), where the loop is disciplined to frequency.
1275 1.27 jonathan *
1276 1.27 jonathan * Note: splclock() is in effect.
1277 1.27 jonathan */
1278 1.27 jonathan void
1279 1.63 thorpej hardupdate(long offset)
1280 1.27 jonathan {
1281 1.27 jonathan long ltemp, mtemp;
1282 1.27 jonathan
1283 1.27 jonathan if (!(time_status & STA_PLL) && !(time_status & STA_PPSTIME))
1284 1.27 jonathan return;
1285 1.27 jonathan ltemp = offset;
1286 1.27 jonathan #ifdef PPS_SYNC
1287 1.27 jonathan if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
1288 1.27 jonathan ltemp = pps_offset;
1289 1.27 jonathan #endif /* PPS_SYNC */
1290 1.27 jonathan
1291 1.27 jonathan /*
1292 1.27 jonathan * Scale the phase adjustment and clamp to the operating range.
1293 1.27 jonathan */
1294 1.27 jonathan if (ltemp > MAXPHASE)
1295 1.27 jonathan time_offset = MAXPHASE << SHIFT_UPDATE;
1296 1.27 jonathan else if (ltemp < -MAXPHASE)
1297 1.27 jonathan time_offset = -(MAXPHASE << SHIFT_UPDATE);
1298 1.27 jonathan else
1299 1.27 jonathan time_offset = ltemp << SHIFT_UPDATE;
1300 1.27 jonathan
1301 1.27 jonathan /*
1302 1.27 jonathan * Select whether the frequency is to be controlled and in which
1303 1.27 jonathan * mode (PLL or FLL). Clamp to the operating range. Ugly
1304 1.27 jonathan * multiply/divide should be replaced someday.
1305 1.27 jonathan */
1306 1.27 jonathan if (time_status & STA_FREQHOLD || time_reftime == 0)
1307 1.27 jonathan time_reftime = time.tv_sec;
1308 1.27 jonathan mtemp = time.tv_sec - time_reftime;
1309 1.27 jonathan time_reftime = time.tv_sec;
1310 1.27 jonathan if (time_status & STA_FLL) {
1311 1.27 jonathan if (mtemp >= MINSEC) {
1312 1.27 jonathan ltemp = ((time_offset / mtemp) << (SHIFT_USEC -
1313 1.27 jonathan SHIFT_UPDATE));
1314 1.27 jonathan if (ltemp < 0)
1315 1.27 jonathan time_freq -= -ltemp >> SHIFT_KH;
1316 1.27 jonathan else
1317 1.27 jonathan time_freq += ltemp >> SHIFT_KH;
1318 1.27 jonathan }
1319 1.27 jonathan } else {
1320 1.27 jonathan if (mtemp < MAXSEC) {
1321 1.27 jonathan ltemp *= mtemp;
1322 1.27 jonathan if (ltemp < 0)
1323 1.27 jonathan time_freq -= -ltemp >> (time_constant +
1324 1.27 jonathan time_constant + SHIFT_KF -
1325 1.27 jonathan SHIFT_USEC);
1326 1.27 jonathan else
1327 1.27 jonathan time_freq += ltemp >> (time_constant +
1328 1.27 jonathan time_constant + SHIFT_KF -
1329 1.27 jonathan SHIFT_USEC);
1330 1.27 jonathan }
1331 1.27 jonathan }
1332 1.27 jonathan if (time_freq > time_tolerance)
1333 1.27 jonathan time_freq = time_tolerance;
1334 1.27 jonathan else if (time_freq < -time_tolerance)
1335 1.27 jonathan time_freq = -time_tolerance;
1336 1.27 jonathan }
1337 1.27 jonathan
1338 1.27 jonathan #ifdef PPS_SYNC
1339 1.27 jonathan /*
1340 1.27 jonathan * hardpps() - discipline CPU clock oscillator to external PPS signal
1341 1.27 jonathan *
1342 1.27 jonathan * This routine is called at each PPS interrupt in order to discipline
1343 1.27 jonathan * the CPU clock oscillator to the PPS signal. It measures the PPS phase
1344 1.27 jonathan * and leaves it in a handy spot for the hardclock() routine. It
1345 1.27 jonathan * integrates successive PPS phase differences and calculates the
1346 1.27 jonathan * frequency offset. This is used in hardclock() to discipline the CPU
1347 1.27 jonathan * clock oscillator so that intrinsic frequency error is cancelled out.
1348 1.27 jonathan * The code requires the caller to capture the time and hardware counter
1349 1.27 jonathan * value at the on-time PPS signal transition.
1350 1.27 jonathan *
1351 1.27 jonathan * Note that, on some Unix systems, this routine runs at an interrupt
1352 1.27 jonathan * priority level higher than the timer interrupt routine hardclock().
1353 1.27 jonathan * Therefore, the variables used are distinct from the hardclock()
1354 1.27 jonathan * variables, except for certain exceptions: The PPS frequency pps_freq
1355 1.27 jonathan * and phase pps_offset variables are determined by this routine and
1356 1.27 jonathan * updated atomically. The time_tolerance variable can be considered a
1357 1.27 jonathan * constant, since it is infrequently changed, and then only when the
1358 1.27 jonathan * PPS signal is disabled. The watchdog counter pps_valid is updated
1359 1.27 jonathan * once per second by hardclock() and is atomically cleared in this
1360 1.27 jonathan * routine.
1361 1.27 jonathan */
1362 1.27 jonathan void
1363 1.63 thorpej hardpps(struct timeval *tvp, /* time at PPS */
1364 1.63 thorpej long usec /* hardware counter at PPS */)
1365 1.27 jonathan {
1366 1.27 jonathan long u_usec, v_usec, bigtick;
1367 1.27 jonathan long cal_sec, cal_usec;
1368 1.27 jonathan
1369 1.27 jonathan /*
1370 1.27 jonathan * An occasional glitch can be produced when the PPS interrupt
1371 1.27 jonathan * occurs in the hardclock() routine before the time variable is
1372 1.27 jonathan * updated. Here the offset is discarded when the difference
1373 1.27 jonathan * between it and the last one is greater than tick/2, but not
1374 1.27 jonathan * if the interval since the first discard exceeds 30 s.
1375 1.27 jonathan */
1376 1.27 jonathan time_status |= STA_PPSSIGNAL;
1377 1.27 jonathan time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
1378 1.27 jonathan pps_valid = 0;
1379 1.27 jonathan u_usec = -tvp->tv_usec;
1380 1.27 jonathan if (u_usec < -500000)
1381 1.27 jonathan u_usec += 1000000;
1382 1.27 jonathan v_usec = pps_offset - u_usec;
1383 1.27 jonathan if (v_usec < 0)
1384 1.27 jonathan v_usec = -v_usec;
1385 1.27 jonathan if (v_usec > (tick >> 1)) {
1386 1.27 jonathan if (pps_glitch > MAXGLITCH) {
1387 1.27 jonathan pps_glitch = 0;
1388 1.27 jonathan pps_tf[2] = u_usec;
1389 1.27 jonathan pps_tf[1] = u_usec;
1390 1.27 jonathan } else {
1391 1.27 jonathan pps_glitch++;
1392 1.27 jonathan u_usec = pps_offset;
1393 1.27 jonathan }
1394 1.27 jonathan } else
1395 1.27 jonathan pps_glitch = 0;
1396 1.27 jonathan
1397 1.27 jonathan /*
1398 1.27 jonathan * A three-stage median filter is used to help deglitch the pps
1399 1.27 jonathan * time. The median sample becomes the time offset estimate; the
1400 1.27 jonathan * difference between the other two samples becomes the time
1401 1.27 jonathan * dispersion (jitter) estimate.
1402 1.27 jonathan */
1403 1.27 jonathan pps_tf[2] = pps_tf[1];
1404 1.27 jonathan pps_tf[1] = pps_tf[0];
1405 1.27 jonathan pps_tf[0] = u_usec;
1406 1.27 jonathan if (pps_tf[0] > pps_tf[1]) {
1407 1.27 jonathan if (pps_tf[1] > pps_tf[2]) {
1408 1.27 jonathan pps_offset = pps_tf[1]; /* 0 1 2 */
1409 1.27 jonathan v_usec = pps_tf[0] - pps_tf[2];
1410 1.27 jonathan } else if (pps_tf[2] > pps_tf[0]) {
1411 1.27 jonathan pps_offset = pps_tf[0]; /* 2 0 1 */
1412 1.27 jonathan v_usec = pps_tf[2] - pps_tf[1];
1413 1.27 jonathan } else {
1414 1.27 jonathan pps_offset = pps_tf[2]; /* 0 2 1 */
1415 1.27 jonathan v_usec = pps_tf[0] - pps_tf[1];
1416 1.27 jonathan }
1417 1.27 jonathan } else {
1418 1.27 jonathan if (pps_tf[1] < pps_tf[2]) {
1419 1.27 jonathan pps_offset = pps_tf[1]; /* 2 1 0 */
1420 1.27 jonathan v_usec = pps_tf[2] - pps_tf[0];
1421 1.27 jonathan } else if (pps_tf[2] < pps_tf[0]) {
1422 1.27 jonathan pps_offset = pps_tf[0]; /* 1 0 2 */
1423 1.27 jonathan v_usec = pps_tf[1] - pps_tf[2];
1424 1.27 jonathan } else {
1425 1.27 jonathan pps_offset = pps_tf[2]; /* 1 2 0 */
1426 1.27 jonathan v_usec = pps_tf[1] - pps_tf[0];
1427 1.27 jonathan }
1428 1.27 jonathan }
1429 1.27 jonathan if (v_usec > MAXTIME)
1430 1.27 jonathan pps_jitcnt++;
1431 1.27 jonathan v_usec = (v_usec << PPS_AVG) - pps_jitter;
1432 1.27 jonathan if (v_usec < 0)
1433 1.27 jonathan pps_jitter -= -v_usec >> PPS_AVG;
1434 1.27 jonathan else
1435 1.27 jonathan pps_jitter += v_usec >> PPS_AVG;
1436 1.27 jonathan if (pps_jitter > (MAXTIME >> 1))
1437 1.27 jonathan time_status |= STA_PPSJITTER;
1438 1.27 jonathan
1439 1.27 jonathan /*
1440 1.27 jonathan * During the calibration interval adjust the starting time when
1441 1.27 jonathan * the tick overflows. At the end of the interval compute the
1442 1.27 jonathan * duration of the interval and the difference of the hardware
1443 1.27 jonathan * counters at the beginning and end of the interval. This code
1444 1.27 jonathan * is deliciously complicated by the fact valid differences may
1445 1.27 jonathan * exceed the value of tick when using long calibration
1446 1.27 jonathan * intervals and small ticks. Note that the counter can be
1447 1.27 jonathan * greater than tick if caught at just the wrong instant, but
1448 1.27 jonathan * the values returned and used here are correct.
1449 1.27 jonathan */
1450 1.27 jonathan bigtick = (long)tick << SHIFT_USEC;
1451 1.27 jonathan pps_usec -= pps_freq;
1452 1.27 jonathan if (pps_usec >= bigtick)
1453 1.27 jonathan pps_usec -= bigtick;
1454 1.27 jonathan if (pps_usec < 0)
1455 1.27 jonathan pps_usec += bigtick;
1456 1.27 jonathan pps_time.tv_sec++;
1457 1.27 jonathan pps_count++;
1458 1.27 jonathan if (pps_count < (1 << pps_shift))
1459 1.27 jonathan return;
1460 1.27 jonathan pps_count = 0;
1461 1.27 jonathan pps_calcnt++;
1462 1.27 jonathan u_usec = usec << SHIFT_USEC;
1463 1.27 jonathan v_usec = pps_usec - u_usec;
1464 1.27 jonathan if (v_usec >= bigtick >> 1)
1465 1.27 jonathan v_usec -= bigtick;
1466 1.27 jonathan if (v_usec < -(bigtick >> 1))
1467 1.27 jonathan v_usec += bigtick;
1468 1.27 jonathan if (v_usec < 0)
1469 1.27 jonathan v_usec = -(-v_usec >> pps_shift);
1470 1.27 jonathan else
1471 1.27 jonathan v_usec = v_usec >> pps_shift;
1472 1.27 jonathan pps_usec = u_usec;
1473 1.27 jonathan cal_sec = tvp->tv_sec;
1474 1.27 jonathan cal_usec = tvp->tv_usec;
1475 1.27 jonathan cal_sec -= pps_time.tv_sec;
1476 1.27 jonathan cal_usec -= pps_time.tv_usec;
1477 1.27 jonathan if (cal_usec < 0) {
1478 1.27 jonathan cal_usec += 1000000;
1479 1.27 jonathan cal_sec--;
1480 1.27 jonathan }
1481 1.27 jonathan pps_time = *tvp;
1482 1.27 jonathan
1483 1.27 jonathan /*
1484 1.27 jonathan * Check for lost interrupts, noise, excessive jitter and
1485 1.27 jonathan * excessive frequency error. The number of timer ticks during
1486 1.27 jonathan * the interval may vary +-1 tick. Add to this a margin of one
1487 1.27 jonathan * tick for the PPS signal jitter and maximum frequency
1488 1.27 jonathan * deviation. If the limits are exceeded, the calibration
1489 1.27 jonathan * interval is reset to the minimum and we start over.
1490 1.27 jonathan */
1491 1.27 jonathan u_usec = (long)tick << 1;
1492 1.27 jonathan if (!((cal_sec == -1 && cal_usec > (1000000 - u_usec))
1493 1.27 jonathan || (cal_sec == 0 && cal_usec < u_usec))
1494 1.27 jonathan || v_usec > time_tolerance || v_usec < -time_tolerance) {
1495 1.27 jonathan pps_errcnt++;
1496 1.27 jonathan pps_shift = PPS_SHIFT;
1497 1.27 jonathan pps_intcnt = 0;
1498 1.27 jonathan time_status |= STA_PPSERROR;
1499 1.27 jonathan return;
1500 1.27 jonathan }
1501 1.27 jonathan
1502 1.27 jonathan /*
1503 1.27 jonathan * A three-stage median filter is used to help deglitch the pps
1504 1.27 jonathan * frequency. The median sample becomes the frequency offset
1505 1.27 jonathan * estimate; the difference between the other two samples
1506 1.27 jonathan * becomes the frequency dispersion (stability) estimate.
1507 1.27 jonathan */
1508 1.27 jonathan pps_ff[2] = pps_ff[1];
1509 1.27 jonathan pps_ff[1] = pps_ff[0];
1510 1.27 jonathan pps_ff[0] = v_usec;
1511 1.27 jonathan if (pps_ff[0] > pps_ff[1]) {
1512 1.27 jonathan if (pps_ff[1] > pps_ff[2]) {
1513 1.27 jonathan u_usec = pps_ff[1]; /* 0 1 2 */
1514 1.27 jonathan v_usec = pps_ff[0] - pps_ff[2];
1515 1.27 jonathan } else if (pps_ff[2] > pps_ff[0]) {
1516 1.27 jonathan u_usec = pps_ff[0]; /* 2 0 1 */
1517 1.27 jonathan v_usec = pps_ff[2] - pps_ff[1];
1518 1.27 jonathan } else {
1519 1.27 jonathan u_usec = pps_ff[2]; /* 0 2 1 */
1520 1.27 jonathan v_usec = pps_ff[0] - pps_ff[1];
1521 1.27 jonathan }
1522 1.27 jonathan } else {
1523 1.27 jonathan if (pps_ff[1] < pps_ff[2]) {
1524 1.27 jonathan u_usec = pps_ff[1]; /* 2 1 0 */
1525 1.27 jonathan v_usec = pps_ff[2] - pps_ff[0];
1526 1.27 jonathan } else if (pps_ff[2] < pps_ff[0]) {
1527 1.27 jonathan u_usec = pps_ff[0]; /* 1 0 2 */
1528 1.27 jonathan v_usec = pps_ff[1] - pps_ff[2];
1529 1.27 jonathan } else {
1530 1.27 jonathan u_usec = pps_ff[2]; /* 1 2 0 */
1531 1.27 jonathan v_usec = pps_ff[1] - pps_ff[0];
1532 1.27 jonathan }
1533 1.27 jonathan }
1534 1.27 jonathan
1535 1.27 jonathan /*
1536 1.27 jonathan * Here the frequency dispersion (stability) is updated. If it
1537 1.27 jonathan * is less than one-fourth the maximum (MAXFREQ), the frequency
1538 1.27 jonathan * offset is updated as well, but clamped to the tolerance. It
1539 1.27 jonathan * will be processed later by the hardclock() routine.
1540 1.27 jonathan */
1541 1.27 jonathan v_usec = (v_usec >> 1) - pps_stabil;
1542 1.27 jonathan if (v_usec < 0)
1543 1.27 jonathan pps_stabil -= -v_usec >> PPS_AVG;
1544 1.27 jonathan else
1545 1.27 jonathan pps_stabil += v_usec >> PPS_AVG;
1546 1.27 jonathan if (pps_stabil > MAXFREQ >> 2) {
1547 1.27 jonathan pps_stbcnt++;
1548 1.27 jonathan time_status |= STA_PPSWANDER;
1549 1.27 jonathan return;
1550 1.27 jonathan }
1551 1.27 jonathan if (time_status & STA_PPSFREQ) {
1552 1.27 jonathan if (u_usec < 0) {
1553 1.27 jonathan pps_freq -= -u_usec >> PPS_AVG;
1554 1.27 jonathan if (pps_freq < -time_tolerance)
1555 1.27 jonathan pps_freq = -time_tolerance;
1556 1.27 jonathan u_usec = -u_usec;
1557 1.27 jonathan } else {
1558 1.27 jonathan pps_freq += u_usec >> PPS_AVG;
1559 1.27 jonathan if (pps_freq > time_tolerance)
1560 1.27 jonathan pps_freq = time_tolerance;
1561 1.27 jonathan }
1562 1.27 jonathan }
1563 1.27 jonathan
1564 1.27 jonathan /*
1565 1.27 jonathan * Here the calibration interval is adjusted. If the maximum
1566 1.27 jonathan * time difference is greater than tick / 4, reduce the interval
1567 1.27 jonathan * by half. If this is not the case for four consecutive
1568 1.27 jonathan * intervals, double the interval.
1569 1.27 jonathan */
1570 1.27 jonathan if (u_usec << pps_shift > bigtick >> 2) {
1571 1.27 jonathan pps_intcnt = 0;
1572 1.27 jonathan if (pps_shift > PPS_SHIFT)
1573 1.27 jonathan pps_shift--;
1574 1.27 jonathan } else if (pps_intcnt >= 4) {
1575 1.27 jonathan pps_intcnt = 0;
1576 1.27 jonathan if (pps_shift < PPS_SHIFTMAX)
1577 1.27 jonathan pps_shift++;
1578 1.27 jonathan } else
1579 1.27 jonathan pps_intcnt++;
1580 1.27 jonathan }
1581 1.27 jonathan #endif /* PPS_SYNC */
1582 1.27 jonathan #endif /* NTP */
1583 1.95 christos
1584 1.99 kardel /* timecounter compat functions */
1585 1.99 kardel void
1586 1.95 christos nanotime(struct timespec *ts)
1587 1.95 christos {
1588 1.95 christos struct timeval tv;
1589 1.95 christos
1590 1.95 christos microtime(&tv);
1591 1.95 christos TIMEVAL_TO_TIMESPEC(&tv, ts);
1592 1.95 christos }
1593 1.99 kardel
1594 1.99 kardel void
1595 1.99 kardel getbinuptime(struct bintime *bt)
1596 1.99 kardel {
1597 1.99 kardel struct timeval tv;
1598 1.99 kardel
1599 1.99 kardel microtime(&tv);
1600 1.99 kardel timeval2bintime(&tv, bt);
1601 1.99 kardel }
1602 1.99 kardel
1603 1.99 kardel void
1604 1.99 kardel nanouptime(struct timespec *tsp)
1605 1.99 kardel {
1606 1.99 kardel int s;
1607 1.99 kardel
1608 1.99 kardel s = splclock();
1609 1.99 kardel TIMEVAL_TO_TIMESPEC(&mono_time, tsp);
1610 1.99 kardel splx(s);
1611 1.99 kardel }
1612 1.99 kardel
1613 1.99 kardel void
1614 1.99 kardel getnanouptime(struct timespec *tsp)
1615 1.99 kardel {
1616 1.99 kardel int s;
1617 1.99 kardel
1618 1.99 kardel s = splclock();
1619 1.99 kardel TIMEVAL_TO_TIMESPEC(&mono_time, tsp);
1620 1.99 kardel splx(s);
1621 1.99 kardel }
1622 1.99 kardel
1623 1.99 kardel void
1624 1.99 kardel getmicrouptime(struct timeval *tvp)
1625 1.99 kardel {
1626 1.99 kardel int s;
1627 1.99 kardel
1628 1.99 kardel s = splclock();
1629 1.99 kardel *tvp = mono_time;
1630 1.99 kardel splx(s);
1631 1.99 kardel }
1632 1.99 kardel
1633 1.99 kardel void
1634 1.99 kardel getnanotime(struct timespec *tsp)
1635 1.99 kardel {
1636 1.99 kardel int s;
1637 1.99 kardel
1638 1.99 kardel s = splclock();
1639 1.99 kardel TIMEVAL_TO_TIMESPEC(&time, tsp);
1640 1.99 kardel splx(s);
1641 1.99 kardel }
1642 1.99 kardel
1643 1.99 kardel void
1644 1.99 kardel getmicrotime(struct timeval *tvp)
1645 1.99 kardel {
1646 1.99 kardel int s;
1647 1.99 kardel
1648 1.99 kardel s = splclock();
1649 1.99 kardel *tvp = time;
1650 1.99 kardel splx(s);
1651 1.99 kardel }
1652 1.107 dsl
1653 1.107 dsl u_int64_t
1654 1.107 dsl tc_getfrequency(void)
1655 1.107 dsl {
1656 1.107 dsl return hz;
1657 1.107 dsl }
1658 1.99 kardel #endif /* !__HAVE_TIMECOUNTER */
1659