clock.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/tuneable.h>
#include <sys/sysmacros.h>
#include <sys/archsystm.h>
#include <sys/mem_cage.h>
/*
* for NTP support
*/
#include <sys/inttypes.h>
/*
* clock is called straight from
* the real time clock interrupt.
*
* Functions:
* reprime clock
* schedule callouts
* maintain date
* jab the scheduler
*/
extern kcondvar_t fsflush_cv;
extern int idleswtch; /* flag set while idle in pswtch() */
/*
* high-precision avenrun values. These are needed to make the
* regular avenrun values accurate.
*/
/*
* Phase/frequency-lock loop (PLL/FLL) definitions
*
* The following variables are read and set by the ntp_adjtime() system
* call.
*
* time_state shows the state of the system clock, with values defined
* in the timex.h header file.
*
* time_status shows the status of the system clock, with bits defined
* in the timex.h header file.
*
* increments.
*
* time_constant determines the bandwidth or "stiffness" of the PLL.
*
* time_tolerance determines maximum frequency error or tolerance of the
* CPU clock oscillator and is a property of the architecture; however,
* in principle it could change as result of the presence of external
* discipline signals, for instance.
*
* time_precision is usually equal to the kernel tick variable; however,
* in cases where a precision clock counter or external clock is
* available, the resolution can be much less than this and depend on
* whether the external clock is working or not.
*
* time_maxerror is initialized by a ntp_adjtime() call and increased by
* the kernel once each second to reflect the maximum error bound
* growth.
*
* time_esterror is set and read by the ntp_adjtime() call, but
* otherwise not used by the kernel.
*/
/*
* residual time and frequency offset of the local clock. The scale
* factors are defined in the timex.h header file.
*
* time_phase and time_freq are the phase increment and the frequency
* increment, respectively, of the kernel time variable.
*
* time_freq is set via ntp_adjtime() from a value stored in a file when
* the synchronization daemon is first started. Its value is retrieved
* via ntp_adjtime() and written to the file about once per hour by the
* daemon.
*
* time_adj is the adjustment added to the value of tick at each timer
* interrupt and is recomputed from time_phase and time_freq at each
* seconds rollover.
*
* time_reftime is the second's portion of the system time at the last
* call to ntp_adjtime(). It is used to adjust the time_freq variable
* and to increase the time_maxerror as the time since last update
* increases.
*/
/*
* The scale factors of the following variables are defined in the
* timex.h header file.
*
* pps_time contains the time at each calibration interval, as read by
* microtime(). pps_count counts the seconds of the calibration
* interval, the duration of which is nominally pps_shift in powers of
* two.
*
* pps_offset is the time offset produced by the time median filter
* pps_tf[], while pps_jitter is the dispersion (jitter) measured by
* this filter.
*
* pps_freq is the frequency offset produced by the frequency median
* filter pps_ff[], while pps_stabil is the dispersion (wander) measured
* by this filter.
*
* pps_usec is latched from a high resolution counter or external clock
* at pps_time. Here we want the hardware counter contents only, not the
* contents plus the time_tv.usec as usual.
*
* pps_valid counts the number of seconds since the last PPS update. It
* is used as a watchdog timer to disable the PPS discipline should the
* PPS signal be lost.
*
* pps_glitch counts the number of seconds since the beginning of an
* offset burst more than tick/2 from current nominal offset. It is used
* mainly to suppress error bursts due to priority conflicts between the
* PPS interrupt and timer interrupt.
*
* pps_intcnt counts the calibration intervals for use in the interval-
* adaptation algorithm. It's just too complicated for words.
*/
/*
* PPS signal quality monitors
*
* pps_jitcnt counts the seconds that have been discarded because the
* jitter measured by the time median filter exceeds the limit MAXTIME
* (100 us).
*
* pps_calcnt counts the frequency calibration intervals, which are
* variable from 4 s to 256 s.
*
* pps_errcnt counts the calibration intervals which have been discarded
* because the wander exceeds the limit MAXFREQ (100 ppm) or where the
* calibration interval jitter exceeds two ticks.
*
* pps_stbcnt counts the calibration intervals that have been discarded
* because the frequency wander exceeds the limit MAXFREQ / 4 (25 us).
*/
/* The following variables require no explicit locking */
static int fsflushcnt; /* counter for t_fsflushr */
int tod_needsync = 0; /* need to sync tod chip with software time */
static int tod_broken = 0; /* clock chip doesn't work */
static int lgrp_ticks; /* counter to schedule lgrp load calcs */
/*
* rechoose_interval_history is used to detect when rechoose_interval's
* value has changed (via hotpatching for example), so that the
* cached values in the cpu structures may be updated.
*/
static int rechoose_interval_history = RECHOOSE_INTERVAL;
/*
* for tod fault detection
*/
#define TOD_FILTER_N 4
static int tod_faulted = TOD_NOFAULT;
static int tod_fault_reset_flag = 0;
int tod_validate_enable = 1;
/*
* tod_fault_table[] must be aligned with
* enum tod_fault_type in systm.h
*/
static char *tod_fault_table[] = {
"Reversed", /* TOD_REVERSED */
"Stalled", /* TOD_STALLED */
"Jumped", /* TOD_JUMPED */
"Changed in Clock Rate" /* TOD_RATECHANGED */
/*
* no strings needed for TOD_NOFAULT
*/
};
/*
* test hook for tod broken detection in tod_validate
*/
int tod_unit_test = 0;
#define CLOCK_ADJ_HIST_SIZE 4
static int adj_hist_entry;
static void clock_tick(kthread_t *);
static void calcloadavg(int, uint64_t *);
static int genloadavg(struct loadavg_s *);
static void loadavg_update();
void (*cmm_clock_callout)() = NULL;
#ifdef KSLICE
#endif
static void
clock(void)
{
kthread_t *t;
int pinned_intr = 0;
int exiting;
extern void set_anoninfo();
extern void set_freemem();
void (*funcp)();
int s;
int do_lgrp_load;
int rechoose_update = 0;
int rechoose;
int i;
if (panicstr)
return;
set_anoninfo();
/*
* Make sure that 'freemem' do not drift too far from the truth
*/
set_freemem();
/*
* Before the section which is repeated is executed, we do
* the time delta processing which occurs every clock tick
*
* There is additional processing which happens every time
* the nanosecond counter rolls over which is described
* below - see the section which begins with : if (one_sec)
*
* This section marks the beginning of the precision-kernel
* code fragment.
*
* First, compute the phase adjustment. If the low-order bits
* (time_phase) of the update overflow, bump the higher order
* bits (time_update).
*/
time_phase += time_adj;
if (time_phase <= -FINEUSEC) {
s = hr_clock_lock();
hr_clock_unlock(s);
} else if (time_phase >= FINEUSEC) {
s = hr_clock_lock();
hr_clock_unlock(s);
}
/*
* End of precision-kernel code fragment which is processed
* every timer interrupt.
*
* Continue with the interrupt processing as scheduled.
*
* Did we pin another interrupt thread? Need to check this before
* grabbing any adaptive locks, since if we block on a lock the
* pinned thread could escape. Note that this is just a heuristic;
* if we take multiple laps though clock() without returning from
* the interrupt because we have another clock tick pending, then
* the pinned interrupt could be released by one of the previous
* laps. The only consequence is that the CPU will be counted as
* in idle (or wait) state once the pinned interrupt is released.
* Since this accounting is inaccurate by nature, this isn't a big
* deal --- but we should try to get it right in the common case
* where we only call clock() once per interrupt.
*/
/*
* Count the number of runnable threads and the number waiting
* for some form of I/O to complete -- gets added to
* sysinfo.waiting. To know the state of the system, must add
* wait counts from all CPUs. Also add up the per-partition
* statistics.
*/
w_io = 0;
nrunnable = 0;
/*
*/
do_lgrp_load = 0;
lgrp_ticks = 0;
do_lgrp_load = 1;
}
/*
* The dispatcher tunable rechoose_interval may be hot-patched.
* Note if it has a new value. If so, the effective rechoose_interval
* cached in the cpu structures needs to be updated.
* If needed we'll do this during the walk of the cpu_list below.
*/
if (rechoose_interval != rechoose_interval_history) {
rechoose_update = 1;
}
if (one_sec)
/*
* First count the threads waiting on kpreempt queues in each
* CPU partition.
*/
do {
cpupart->cp_updates++;
if (one_sec) {
cpupart->cp_nrunning = 0;
}
/* Now count the per-CPU statistics. */
do {
if (one_sec)
if (do_lgrp_load &&
/*
* When updating the lgroup's load average,
* account for the thread running on the CPU.
* If the CPU is the current one, then we need
* to account for the underlying thread which
* got the clock interrupt not the thread that is
* handling the interrupt and caculating the load
* average
*/
t = cp->cpu_thread;
t = t->t_intr;
/*
* Account for the load average for this thread if
* it isn't the idle thread or it is on the interrupt
* stack and not the current CPU handling the clock
* interrupt
*/
CPU_ON_INTR(cp))) {
/* local thread */
} else {
/*
* This is a remote thread, charge it
* against its home lgroup. Note that
* we notice that a thread is remote
* only if it's currently executing.
* This is a reasonable approximation,
* since queued remote threads are rare.
* Note also that if we didn't charge
* it to its home lgroup, remote
* execution would often make a system
* appear balanced even though it was
* would often not be done correctly.
*/
lgrp_loadavg(t->t_lpl,
}
}
}
/*
* The platform may define a per physical processor
* adjustment of rechoose_interval. The effective
* (base + adjustment) rechoose_interval is cached
* in the cpu structures for efficiency. Above we detect
* if the cached values need updating, and here is where
* the update happens.
*/
if (rechoose_update) {
}
/*
* Do tick processing for all the active threads running in
* the system.
*/
nrunning = 0;
do {
int intr;
int thread_away;
/*
* Don't do any tick processing on CPUs that
* aren't even in the system or aren't up yet.
*/
continue;
}
/*
* The locking here is rather tricky. We use
* thread_free_lock to keep the currently running
* thread from being freed or recycled while we're
* looking at it. We can then check if the thread
* is exiting and get the appropriate p_lock if it
* is not. We have to be careful, though, because
* the _process_ can still be freed while we're
* holding thread_free_lock. To avoid touching the
* proc structure we put a pointer to the p_lock in the
* thread structure. The p_lock is persistent so we
* can acquire it even if the process is gone. At that
* point we can check (again) if the thread is exiting
* and either drop the lock or do the tick processing.
*/
/*
* We cannot hold the cpu_lock to prevent the
* cpu_list from changing in the clock interrupt.
* As long as we don't block (or don't get pre-empted)
* the cpu_list will not change (all threads are paused
* before list modification). If the list does change
* any deleted cpu structures will remain with cpu_next
* set to NULL, hence the following test.
*/
break;
}
/*
* 't' will be the clock interrupt thread on this
* CPU. Use the pinned thread (if any) on this CPU
* as the target of the clock tick. If we pinned
* an interrupt, though, just keep using the clock
* interrupt thread since the formerly pinned one
* may have gone away. One interrupt thread is as
* good as another, and this means we don't have
* to continue to check pinned_intr in subsequent
* code.
*/
t = t->t_intr;
}
/*
* Thread is exiting (or uninteresting) so don't
* do tick processing or grab p_lock. Once we
* drop thread_free_lock we can't look inside the
* thread or lwp structure, since the thread may
* have gone away.
*/
exiting = 1;
} else {
/*
* OK, try to grab the process lock. See
* comments above for why we're not using
* ttoproc(t)->p_lockp here.
*/
/* See above comment. */
break;
}
/*
* The thread may have exited between when we
* checked above, and when we got the p_lock.
*/
if (t->t_proc_flag & TP_LWPEXIT) {
exiting = 1;
} else {
exiting = 0;
}
}
/*
* Either we have the p_lock for the thread's process,
* or we don't care about the thread structure any more.
* Either way we can drop thread_free_lock.
*/
/*
* Update user, system, and idle cpu times.
*/
if (one_sec) {
nrunning++;
}
/*
* If we haven't done tick processing for this
* lwp, then do it now. Since we don't hold the
* lwp down on a CPU it can migrate and show up
* more than once, hence the lbolt check.
*
* Also, make sure that it's okay to perform the
* tick processing before calling clock_tick.
* Setting thread_away to a TRUE value (ie. not 0)
* results in tick processing not being performed for
* that thread. Or, in other words, keeps the thread
* away from clock_tick processing.
*/
clock_tick(t);
}
#ifdef KSLICE
/*
* Ah what the heck, give this kid a taste of the real
* world and yank the rug out from under it.
* But, only if we are running UniProcessor.
*/
aston(t);
}
#endif
if (!exiting)
/*
* bump time in ticks
*
* We rely on there being only one clock thread and hence
* don't need a lock to protect lbolt.
*/
lbolt++;
/*
* Check for a callout that needs be called from the clock
* thread to support the membership protocol in a clustered
* system. Copy the function pointer so that we can reset
* this to NULL if needed.
*/
(*funcp)();
/*
* Wakeup the cageout thread waiters once per second.
*/
if (one_sec)
kcage_tick();
/*
* Schedule timeout() requests if any are due at this time.
*/
if (one_sec) {
int s;
/*
* Beginning of precision-kernel code fragment executed
* every second.
*
* On rollover of the second the phase adjustment to be
* used for the next second is calculated. Also, the
* maximum error is increased by the tolerance. If the
* PPS frequency discipline code is present, the phase is
* increased to compensate for the CPU clock oscillator
* frequency error.
*
* On a 32-bit machine and given parameters in the timex.h
* header file, the maximum phase adjustment is +-512 ms
* and maximum frequency offset is (a tad less than)
* +-512 ppm. On a 64-bit machine, you shouldn't need to ask.
*/
/*
* Leap second processing. If in leap-insert state at
* the end of the day, the system clock is set back one
* second; if in leap-delete state, the system clock is
* set ahead one second. The microtime() routine or
* external clock driver will insure that reported time
* is always monotonic. The ugly divides should be
* replaced.
*/
switch (time_state) {
case TIME_OK:
if (time_status & STA_INS)
else if (time_status & STA_DEL)
break;
case TIME_INS:
s = hr_clock_lock();
hr_clock_unlock(s);
}
break;
case TIME_DEL:
s = hr_clock_lock();
hr_clock_unlock(s);
}
break;
case TIME_OOP:
break;
case TIME_WAIT:
default:
break;
}
/*
* Compute the phase adjustment for the next second. In
* PLL mode, the offset is reduced by a fixed factor
* times the time constant. In FLL mode the offset is
* used directly. In either mode, the maximum phase
* adjustment for each second is clamped so as to spread
* the adjustment over not more than the number of
* seconds between updates.
*/
if (time_offset == 0)
time_adj = 0;
else if (time_offset < 0) {
lltemp = -time_offset;
if (!(time_status & STA_FLL)) {
else
}
time_offset += lltemp;
} else {
if (!(time_status & STA_FLL)) {
else
}
time_offset -= lltemp;
}
/*
* Compute the frequency estimate and additional phase
* adjustment due to frequency error for the next
* second. When the PPS signal is engaged, gnaw on the
* watchdog counter and update the frequency computed by
* the pll and the PPS signal.
*/
pps_valid++;
}
if (lltemp)
/*
* End of precision kernel-code fragment
*
* The section below should be modified if we are planning
* to use NTP for synchronization.
*
* Note: the clock synchronization code now assumes
* the following:
* - if dosynctodr is 1, then compute the drift between
* the tod chip and software time and adjust one or
* the other depending on the circumstances
*
* - if dosynctodr is 0, then the tod chip is independent
* of the software clock and should not be adjusted,
* but allowed to free run. this allows NTP to sync.
* hrestime without any interference from the tod chip.
*/
int s;
if (absdrift > 2) {
s = hr_clock_lock();
membar_enter(); /* hrestime visible */
timedelta = 0;
timechanged++;
tod_needsync = 0;
hr_clock_unlock(s);
}
} else {
if (tod_needsync || !dosynctodr) {
gethrestime(&tod);
s = hr_clock_lock();
if (timedelta == 0)
tod_needsync = 0;
hr_clock_unlock(s);
} else {
/*
* If the drift is 2 seconds on the
* money, then the TOD is adjusting
* the clock; record that.
*/
s = hr_clock_lock();
hr_clock_unlock(s);
}
}
}
one_sec = 0;
/*
* Some drivers still depend on this... XXX
*/
{
/* number of reserved and allocated pages */
#ifdef DEBUG
#endif
}
if (nrunnable) {
}
if (nswapped) {
}
/*
* Wake up fsflush to write out DELWRI
* buffers, dirty pages and other cached
* administrative data, e.g. inodes.
*/
if (--fsflushcnt <= 0) {
}
vmmeter();
for (i = 0; i < 3; i++)
/*
* At the moment avenrun[] can only hold 31
* bits of load average as it is a signed
* int in the API. We need to ensure that
* hp_avenrun[i] >> (16 - FSHIFT) will not be
* too large. If it is, we put the largest value
* that we can use into avenrun[i]. This is
* kludgey, but about all we can do until we
* avenrun[] is declared as an array of uint64[]
*/
(16 - FSHIFT));
else
avenrun[i] = 0x7fffffff;
do {
/*
* Wake up the swapper thread if necessary.
*/
if (runin ||
t = &t0;
thread_lock(t);
if (t->t_state == TS_STOPPED) {
wake_sched_sec = 0;
t->t_whystop = 0;
t->t_whatstop = 0;
t->t_schedflag &= ~TS_ALLSTART;
setfrontdq(t);
}
thread_unlock(t);
}
}
/*
* Wake up the swapper if any high priority swapped-out threads
* became runable during the last tick.
*/
if (wake_sched) {
t = &t0;
thread_lock(t);
if (t->t_state == TS_STOPPED) {
wake_sched = 0;
t->t_whystop = 0;
t->t_whatstop = 0;
t->t_schedflag &= ~TS_ALLSTART;
setfrontdq(t);
}
thread_unlock(t);
}
}
void
clock_init(void)
{
}
/*
* Called before calcloadavg to get 10-sec moving loadavg together
*/
static int
{
int avg;
int spos; /* starting position */
int cpos; /* moving current position */
int i;
int slen;
/* 10-second snapshot, calculate first positon */
return (0);
}
}
return (avg);
}
/*
* Run every second from clock () to update the loadavg count available to the
* system and cpu-partitions.
*
* This works by sampling the previous usr, sys, wait time elapsed,
* computing a delta, and adding that delta to the elapsed usr, sys,
* wait increase.
*/
static void
{
int prev;
/*
* first pass totals up per-cpu statistics for system and cpu
* partitions
*/
do {
/* compute delta against last total */
cpu_total = 0;
} else {
if (cpu_total < 0)
cpu_total = 0;
}
/*
* Second pass updates counts
*/
do {
}
/*
* clock_update() - local clock update
*
* This routine is called by ntp_adjtime() to update the local clock
* phase and frequency. The implementation is of an
* adaptive-parameter, hybrid phase/frequency-lock loop (PLL/FLL). The
* routine computes new time and frequency offset estimates for each
* call. The PPS signal itself determines the new time offset,
* instead of the calling argument. Presumably, calls to
* ntp_adjtime() occur only when the caller believes the local clock
* is valid within some bound (+-128 ms with NTP). If the caller's
* time is far different than the PPS time, an argument will ensue,
* and it's not clear who will lose.
*
* For uncompensated quartz crystal oscillatores and nominal update
* intervals less than 1024 s, operation should be in phase-lock mode
* (STA_FLL = 0), where the loop is disciplined to phase. For update
* intervals greater than this, operation should be in frequency-lock
* mode (STA_FLL = 1), where the loop is disciplined to frequency.
*
* Note: mutex(&tod_lock) is in effect.
*/
void
clock_update(int offset)
{
return;
ltemp = pps_offset;
/*
* Scale the phase adjustment and clamp to the operating range.
*/
else
/*
* Select whether the frequency is to be controlled and in which
* mode (PLL or FLL). Clamp to the operating range. Ugly
*/
if (time_status & STA_FLL) {
SCALE_UPDATE));
if (ltemp)
}
} else {
if (ltemp)
SCALE_USEC) / SCALE_KF)
}
}
if (time_freq > time_tolerance)
else if (time_freq < -time_tolerance)
s = hr_clock_lock();
tod_needsync = 1;
hr_clock_unlock(s);
}
/*
* ddi_hardpps() - discipline CPU clock oscillator to external PPS signal
*
* This routine is called at each PPS interrupt in order to discipline
* the CPU clock oscillator to the PPS signal. It measures the PPS phase
* and leaves it in a handy spot for the clock() routine. It
* integrates successive PPS phase differences and calculates the
* frequency offset. This is used in clock() to discipline the CPU
* clock oscillator so that intrinsic frequency error is cancelled out.
* The code requires the caller to capture the time and hardware counter
* value at the on-time PPS signal transition.
*
* Note that, on some Unix systems, this routine runs at an interrupt
* priority level higher than the timer interrupt routine clock().
* Therefore, the variables used are distinct from the clock()
* variables, except for certain exceptions: The PPS frequency pps_freq
* and phase pps_offset variables are determined by this routine and
* updated atomically. The time_tolerance variable can be considered a
* constant, since it is infrequently changed, and then only when the
* PPS signal is disabled. The watchdog counter pps_valid is updated
* once per second by clock() and is atomically cleared in this
* routine.
*
* tvp is the time of the last tick; usec is a microsecond count since the
* last tick.
*
* Note: In Solaris systems, the tick value is actually given by
* usec_per_tick. This is called from the serial driver cdintr(),
* or equivalent, at a high PIL. Because the kernel keeps a
* highresolution time, the following code can accept either
* the traditional argument pair, or the current highres timestamp
* in tvp and zero in usec.
*/
void
{
int cal_usec;
/*
* An occasional glitch can be produced when the PPS interrupt
* occurs in the clock() routine before the time variable is
* updated. Here the offset is discarded when the difference
* between it and the last one is greater than tick/2, but not
* if the interval since the first discard exceeds 30 s.
*/
pps_valid = 0;
if (v_usec < 0)
if (pps_glitch > MAXGLITCH) {
pps_glitch = 0;
} else {
pps_glitch++;
u_usec = pps_offset;
}
} else
pps_glitch = 0;
/*
* A three-stage median filter is used to help deglitch the pps
* time. The median sample becomes the time offset estimate; the
* difference between the other two samples becomes the time
* dispersion (jitter) estimate.
*/
} else {
}
} else {
} else {
}
}
pps_jitcnt++;
/*
* During the calibration interval adjust the starting time when
* the tick overflows. At the end of the interval compute the
* duration of the interval and the difference of the hardware
* counters at the beginning and end of the interval. This code
* is deliciously complicated by the fact valid differences may
* exceed the value of tick when using long calibration
* intervals and small ticks. Note that the counter can be
* greater than tick if caught at just the wrong instant, but
* the values returned and used here are correct.
*/
if (pps_usec < 0)
pps_count++;
return;
pps_count = 0;
pps_calcnt++;
if (v_usec < 0)
else
if (cal_usec < 0) {
cal_sec--;
}
/*
* Check for lost interrupts, noise, excessive jitter and
* excessive frequency error. The number of timer ticks during
* the interval may vary +-1 tick. Add to this a margin of one
* tick for the PPS signal jitter and maximum frequency
* deviation. If the limits are exceeded, the calibration
* interval is reset to the minimum and we start over.
*/
pps_errcnt++;
pps_intcnt = 0;
return;
}
/*
* A three-stage median filter is used to help deglitch the pps
* frequency. The median sample becomes the frequency offset
* estimate; the difference between the other two samples
* becomes the frequency dispersion (stability) estimate.
*/
} else {
}
} else {
} else {
}
}
/*
* Here the frequency dispersion (stability) is updated. If it
* is less than one-fourth the maximum (MAXFREQ), the frequency
* offset is updated as well, but clamped to the tolerance. It
* will be processed later by the clock() routine.
*/
if (v_usec < 0)
else
pps_stbcnt++;
return;
}
if (time_status & STA_PPSFREQ) {
if (u_usec < 0) {
if (pps_freq < -time_tolerance)
} else {
if (pps_freq > time_tolerance)
}
}
/*
* Here the calibration interval is adjusted. If the maximum
* time difference is greater than tick / 4, reduce the interval
* by half. If this is not the case for four consecutive
* intervals, double the interval.
*/
pps_intcnt = 0;
pps_shift--;
} else if (pps_intcnt >= 4) {
pps_intcnt = 0;
if (pps_shift < PPS_SHIFTMAX)
pps_shift++;
} else
pps_intcnt++;
/*
* If recovering from kmdb, then make sure the tod chip gets resynced.
* If we took an early exit above, then we don't yet have a stable
* calibration signal to lock onto, so don't mark the tod for sync
* until we get all the way here.
*/
{
int s = hr_clock_lock();
tod_needsync = 1;
hr_clock_unlock(s);
}
}
/*
* Handle clock tick processing for a thread.
* Check for timer action, enforce CPU rlimit, do profiling etc.
*/
void
clock_tick(kthread_t *t)
{
int poke = 0; /* notify another CPU */
int user_mode;
panic("clock_tick: no lwp");
/*NOTREACHED*/
}
CL_TICK(t); /* Class specific tick processing */
/* pp->p_lock makes sure that the thread does not exit */
/*
* Update process times. Should use high res clock and state
* changes instead of statistical sampling method. XXX
*/
if (user_mode) {
} else {
}
/*
* Update user profiling statistics. Get the pc from the
* lwp when the AST happens.
*/
if (user_mode) {
poke = 1;
aston(t);
}
}
/*
* If CPU was in user state, process lwp-virtual time
* interval timer.
*/
if (user_mode &&
poke = 1;
}
poke = 1;
}
/*
* Enforce CPU resource controls:
* (a) process.max-cpu-time resource control
*/
/*
* (b) task.max-cpu-time resource control
*/
/*
* Update memory usage for the currently running process.
*/
/*
* Notify the CPU the thread is running on.
*/
}
void
{
int ticks;
do {
mutex_enter(&p->p_pflock);
/*
* Old-style profiling
*/
mutex_exit(&p->p_pflock);
return;
}
}
}
/*
* PC Sampling
*/
int result;
#ifdef __lint
#endif
while (ticks-- > 0) {
/* buffer full, turn off sampling */
break;
}
switch (SIZEOF_PTR(model)) {
case sizeof (uint32_t):
break;
#ifdef _LP64
case sizeof (uint64_t):
break;
#endif
default:
"data model");
result = -1;
break;
}
if (result != 0) {
break;
}
pr->pr_samples++;
}
}
mutex_exit(&p->p_pflock);
}
static void
delay_wakeup(void *arg)
{
mutex_enter(&t->t_delay_lock);
cv_signal(&t->t_delay_cv);
mutex_exit(&t->t_delay_lock);
}
void
{
/*
* Timeouts aren't running, so all we can do is spin.
*/
return;
}
mutex_enter(&t->t_delay_lock);
mutex_exit(&t->t_delay_lock);
}
}
/*
* Like delay, but interruptible by a signal.
*/
int
{
do {
} while (rc > 0);
if (rc == 0)
return (EINTR);
return (0);
}
#define SECONDS_PER_DAY 86400
/*
* Initialize the system time based on the TOD chip. approx is used as
* an approximation of time (e.g. from the filesystem) in the event that
* the TOD chip has been cleared or is unresponsive. An approx of -1
* means the filesystem doesn't keep time.
*/
void
{
int spl;
int set_clock = 0;
/*
* If the TOD chip is reporting some time after 1971,
* then it probably didn't lose power or become otherwise
* cleared in the recent past; check to assure that
* the time coming from the filesystem isn't in the future
* according to the TOD chip.
*/
"than time on time-of-day chip; check date.");
}
} else {
/*
* If the TOD chip isn't giving correct time, then set it to
* the time that was passed in as a rough estimate. If we
* don't have an estimate, then set the clock back to a time
* when Oliver North, ALF and Dire Straits were all on the
* collective brain: 1987.
*/
if (approx == -1)
else
/*
* Attempt to write the new time to the TOD chip. Set spl high
* to avoid getting preempted between the tod_set and tod_get.
*/
tod_broken = 1;
dosynctodr = 0;
" dead batteries?");
} else {
"incorrect date; check and reset.");
}
set_clock = 1;
}
if (!boot_time) {
set_clock = 1;
}
if (set_clock)
set_hrestime(&ts);
}
int timechanged; /* for testing if the system time has been reset */
void
{
int spl = hr_clock_lock();
membar_enter(); /* hrestime must be visible before timechanged++ */
timedelta = 0;
timechanged++;
}
static uint_t deadman_seconds;
static uint32_t deadman_panics;
static int deadman_enabled = 0;
static int deadman_panic_timers = 1;
static void
deadman(void)
{
if (panicstr) {
/*
* During panic, other CPUs besides the panic
* master continue to handle cyclics and some other
* interrupts. The code below is intended to be
* single threaded, so any CPU other than the master
* must keep out.
*/
return;
/*
* If we're panicking, the deadman cyclic continues to increase
* lbolt in case the dump device driver relies on this for
* timeouts. Note that we rely on deadman() being invoked once
* per second, and credit lbolt and lbolt64 with hz ticks each.
*/
if (!deadman_panic_timers)
return; /* allow all timers to be manually disabled */
/*
* If we are generating a crash dump or syncing filesystems and
* the corresponding timer is set, decrement it and re-enter
* the panic code to abort it and advance to the next state.
* The panic states and triggers are explained in panic.c.
*/
if (panic_dump) {
if (dump_timeleft && (--dump_timeleft == 0)) {
panic("panic dump timeout");
/*NOTREACHED*/
}
} else if (panic_sync) {
if (sync_timeleft && (--sync_timeleft == 0)) {
panic("panic sync timeout");
/*NOTREACHED*/
}
}
return;
}
return;
}
if (CPU->cpu_deadman_countdown-- > 0)
return;
/*
* Regardless of whether or not we actually bring the system down,
* bump the deadman_panics variable.
*
* N.B. deadman_panics is incremented once for each CPU that
* passes through here. It's expected that all the CPUs will
* detect this condition within one second of each other, so
* when deadman_enabled is off, deadman_panics will
* typically be a multiple of the total number of CPUs in
* the system.
*/
if (!deadman_enabled) {
return;
}
/*
* If we're here, we want to bring the system down.
*/
panic("deadman: timed out after %d seconds of clock "
"inactivity", deadman_seconds);
/*NOTREACHED*/
}
/*ARGSUSED*/
static void
{
cpu->cpu_deadman_lbolt = 0;
/*
* Stagger the CPUs so that they don't all run deadman() at
* the same time. Simplest reason to do this is to make it
* more likely that only one CPU will panic in case of a
* timeout. This is (strictly speaking) an aesthetic, not a
* technical consideration.
*
* The interval must be one second in accordance with the
* code in deadman() above to increase lbolt during panic.
*/
}
void
deadman_init(void)
{
if (deadman_seconds == 0)
if (snooping)
deadman_enabled = 1;
}
/*
* tod_fault() is for updating tod validate mechanism state:
* (1) TOD_NOFAULT: for resetting the state to 'normal'.
* currently used for debugging only
* (2) The following four cases detected by tod validate mechanism:
* TOD_REVERSED: current tod value is less than previous value.
* TOD_STALLED: current tod value hasn't advanced.
* TOD_JUMPED: current tod value advanced too far from previous value.
* TOD_RATECHANGED: the ratio between average tod delta and
* average tick delta has changed.
*/
enum tod_fault_type
{
if (tod_faulted != ftype) {
switch (ftype) {
case TOD_NOFAULT:
if (&plat_tod_fault)
"Time of Day clock.");
tod_faulted = ftype;
break;
case TOD_REVERSED:
case TOD_JUMPED:
if (tod_faulted == TOD_NOFAULT) {
if (&plat_tod_fault)
"reason [%s by 0x%x]. -- "
" Stopped tracking Time Of Day clock.",
tod_faulted = ftype;
}
break;
case TOD_STALLED:
case TOD_RATECHANGED:
if (tod_faulted == TOD_NOFAULT) {
if (&plat_tod_fault)
"reason [%s]. -- "
" Stopped tracking Time Of Day clock.",
tod_faulted = ftype;
}
break;
default:
break;
}
}
return (tod_faulted);
}
void
{
tod_fault_reset_flag = 1;
}
/*
* tod_validate() is used for checking values returned by tod_get().
* Four error cases can be detected by this routine:
* TOD_REVERSED: current tod value is less than previous.
* TOD_STALLED: current tod value hasn't advanced.
* TOD_JUMPED: current tod value advanced too far from previous value.
* TOD_RATECHANGED: the ratio between average tod delta and
* average tick delta has changed.
*/
{
long dtick;
int dtick_delta;
int off = 0;
static int firsttime = 1;
static long dtick_avg = TOD_REF_FREQ;
/*
* If TOD is already faulted, there is nothing to do
*/
return (tod);
}
/*
* Update prev_tod and prev_tick values for first run
*/
if (firsttime) {
firsttime = 0;
return (tod);
}
/*
* For either of these conditions, we need to reset ourself
* and start validation from zero since each condition
* indicates that the TOD will be updated with new value
* Also, note that tod_needsync will be reset in clock()
*/
if (tod_needsync || tod_fault_reset_flag) {
firsttime = 1;
prev_tod = 0;
prev_tick = 0;
if (tod_fault_reset_flag)
tod_fault_reset_flag = 0;
return (tod);
}
/* test hook */
switch (tod_unit_test) {
case 1: /* for testing jumping tod */
tod += tod_test_injector;
tod_unit_test = 0;
break;
case 2: /* for testing stuck tod bit */
tod_unit_test = 0;
break;
case 3: /* for testing stalled tod */
tod_unit_test = 0;
break;
case 4: /* reset tod fault status */
(void) tod_fault(TOD_NOFAULT, 0);
tod_unit_test = 0;
break;
default:
break;
}
if (diff_tod < 0) {
/* ERROR - tod reversed */
} else if (diff_tod == 0) {
/* tod did not advance */
if (diff_tick > TOD_STALL_THRESHOLD) {
/* ERROR - tod stalled */
} else {
/*
* Make sure we don't update prev_tick
* so that diff_tick is calculated since
* the first diff_tod == 0
*/
return (tod);
}
} else {
/* calculate dtick */
/* update dtick averages */
/*
* Calculate dtick_delta as
* variation from reference freq in quartiles
*/
(TOD_REF_FREQ >> 2);
/*
* Even with a perfectly functioning TOD device,
* when the number of elapsed seconds is low the
* algorithm can calculate a rate that is beyond
* tolerance, causing an error. The algorithm is
* inaccurate when elapsed time is low (less than
* 5 seconds).
*/
if (diff_tod > 4) {
if (dtick < TOD_JUMP_THRESHOLD) {
/* ERROR - tod jumped */
} else if (dtick_delta) {
/* ERROR - change in clock rate */
}
}
}
if (tod_bad != TOD_NOFAULT) {
/*
* Disable dosynctodr since we are going to fault
* the TOD chip anyway here
*/
dosynctodr = 0;
/*
* Set tod to the correct value from hrestime
*/
}
return (tod);
}
static void
{
uint_t i;
int64_t q, r;
/*
* Compute load average over the last 1, 5, and 15 minutes
* (60, 300, and 900 seconds). The constants in f[3] are for
* exponential decay:
* (1 - exp(-1/60)) << 13 = 135,
* (1 - exp(-1/300)) << 13 = 27,
* (1 - exp(-1/900)) << 13 = 9.
*/
/*
* a little hoop-jumping to avoid integer overflow
*/
for (i = 0; i < 3; i++) {
}
}