17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 237c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate /* 277c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 287c478bd9Sstevel@tonic-gate * Use is subject to license terms. 297c478bd9Sstevel@tonic-gate */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate #include <sys/param.h> 347c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 357c478bd9Sstevel@tonic-gate #include <sys/types.h> 367c478bd9Sstevel@tonic-gate #include <sys/tuneable.h> 377c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 387c478bd9Sstevel@tonic-gate #include <sys/systm.h> 397c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 407c478bd9Sstevel@tonic-gate #include <sys/lgrp.h> 417c478bd9Sstevel@tonic-gate #include <sys/user.h> 427c478bd9Sstevel@tonic-gate #include <sys/proc.h> 437c478bd9Sstevel@tonic-gate #include <sys/callo.h> 447c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 457c478bd9Sstevel@tonic-gate #include <sys/var.h> 467c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 477c478bd9Sstevel@tonic-gate #include <sys/swap.h> 487c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 497c478bd9Sstevel@tonic-gate #include <sys/class.h> 507c478bd9Sstevel@tonic-gate #include <sys/time.h> 517c478bd9Sstevel@tonic-gate #include <sys/debug.h> 527c478bd9Sstevel@tonic-gate #include <sys/vtrace.h> 537c478bd9Sstevel@tonic-gate #include <sys/spl.h> 547c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 557c478bd9Sstevel@tonic-gate #include <sys/dumphdr.h> 567c478bd9Sstevel@tonic-gate #include <sys/archsystm.h> 577c478bd9Sstevel@tonic-gate #include <sys/fs/swapnode.h> 587c478bd9Sstevel@tonic-gate #include <sys/panic.h> 597c478bd9Sstevel@tonic-gate #include <sys/disp.h> 607c478bd9Sstevel@tonic-gate #include <sys/msacct.h> 617c478bd9Sstevel@tonic-gate #include <sys/mem_cage.h> 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate #include <vm/page.h> 647c478bd9Sstevel@tonic-gate #include <vm/anon.h> 657c478bd9Sstevel@tonic-gate #include <vm/rm.h> 667c478bd9Sstevel@tonic-gate #include <sys/cyclic.h> 677c478bd9Sstevel@tonic-gate #include <sys/cpupart.h> 687c478bd9Sstevel@tonic-gate #include <sys/rctl.h> 697c478bd9Sstevel@tonic-gate #include <sys/task.h> 707c478bd9Sstevel@tonic-gate #include <sys/chip.h> 717c478bd9Sstevel@tonic-gate #include <sys/sdt.h> 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate /* 747c478bd9Sstevel@tonic-gate * for NTP support 757c478bd9Sstevel@tonic-gate */ 767c478bd9Sstevel@tonic-gate #include <sys/timex.h> 777c478bd9Sstevel@tonic-gate #include <sys/inttypes.h> 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate /* 807c478bd9Sstevel@tonic-gate * clock is called straight from 817c478bd9Sstevel@tonic-gate * the real time clock interrupt. 827c478bd9Sstevel@tonic-gate * 837c478bd9Sstevel@tonic-gate * Functions: 847c478bd9Sstevel@tonic-gate * reprime clock 857c478bd9Sstevel@tonic-gate * schedule callouts 867c478bd9Sstevel@tonic-gate * maintain date 877c478bd9Sstevel@tonic-gate * jab the scheduler 887c478bd9Sstevel@tonic-gate */ 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate extern kcondvar_t fsflush_cv; 917c478bd9Sstevel@tonic-gate extern sysinfo_t sysinfo; 927c478bd9Sstevel@tonic-gate extern vminfo_t vminfo; 937c478bd9Sstevel@tonic-gate extern int idleswtch; /* flag set while idle in pswtch() */ 947c478bd9Sstevel@tonic-gate 957c478bd9Sstevel@tonic-gate /* 967c478bd9Sstevel@tonic-gate * high-precision avenrun values. These are needed to make the 977c478bd9Sstevel@tonic-gate * regular avenrun values accurate. 987c478bd9Sstevel@tonic-gate */ 997c478bd9Sstevel@tonic-gate static uint64_t hp_avenrun[3]; 1007c478bd9Sstevel@tonic-gate int avenrun[3]; /* FSCALED average run queue lengths */ 1017c478bd9Sstevel@tonic-gate time_t time; /* time in seconds since 1970 - for compatibility only */ 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate static struct loadavg_s loadavg; 1047c478bd9Sstevel@tonic-gate /* 1057c478bd9Sstevel@tonic-gate * Phase/frequency-lock loop (PLL/FLL) definitions 1067c478bd9Sstevel@tonic-gate * 1077c478bd9Sstevel@tonic-gate * The following variables are read and set by the ntp_adjtime() system 1087c478bd9Sstevel@tonic-gate * call. 1097c478bd9Sstevel@tonic-gate * 1107c478bd9Sstevel@tonic-gate * time_state shows the state of the system clock, with values defined 1117c478bd9Sstevel@tonic-gate * in the timex.h header file. 1127c478bd9Sstevel@tonic-gate * 1137c478bd9Sstevel@tonic-gate * time_status shows the status of the system clock, with bits defined 1147c478bd9Sstevel@tonic-gate * in the timex.h header file. 1157c478bd9Sstevel@tonic-gate * 1167c478bd9Sstevel@tonic-gate * time_offset is used by the PLL/FLL to adjust the system time in small 1177c478bd9Sstevel@tonic-gate * increments. 1187c478bd9Sstevel@tonic-gate * 1197c478bd9Sstevel@tonic-gate * time_constant determines the bandwidth or "stiffness" of the PLL. 1207c478bd9Sstevel@tonic-gate * 1217c478bd9Sstevel@tonic-gate * time_tolerance determines maximum frequency error or tolerance of the 1227c478bd9Sstevel@tonic-gate * CPU clock oscillator and is a property of the architecture; however, 1237c478bd9Sstevel@tonic-gate * in principle it could change as result of the presence of external 1247c478bd9Sstevel@tonic-gate * discipline signals, for instance. 1257c478bd9Sstevel@tonic-gate * 1267c478bd9Sstevel@tonic-gate * time_precision is usually equal to the kernel tick variable; however, 1277c478bd9Sstevel@tonic-gate * in cases where a precision clock counter or external clock is 1287c478bd9Sstevel@tonic-gate * available, the resolution can be much less than this and depend on 1297c478bd9Sstevel@tonic-gate * whether the external clock is working or not. 1307c478bd9Sstevel@tonic-gate * 1317c478bd9Sstevel@tonic-gate * time_maxerror is initialized by a ntp_adjtime() call and increased by 1327c478bd9Sstevel@tonic-gate * the kernel once each second to reflect the maximum error bound 1337c478bd9Sstevel@tonic-gate * growth. 1347c478bd9Sstevel@tonic-gate * 1357c478bd9Sstevel@tonic-gate * time_esterror is set and read by the ntp_adjtime() call, but 1367c478bd9Sstevel@tonic-gate * otherwise not used by the kernel. 1377c478bd9Sstevel@tonic-gate */ 1387c478bd9Sstevel@tonic-gate int32_t time_state = TIME_OK; /* clock state */ 1397c478bd9Sstevel@tonic-gate int32_t time_status = STA_UNSYNC; /* clock status bits */ 1407c478bd9Sstevel@tonic-gate int32_t time_offset = 0; /* time offset (us) */ 1417c478bd9Sstevel@tonic-gate int32_t time_constant = 0; /* pll time constant */ 1427c478bd9Sstevel@tonic-gate int32_t time_tolerance = MAXFREQ; /* frequency tolerance (scaled ppm) */ 1437c478bd9Sstevel@tonic-gate int32_t time_precision = 1; /* clock precision (us) */ 1447c478bd9Sstevel@tonic-gate int32_t time_maxerror = MAXPHASE; /* maximum error (us) */ 1457c478bd9Sstevel@tonic-gate int32_t time_esterror = MAXPHASE; /* estimated error (us) */ 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate /* 1487c478bd9Sstevel@tonic-gate * The following variables establish the state of the PLL/FLL and the 1497c478bd9Sstevel@tonic-gate * residual time and frequency offset of the local clock. The scale 1507c478bd9Sstevel@tonic-gate * factors are defined in the timex.h header file. 1517c478bd9Sstevel@tonic-gate * 1527c478bd9Sstevel@tonic-gate * time_phase and time_freq are the phase increment and the frequency 1537c478bd9Sstevel@tonic-gate * increment, respectively, of the kernel time variable. 1547c478bd9Sstevel@tonic-gate * 1557c478bd9Sstevel@tonic-gate * time_freq is set via ntp_adjtime() from a value stored in a file when 1567c478bd9Sstevel@tonic-gate * the synchronization daemon is first started. Its value is retrieved 1577c478bd9Sstevel@tonic-gate * via ntp_adjtime() and written to the file about once per hour by the 1587c478bd9Sstevel@tonic-gate * daemon. 1597c478bd9Sstevel@tonic-gate * 1607c478bd9Sstevel@tonic-gate * time_adj is the adjustment added to the value of tick at each timer 1617c478bd9Sstevel@tonic-gate * interrupt and is recomputed from time_phase and time_freq at each 1627c478bd9Sstevel@tonic-gate * seconds rollover. 1637c478bd9Sstevel@tonic-gate * 1647c478bd9Sstevel@tonic-gate * time_reftime is the second's portion of the system time at the last 1657c478bd9Sstevel@tonic-gate * call to ntp_adjtime(). It is used to adjust the time_freq variable 1667c478bd9Sstevel@tonic-gate * and to increase the time_maxerror as the time since last update 1677c478bd9Sstevel@tonic-gate * increases. 1687c478bd9Sstevel@tonic-gate */ 1697c478bd9Sstevel@tonic-gate int32_t time_phase = 0; /* phase offset (scaled us) */ 1707c478bd9Sstevel@tonic-gate int32_t time_freq = 0; /* frequency offset (scaled ppm) */ 1717c478bd9Sstevel@tonic-gate int32_t time_adj = 0; /* tick adjust (scaled 1 / hz) */ 1727c478bd9Sstevel@tonic-gate int32_t time_reftime = 0; /* time at last adjustment (s) */ 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate /* 1757c478bd9Sstevel@tonic-gate * The scale factors of the following variables are defined in the 1767c478bd9Sstevel@tonic-gate * timex.h header file. 1777c478bd9Sstevel@tonic-gate * 1787c478bd9Sstevel@tonic-gate * pps_time contains the time at each calibration interval, as read by 1797c478bd9Sstevel@tonic-gate * microtime(). pps_count counts the seconds of the calibration 1807c478bd9Sstevel@tonic-gate * interval, the duration of which is nominally pps_shift in powers of 1817c478bd9Sstevel@tonic-gate * two. 1827c478bd9Sstevel@tonic-gate * 1837c478bd9Sstevel@tonic-gate * pps_offset is the time offset produced by the time median filter 1847c478bd9Sstevel@tonic-gate * pps_tf[], while pps_jitter is the dispersion (jitter) measured by 1857c478bd9Sstevel@tonic-gate * this filter. 1867c478bd9Sstevel@tonic-gate * 1877c478bd9Sstevel@tonic-gate * pps_freq is the frequency offset produced by the frequency median 1887c478bd9Sstevel@tonic-gate * filter pps_ff[], while pps_stabil is the dispersion (wander) measured 1897c478bd9Sstevel@tonic-gate * by this filter. 1907c478bd9Sstevel@tonic-gate * 1917c478bd9Sstevel@tonic-gate * pps_usec is latched from a high resolution counter or external clock 1927c478bd9Sstevel@tonic-gate * at pps_time. Here we want the hardware counter contents only, not the 1937c478bd9Sstevel@tonic-gate * contents plus the time_tv.usec as usual. 1947c478bd9Sstevel@tonic-gate * 1957c478bd9Sstevel@tonic-gate * pps_valid counts the number of seconds since the last PPS update. It 1967c478bd9Sstevel@tonic-gate * is used as a watchdog timer to disable the PPS discipline should the 1977c478bd9Sstevel@tonic-gate * PPS signal be lost. 1987c478bd9Sstevel@tonic-gate * 1997c478bd9Sstevel@tonic-gate * pps_glitch counts the number of seconds since the beginning of an 2007c478bd9Sstevel@tonic-gate * offset burst more than tick/2 from current nominal offset. It is used 2017c478bd9Sstevel@tonic-gate * mainly to suppress error bursts due to priority conflicts between the 2027c478bd9Sstevel@tonic-gate * PPS interrupt and timer interrupt. 2037c478bd9Sstevel@tonic-gate * 2047c478bd9Sstevel@tonic-gate * pps_intcnt counts the calibration intervals for use in the interval- 2057c478bd9Sstevel@tonic-gate * adaptation algorithm. It's just too complicated for words. 2067c478bd9Sstevel@tonic-gate */ 2077c478bd9Sstevel@tonic-gate struct timeval pps_time; /* kernel time at last interval */ 2087c478bd9Sstevel@tonic-gate int32_t pps_tf[] = {0, 0, 0}; /* pps time offset median filter (us) */ 2097c478bd9Sstevel@tonic-gate int32_t pps_offset = 0; /* pps time offset (us) */ 2107c478bd9Sstevel@tonic-gate int32_t pps_jitter = MAXTIME; /* time dispersion (jitter) (us) */ 2117c478bd9Sstevel@tonic-gate int32_t pps_ff[] = {0, 0, 0}; /* pps frequency offset median filter */ 2127c478bd9Sstevel@tonic-gate int32_t pps_freq = 0; /* frequency offset (scaled ppm) */ 2137c478bd9Sstevel@tonic-gate int32_t pps_stabil = MAXFREQ; /* frequency dispersion (scaled ppm) */ 2147c478bd9Sstevel@tonic-gate int32_t pps_usec = 0; /* microsec counter at last interval */ 2157c478bd9Sstevel@tonic-gate int32_t pps_valid = PPS_VALID; /* pps signal watchdog counter */ 2167c478bd9Sstevel@tonic-gate int32_t pps_glitch = 0; /* pps signal glitch counter */ 2177c478bd9Sstevel@tonic-gate int32_t pps_count = 0; /* calibration interval counter (s) */ 2187c478bd9Sstevel@tonic-gate int32_t pps_shift = PPS_SHIFT; /* interval duration (s) (shift) */ 2197c478bd9Sstevel@tonic-gate int32_t pps_intcnt = 0; /* intervals at current duration */ 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate /* 2227c478bd9Sstevel@tonic-gate * PPS signal quality monitors 2237c478bd9Sstevel@tonic-gate * 2247c478bd9Sstevel@tonic-gate * pps_jitcnt counts the seconds that have been discarded because the 2257c478bd9Sstevel@tonic-gate * jitter measured by the time median filter exceeds the limit MAXTIME 2267c478bd9Sstevel@tonic-gate * (100 us). 2277c478bd9Sstevel@tonic-gate * 2287c478bd9Sstevel@tonic-gate * pps_calcnt counts the frequency calibration intervals, which are 2297c478bd9Sstevel@tonic-gate * variable from 4 s to 256 s. 2307c478bd9Sstevel@tonic-gate * 2317c478bd9Sstevel@tonic-gate * pps_errcnt counts the calibration intervals which have been discarded 2327c478bd9Sstevel@tonic-gate * because the wander exceeds the limit MAXFREQ (100 ppm) or where the 2337c478bd9Sstevel@tonic-gate * calibration interval jitter exceeds two ticks. 2347c478bd9Sstevel@tonic-gate * 2357c478bd9Sstevel@tonic-gate * pps_stbcnt counts the calibration intervals that have been discarded 2367c478bd9Sstevel@tonic-gate * because the frequency wander exceeds the limit MAXFREQ / 4 (25 us). 2377c478bd9Sstevel@tonic-gate */ 2387c478bd9Sstevel@tonic-gate int32_t pps_jitcnt = 0; /* jitter limit exceeded */ 2397c478bd9Sstevel@tonic-gate int32_t pps_calcnt = 0; /* calibration intervals */ 2407c478bd9Sstevel@tonic-gate int32_t pps_errcnt = 0; /* calibration errors */ 2417c478bd9Sstevel@tonic-gate int32_t pps_stbcnt = 0; /* stability limit exceeded */ 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate /* The following variables require no explicit locking */ 2447c478bd9Sstevel@tonic-gate volatile clock_t lbolt; /* time in Hz since last boot */ 2457c478bd9Sstevel@tonic-gate volatile int64_t lbolt64; /* lbolt64 won't wrap for 2.9 billion yrs */ 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate kcondvar_t lbolt_cv; 2487c478bd9Sstevel@tonic-gate int one_sec = 1; /* turned on once every second */ 2497c478bd9Sstevel@tonic-gate static int fsflushcnt; /* counter for t_fsflushr */ 2507c478bd9Sstevel@tonic-gate int dosynctodr = 1; /* patchable; enable/disable sync to TOD chip */ 2517c478bd9Sstevel@tonic-gate int tod_needsync = 0; /* need to sync tod chip with software time */ 2527c478bd9Sstevel@tonic-gate static int tod_broken = 0; /* clock chip doesn't work */ 2537c478bd9Sstevel@tonic-gate time_t boot_time = 0; /* Boot time in seconds since 1970 */ 2547c478bd9Sstevel@tonic-gate cyclic_id_t clock_cyclic; /* clock()'s cyclic_id */ 2557c478bd9Sstevel@tonic-gate cyclic_id_t deadman_cyclic; /* deadman()'s cyclic_id */ 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate static int lgrp_ticks; /* counter to schedule lgrp load calcs */ 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate /* 2607c478bd9Sstevel@tonic-gate * rechoose_interval_history is used to detect when rechoose_interval's 2617c478bd9Sstevel@tonic-gate * value has changed (via hotpatching for example), so that the 2627c478bd9Sstevel@tonic-gate * cached values in the cpu structures may be updated. 2637c478bd9Sstevel@tonic-gate */ 2647c478bd9Sstevel@tonic-gate static int rechoose_interval_history = RECHOOSE_INTERVAL; 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate /* 2677c478bd9Sstevel@tonic-gate * for tod fault detection 2687c478bd9Sstevel@tonic-gate */ 2697c478bd9Sstevel@tonic-gate #define TOD_REF_FREQ ((longlong_t)(NANOSEC)) 2707c478bd9Sstevel@tonic-gate #define TOD_STALL_THRESHOLD (TOD_REF_FREQ * 3 / 2) 2717c478bd9Sstevel@tonic-gate #define TOD_JUMP_THRESHOLD (TOD_REF_FREQ / 2) 2727c478bd9Sstevel@tonic-gate #define TOD_FILTER_N 4 2737c478bd9Sstevel@tonic-gate #define TOD_FILTER_SETTLE (4 * TOD_FILTER_N) 2747c478bd9Sstevel@tonic-gate static int tod_faulted = TOD_NOFAULT; 2757c478bd9Sstevel@tonic-gate static int tod_fault_reset_flag = 0; 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate /* patchable via /etc/system */ 2787c478bd9Sstevel@tonic-gate int tod_validate_enable = 1; 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate /* 281*2c891a87Ssethg * On non-SPARC systems, TOD validation must be deferred until gethrtime 282*2c891a87Ssethg * returns non-zero values (after mach_clkinit's execution). 283*2c891a87Ssethg * On SPARC systems, it must be deferred until after hrtime_base 284*2c891a87Ssethg * and hres_last_tick are set (in the first invocation of hres_tick). 285*2c891a87Ssethg * Since in both cases the prerequisites occur before the invocation of 286*2c891a87Ssethg * tod_get() in clock(), the deferment is lifted there. 287*2c891a87Ssethg */ 288*2c891a87Ssethg static boolean_t tod_validate_deferred = B_TRUE; 289*2c891a87Ssethg 290*2c891a87Ssethg /* 2917c478bd9Sstevel@tonic-gate * tod_fault_table[] must be aligned with 2927c478bd9Sstevel@tonic-gate * enum tod_fault_type in systm.h 2937c478bd9Sstevel@tonic-gate */ 2947c478bd9Sstevel@tonic-gate static char *tod_fault_table[] = { 2957c478bd9Sstevel@tonic-gate "Reversed", /* TOD_REVERSED */ 2967c478bd9Sstevel@tonic-gate "Stalled", /* TOD_STALLED */ 2977c478bd9Sstevel@tonic-gate "Jumped", /* TOD_JUMPED */ 2987c478bd9Sstevel@tonic-gate "Changed in Clock Rate" /* TOD_RATECHANGED */ 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * no strings needed for TOD_NOFAULT 3017c478bd9Sstevel@tonic-gate */ 3027c478bd9Sstevel@tonic-gate }; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate /* 3057c478bd9Sstevel@tonic-gate * test hook for tod broken detection in tod_validate 3067c478bd9Sstevel@tonic-gate */ 3077c478bd9Sstevel@tonic-gate int tod_unit_test = 0; 3087c478bd9Sstevel@tonic-gate time_t tod_test_injector; 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate #define CLOCK_ADJ_HIST_SIZE 4 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate static int adj_hist_entry; 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate int64_t clock_adj_hist[CLOCK_ADJ_HIST_SIZE]; 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate static void clock_tick(kthread_t *); 3177c478bd9Sstevel@tonic-gate static void calcloadavg(int, uint64_t *); 3187c478bd9Sstevel@tonic-gate static int genloadavg(struct loadavg_s *); 3197c478bd9Sstevel@tonic-gate static void loadavg_update(); 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate void (*cmm_clock_callout)() = NULL; 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate #ifdef KSLICE 3247c478bd9Sstevel@tonic-gate int kslice = KSLICE; 3257c478bd9Sstevel@tonic-gate #endif 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate static void 3287c478bd9Sstevel@tonic-gate clock(void) 3297c478bd9Sstevel@tonic-gate { 3307c478bd9Sstevel@tonic-gate kthread_t *t; 3317c478bd9Sstevel@tonic-gate kmutex_t *plockp; /* pointer to thread's process lock */ 3327c478bd9Sstevel@tonic-gate int pinned_intr = 0; 3337c478bd9Sstevel@tonic-gate uint_t nrunnable, nrunning; 3347c478bd9Sstevel@tonic-gate uint_t w_io; 3357c478bd9Sstevel@tonic-gate cpu_t *cp; 3367c478bd9Sstevel@tonic-gate cpupart_t *cpupart; 3377c478bd9Sstevel@tonic-gate int exiting; 3387c478bd9Sstevel@tonic-gate extern void set_anoninfo(); 3397c478bd9Sstevel@tonic-gate extern void set_freemem(); 3407c478bd9Sstevel@tonic-gate void (*funcp)(); 3417c478bd9Sstevel@tonic-gate int32_t ltemp; 3427c478bd9Sstevel@tonic-gate int64_t lltemp; 3437c478bd9Sstevel@tonic-gate int s; 3447c478bd9Sstevel@tonic-gate int do_lgrp_load; 3457c478bd9Sstevel@tonic-gate int rechoose_update = 0; 3467c478bd9Sstevel@tonic-gate int rechoose; 3477c478bd9Sstevel@tonic-gate int i; 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate if (panicstr) 3507c478bd9Sstevel@tonic-gate return; 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate set_anoninfo(); 3537c478bd9Sstevel@tonic-gate /* 3547c478bd9Sstevel@tonic-gate * Make sure that 'freemem' do not drift too far from the truth 3557c478bd9Sstevel@tonic-gate */ 3567c478bd9Sstevel@tonic-gate set_freemem(); 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate /* 3607c478bd9Sstevel@tonic-gate * Before the section which is repeated is executed, we do 3617c478bd9Sstevel@tonic-gate * the time delta processing which occurs every clock tick 3627c478bd9Sstevel@tonic-gate * 3637c478bd9Sstevel@tonic-gate * There is additional processing which happens every time 3647c478bd9Sstevel@tonic-gate * the nanosecond counter rolls over which is described 3657c478bd9Sstevel@tonic-gate * below - see the section which begins with : if (one_sec) 3667c478bd9Sstevel@tonic-gate * 3677c478bd9Sstevel@tonic-gate * This section marks the beginning of the precision-kernel 3687c478bd9Sstevel@tonic-gate * code fragment. 3697c478bd9Sstevel@tonic-gate * 3707c478bd9Sstevel@tonic-gate * First, compute the phase adjustment. If the low-order bits 3717c478bd9Sstevel@tonic-gate * (time_phase) of the update overflow, bump the higher order 3727c478bd9Sstevel@tonic-gate * bits (time_update). 3737c478bd9Sstevel@tonic-gate */ 3747c478bd9Sstevel@tonic-gate time_phase += time_adj; 3757c478bd9Sstevel@tonic-gate if (time_phase <= -FINEUSEC) { 3767c478bd9Sstevel@tonic-gate ltemp = -time_phase / SCALE_PHASE; 3777c478bd9Sstevel@tonic-gate time_phase += ltemp * SCALE_PHASE; 3787c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 3797c478bd9Sstevel@tonic-gate timedelta -= ltemp * (NANOSEC/MICROSEC); 3807c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 3817c478bd9Sstevel@tonic-gate } else if (time_phase >= FINEUSEC) { 3827c478bd9Sstevel@tonic-gate ltemp = time_phase / SCALE_PHASE; 3837c478bd9Sstevel@tonic-gate time_phase -= ltemp * SCALE_PHASE; 3847c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 3857c478bd9Sstevel@tonic-gate timedelta += ltemp * (NANOSEC/MICROSEC); 3867c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate /* 3907c478bd9Sstevel@tonic-gate * End of precision-kernel code fragment which is processed 3917c478bd9Sstevel@tonic-gate * every timer interrupt. 3927c478bd9Sstevel@tonic-gate * 3937c478bd9Sstevel@tonic-gate * Continue with the interrupt processing as scheduled. 3947c478bd9Sstevel@tonic-gate * 3957c478bd9Sstevel@tonic-gate * Did we pin another interrupt thread? Need to check this before 3967c478bd9Sstevel@tonic-gate * grabbing any adaptive locks, since if we block on a lock the 3977c478bd9Sstevel@tonic-gate * pinned thread could escape. Note that this is just a heuristic; 3987c478bd9Sstevel@tonic-gate * if we take multiple laps though clock() without returning from 3997c478bd9Sstevel@tonic-gate * the interrupt because we have another clock tick pending, then 4007c478bd9Sstevel@tonic-gate * the pinned interrupt could be released by one of the previous 4017c478bd9Sstevel@tonic-gate * laps. The only consequence is that the CPU will be counted as 4027c478bd9Sstevel@tonic-gate * in idle (or wait) state once the pinned interrupt is released. 4037c478bd9Sstevel@tonic-gate * Since this accounting is inaccurate by nature, this isn't a big 4047c478bd9Sstevel@tonic-gate * deal --- but we should try to get it right in the common case 4057c478bd9Sstevel@tonic-gate * where we only call clock() once per interrupt. 4067c478bd9Sstevel@tonic-gate */ 4077c478bd9Sstevel@tonic-gate if (curthread->t_intr != NULL) 4087c478bd9Sstevel@tonic-gate pinned_intr = (curthread->t_intr->t_flag & T_INTR_THREAD); 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /* 4117c478bd9Sstevel@tonic-gate * Count the number of runnable threads and the number waiting 4127c478bd9Sstevel@tonic-gate * for some form of I/O to complete -- gets added to 4137c478bd9Sstevel@tonic-gate * sysinfo.waiting. To know the state of the system, must add 4147c478bd9Sstevel@tonic-gate * wait counts from all CPUs. Also add up the per-partition 4157c478bd9Sstevel@tonic-gate * statistics. 4167c478bd9Sstevel@tonic-gate */ 4177c478bd9Sstevel@tonic-gate w_io = 0; 4187c478bd9Sstevel@tonic-gate nrunnable = 0; 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate /* 4217c478bd9Sstevel@tonic-gate * keep track of when to update lgrp/part loads 4227c478bd9Sstevel@tonic-gate */ 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate do_lgrp_load = 0; 4257c478bd9Sstevel@tonic-gate if (lgrp_ticks++ >= hz / 10) { 4267c478bd9Sstevel@tonic-gate lgrp_ticks = 0; 4277c478bd9Sstevel@tonic-gate do_lgrp_load = 1; 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate /* 4317c478bd9Sstevel@tonic-gate * The dispatcher tunable rechoose_interval may be hot-patched. 4327c478bd9Sstevel@tonic-gate * Note if it has a new value. If so, the effective rechoose_interval 4337c478bd9Sstevel@tonic-gate * cached in the cpu structures needs to be updated. 4347c478bd9Sstevel@tonic-gate * If needed we'll do this during the walk of the cpu_list below. 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate if (rechoose_interval != rechoose_interval_history) { 4377c478bd9Sstevel@tonic-gate rechoose_interval_history = rechoose_interval; 4387c478bd9Sstevel@tonic-gate rechoose_update = 1; 4397c478bd9Sstevel@tonic-gate } 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate if (one_sec) 4427c478bd9Sstevel@tonic-gate loadavg_update(); 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate /* 4467c478bd9Sstevel@tonic-gate * First count the threads waiting on kpreempt queues in each 4477c478bd9Sstevel@tonic-gate * CPU partition. 4487c478bd9Sstevel@tonic-gate */ 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate cpupart = cp_list_head; 4517c478bd9Sstevel@tonic-gate do { 4527c478bd9Sstevel@tonic-gate uint_t cpupart_nrunnable = cpupart->cp_kp_queue.disp_nrunnable; 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate cpupart->cp_updates++; 4557c478bd9Sstevel@tonic-gate nrunnable += cpupart_nrunnable; 4567c478bd9Sstevel@tonic-gate cpupart->cp_nrunnable_cum += cpupart_nrunnable; 4577c478bd9Sstevel@tonic-gate if (one_sec) { 4587c478bd9Sstevel@tonic-gate cpupart->cp_nrunning = 0; 4597c478bd9Sstevel@tonic-gate cpupart->cp_nrunnable = cpupart_nrunnable; 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate } while ((cpupart = cpupart->cp_next) != cp_list_head); 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate /* Now count the per-CPU statistics. */ 4657c478bd9Sstevel@tonic-gate cp = cpu_list; 4667c478bd9Sstevel@tonic-gate do { 4677c478bd9Sstevel@tonic-gate uint_t cpu_nrunnable = cp->cpu_disp->disp_nrunnable; 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate nrunnable += cpu_nrunnable; 4707c478bd9Sstevel@tonic-gate cpupart = cp->cpu_part; 4717c478bd9Sstevel@tonic-gate cpupart->cp_nrunnable_cum += cpu_nrunnable; 4727c478bd9Sstevel@tonic-gate if (one_sec) 4737c478bd9Sstevel@tonic-gate cpupart->cp_nrunnable += cpu_nrunnable; 4747c478bd9Sstevel@tonic-gate if (do_lgrp_load && 4757c478bd9Sstevel@tonic-gate (cp->cpu_flags & CPU_EXISTS)) { 4767c478bd9Sstevel@tonic-gate /* 4777c478bd9Sstevel@tonic-gate * When updating the lgroup's load average, 4787c478bd9Sstevel@tonic-gate * account for the thread running on the CPU. 4797c478bd9Sstevel@tonic-gate * If the CPU is the current one, then we need 4807c478bd9Sstevel@tonic-gate * to account for the underlying thread which 4817c478bd9Sstevel@tonic-gate * got the clock interrupt not the thread that is 4827c478bd9Sstevel@tonic-gate * handling the interrupt and caculating the load 4837c478bd9Sstevel@tonic-gate * average 4847c478bd9Sstevel@tonic-gate */ 4857c478bd9Sstevel@tonic-gate t = cp->cpu_thread; 4867c478bd9Sstevel@tonic-gate if (CPU == cp) 4877c478bd9Sstevel@tonic-gate t = t->t_intr; 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate /* 4907c478bd9Sstevel@tonic-gate * Account for the load average for this thread if 4917c478bd9Sstevel@tonic-gate * it isn't the idle thread or it is on the interrupt 4927c478bd9Sstevel@tonic-gate * stack and not the current CPU handling the clock 4937c478bd9Sstevel@tonic-gate * interrupt 4947c478bd9Sstevel@tonic-gate */ 4957c478bd9Sstevel@tonic-gate if ((t && t != cp->cpu_idle_thread) || (CPU != cp && 4967c478bd9Sstevel@tonic-gate CPU_ON_INTR(cp))) { 4977c478bd9Sstevel@tonic-gate if (t->t_lpl == cp->cpu_lpl) { 4987c478bd9Sstevel@tonic-gate /* local thread */ 4997c478bd9Sstevel@tonic-gate cpu_nrunnable++; 5007c478bd9Sstevel@tonic-gate } else { 5017c478bd9Sstevel@tonic-gate /* 5027c478bd9Sstevel@tonic-gate * This is a remote thread, charge it 5037c478bd9Sstevel@tonic-gate * against its home lgroup. Note that 5047c478bd9Sstevel@tonic-gate * we notice that a thread is remote 5057c478bd9Sstevel@tonic-gate * only if it's currently executing. 5067c478bd9Sstevel@tonic-gate * This is a reasonable approximation, 5077c478bd9Sstevel@tonic-gate * since queued remote threads are rare. 5087c478bd9Sstevel@tonic-gate * Note also that if we didn't charge 5097c478bd9Sstevel@tonic-gate * it to its home lgroup, remote 5107c478bd9Sstevel@tonic-gate * execution would often make a system 5117c478bd9Sstevel@tonic-gate * appear balanced even though it was 5127c478bd9Sstevel@tonic-gate * not, and thread placement/migration 5137c478bd9Sstevel@tonic-gate * would often not be done correctly. 5147c478bd9Sstevel@tonic-gate */ 5157c478bd9Sstevel@tonic-gate lgrp_loadavg(t->t_lpl, 5167c478bd9Sstevel@tonic-gate LGRP_LOADAVG_IN_THREAD_MAX, 0); 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate } 5197c478bd9Sstevel@tonic-gate lgrp_loadavg(cp->cpu_lpl, 5207c478bd9Sstevel@tonic-gate cpu_nrunnable * LGRP_LOADAVG_IN_THREAD_MAX, 1); 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate /* 5237c478bd9Sstevel@tonic-gate * The platform may define a per physical processor 5247c478bd9Sstevel@tonic-gate * adjustment of rechoose_interval. The effective 5257c478bd9Sstevel@tonic-gate * (base + adjustment) rechoose_interval is cached 5267c478bd9Sstevel@tonic-gate * in the cpu structures for efficiency. Above we detect 5277c478bd9Sstevel@tonic-gate * if the cached values need updating, and here is where 5287c478bd9Sstevel@tonic-gate * the update happens. 5297c478bd9Sstevel@tonic-gate */ 5307c478bd9Sstevel@tonic-gate if (rechoose_update) { 5317c478bd9Sstevel@tonic-gate rechoose = rechoose_interval + 5327c478bd9Sstevel@tonic-gate cp->cpu_chip->chip_rechoose_adj; 5337c478bd9Sstevel@tonic-gate cp->cpu_rechoose = (rechoose < 0) ? 0 : rechoose; 5347c478bd9Sstevel@tonic-gate } 5357c478bd9Sstevel@tonic-gate } while ((cp = cp->cpu_next) != cpu_list); 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate /* 5387c478bd9Sstevel@tonic-gate * Do tick processing for all the active threads running in 5397c478bd9Sstevel@tonic-gate * the system. 5407c478bd9Sstevel@tonic-gate */ 5417c478bd9Sstevel@tonic-gate cp = cpu_list; 5427c478bd9Sstevel@tonic-gate nrunning = 0; 5437c478bd9Sstevel@tonic-gate do { 5447c478bd9Sstevel@tonic-gate klwp_id_t lwp; 5457c478bd9Sstevel@tonic-gate int intr; 5467c478bd9Sstevel@tonic-gate int thread_away; 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate /* 5497c478bd9Sstevel@tonic-gate * Don't do any tick processing on CPUs that 5507c478bd9Sstevel@tonic-gate * aren't even in the system or aren't up yet. 5517c478bd9Sstevel@tonic-gate */ 5527c478bd9Sstevel@tonic-gate if ((cp->cpu_flags & CPU_EXISTS) == 0) { 5537c478bd9Sstevel@tonic-gate continue; 5547c478bd9Sstevel@tonic-gate } 5557c478bd9Sstevel@tonic-gate 5567c478bd9Sstevel@tonic-gate /* 5577c478bd9Sstevel@tonic-gate * The locking here is rather tricky. We use 5587c478bd9Sstevel@tonic-gate * thread_free_lock to keep the currently running 5597c478bd9Sstevel@tonic-gate * thread from being freed or recycled while we're 5607c478bd9Sstevel@tonic-gate * looking at it. We can then check if the thread 5617c478bd9Sstevel@tonic-gate * is exiting and get the appropriate p_lock if it 5627c478bd9Sstevel@tonic-gate * is not. We have to be careful, though, because 5637c478bd9Sstevel@tonic-gate * the _process_ can still be freed while we're 5647c478bd9Sstevel@tonic-gate * holding thread_free_lock. To avoid touching the 5657c478bd9Sstevel@tonic-gate * proc structure we put a pointer to the p_lock in the 5667c478bd9Sstevel@tonic-gate * thread structure. The p_lock is persistent so we 5677c478bd9Sstevel@tonic-gate * can acquire it even if the process is gone. At that 5687c478bd9Sstevel@tonic-gate * point we can check (again) if the thread is exiting 5697c478bd9Sstevel@tonic-gate * and either drop the lock or do the tick processing. 5707c478bd9Sstevel@tonic-gate */ 5717c478bd9Sstevel@tonic-gate mutex_enter(&thread_free_lock); 5727c478bd9Sstevel@tonic-gate /* 5737c478bd9Sstevel@tonic-gate * We cannot hold the cpu_lock to prevent the 5747c478bd9Sstevel@tonic-gate * cpu_list from changing in the clock interrupt. 5757c478bd9Sstevel@tonic-gate * As long as we don't block (or don't get pre-empted) 5767c478bd9Sstevel@tonic-gate * the cpu_list will not change (all threads are paused 5777c478bd9Sstevel@tonic-gate * before list modification). If the list does change 5787c478bd9Sstevel@tonic-gate * any deleted cpu structures will remain with cpu_next 5797c478bd9Sstevel@tonic-gate * set to NULL, hence the following test. 5807c478bd9Sstevel@tonic-gate */ 5817c478bd9Sstevel@tonic-gate if (cp->cpu_next == NULL) { 5827c478bd9Sstevel@tonic-gate mutex_exit(&thread_free_lock); 5837c478bd9Sstevel@tonic-gate break; 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate t = cp->cpu_thread; /* Current running thread */ 5867c478bd9Sstevel@tonic-gate if (CPU == cp) { 5877c478bd9Sstevel@tonic-gate /* 5887c478bd9Sstevel@tonic-gate * 't' will be the clock interrupt thread on this 5897c478bd9Sstevel@tonic-gate * CPU. Use the pinned thread (if any) on this CPU 5907c478bd9Sstevel@tonic-gate * as the target of the clock tick. If we pinned 5917c478bd9Sstevel@tonic-gate * an interrupt, though, just keep using the clock 5927c478bd9Sstevel@tonic-gate * interrupt thread since the formerly pinned one 5937c478bd9Sstevel@tonic-gate * may have gone away. One interrupt thread is as 5947c478bd9Sstevel@tonic-gate * good as another, and this means we don't have 5957c478bd9Sstevel@tonic-gate * to continue to check pinned_intr in subsequent 5967c478bd9Sstevel@tonic-gate * code. 5977c478bd9Sstevel@tonic-gate */ 5987c478bd9Sstevel@tonic-gate ASSERT(t == curthread); 5997c478bd9Sstevel@tonic-gate if (t->t_intr != NULL && !pinned_intr) 6007c478bd9Sstevel@tonic-gate t = t->t_intr; 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate intr = t->t_flag & T_INTR_THREAD; 6047c478bd9Sstevel@tonic-gate lwp = ttolwp(t); 6057c478bd9Sstevel@tonic-gate if (lwp == NULL || (t->t_proc_flag & TP_LWPEXIT) || intr) { 6067c478bd9Sstevel@tonic-gate /* 6077c478bd9Sstevel@tonic-gate * Thread is exiting (or uninteresting) so don't 6087c478bd9Sstevel@tonic-gate * do tick processing or grab p_lock. Once we 6097c478bd9Sstevel@tonic-gate * drop thread_free_lock we can't look inside the 6107c478bd9Sstevel@tonic-gate * thread or lwp structure, since the thread may 6117c478bd9Sstevel@tonic-gate * have gone away. 6127c478bd9Sstevel@tonic-gate */ 6137c478bd9Sstevel@tonic-gate exiting = 1; 6147c478bd9Sstevel@tonic-gate } else { 6157c478bd9Sstevel@tonic-gate /* 6167c478bd9Sstevel@tonic-gate * OK, try to grab the process lock. See 6177c478bd9Sstevel@tonic-gate * comments above for why we're not using 6187c478bd9Sstevel@tonic-gate * ttoproc(t)->p_lockp here. 6197c478bd9Sstevel@tonic-gate */ 6207c478bd9Sstevel@tonic-gate plockp = t->t_plockp; 6217c478bd9Sstevel@tonic-gate mutex_enter(plockp); 6227c478bd9Sstevel@tonic-gate /* See above comment. */ 6237c478bd9Sstevel@tonic-gate if (cp->cpu_next == NULL) { 6247c478bd9Sstevel@tonic-gate mutex_exit(plockp); 6257c478bd9Sstevel@tonic-gate mutex_exit(&thread_free_lock); 6267c478bd9Sstevel@tonic-gate break; 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate /* 6297c478bd9Sstevel@tonic-gate * The thread may have exited between when we 6307c478bd9Sstevel@tonic-gate * checked above, and when we got the p_lock. 6317c478bd9Sstevel@tonic-gate */ 6327c478bd9Sstevel@tonic-gate if (t->t_proc_flag & TP_LWPEXIT) { 6337c478bd9Sstevel@tonic-gate mutex_exit(plockp); 6347c478bd9Sstevel@tonic-gate exiting = 1; 6357c478bd9Sstevel@tonic-gate } else { 6367c478bd9Sstevel@tonic-gate exiting = 0; 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate /* 6407c478bd9Sstevel@tonic-gate * Either we have the p_lock for the thread's process, 6417c478bd9Sstevel@tonic-gate * or we don't care about the thread structure any more. 6427c478bd9Sstevel@tonic-gate * Either way we can drop thread_free_lock. 6437c478bd9Sstevel@tonic-gate */ 6447c478bd9Sstevel@tonic-gate mutex_exit(&thread_free_lock); 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate /* 6477c478bd9Sstevel@tonic-gate * Update user, system, and idle cpu times. 6487c478bd9Sstevel@tonic-gate */ 6497c478bd9Sstevel@tonic-gate if (one_sec) { 6507c478bd9Sstevel@tonic-gate nrunning++; 6517c478bd9Sstevel@tonic-gate cp->cpu_part->cp_nrunning++; 6527c478bd9Sstevel@tonic-gate } 6537c478bd9Sstevel@tonic-gate /* 6547c478bd9Sstevel@tonic-gate * If we haven't done tick processing for this 6557c478bd9Sstevel@tonic-gate * lwp, then do it now. Since we don't hold the 6567c478bd9Sstevel@tonic-gate * lwp down on a CPU it can migrate and show up 6577c478bd9Sstevel@tonic-gate * more than once, hence the lbolt check. 6587c478bd9Sstevel@tonic-gate * 6597c478bd9Sstevel@tonic-gate * Also, make sure that it's okay to perform the 6607c478bd9Sstevel@tonic-gate * tick processing before calling clock_tick. 6617c478bd9Sstevel@tonic-gate * Setting thread_away to a TRUE value (ie. not 0) 6627c478bd9Sstevel@tonic-gate * results in tick processing not being performed for 6637c478bd9Sstevel@tonic-gate * that thread. Or, in other words, keeps the thread 6647c478bd9Sstevel@tonic-gate * away from clock_tick processing. 6657c478bd9Sstevel@tonic-gate */ 6667c478bd9Sstevel@tonic-gate thread_away = ((cp->cpu_flags & CPU_QUIESCED) || 6677c478bd9Sstevel@tonic-gate CPU_ON_INTR(cp) || intr || 6687c478bd9Sstevel@tonic-gate (cp->cpu_dispthread == cp->cpu_idle_thread) || exiting); 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate if ((!thread_away) && (lbolt - t->t_lbolt != 0)) { 6717c478bd9Sstevel@tonic-gate t->t_lbolt = lbolt; 6727c478bd9Sstevel@tonic-gate clock_tick(t); 6737c478bd9Sstevel@tonic-gate } 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate #ifdef KSLICE 6767c478bd9Sstevel@tonic-gate /* 6777c478bd9Sstevel@tonic-gate * Ah what the heck, give this kid a taste of the real 6787c478bd9Sstevel@tonic-gate * world and yank the rug out from under it. 6797c478bd9Sstevel@tonic-gate * But, only if we are running UniProcessor. 6807c478bd9Sstevel@tonic-gate */ 6817c478bd9Sstevel@tonic-gate if ((kslice) && (ncpus == 1)) { 6827c478bd9Sstevel@tonic-gate aston(t); 6837c478bd9Sstevel@tonic-gate cp->cpu_runrun = 1; 6847c478bd9Sstevel@tonic-gate cp->cpu_kprunrun = 1; 6857c478bd9Sstevel@tonic-gate } 6867c478bd9Sstevel@tonic-gate #endif 6877c478bd9Sstevel@tonic-gate if (!exiting) 6887c478bd9Sstevel@tonic-gate mutex_exit(plockp); 6897c478bd9Sstevel@tonic-gate } while ((cp = cp->cpu_next) != cpu_list); 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate /* 6927c478bd9Sstevel@tonic-gate * bump time in ticks 6937c478bd9Sstevel@tonic-gate * 6947c478bd9Sstevel@tonic-gate * We rely on there being only one clock thread and hence 6957c478bd9Sstevel@tonic-gate * don't need a lock to protect lbolt. 6967c478bd9Sstevel@tonic-gate */ 6977c478bd9Sstevel@tonic-gate lbolt++; 6987c478bd9Sstevel@tonic-gate atomic_add_64((uint64_t *)&lbolt64, (int64_t)1); 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate /* 7017c478bd9Sstevel@tonic-gate * Check for a callout that needs be called from the clock 7027c478bd9Sstevel@tonic-gate * thread to support the membership protocol in a clustered 7037c478bd9Sstevel@tonic-gate * system. Copy the function pointer so that we can reset 7047c478bd9Sstevel@tonic-gate * this to NULL if needed. 7057c478bd9Sstevel@tonic-gate */ 7067c478bd9Sstevel@tonic-gate if ((funcp = cmm_clock_callout) != NULL) 7077c478bd9Sstevel@tonic-gate (*funcp)(); 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate /* 7107c478bd9Sstevel@tonic-gate * Wakeup the cageout thread waiters once per second. 7117c478bd9Sstevel@tonic-gate */ 7127c478bd9Sstevel@tonic-gate if (one_sec) 7137c478bd9Sstevel@tonic-gate kcage_tick(); 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate /* 7167c478bd9Sstevel@tonic-gate * Schedule timeout() requests if any are due at this time. 7177c478bd9Sstevel@tonic-gate */ 7187c478bd9Sstevel@tonic-gate callout_schedule(); 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate if (one_sec) { 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate int drift, absdrift; 7237c478bd9Sstevel@tonic-gate timestruc_t tod; 7247c478bd9Sstevel@tonic-gate int s; 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate /* 7277c478bd9Sstevel@tonic-gate * Beginning of precision-kernel code fragment executed 7287c478bd9Sstevel@tonic-gate * every second. 7297c478bd9Sstevel@tonic-gate * 7307c478bd9Sstevel@tonic-gate * On rollover of the second the phase adjustment to be 7317c478bd9Sstevel@tonic-gate * used for the next second is calculated. Also, the 7327c478bd9Sstevel@tonic-gate * maximum error is increased by the tolerance. If the 7337c478bd9Sstevel@tonic-gate * PPS frequency discipline code is present, the phase is 7347c478bd9Sstevel@tonic-gate * increased to compensate for the CPU clock oscillator 7357c478bd9Sstevel@tonic-gate * frequency error. 7367c478bd9Sstevel@tonic-gate * 7377c478bd9Sstevel@tonic-gate * On a 32-bit machine and given parameters in the timex.h 7387c478bd9Sstevel@tonic-gate * header file, the maximum phase adjustment is +-512 ms 7397c478bd9Sstevel@tonic-gate * and maximum frequency offset is (a tad less than) 7407c478bd9Sstevel@tonic-gate * +-512 ppm. On a 64-bit machine, you shouldn't need to ask. 7417c478bd9Sstevel@tonic-gate */ 7427c478bd9Sstevel@tonic-gate time_maxerror += time_tolerance / SCALE_USEC; 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate /* 7457c478bd9Sstevel@tonic-gate * Leap second processing. If in leap-insert state at 7467c478bd9Sstevel@tonic-gate * the end of the day, the system clock is set back one 7477c478bd9Sstevel@tonic-gate * second; if in leap-delete state, the system clock is 7487c478bd9Sstevel@tonic-gate * set ahead one second. The microtime() routine or 7497c478bd9Sstevel@tonic-gate * external clock driver will insure that reported time 7507c478bd9Sstevel@tonic-gate * is always monotonic. The ugly divides should be 7517c478bd9Sstevel@tonic-gate * replaced. 7527c478bd9Sstevel@tonic-gate */ 7537c478bd9Sstevel@tonic-gate switch (time_state) { 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate case TIME_OK: 7567c478bd9Sstevel@tonic-gate if (time_status & STA_INS) 7577c478bd9Sstevel@tonic-gate time_state = TIME_INS; 7587c478bd9Sstevel@tonic-gate else if (time_status & STA_DEL) 7597c478bd9Sstevel@tonic-gate time_state = TIME_DEL; 7607c478bd9Sstevel@tonic-gate break; 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate case TIME_INS: 7637c478bd9Sstevel@tonic-gate if (hrestime.tv_sec % 86400 == 0) { 7647c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 7657c478bd9Sstevel@tonic-gate hrestime.tv_sec--; 7667c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 7677c478bd9Sstevel@tonic-gate time_state = TIME_OOP; 7687c478bd9Sstevel@tonic-gate } 7697c478bd9Sstevel@tonic-gate break; 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate case TIME_DEL: 7727c478bd9Sstevel@tonic-gate if ((hrestime.tv_sec + 1) % 86400 == 0) { 7737c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 7747c478bd9Sstevel@tonic-gate hrestime.tv_sec++; 7757c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 7767c478bd9Sstevel@tonic-gate time_state = TIME_WAIT; 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate break; 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate case TIME_OOP: 7817c478bd9Sstevel@tonic-gate time_state = TIME_WAIT; 7827c478bd9Sstevel@tonic-gate break; 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate case TIME_WAIT: 7857c478bd9Sstevel@tonic-gate if (!(time_status & (STA_INS | STA_DEL))) 7867c478bd9Sstevel@tonic-gate time_state = TIME_OK; 7877c478bd9Sstevel@tonic-gate default: 7887c478bd9Sstevel@tonic-gate break; 7897c478bd9Sstevel@tonic-gate } 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate /* 7927c478bd9Sstevel@tonic-gate * Compute the phase adjustment for the next second. In 7937c478bd9Sstevel@tonic-gate * PLL mode, the offset is reduced by a fixed factor 7947c478bd9Sstevel@tonic-gate * times the time constant. In FLL mode the offset is 7957c478bd9Sstevel@tonic-gate * used directly. In either mode, the maximum phase 7967c478bd9Sstevel@tonic-gate * adjustment for each second is clamped so as to spread 7977c478bd9Sstevel@tonic-gate * the adjustment over not more than the number of 7987c478bd9Sstevel@tonic-gate * seconds between updates. 7997c478bd9Sstevel@tonic-gate */ 8007c478bd9Sstevel@tonic-gate if (time_offset == 0) 8017c478bd9Sstevel@tonic-gate time_adj = 0; 8027c478bd9Sstevel@tonic-gate else if (time_offset < 0) { 8037c478bd9Sstevel@tonic-gate lltemp = -time_offset; 8047c478bd9Sstevel@tonic-gate if (!(time_status & STA_FLL)) { 8057c478bd9Sstevel@tonic-gate if ((1 << time_constant) >= SCALE_KG) 8067c478bd9Sstevel@tonic-gate lltemp *= (1 << time_constant) / 8077c478bd9Sstevel@tonic-gate SCALE_KG; 8087c478bd9Sstevel@tonic-gate else 8097c478bd9Sstevel@tonic-gate lltemp = (lltemp / SCALE_KG) >> 8107c478bd9Sstevel@tonic-gate time_constant; 8117c478bd9Sstevel@tonic-gate } 8127c478bd9Sstevel@tonic-gate if (lltemp > (MAXPHASE / MINSEC) * SCALE_UPDATE) 8137c478bd9Sstevel@tonic-gate lltemp = (MAXPHASE / MINSEC) * SCALE_UPDATE; 8147c478bd9Sstevel@tonic-gate time_offset += lltemp; 8157c478bd9Sstevel@tonic-gate time_adj = -(lltemp * SCALE_PHASE) / hz / SCALE_UPDATE; 8167c478bd9Sstevel@tonic-gate } else { 8177c478bd9Sstevel@tonic-gate lltemp = time_offset; 8187c478bd9Sstevel@tonic-gate if (!(time_status & STA_FLL)) { 8197c478bd9Sstevel@tonic-gate if ((1 << time_constant) >= SCALE_KG) 8207c478bd9Sstevel@tonic-gate lltemp *= (1 << time_constant) / 8217c478bd9Sstevel@tonic-gate SCALE_KG; 8227c478bd9Sstevel@tonic-gate else 8237c478bd9Sstevel@tonic-gate lltemp = (lltemp / SCALE_KG) >> 8247c478bd9Sstevel@tonic-gate time_constant; 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate if (lltemp > (MAXPHASE / MINSEC) * SCALE_UPDATE) 8277c478bd9Sstevel@tonic-gate lltemp = (MAXPHASE / MINSEC) * SCALE_UPDATE; 8287c478bd9Sstevel@tonic-gate time_offset -= lltemp; 8297c478bd9Sstevel@tonic-gate time_adj = (lltemp * SCALE_PHASE) / hz / SCALE_UPDATE; 8307c478bd9Sstevel@tonic-gate } 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate /* 8337c478bd9Sstevel@tonic-gate * Compute the frequency estimate and additional phase 8347c478bd9Sstevel@tonic-gate * adjustment due to frequency error for the next 8357c478bd9Sstevel@tonic-gate * second. When the PPS signal is engaged, gnaw on the 8367c478bd9Sstevel@tonic-gate * watchdog counter and update the frequency computed by 8377c478bd9Sstevel@tonic-gate * the pll and the PPS signal. 8387c478bd9Sstevel@tonic-gate */ 8397c478bd9Sstevel@tonic-gate pps_valid++; 8407c478bd9Sstevel@tonic-gate if (pps_valid == PPS_VALID) { 8417c478bd9Sstevel@tonic-gate pps_jitter = MAXTIME; 8427c478bd9Sstevel@tonic-gate pps_stabil = MAXFREQ; 8437c478bd9Sstevel@tonic-gate time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER | 8447c478bd9Sstevel@tonic-gate STA_PPSWANDER | STA_PPSERROR); 8457c478bd9Sstevel@tonic-gate } 8467c478bd9Sstevel@tonic-gate lltemp = time_freq + pps_freq; 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate if (lltemp) 8497c478bd9Sstevel@tonic-gate time_adj += (lltemp * SCALE_PHASE) / (SCALE_USEC * hz); 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate /* 8527c478bd9Sstevel@tonic-gate * End of precision kernel-code fragment 8537c478bd9Sstevel@tonic-gate * 8547c478bd9Sstevel@tonic-gate * The section below should be modified if we are planning 8557c478bd9Sstevel@tonic-gate * to use NTP for synchronization. 8567c478bd9Sstevel@tonic-gate * 8577c478bd9Sstevel@tonic-gate * Note: the clock synchronization code now assumes 8587c478bd9Sstevel@tonic-gate * the following: 8597c478bd9Sstevel@tonic-gate * - if dosynctodr is 1, then compute the drift between 8607c478bd9Sstevel@tonic-gate * the tod chip and software time and adjust one or 8617c478bd9Sstevel@tonic-gate * the other depending on the circumstances 8627c478bd9Sstevel@tonic-gate * 8637c478bd9Sstevel@tonic-gate * - if dosynctodr is 0, then the tod chip is independent 8647c478bd9Sstevel@tonic-gate * of the software clock and should not be adjusted, 8657c478bd9Sstevel@tonic-gate * but allowed to free run. this allows NTP to sync. 8667c478bd9Sstevel@tonic-gate * hrestime without any interference from the tod chip. 8677c478bd9Sstevel@tonic-gate */ 8687c478bd9Sstevel@tonic-gate 869*2c891a87Ssethg tod_validate_deferred = B_FALSE; 8707c478bd9Sstevel@tonic-gate mutex_enter(&tod_lock); 8717c478bd9Sstevel@tonic-gate tod = tod_get(); 8727c478bd9Sstevel@tonic-gate drift = tod.tv_sec - hrestime.tv_sec; 8737c478bd9Sstevel@tonic-gate absdrift = (drift >= 0) ? drift : -drift; 8747c478bd9Sstevel@tonic-gate if (tod_needsync || absdrift > 1) { 8757c478bd9Sstevel@tonic-gate int s; 8767c478bd9Sstevel@tonic-gate if (absdrift > 2) { 8777c478bd9Sstevel@tonic-gate if (!tod_broken && tod_faulted == TOD_NOFAULT) { 8787c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 8797c478bd9Sstevel@tonic-gate hrestime = tod; 8807c478bd9Sstevel@tonic-gate membar_enter(); /* hrestime visible */ 8817c478bd9Sstevel@tonic-gate timedelta = 0; 8827c478bd9Sstevel@tonic-gate timechanged++; 8837c478bd9Sstevel@tonic-gate tod_needsync = 0; 8847c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 8857c478bd9Sstevel@tonic-gate } 8867c478bd9Sstevel@tonic-gate } else { 8877c478bd9Sstevel@tonic-gate if (tod_needsync || !dosynctodr) { 8887c478bd9Sstevel@tonic-gate gethrestime(&tod); 8897c478bd9Sstevel@tonic-gate tod_set(tod); 8907c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 8917c478bd9Sstevel@tonic-gate if (timedelta == 0) 8927c478bd9Sstevel@tonic-gate tod_needsync = 0; 8937c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 8947c478bd9Sstevel@tonic-gate } else { 8957c478bd9Sstevel@tonic-gate /* 8967c478bd9Sstevel@tonic-gate * If the drift is 2 seconds on the 8977c478bd9Sstevel@tonic-gate * money, then the TOD is adjusting 8987c478bd9Sstevel@tonic-gate * the clock; record that. 8997c478bd9Sstevel@tonic-gate */ 9007c478bd9Sstevel@tonic-gate clock_adj_hist[adj_hist_entry++ % 9017c478bd9Sstevel@tonic-gate CLOCK_ADJ_HIST_SIZE] = lbolt64; 9027c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 9037c478bd9Sstevel@tonic-gate timedelta = (int64_t)drift*NANOSEC; 9047c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate } 9077c478bd9Sstevel@tonic-gate } 9087c478bd9Sstevel@tonic-gate one_sec = 0; 9097c478bd9Sstevel@tonic-gate time = gethrestime_sec(); /* for crusty old kmem readers */ 9107c478bd9Sstevel@tonic-gate mutex_exit(&tod_lock); 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate /* 9137c478bd9Sstevel@tonic-gate * Some drivers still depend on this... XXX 9147c478bd9Sstevel@tonic-gate */ 9157c478bd9Sstevel@tonic-gate cv_broadcast(&lbolt_cv); 9167c478bd9Sstevel@tonic-gate 9177c478bd9Sstevel@tonic-gate sysinfo.updates++; 9187c478bd9Sstevel@tonic-gate vminfo.freemem += freemem; 9197c478bd9Sstevel@tonic-gate { 9207c478bd9Sstevel@tonic-gate pgcnt_t maxswap, resv, free; 9217c478bd9Sstevel@tonic-gate pgcnt_t avail = 9227c478bd9Sstevel@tonic-gate MAX((spgcnt_t)(availrmem - swapfs_minfree), 0); 9237c478bd9Sstevel@tonic-gate 9247c478bd9Sstevel@tonic-gate maxswap = k_anoninfo.ani_mem_resv 9257c478bd9Sstevel@tonic-gate + k_anoninfo.ani_max +avail; 9267c478bd9Sstevel@tonic-gate free = k_anoninfo.ani_free + avail; 9277c478bd9Sstevel@tonic-gate resv = k_anoninfo.ani_phys_resv + 9287c478bd9Sstevel@tonic-gate k_anoninfo.ani_mem_resv; 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate vminfo.swap_resv += resv; 9317c478bd9Sstevel@tonic-gate /* number of reserved and allocated pages */ 9327c478bd9Sstevel@tonic-gate #ifdef DEBUG 9337c478bd9Sstevel@tonic-gate if (maxswap < free) 9347c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "clock: maxswap < free"); 9357c478bd9Sstevel@tonic-gate if (maxswap < resv) 9367c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "clock: maxswap < resv"); 9377c478bd9Sstevel@tonic-gate #endif 9387c478bd9Sstevel@tonic-gate vminfo.swap_alloc += maxswap - free; 9397c478bd9Sstevel@tonic-gate vminfo.swap_avail += maxswap - resv; 9407c478bd9Sstevel@tonic-gate vminfo.swap_free += free; 9417c478bd9Sstevel@tonic-gate } 9427c478bd9Sstevel@tonic-gate if (nrunnable) { 9437c478bd9Sstevel@tonic-gate sysinfo.runque += nrunnable; 9447c478bd9Sstevel@tonic-gate sysinfo.runocc++; 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate if (nswapped) { 9477c478bd9Sstevel@tonic-gate sysinfo.swpque += nswapped; 9487c478bd9Sstevel@tonic-gate sysinfo.swpocc++; 9497c478bd9Sstevel@tonic-gate } 9507c478bd9Sstevel@tonic-gate sysinfo.waiting += w_io; 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate /* 9537c478bd9Sstevel@tonic-gate * Wake up fsflush to write out DELWRI 9547c478bd9Sstevel@tonic-gate * buffers, dirty pages and other cached 9557c478bd9Sstevel@tonic-gate * administrative data, e.g. inodes. 9567c478bd9Sstevel@tonic-gate */ 9577c478bd9Sstevel@tonic-gate if (--fsflushcnt <= 0) { 9587c478bd9Sstevel@tonic-gate fsflushcnt = tune.t_fsflushr; 9597c478bd9Sstevel@tonic-gate cv_signal(&fsflush_cv); 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate 9627c478bd9Sstevel@tonic-gate vmmeter(); 9637c478bd9Sstevel@tonic-gate calcloadavg(genloadavg(&loadavg), hp_avenrun); 9647c478bd9Sstevel@tonic-gate for (i = 0; i < 3; i++) 9657c478bd9Sstevel@tonic-gate /* 9667c478bd9Sstevel@tonic-gate * At the moment avenrun[] can only hold 31 9677c478bd9Sstevel@tonic-gate * bits of load average as it is a signed 9687c478bd9Sstevel@tonic-gate * int in the API. We need to ensure that 9697c478bd9Sstevel@tonic-gate * hp_avenrun[i] >> (16 - FSHIFT) will not be 9707c478bd9Sstevel@tonic-gate * too large. If it is, we put the largest value 9717c478bd9Sstevel@tonic-gate * that we can use into avenrun[i]. This is 9727c478bd9Sstevel@tonic-gate * kludgey, but about all we can do until we 9737c478bd9Sstevel@tonic-gate * avenrun[] is declared as an array of uint64[] 9747c478bd9Sstevel@tonic-gate */ 9757c478bd9Sstevel@tonic-gate if (hp_avenrun[i] < ((uint64_t)1<<(31+16-FSHIFT))) 9767c478bd9Sstevel@tonic-gate avenrun[i] = (int32_t)(hp_avenrun[i] >> 9777c478bd9Sstevel@tonic-gate (16 - FSHIFT)); 9787c478bd9Sstevel@tonic-gate else 9797c478bd9Sstevel@tonic-gate avenrun[i] = 0x7fffffff; 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate cpupart = cp_list_head; 9827c478bd9Sstevel@tonic-gate do { 9837c478bd9Sstevel@tonic-gate calcloadavg(genloadavg(&cpupart->cp_loadavg), 9847c478bd9Sstevel@tonic-gate cpupart->cp_hp_avenrun); 9857c478bd9Sstevel@tonic-gate } while ((cpupart = cpupart->cp_next) != cp_list_head); 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate /* 9887c478bd9Sstevel@tonic-gate * Wake up the swapper thread if necessary. 9897c478bd9Sstevel@tonic-gate */ 9907c478bd9Sstevel@tonic-gate if (runin || 9917c478bd9Sstevel@tonic-gate (runout && (avefree < desfree || wake_sched_sec))) { 9927c478bd9Sstevel@tonic-gate t = &t0; 9937c478bd9Sstevel@tonic-gate thread_lock(t); 9947c478bd9Sstevel@tonic-gate if (t->t_state == TS_STOPPED) { 9957c478bd9Sstevel@tonic-gate runin = runout = 0; 9967c478bd9Sstevel@tonic-gate wake_sched_sec = 0; 9977c478bd9Sstevel@tonic-gate t->t_whystop = 0; 9987c478bd9Sstevel@tonic-gate t->t_whatstop = 0; 9997c478bd9Sstevel@tonic-gate t->t_schedflag &= ~TS_ALLSTART; 10007c478bd9Sstevel@tonic-gate THREAD_TRANSITION(t); 10017c478bd9Sstevel@tonic-gate setfrontdq(t); 10027c478bd9Sstevel@tonic-gate } 10037c478bd9Sstevel@tonic-gate thread_unlock(t); 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate } 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate /* 10087c478bd9Sstevel@tonic-gate * Wake up the swapper if any high priority swapped-out threads 10097c478bd9Sstevel@tonic-gate * became runable during the last tick. 10107c478bd9Sstevel@tonic-gate */ 10117c478bd9Sstevel@tonic-gate if (wake_sched) { 10127c478bd9Sstevel@tonic-gate t = &t0; 10137c478bd9Sstevel@tonic-gate thread_lock(t); 10147c478bd9Sstevel@tonic-gate if (t->t_state == TS_STOPPED) { 10157c478bd9Sstevel@tonic-gate runin = runout = 0; 10167c478bd9Sstevel@tonic-gate wake_sched = 0; 10177c478bd9Sstevel@tonic-gate t->t_whystop = 0; 10187c478bd9Sstevel@tonic-gate t->t_whatstop = 0; 10197c478bd9Sstevel@tonic-gate t->t_schedflag &= ~TS_ALLSTART; 10207c478bd9Sstevel@tonic-gate THREAD_TRANSITION(t); 10217c478bd9Sstevel@tonic-gate setfrontdq(t); 10227c478bd9Sstevel@tonic-gate } 10237c478bd9Sstevel@tonic-gate thread_unlock(t); 10247c478bd9Sstevel@tonic-gate } 10257c478bd9Sstevel@tonic-gate } 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate void 10287c478bd9Sstevel@tonic-gate clock_init(void) 10297c478bd9Sstevel@tonic-gate { 10307c478bd9Sstevel@tonic-gate cyc_handler_t hdlr; 10317c478bd9Sstevel@tonic-gate cyc_time_t when; 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate hdlr.cyh_func = (cyc_func_t)clock; 10347c478bd9Sstevel@tonic-gate hdlr.cyh_level = CY_LOCK_LEVEL; 10357c478bd9Sstevel@tonic-gate hdlr.cyh_arg = NULL; 10367c478bd9Sstevel@tonic-gate 10377c478bd9Sstevel@tonic-gate when.cyt_when = 0; 10387c478bd9Sstevel@tonic-gate when.cyt_interval = nsec_per_tick; 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 10417c478bd9Sstevel@tonic-gate clock_cyclic = cyclic_add(&hdlr, &when); 10427c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 10437c478bd9Sstevel@tonic-gate } 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate /* 10467c478bd9Sstevel@tonic-gate * Called before calcloadavg to get 10-sec moving loadavg together 10477c478bd9Sstevel@tonic-gate */ 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate static int 10507c478bd9Sstevel@tonic-gate genloadavg(struct loadavg_s *avgs) 10517c478bd9Sstevel@tonic-gate { 10527c478bd9Sstevel@tonic-gate int avg; 10537c478bd9Sstevel@tonic-gate int spos; /* starting position */ 10547c478bd9Sstevel@tonic-gate int cpos; /* moving current position */ 10557c478bd9Sstevel@tonic-gate int i; 10567c478bd9Sstevel@tonic-gate int slen; 10577c478bd9Sstevel@tonic-gate hrtime_t hr_avg; 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate /* 10-second snapshot, calculate first positon */ 10607c478bd9Sstevel@tonic-gate if (avgs->lg_len == 0) { 10617c478bd9Sstevel@tonic-gate return (0); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate slen = avgs->lg_len < S_MOVAVG_SZ ? avgs->lg_len : S_MOVAVG_SZ; 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate spos = (avgs->lg_cur - 1) >= 0 ? avgs->lg_cur - 1 : 10667c478bd9Sstevel@tonic-gate S_LOADAVG_SZ + (avgs->lg_cur - 1); 10677c478bd9Sstevel@tonic-gate for (i = hr_avg = 0; i < slen; i++) { 10687c478bd9Sstevel@tonic-gate cpos = (spos - i) >= 0 ? spos - i : S_LOADAVG_SZ + (spos - i); 10697c478bd9Sstevel@tonic-gate hr_avg += avgs->lg_loads[cpos]; 10707c478bd9Sstevel@tonic-gate } 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate hr_avg = hr_avg / slen; 10737c478bd9Sstevel@tonic-gate avg = hr_avg / (NANOSEC / LGRP_LOADAVG_IN_THREAD_MAX); 10747c478bd9Sstevel@tonic-gate 10757c478bd9Sstevel@tonic-gate return (avg); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate /* 10797c478bd9Sstevel@tonic-gate * Run every second from clock () to update the loadavg count available to the 10807c478bd9Sstevel@tonic-gate * system and cpu-partitions. 10817c478bd9Sstevel@tonic-gate * 10827c478bd9Sstevel@tonic-gate * This works by sampling the previous usr, sys, wait time elapsed, 10837c478bd9Sstevel@tonic-gate * computing a delta, and adding that delta to the elapsed usr, sys, 10847c478bd9Sstevel@tonic-gate * wait increase. 10857c478bd9Sstevel@tonic-gate */ 10867c478bd9Sstevel@tonic-gate 10877c478bd9Sstevel@tonic-gate static void 10887c478bd9Sstevel@tonic-gate loadavg_update() 10897c478bd9Sstevel@tonic-gate { 10907c478bd9Sstevel@tonic-gate cpu_t *cp; 10917c478bd9Sstevel@tonic-gate cpupart_t *cpupart; 10927c478bd9Sstevel@tonic-gate hrtime_t cpu_total; 10937c478bd9Sstevel@tonic-gate int prev; 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate cp = cpu_list; 10967c478bd9Sstevel@tonic-gate loadavg.lg_total = 0; 10977c478bd9Sstevel@tonic-gate 10987c478bd9Sstevel@tonic-gate /* 10997c478bd9Sstevel@tonic-gate * first pass totals up per-cpu statistics for system and cpu 11007c478bd9Sstevel@tonic-gate * partitions 11017c478bd9Sstevel@tonic-gate */ 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate do { 11047c478bd9Sstevel@tonic-gate struct loadavg_s *lavg; 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate lavg = &cp->cpu_loadavg; 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate cpu_total = cp->cpu_acct[CMS_USER] + 11097c478bd9Sstevel@tonic-gate cp->cpu_acct[CMS_SYSTEM] + cp->cpu_waitrq; 11107c478bd9Sstevel@tonic-gate /* compute delta against last total */ 11117c478bd9Sstevel@tonic-gate scalehrtime(&cpu_total); 11127c478bd9Sstevel@tonic-gate prev = (lavg->lg_cur - 1) >= 0 ? lavg->lg_cur - 1 : 11137c478bd9Sstevel@tonic-gate S_LOADAVG_SZ + (lavg->lg_cur - 1); 11147c478bd9Sstevel@tonic-gate if (lavg->lg_loads[prev] <= 0) { 11157c478bd9Sstevel@tonic-gate lavg->lg_loads[lavg->lg_cur] = cpu_total; 11167c478bd9Sstevel@tonic-gate cpu_total = 0; 11177c478bd9Sstevel@tonic-gate } else { 11187c478bd9Sstevel@tonic-gate lavg->lg_loads[lavg->lg_cur] = cpu_total; 11197c478bd9Sstevel@tonic-gate cpu_total = cpu_total - lavg->lg_loads[prev]; 11207c478bd9Sstevel@tonic-gate if (cpu_total < 0) 11217c478bd9Sstevel@tonic-gate cpu_total = 0; 11227c478bd9Sstevel@tonic-gate } 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate lavg->lg_cur = (lavg->lg_cur + 1) % S_LOADAVG_SZ; 11257c478bd9Sstevel@tonic-gate lavg->lg_len = (lavg->lg_len + 1) < S_LOADAVG_SZ ? 11267c478bd9Sstevel@tonic-gate lavg->lg_len + 1 : S_LOADAVG_SZ; 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate loadavg.lg_total += cpu_total; 11297c478bd9Sstevel@tonic-gate cp->cpu_part->cp_loadavg.lg_total += cpu_total; 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate } while ((cp = cp->cpu_next) != cpu_list); 11327c478bd9Sstevel@tonic-gate 11337c478bd9Sstevel@tonic-gate loadavg.lg_loads[loadavg.lg_cur] = loadavg.lg_total; 11347c478bd9Sstevel@tonic-gate loadavg.lg_cur = (loadavg.lg_cur + 1) % S_LOADAVG_SZ; 11357c478bd9Sstevel@tonic-gate loadavg.lg_len = (loadavg.lg_len + 1) < S_LOADAVG_SZ ? 11367c478bd9Sstevel@tonic-gate loadavg.lg_len + 1 : S_LOADAVG_SZ; 11377c478bd9Sstevel@tonic-gate /* 11387c478bd9Sstevel@tonic-gate * Second pass updates counts 11397c478bd9Sstevel@tonic-gate */ 11407c478bd9Sstevel@tonic-gate cpupart = cp_list_head; 11417c478bd9Sstevel@tonic-gate 11427c478bd9Sstevel@tonic-gate do { 11437c478bd9Sstevel@tonic-gate struct loadavg_s *lavg; 11447c478bd9Sstevel@tonic-gate 11457c478bd9Sstevel@tonic-gate lavg = &cpupart->cp_loadavg; 11467c478bd9Sstevel@tonic-gate lavg->lg_loads[lavg->lg_cur] = lavg->lg_total; 11477c478bd9Sstevel@tonic-gate lavg->lg_total = 0; 11487c478bd9Sstevel@tonic-gate lavg->lg_cur = (lavg->lg_cur + 1) % S_LOADAVG_SZ; 11497c478bd9Sstevel@tonic-gate lavg->lg_len = (lavg->lg_len + 1) < S_LOADAVG_SZ ? 11507c478bd9Sstevel@tonic-gate lavg->lg_len + 1 : S_LOADAVG_SZ; 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate } while ((cpupart = cpupart->cp_next) != cp_list_head); 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate /* 11577c478bd9Sstevel@tonic-gate * clock_update() - local clock update 11587c478bd9Sstevel@tonic-gate * 11597c478bd9Sstevel@tonic-gate * This routine is called by ntp_adjtime() to update the local clock 11607c478bd9Sstevel@tonic-gate * phase and frequency. The implementation is of an 11617c478bd9Sstevel@tonic-gate * adaptive-parameter, hybrid phase/frequency-lock loop (PLL/FLL). The 11627c478bd9Sstevel@tonic-gate * routine computes new time and frequency offset estimates for each 11637c478bd9Sstevel@tonic-gate * call. The PPS signal itself determines the new time offset, 11647c478bd9Sstevel@tonic-gate * instead of the calling argument. Presumably, calls to 11657c478bd9Sstevel@tonic-gate * ntp_adjtime() occur only when the caller believes the local clock 11667c478bd9Sstevel@tonic-gate * is valid within some bound (+-128 ms with NTP). If the caller's 11677c478bd9Sstevel@tonic-gate * time is far different than the PPS time, an argument will ensue, 11687c478bd9Sstevel@tonic-gate * and it's not clear who will lose. 11697c478bd9Sstevel@tonic-gate * 11707c478bd9Sstevel@tonic-gate * For uncompensated quartz crystal oscillatores and nominal update 11717c478bd9Sstevel@tonic-gate * intervals less than 1024 s, operation should be in phase-lock mode 11727c478bd9Sstevel@tonic-gate * (STA_FLL = 0), where the loop is disciplined to phase. For update 11737c478bd9Sstevel@tonic-gate * intervals greater than this, operation should be in frequency-lock 11747c478bd9Sstevel@tonic-gate * mode (STA_FLL = 1), where the loop is disciplined to frequency. 11757c478bd9Sstevel@tonic-gate * 11767c478bd9Sstevel@tonic-gate * Note: mutex(&tod_lock) is in effect. 11777c478bd9Sstevel@tonic-gate */ 11787c478bd9Sstevel@tonic-gate void 11797c478bd9Sstevel@tonic-gate clock_update(int offset) 11807c478bd9Sstevel@tonic-gate { 11817c478bd9Sstevel@tonic-gate int ltemp, mtemp, s; 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&tod_lock)); 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate if (!(time_status & STA_PLL) && !(time_status & STA_PPSTIME)) 11867c478bd9Sstevel@tonic-gate return; 11877c478bd9Sstevel@tonic-gate ltemp = offset; 11887c478bd9Sstevel@tonic-gate if ((time_status & STA_PPSTIME) && (time_status & STA_PPSSIGNAL)) 11897c478bd9Sstevel@tonic-gate ltemp = pps_offset; 11907c478bd9Sstevel@tonic-gate 11917c478bd9Sstevel@tonic-gate /* 11927c478bd9Sstevel@tonic-gate * Scale the phase adjustment and clamp to the operating range. 11937c478bd9Sstevel@tonic-gate */ 11947c478bd9Sstevel@tonic-gate if (ltemp > MAXPHASE) 11957c478bd9Sstevel@tonic-gate time_offset = MAXPHASE * SCALE_UPDATE; 11967c478bd9Sstevel@tonic-gate else if (ltemp < -MAXPHASE) 11977c478bd9Sstevel@tonic-gate time_offset = -(MAXPHASE * SCALE_UPDATE); 11987c478bd9Sstevel@tonic-gate else 11997c478bd9Sstevel@tonic-gate time_offset = ltemp * SCALE_UPDATE; 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate /* 12027c478bd9Sstevel@tonic-gate * Select whether the frequency is to be controlled and in which 12037c478bd9Sstevel@tonic-gate * mode (PLL or FLL). Clamp to the operating range. Ugly 12047c478bd9Sstevel@tonic-gate * multiply/divide should be replaced someday. 12057c478bd9Sstevel@tonic-gate */ 12067c478bd9Sstevel@tonic-gate if (time_status & STA_FREQHOLD || time_reftime == 0) 12077c478bd9Sstevel@tonic-gate time_reftime = hrestime.tv_sec; 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate mtemp = hrestime.tv_sec - time_reftime; 12107c478bd9Sstevel@tonic-gate time_reftime = hrestime.tv_sec; 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate if (time_status & STA_FLL) { 12137c478bd9Sstevel@tonic-gate if (mtemp >= MINSEC) { 12147c478bd9Sstevel@tonic-gate ltemp = ((time_offset / mtemp) * (SCALE_USEC / 12157c478bd9Sstevel@tonic-gate SCALE_UPDATE)); 12167c478bd9Sstevel@tonic-gate if (ltemp) 12177c478bd9Sstevel@tonic-gate time_freq += ltemp / SCALE_KH; 12187c478bd9Sstevel@tonic-gate } 12197c478bd9Sstevel@tonic-gate } else { 12207c478bd9Sstevel@tonic-gate if (mtemp < MAXSEC) { 12217c478bd9Sstevel@tonic-gate ltemp *= mtemp; 12227c478bd9Sstevel@tonic-gate if (ltemp) 12237c478bd9Sstevel@tonic-gate time_freq += (int)(((int64_t)ltemp * 12247c478bd9Sstevel@tonic-gate SCALE_USEC) / SCALE_KF) 12257c478bd9Sstevel@tonic-gate / (1 << (time_constant * 2)); 12267c478bd9Sstevel@tonic-gate } 12277c478bd9Sstevel@tonic-gate } 12287c478bd9Sstevel@tonic-gate if (time_freq > time_tolerance) 12297c478bd9Sstevel@tonic-gate time_freq = time_tolerance; 12307c478bd9Sstevel@tonic-gate else if (time_freq < -time_tolerance) 12317c478bd9Sstevel@tonic-gate time_freq = -time_tolerance; 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate s = hr_clock_lock(); 12347c478bd9Sstevel@tonic-gate tod_needsync = 1; 12357c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate /* 12397c478bd9Sstevel@tonic-gate * ddi_hardpps() - discipline CPU clock oscillator to external PPS signal 12407c478bd9Sstevel@tonic-gate * 12417c478bd9Sstevel@tonic-gate * This routine is called at each PPS interrupt in order to discipline 12427c478bd9Sstevel@tonic-gate * the CPU clock oscillator to the PPS signal. It measures the PPS phase 12437c478bd9Sstevel@tonic-gate * and leaves it in a handy spot for the clock() routine. It 12447c478bd9Sstevel@tonic-gate * integrates successive PPS phase differences and calculates the 12457c478bd9Sstevel@tonic-gate * frequency offset. This is used in clock() to discipline the CPU 12467c478bd9Sstevel@tonic-gate * clock oscillator so that intrinsic frequency error is cancelled out. 12477c478bd9Sstevel@tonic-gate * The code requires the caller to capture the time and hardware counter 12487c478bd9Sstevel@tonic-gate * value at the on-time PPS signal transition. 12497c478bd9Sstevel@tonic-gate * 12507c478bd9Sstevel@tonic-gate * Note that, on some Unix systems, this routine runs at an interrupt 12517c478bd9Sstevel@tonic-gate * priority level higher than the timer interrupt routine clock(). 12527c478bd9Sstevel@tonic-gate * Therefore, the variables used are distinct from the clock() 12537c478bd9Sstevel@tonic-gate * variables, except for certain exceptions: The PPS frequency pps_freq 12547c478bd9Sstevel@tonic-gate * and phase pps_offset variables are determined by this routine and 12557c478bd9Sstevel@tonic-gate * updated atomically. The time_tolerance variable can be considered a 12567c478bd9Sstevel@tonic-gate * constant, since it is infrequently changed, and then only when the 12577c478bd9Sstevel@tonic-gate * PPS signal is disabled. The watchdog counter pps_valid is updated 12587c478bd9Sstevel@tonic-gate * once per second by clock() and is atomically cleared in this 12597c478bd9Sstevel@tonic-gate * routine. 12607c478bd9Sstevel@tonic-gate * 12617c478bd9Sstevel@tonic-gate * tvp is the time of the last tick; usec is a microsecond count since the 12627c478bd9Sstevel@tonic-gate * last tick. 12637c478bd9Sstevel@tonic-gate * 12647c478bd9Sstevel@tonic-gate * Note: In Solaris systems, the tick value is actually given by 12657c478bd9Sstevel@tonic-gate * usec_per_tick. This is called from the serial driver cdintr(), 12667c478bd9Sstevel@tonic-gate * or equivalent, at a high PIL. Because the kernel keeps a 12677c478bd9Sstevel@tonic-gate * highresolution time, the following code can accept either 12687c478bd9Sstevel@tonic-gate * the traditional argument pair, or the current highres timestamp 12697c478bd9Sstevel@tonic-gate * in tvp and zero in usec. 12707c478bd9Sstevel@tonic-gate */ 12717c478bd9Sstevel@tonic-gate void 12727c478bd9Sstevel@tonic-gate ddi_hardpps(struct timeval *tvp, int usec) 12737c478bd9Sstevel@tonic-gate { 12747c478bd9Sstevel@tonic-gate int u_usec, v_usec, bigtick; 12757c478bd9Sstevel@tonic-gate time_t cal_sec; 12767c478bd9Sstevel@tonic-gate int cal_usec; 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * An occasional glitch can be produced when the PPS interrupt 12807c478bd9Sstevel@tonic-gate * occurs in the clock() routine before the time variable is 12817c478bd9Sstevel@tonic-gate * updated. Here the offset is discarded when the difference 12827c478bd9Sstevel@tonic-gate * between it and the last one is greater than tick/2, but not 12837c478bd9Sstevel@tonic-gate * if the interval since the first discard exceeds 30 s. 12847c478bd9Sstevel@tonic-gate */ 12857c478bd9Sstevel@tonic-gate time_status |= STA_PPSSIGNAL; 12867c478bd9Sstevel@tonic-gate time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR); 12877c478bd9Sstevel@tonic-gate pps_valid = 0; 12887c478bd9Sstevel@tonic-gate u_usec = -tvp->tv_usec; 12897c478bd9Sstevel@tonic-gate if (u_usec < -(MICROSEC/2)) 12907c478bd9Sstevel@tonic-gate u_usec += MICROSEC; 12917c478bd9Sstevel@tonic-gate v_usec = pps_offset - u_usec; 12927c478bd9Sstevel@tonic-gate if (v_usec < 0) 12937c478bd9Sstevel@tonic-gate v_usec = -v_usec; 12947c478bd9Sstevel@tonic-gate if (v_usec > (usec_per_tick >> 1)) { 12957c478bd9Sstevel@tonic-gate if (pps_glitch > MAXGLITCH) { 12967c478bd9Sstevel@tonic-gate pps_glitch = 0; 12977c478bd9Sstevel@tonic-gate pps_tf[2] = u_usec; 12987c478bd9Sstevel@tonic-gate pps_tf[1] = u_usec; 12997c478bd9Sstevel@tonic-gate } else { 13007c478bd9Sstevel@tonic-gate pps_glitch++; 13017c478bd9Sstevel@tonic-gate u_usec = pps_offset; 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate } else 13047c478bd9Sstevel@tonic-gate pps_glitch = 0; 13057c478bd9Sstevel@tonic-gate 13067c478bd9Sstevel@tonic-gate /* 13077c478bd9Sstevel@tonic-gate * A three-stage median filter is used to help deglitch the pps 13087c478bd9Sstevel@tonic-gate * time. The median sample becomes the time offset estimate; the 13097c478bd9Sstevel@tonic-gate * difference between the other two samples becomes the time 13107c478bd9Sstevel@tonic-gate * dispersion (jitter) estimate. 13117c478bd9Sstevel@tonic-gate */ 13127c478bd9Sstevel@tonic-gate pps_tf[2] = pps_tf[1]; 13137c478bd9Sstevel@tonic-gate pps_tf[1] = pps_tf[0]; 13147c478bd9Sstevel@tonic-gate pps_tf[0] = u_usec; 13157c478bd9Sstevel@tonic-gate if (pps_tf[0] > pps_tf[1]) { 13167c478bd9Sstevel@tonic-gate if (pps_tf[1] > pps_tf[2]) { 13177c478bd9Sstevel@tonic-gate pps_offset = pps_tf[1]; /* 0 1 2 */ 13187c478bd9Sstevel@tonic-gate v_usec = pps_tf[0] - pps_tf[2]; 13197c478bd9Sstevel@tonic-gate } else if (pps_tf[2] > pps_tf[0]) { 13207c478bd9Sstevel@tonic-gate pps_offset = pps_tf[0]; /* 2 0 1 */ 13217c478bd9Sstevel@tonic-gate v_usec = pps_tf[2] - pps_tf[1]; 13227c478bd9Sstevel@tonic-gate } else { 13237c478bd9Sstevel@tonic-gate pps_offset = pps_tf[2]; /* 0 2 1 */ 13247c478bd9Sstevel@tonic-gate v_usec = pps_tf[0] - pps_tf[1]; 13257c478bd9Sstevel@tonic-gate } 13267c478bd9Sstevel@tonic-gate } else { 13277c478bd9Sstevel@tonic-gate if (pps_tf[1] < pps_tf[2]) { 13287c478bd9Sstevel@tonic-gate pps_offset = pps_tf[1]; /* 2 1 0 */ 13297c478bd9Sstevel@tonic-gate v_usec = pps_tf[2] - pps_tf[0]; 13307c478bd9Sstevel@tonic-gate } else if (pps_tf[2] < pps_tf[0]) { 13317c478bd9Sstevel@tonic-gate pps_offset = pps_tf[0]; /* 1 0 2 */ 13327c478bd9Sstevel@tonic-gate v_usec = pps_tf[1] - pps_tf[2]; 13337c478bd9Sstevel@tonic-gate } else { 13347c478bd9Sstevel@tonic-gate pps_offset = pps_tf[2]; /* 1 2 0 */ 13357c478bd9Sstevel@tonic-gate v_usec = pps_tf[1] - pps_tf[0]; 13367c478bd9Sstevel@tonic-gate } 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate if (v_usec > MAXTIME) 13397c478bd9Sstevel@tonic-gate pps_jitcnt++; 13407c478bd9Sstevel@tonic-gate v_usec = (v_usec << PPS_AVG) - pps_jitter; 13417c478bd9Sstevel@tonic-gate pps_jitter += v_usec / (1 << PPS_AVG); 13427c478bd9Sstevel@tonic-gate if (pps_jitter > (MAXTIME >> 1)) 13437c478bd9Sstevel@tonic-gate time_status |= STA_PPSJITTER; 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate /* 13467c478bd9Sstevel@tonic-gate * During the calibration interval adjust the starting time when 13477c478bd9Sstevel@tonic-gate * the tick overflows. At the end of the interval compute the 13487c478bd9Sstevel@tonic-gate * duration of the interval and the difference of the hardware 13497c478bd9Sstevel@tonic-gate * counters at the beginning and end of the interval. This code 13507c478bd9Sstevel@tonic-gate * is deliciously complicated by the fact valid differences may 13517c478bd9Sstevel@tonic-gate * exceed the value of tick when using long calibration 13527c478bd9Sstevel@tonic-gate * intervals and small ticks. Note that the counter can be 13537c478bd9Sstevel@tonic-gate * greater than tick if caught at just the wrong instant, but 13547c478bd9Sstevel@tonic-gate * the values returned and used here are correct. 13557c478bd9Sstevel@tonic-gate */ 13567c478bd9Sstevel@tonic-gate bigtick = (int)usec_per_tick * SCALE_USEC; 13577c478bd9Sstevel@tonic-gate pps_usec -= pps_freq; 13587c478bd9Sstevel@tonic-gate if (pps_usec >= bigtick) 13597c478bd9Sstevel@tonic-gate pps_usec -= bigtick; 13607c478bd9Sstevel@tonic-gate if (pps_usec < 0) 13617c478bd9Sstevel@tonic-gate pps_usec += bigtick; 13627c478bd9Sstevel@tonic-gate pps_time.tv_sec++; 13637c478bd9Sstevel@tonic-gate pps_count++; 13647c478bd9Sstevel@tonic-gate if (pps_count < (1 << pps_shift)) 13657c478bd9Sstevel@tonic-gate return; 13667c478bd9Sstevel@tonic-gate pps_count = 0; 13677c478bd9Sstevel@tonic-gate pps_calcnt++; 13687c478bd9Sstevel@tonic-gate u_usec = usec * SCALE_USEC; 13697c478bd9Sstevel@tonic-gate v_usec = pps_usec - u_usec; 13707c478bd9Sstevel@tonic-gate if (v_usec >= bigtick >> 1) 13717c478bd9Sstevel@tonic-gate v_usec -= bigtick; 13727c478bd9Sstevel@tonic-gate if (v_usec < -(bigtick >> 1)) 13737c478bd9Sstevel@tonic-gate v_usec += bigtick; 13747c478bd9Sstevel@tonic-gate if (v_usec < 0) 13757c478bd9Sstevel@tonic-gate v_usec = -(-v_usec >> pps_shift); 13767c478bd9Sstevel@tonic-gate else 13777c478bd9Sstevel@tonic-gate v_usec = v_usec >> pps_shift; 13787c478bd9Sstevel@tonic-gate pps_usec = u_usec; 13797c478bd9Sstevel@tonic-gate cal_sec = tvp->tv_sec; 13807c478bd9Sstevel@tonic-gate cal_usec = tvp->tv_usec; 13817c478bd9Sstevel@tonic-gate cal_sec -= pps_time.tv_sec; 13827c478bd9Sstevel@tonic-gate cal_usec -= pps_time.tv_usec; 13837c478bd9Sstevel@tonic-gate if (cal_usec < 0) { 13847c478bd9Sstevel@tonic-gate cal_usec += MICROSEC; 13857c478bd9Sstevel@tonic-gate cal_sec--; 13867c478bd9Sstevel@tonic-gate } 13877c478bd9Sstevel@tonic-gate pps_time = *tvp; 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate /* 13907c478bd9Sstevel@tonic-gate * Check for lost interrupts, noise, excessive jitter and 13917c478bd9Sstevel@tonic-gate * excessive frequency error. The number of timer ticks during 13927c478bd9Sstevel@tonic-gate * the interval may vary +-1 tick. Add to this a margin of one 13937c478bd9Sstevel@tonic-gate * tick for the PPS signal jitter and maximum frequency 13947c478bd9Sstevel@tonic-gate * deviation. If the limits are exceeded, the calibration 13957c478bd9Sstevel@tonic-gate * interval is reset to the minimum and we start over. 13967c478bd9Sstevel@tonic-gate */ 13977c478bd9Sstevel@tonic-gate u_usec = (int)usec_per_tick << 1; 13987c478bd9Sstevel@tonic-gate if (!((cal_sec == -1 && cal_usec > (MICROSEC - u_usec)) || 13997c478bd9Sstevel@tonic-gate (cal_sec == 0 && cal_usec < u_usec)) || 14007c478bd9Sstevel@tonic-gate v_usec > time_tolerance || v_usec < -time_tolerance) { 14017c478bd9Sstevel@tonic-gate pps_errcnt++; 14027c478bd9Sstevel@tonic-gate pps_shift = PPS_SHIFT; 14037c478bd9Sstevel@tonic-gate pps_intcnt = 0; 14047c478bd9Sstevel@tonic-gate time_status |= STA_PPSERROR; 14057c478bd9Sstevel@tonic-gate return; 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate /* 14097c478bd9Sstevel@tonic-gate * A three-stage median filter is used to help deglitch the pps 14107c478bd9Sstevel@tonic-gate * frequency. The median sample becomes the frequency offset 14117c478bd9Sstevel@tonic-gate * estimate; the difference between the other two samples 14127c478bd9Sstevel@tonic-gate * becomes the frequency dispersion (stability) estimate. 14137c478bd9Sstevel@tonic-gate */ 14147c478bd9Sstevel@tonic-gate pps_ff[2] = pps_ff[1]; 14157c478bd9Sstevel@tonic-gate pps_ff[1] = pps_ff[0]; 14167c478bd9Sstevel@tonic-gate pps_ff[0] = v_usec; 14177c478bd9Sstevel@tonic-gate if (pps_ff[0] > pps_ff[1]) { 14187c478bd9Sstevel@tonic-gate if (pps_ff[1] > pps_ff[2]) { 14197c478bd9Sstevel@tonic-gate u_usec = pps_ff[1]; /* 0 1 2 */ 14207c478bd9Sstevel@tonic-gate v_usec = pps_ff[0] - pps_ff[2]; 14217c478bd9Sstevel@tonic-gate } else if (pps_ff[2] > pps_ff[0]) { 14227c478bd9Sstevel@tonic-gate u_usec = pps_ff[0]; /* 2 0 1 */ 14237c478bd9Sstevel@tonic-gate v_usec = pps_ff[2] - pps_ff[1]; 14247c478bd9Sstevel@tonic-gate } else { 14257c478bd9Sstevel@tonic-gate u_usec = pps_ff[2]; /* 0 2 1 */ 14267c478bd9Sstevel@tonic-gate v_usec = pps_ff[0] - pps_ff[1]; 14277c478bd9Sstevel@tonic-gate } 14287c478bd9Sstevel@tonic-gate } else { 14297c478bd9Sstevel@tonic-gate if (pps_ff[1] < pps_ff[2]) { 14307c478bd9Sstevel@tonic-gate u_usec = pps_ff[1]; /* 2 1 0 */ 14317c478bd9Sstevel@tonic-gate v_usec = pps_ff[2] - pps_ff[0]; 14327c478bd9Sstevel@tonic-gate } else if (pps_ff[2] < pps_ff[0]) { 14337c478bd9Sstevel@tonic-gate u_usec = pps_ff[0]; /* 1 0 2 */ 14347c478bd9Sstevel@tonic-gate v_usec = pps_ff[1] - pps_ff[2]; 14357c478bd9Sstevel@tonic-gate } else { 14367c478bd9Sstevel@tonic-gate u_usec = pps_ff[2]; /* 1 2 0 */ 14377c478bd9Sstevel@tonic-gate v_usec = pps_ff[1] - pps_ff[0]; 14387c478bd9Sstevel@tonic-gate } 14397c478bd9Sstevel@tonic-gate } 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate /* 14427c478bd9Sstevel@tonic-gate * Here the frequency dispersion (stability) is updated. If it 14437c478bd9Sstevel@tonic-gate * is less than one-fourth the maximum (MAXFREQ), the frequency 14447c478bd9Sstevel@tonic-gate * offset is updated as well, but clamped to the tolerance. It 14457c478bd9Sstevel@tonic-gate * will be processed later by the clock() routine. 14467c478bd9Sstevel@tonic-gate */ 14477c478bd9Sstevel@tonic-gate v_usec = (v_usec >> 1) - pps_stabil; 14487c478bd9Sstevel@tonic-gate if (v_usec < 0) 14497c478bd9Sstevel@tonic-gate pps_stabil -= -v_usec >> PPS_AVG; 14507c478bd9Sstevel@tonic-gate else 14517c478bd9Sstevel@tonic-gate pps_stabil += v_usec >> PPS_AVG; 14527c478bd9Sstevel@tonic-gate if (pps_stabil > MAXFREQ >> 2) { 14537c478bd9Sstevel@tonic-gate pps_stbcnt++; 14547c478bd9Sstevel@tonic-gate time_status |= STA_PPSWANDER; 14557c478bd9Sstevel@tonic-gate return; 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate if (time_status & STA_PPSFREQ) { 14587c478bd9Sstevel@tonic-gate if (u_usec < 0) { 14597c478bd9Sstevel@tonic-gate pps_freq -= -u_usec >> PPS_AVG; 14607c478bd9Sstevel@tonic-gate if (pps_freq < -time_tolerance) 14617c478bd9Sstevel@tonic-gate pps_freq = -time_tolerance; 14627c478bd9Sstevel@tonic-gate u_usec = -u_usec; 14637c478bd9Sstevel@tonic-gate } else { 14647c478bd9Sstevel@tonic-gate pps_freq += u_usec >> PPS_AVG; 14657c478bd9Sstevel@tonic-gate if (pps_freq > time_tolerance) 14667c478bd9Sstevel@tonic-gate pps_freq = time_tolerance; 14677c478bd9Sstevel@tonic-gate } 14687c478bd9Sstevel@tonic-gate } 14697c478bd9Sstevel@tonic-gate 14707c478bd9Sstevel@tonic-gate /* 14717c478bd9Sstevel@tonic-gate * Here the calibration interval is adjusted. If the maximum 14727c478bd9Sstevel@tonic-gate * time difference is greater than tick / 4, reduce the interval 14737c478bd9Sstevel@tonic-gate * by half. If this is not the case for four consecutive 14747c478bd9Sstevel@tonic-gate * intervals, double the interval. 14757c478bd9Sstevel@tonic-gate */ 14767c478bd9Sstevel@tonic-gate if (u_usec << pps_shift > bigtick >> 2) { 14777c478bd9Sstevel@tonic-gate pps_intcnt = 0; 14787c478bd9Sstevel@tonic-gate if (pps_shift > PPS_SHIFT) 14797c478bd9Sstevel@tonic-gate pps_shift--; 14807c478bd9Sstevel@tonic-gate } else if (pps_intcnt >= 4) { 14817c478bd9Sstevel@tonic-gate pps_intcnt = 0; 14827c478bd9Sstevel@tonic-gate if (pps_shift < PPS_SHIFTMAX) 14837c478bd9Sstevel@tonic-gate pps_shift++; 14847c478bd9Sstevel@tonic-gate } else 14857c478bd9Sstevel@tonic-gate pps_intcnt++; 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate /* 14887c478bd9Sstevel@tonic-gate * If recovering from kmdb, then make sure the tod chip gets resynced. 14897c478bd9Sstevel@tonic-gate * If we took an early exit above, then we don't yet have a stable 14907c478bd9Sstevel@tonic-gate * calibration signal to lock onto, so don't mark the tod for sync 14917c478bd9Sstevel@tonic-gate * until we get all the way here. 14927c478bd9Sstevel@tonic-gate */ 14937c478bd9Sstevel@tonic-gate { 14947c478bd9Sstevel@tonic-gate int s = hr_clock_lock(); 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate tod_needsync = 1; 14977c478bd9Sstevel@tonic-gate hr_clock_unlock(s); 14987c478bd9Sstevel@tonic-gate } 14997c478bd9Sstevel@tonic-gate } 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate /* 15027c478bd9Sstevel@tonic-gate * Handle clock tick processing for a thread. 15037c478bd9Sstevel@tonic-gate * Check for timer action, enforce CPU rlimit, do profiling etc. 15047c478bd9Sstevel@tonic-gate */ 15057c478bd9Sstevel@tonic-gate void 15067c478bd9Sstevel@tonic-gate clock_tick(kthread_t *t) 15077c478bd9Sstevel@tonic-gate { 15087c478bd9Sstevel@tonic-gate struct proc *pp; 15097c478bd9Sstevel@tonic-gate klwp_id_t lwp; 15107c478bd9Sstevel@tonic-gate struct as *as; 15117c478bd9Sstevel@tonic-gate clock_t utime; 15127c478bd9Sstevel@tonic-gate clock_t stime; 15137c478bd9Sstevel@tonic-gate int poke = 0; /* notify another CPU */ 15147c478bd9Sstevel@tonic-gate int user_mode; 15157c478bd9Sstevel@tonic-gate size_t rss; 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate /* Must be operating on a lwp/thread */ 15187c478bd9Sstevel@tonic-gate if ((lwp = ttolwp(t)) == NULL) { 15197c478bd9Sstevel@tonic-gate panic("clock_tick: no lwp"); 15207c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 15217c478bd9Sstevel@tonic-gate } 15227c478bd9Sstevel@tonic-gate 15237c478bd9Sstevel@tonic-gate CL_TICK(t); /* Class specific tick processing */ 15247c478bd9Sstevel@tonic-gate DTRACE_SCHED1(tick, kthread_t *, t); 15257c478bd9Sstevel@tonic-gate 15267c478bd9Sstevel@tonic-gate pp = ttoproc(t); 15277c478bd9Sstevel@tonic-gate 15287c478bd9Sstevel@tonic-gate /* pp->p_lock makes sure that the thread does not exit */ 15297c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pp->p_lock)); 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate user_mode = (lwp->lwp_state == LWP_USER); 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate /* 15347c478bd9Sstevel@tonic-gate * Update process times. Should use high res clock and state 15357c478bd9Sstevel@tonic-gate * changes instead of statistical sampling method. XXX 15367c478bd9Sstevel@tonic-gate */ 15377c478bd9Sstevel@tonic-gate if (user_mode) { 15387c478bd9Sstevel@tonic-gate pp->p_utime++; 15397c478bd9Sstevel@tonic-gate pp->p_task->tk_cpu_time++; 15407c478bd9Sstevel@tonic-gate } else { 15417c478bd9Sstevel@tonic-gate pp->p_stime++; 15427c478bd9Sstevel@tonic-gate pp->p_task->tk_cpu_time++; 15437c478bd9Sstevel@tonic-gate } 15447c478bd9Sstevel@tonic-gate as = pp->p_as; 15457c478bd9Sstevel@tonic-gate 15467c478bd9Sstevel@tonic-gate /* 15477c478bd9Sstevel@tonic-gate * Update user profiling statistics. Get the pc from the 15487c478bd9Sstevel@tonic-gate * lwp when the AST happens. 15497c478bd9Sstevel@tonic-gate */ 15507c478bd9Sstevel@tonic-gate if (pp->p_prof.pr_scale) { 15517c478bd9Sstevel@tonic-gate atomic_add_32(&lwp->lwp_oweupc, 1); 15527c478bd9Sstevel@tonic-gate if (user_mode) { 15537c478bd9Sstevel@tonic-gate poke = 1; 15547c478bd9Sstevel@tonic-gate aston(t); 15557c478bd9Sstevel@tonic-gate } 15567c478bd9Sstevel@tonic-gate } 15577c478bd9Sstevel@tonic-gate 15587c478bd9Sstevel@tonic-gate utime = pp->p_utime; 15597c478bd9Sstevel@tonic-gate stime = pp->p_stime; 15607c478bd9Sstevel@tonic-gate 15617c478bd9Sstevel@tonic-gate /* 15627c478bd9Sstevel@tonic-gate * If CPU was in user state, process lwp-virtual time 15637c478bd9Sstevel@tonic-gate * interval timer. 15647c478bd9Sstevel@tonic-gate */ 15657c478bd9Sstevel@tonic-gate if (user_mode && 15667c478bd9Sstevel@tonic-gate timerisset(&lwp->lwp_timer[ITIMER_VIRTUAL].it_value) && 15677c478bd9Sstevel@tonic-gate itimerdecr(&lwp->lwp_timer[ITIMER_VIRTUAL], usec_per_tick) == 0) { 15687c478bd9Sstevel@tonic-gate poke = 1; 15697c478bd9Sstevel@tonic-gate sigtoproc(pp, t, SIGVTALRM); 15707c478bd9Sstevel@tonic-gate } 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate if (timerisset(&lwp->lwp_timer[ITIMER_PROF].it_value) && 15737c478bd9Sstevel@tonic-gate itimerdecr(&lwp->lwp_timer[ITIMER_PROF], usec_per_tick) == 0) { 15747c478bd9Sstevel@tonic-gate poke = 1; 15757c478bd9Sstevel@tonic-gate sigtoproc(pp, t, SIGPROF); 15767c478bd9Sstevel@tonic-gate } 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate /* 15797c478bd9Sstevel@tonic-gate * Enforce CPU resource controls: 15807c478bd9Sstevel@tonic-gate * (a) process.max-cpu-time resource control 15817c478bd9Sstevel@tonic-gate */ 15827c478bd9Sstevel@tonic-gate (void) rctl_test(rctlproc_legacy[RLIMIT_CPU], pp->p_rctls, pp, 15837c478bd9Sstevel@tonic-gate (utime + stime)/hz, RCA_UNSAFE_SIGINFO); 15847c478bd9Sstevel@tonic-gate 15857c478bd9Sstevel@tonic-gate /* 15867c478bd9Sstevel@tonic-gate * (b) task.max-cpu-time resource control 15877c478bd9Sstevel@tonic-gate */ 15887c478bd9Sstevel@tonic-gate (void) rctl_test(rc_task_cpu_time, pp->p_task->tk_rctls, pp, 1, 15897c478bd9Sstevel@tonic-gate RCA_UNSAFE_SIGINFO); 15907c478bd9Sstevel@tonic-gate 15917c478bd9Sstevel@tonic-gate /* 15927c478bd9Sstevel@tonic-gate * Update memory usage for the currently running process. 15937c478bd9Sstevel@tonic-gate */ 15947c478bd9Sstevel@tonic-gate rss = rm_asrss(as); 15957c478bd9Sstevel@tonic-gate PTOU(pp)->u_mem += rss; 15967c478bd9Sstevel@tonic-gate if (rss > PTOU(pp)->u_mem_max) 15977c478bd9Sstevel@tonic-gate PTOU(pp)->u_mem_max = rss; 15987c478bd9Sstevel@tonic-gate 15997c478bd9Sstevel@tonic-gate /* 16007c478bd9Sstevel@tonic-gate * Notify the CPU the thread is running on. 16017c478bd9Sstevel@tonic-gate */ 16027c478bd9Sstevel@tonic-gate if (poke && t->t_cpu != CPU) 16037c478bd9Sstevel@tonic-gate poke_cpu(t->t_cpu->cpu_id); 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate void 16077c478bd9Sstevel@tonic-gate profil_tick(uintptr_t upc) 16087c478bd9Sstevel@tonic-gate { 16097c478bd9Sstevel@tonic-gate int ticks; 16107c478bd9Sstevel@tonic-gate proc_t *p = ttoproc(curthread); 16117c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 16127c478bd9Sstevel@tonic-gate struct prof *pr = &p->p_prof; 16137c478bd9Sstevel@tonic-gate 16147c478bd9Sstevel@tonic-gate do { 16157c478bd9Sstevel@tonic-gate ticks = lwp->lwp_oweupc; 16167c478bd9Sstevel@tonic-gate } while (cas32(&lwp->lwp_oweupc, ticks, 0) != ticks); 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate mutex_enter(&p->p_pflock); 16197c478bd9Sstevel@tonic-gate if (pr->pr_scale >= 2 && upc >= pr->pr_off) { 16207c478bd9Sstevel@tonic-gate /* 16217c478bd9Sstevel@tonic-gate * Old-style profiling 16227c478bd9Sstevel@tonic-gate */ 16237c478bd9Sstevel@tonic-gate uint16_t *slot = pr->pr_base; 16247c478bd9Sstevel@tonic-gate uint16_t old, new; 16257c478bd9Sstevel@tonic-gate if (pr->pr_scale != 2) { 16267c478bd9Sstevel@tonic-gate uintptr_t delta = upc - pr->pr_off; 16277c478bd9Sstevel@tonic-gate uintptr_t byteoff = ((delta >> 16) * pr->pr_scale) + 16287c478bd9Sstevel@tonic-gate (((delta & 0xffff) * pr->pr_scale) >> 16); 16297c478bd9Sstevel@tonic-gate if (byteoff >= (uintptr_t)pr->pr_size) { 16307c478bd9Sstevel@tonic-gate mutex_exit(&p->p_pflock); 16317c478bd9Sstevel@tonic-gate return; 16327c478bd9Sstevel@tonic-gate } 16337c478bd9Sstevel@tonic-gate slot += byteoff / sizeof (uint16_t); 16347c478bd9Sstevel@tonic-gate } 16357c478bd9Sstevel@tonic-gate if (fuword16(slot, &old) < 0 || 16367c478bd9Sstevel@tonic-gate (new = old + ticks) > SHRT_MAX || 16377c478bd9Sstevel@tonic-gate suword16(slot, new) < 0) { 16387c478bd9Sstevel@tonic-gate pr->pr_scale = 0; 16397c478bd9Sstevel@tonic-gate } 16407c478bd9Sstevel@tonic-gate } else if (pr->pr_scale == 1) { 16417c478bd9Sstevel@tonic-gate /* 16427c478bd9Sstevel@tonic-gate * PC Sampling 16437c478bd9Sstevel@tonic-gate */ 16447c478bd9Sstevel@tonic-gate model_t model = lwp_getdatamodel(lwp); 16457c478bd9Sstevel@tonic-gate int result; 16467c478bd9Sstevel@tonic-gate #ifdef __lint 16477c478bd9Sstevel@tonic-gate model = model; 16487c478bd9Sstevel@tonic-gate #endif 16497c478bd9Sstevel@tonic-gate while (ticks-- > 0) { 16507c478bd9Sstevel@tonic-gate if (pr->pr_samples == pr->pr_size) { 16517c478bd9Sstevel@tonic-gate /* buffer full, turn off sampling */ 16527c478bd9Sstevel@tonic-gate pr->pr_scale = 0; 16537c478bd9Sstevel@tonic-gate break; 16547c478bd9Sstevel@tonic-gate } 16557c478bd9Sstevel@tonic-gate switch (SIZEOF_PTR(model)) { 16567c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 16577c478bd9Sstevel@tonic-gate result = suword32(pr->pr_base, (uint32_t)upc); 16587c478bd9Sstevel@tonic-gate break; 16597c478bd9Sstevel@tonic-gate #ifdef _LP64 16607c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 16617c478bd9Sstevel@tonic-gate result = suword64(pr->pr_base, (uint64_t)upc); 16627c478bd9Sstevel@tonic-gate break; 16637c478bd9Sstevel@tonic-gate #endif 16647c478bd9Sstevel@tonic-gate default: 16657c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "profil_tick: unexpected " 16667c478bd9Sstevel@tonic-gate "data model"); 16677c478bd9Sstevel@tonic-gate result = -1; 16687c478bd9Sstevel@tonic-gate break; 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate if (result != 0) { 16717c478bd9Sstevel@tonic-gate pr->pr_scale = 0; 16727c478bd9Sstevel@tonic-gate break; 16737c478bd9Sstevel@tonic-gate } 16747c478bd9Sstevel@tonic-gate pr->pr_base = (caddr_t)pr->pr_base + SIZEOF_PTR(model); 16757c478bd9Sstevel@tonic-gate pr->pr_samples++; 16767c478bd9Sstevel@tonic-gate } 16777c478bd9Sstevel@tonic-gate } 16787c478bd9Sstevel@tonic-gate mutex_exit(&p->p_pflock); 16797c478bd9Sstevel@tonic-gate } 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate static void 16827c478bd9Sstevel@tonic-gate delay_wakeup(void *arg) 16837c478bd9Sstevel@tonic-gate { 16847c478bd9Sstevel@tonic-gate kthread_t *t = arg; 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate mutex_enter(&t->t_delay_lock); 16877c478bd9Sstevel@tonic-gate cv_signal(&t->t_delay_cv); 16887c478bd9Sstevel@tonic-gate mutex_exit(&t->t_delay_lock); 16897c478bd9Sstevel@tonic-gate } 16907c478bd9Sstevel@tonic-gate 16917c478bd9Sstevel@tonic-gate void 16927c478bd9Sstevel@tonic-gate delay(clock_t ticks) 16937c478bd9Sstevel@tonic-gate { 16947c478bd9Sstevel@tonic-gate kthread_t *t = curthread; 16957c478bd9Sstevel@tonic-gate clock_t deadline = lbolt + ticks; 16967c478bd9Sstevel@tonic-gate clock_t timeleft; 16977c478bd9Sstevel@tonic-gate timeout_id_t id; 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate if (panicstr && ticks > 0) { 17007c478bd9Sstevel@tonic-gate /* 17017c478bd9Sstevel@tonic-gate * Timeouts aren't running, so all we can do is spin. 17027c478bd9Sstevel@tonic-gate */ 17037c478bd9Sstevel@tonic-gate drv_usecwait(TICK_TO_USEC(ticks)); 17047c478bd9Sstevel@tonic-gate return; 17057c478bd9Sstevel@tonic-gate } 17067c478bd9Sstevel@tonic-gate 17077c478bd9Sstevel@tonic-gate while ((timeleft = deadline - lbolt) > 0) { 17087c478bd9Sstevel@tonic-gate mutex_enter(&t->t_delay_lock); 17097c478bd9Sstevel@tonic-gate id = timeout(delay_wakeup, t, timeleft); 17107c478bd9Sstevel@tonic-gate cv_wait(&t->t_delay_cv, &t->t_delay_lock); 17117c478bd9Sstevel@tonic-gate mutex_exit(&t->t_delay_lock); 17127c478bd9Sstevel@tonic-gate (void) untimeout(id); 17137c478bd9Sstevel@tonic-gate } 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate /* 17177c478bd9Sstevel@tonic-gate * Like delay, but interruptible by a signal. 17187c478bd9Sstevel@tonic-gate */ 17197c478bd9Sstevel@tonic-gate int 17207c478bd9Sstevel@tonic-gate delay_sig(clock_t ticks) 17217c478bd9Sstevel@tonic-gate { 17227c478bd9Sstevel@tonic-gate clock_t deadline = lbolt + ticks; 17237c478bd9Sstevel@tonic-gate clock_t rc; 17247c478bd9Sstevel@tonic-gate 17257c478bd9Sstevel@tonic-gate mutex_enter(&curthread->t_delay_lock); 17267c478bd9Sstevel@tonic-gate do { 17277c478bd9Sstevel@tonic-gate rc = cv_timedwait_sig(&curthread->t_delay_cv, 17287c478bd9Sstevel@tonic-gate &curthread->t_delay_lock, deadline); 17297c478bd9Sstevel@tonic-gate } while (rc > 0); 17307c478bd9Sstevel@tonic-gate mutex_exit(&curthread->t_delay_lock); 17317c478bd9Sstevel@tonic-gate if (rc == 0) 17327c478bd9Sstevel@tonic-gate return (EINTR); 17337c478bd9Sstevel@tonic-gate return (0); 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate #define SECONDS_PER_DAY 86400 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate /* 17397c478bd9Sstevel@tonic-gate * Initialize the system time based on the TOD chip. approx is used as 17407c478bd9Sstevel@tonic-gate * an approximation of time (e.g. from the filesystem) in the event that 17417c478bd9Sstevel@tonic-gate * the TOD chip has been cleared or is unresponsive. An approx of -1 17427c478bd9Sstevel@tonic-gate * means the filesystem doesn't keep time. 17437c478bd9Sstevel@tonic-gate */ 17447c478bd9Sstevel@tonic-gate void 17457c478bd9Sstevel@tonic-gate clkset(time_t approx) 17467c478bd9Sstevel@tonic-gate { 17477c478bd9Sstevel@tonic-gate timestruc_t ts; 17487c478bd9Sstevel@tonic-gate int spl; 17497c478bd9Sstevel@tonic-gate int set_clock = 0; 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate mutex_enter(&tod_lock); 17527c478bd9Sstevel@tonic-gate ts = tod_get(); 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate if (ts.tv_sec > 365 * SECONDS_PER_DAY) { 17557c478bd9Sstevel@tonic-gate /* 17567c478bd9Sstevel@tonic-gate * If the TOD chip is reporting some time after 1971, 17577c478bd9Sstevel@tonic-gate * then it probably didn't lose power or become otherwise 17587c478bd9Sstevel@tonic-gate * cleared in the recent past; check to assure that 17597c478bd9Sstevel@tonic-gate * the time coming from the filesystem isn't in the future 17607c478bd9Sstevel@tonic-gate * according to the TOD chip. 17617c478bd9Sstevel@tonic-gate */ 17627c478bd9Sstevel@tonic-gate if (approx != -1 && approx > ts.tv_sec) { 17637c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Last shutdown is later " 17647c478bd9Sstevel@tonic-gate "than time on time-of-day chip; check date."); 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate } else { 17677c478bd9Sstevel@tonic-gate /* 17687c478bd9Sstevel@tonic-gate * If the TOD chip isn't giving correct time, then set it to 17697c478bd9Sstevel@tonic-gate * the time that was passed in as a rough estimate. If we 17707c478bd9Sstevel@tonic-gate * don't have an estimate, then set the clock back to a time 17717c478bd9Sstevel@tonic-gate * when Oliver North, ALF and Dire Straits were all on the 17727c478bd9Sstevel@tonic-gate * collective brain: 1987. 17737c478bd9Sstevel@tonic-gate */ 17747c478bd9Sstevel@tonic-gate timestruc_t tmp; 17757c478bd9Sstevel@tonic-gate if (approx == -1) 17767c478bd9Sstevel@tonic-gate ts.tv_sec = (1987 - 1970) * 365 * SECONDS_PER_DAY; 17777c478bd9Sstevel@tonic-gate else 17787c478bd9Sstevel@tonic-gate ts.tv_sec = approx; 17797c478bd9Sstevel@tonic-gate ts.tv_nsec = 0; 17807c478bd9Sstevel@tonic-gate 17817c478bd9Sstevel@tonic-gate /* 17827c478bd9Sstevel@tonic-gate * Attempt to write the new time to the TOD chip. Set spl high 17837c478bd9Sstevel@tonic-gate * to avoid getting preempted between the tod_set and tod_get. 17847c478bd9Sstevel@tonic-gate */ 17857c478bd9Sstevel@tonic-gate spl = splhi(); 17867c478bd9Sstevel@tonic-gate tod_set(ts); 17877c478bd9Sstevel@tonic-gate tmp = tod_get(); 17887c478bd9Sstevel@tonic-gate splx(spl); 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate if (tmp.tv_sec != ts.tv_sec && tmp.tv_sec != ts.tv_sec + 1) { 17917c478bd9Sstevel@tonic-gate tod_broken = 1; 17927c478bd9Sstevel@tonic-gate dosynctodr = 0; 17937c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Time-of-day chip unresponsive;" 17947c478bd9Sstevel@tonic-gate " dead batteries?"); 17957c478bd9Sstevel@tonic-gate } else { 17967c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Time-of-day chip had " 17977c478bd9Sstevel@tonic-gate "incorrect date; check and reset."); 17987c478bd9Sstevel@tonic-gate } 17997c478bd9Sstevel@tonic-gate set_clock = 1; 18007c478bd9Sstevel@tonic-gate } 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate if (!boot_time) { 18037c478bd9Sstevel@tonic-gate boot_time = ts.tv_sec; 18047c478bd9Sstevel@tonic-gate set_clock = 1; 18057c478bd9Sstevel@tonic-gate } 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate if (set_clock) 18087c478bd9Sstevel@tonic-gate set_hrestime(&ts); 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate mutex_exit(&tod_lock); 18117c478bd9Sstevel@tonic-gate } 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate int timechanged; /* for testing if the system time has been reset */ 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate void 18167c478bd9Sstevel@tonic-gate set_hrestime(timestruc_t *ts) 18177c478bd9Sstevel@tonic-gate { 18187c478bd9Sstevel@tonic-gate int spl = hr_clock_lock(); 18197c478bd9Sstevel@tonic-gate hrestime = *ts; 18207c478bd9Sstevel@tonic-gate membar_enter(); /* hrestime must be visible before timechanged++ */ 18217c478bd9Sstevel@tonic-gate timedelta = 0; 18227c478bd9Sstevel@tonic-gate timechanged++; 18237c478bd9Sstevel@tonic-gate hr_clock_unlock(spl); 18247c478bd9Sstevel@tonic-gate } 18257c478bd9Sstevel@tonic-gate 18267c478bd9Sstevel@tonic-gate static uint_t deadman_seconds; 18277c478bd9Sstevel@tonic-gate static uint32_t deadman_panics; 18287c478bd9Sstevel@tonic-gate static int deadman_enabled = 0; 18297c478bd9Sstevel@tonic-gate static int deadman_panic_timers = 1; 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate static void 18327c478bd9Sstevel@tonic-gate deadman(void) 18337c478bd9Sstevel@tonic-gate { 18347c478bd9Sstevel@tonic-gate if (panicstr) { 18357c478bd9Sstevel@tonic-gate /* 18367c478bd9Sstevel@tonic-gate * During panic, other CPUs besides the panic 18377c478bd9Sstevel@tonic-gate * master continue to handle cyclics and some other 18387c478bd9Sstevel@tonic-gate * interrupts. The code below is intended to be 18397c478bd9Sstevel@tonic-gate * single threaded, so any CPU other than the master 18407c478bd9Sstevel@tonic-gate * must keep out. 18417c478bd9Sstevel@tonic-gate */ 18427c478bd9Sstevel@tonic-gate if (CPU->cpu_id != panic_cpu.cpu_id) 18437c478bd9Sstevel@tonic-gate return; 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate /* 18467c478bd9Sstevel@tonic-gate * If we're panicking, the deadman cyclic continues to increase 18477c478bd9Sstevel@tonic-gate * lbolt in case the dump device driver relies on this for 18487c478bd9Sstevel@tonic-gate * timeouts. Note that we rely on deadman() being invoked once 18497c478bd9Sstevel@tonic-gate * per second, and credit lbolt and lbolt64 with hz ticks each. 18507c478bd9Sstevel@tonic-gate */ 18517c478bd9Sstevel@tonic-gate lbolt += hz; 18527c478bd9Sstevel@tonic-gate lbolt64 += hz; 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate if (!deadman_panic_timers) 18557c478bd9Sstevel@tonic-gate return; /* allow all timers to be manually disabled */ 18567c478bd9Sstevel@tonic-gate 18577c478bd9Sstevel@tonic-gate /* 18587c478bd9Sstevel@tonic-gate * If we are generating a crash dump or syncing filesystems and 18597c478bd9Sstevel@tonic-gate * the corresponding timer is set, decrement it and re-enter 18607c478bd9Sstevel@tonic-gate * the panic code to abort it and advance to the next state. 18617c478bd9Sstevel@tonic-gate * The panic states and triggers are explained in panic.c. 18627c478bd9Sstevel@tonic-gate */ 18637c478bd9Sstevel@tonic-gate if (panic_dump) { 18647c478bd9Sstevel@tonic-gate if (dump_timeleft && (--dump_timeleft == 0)) { 18657c478bd9Sstevel@tonic-gate panic("panic dump timeout"); 18667c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 18677c478bd9Sstevel@tonic-gate } 18687c478bd9Sstevel@tonic-gate } else if (panic_sync) { 18697c478bd9Sstevel@tonic-gate if (sync_timeleft && (--sync_timeleft == 0)) { 18707c478bd9Sstevel@tonic-gate panic("panic sync timeout"); 18717c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 18727c478bd9Sstevel@tonic-gate } 18737c478bd9Sstevel@tonic-gate } 18747c478bd9Sstevel@tonic-gate 18757c478bd9Sstevel@tonic-gate return; 18767c478bd9Sstevel@tonic-gate } 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate if (lbolt != CPU->cpu_deadman_lbolt) { 18797c478bd9Sstevel@tonic-gate CPU->cpu_deadman_lbolt = lbolt; 18807c478bd9Sstevel@tonic-gate CPU->cpu_deadman_countdown = deadman_seconds; 18817c478bd9Sstevel@tonic-gate return; 18827c478bd9Sstevel@tonic-gate } 18837c478bd9Sstevel@tonic-gate 18847c478bd9Sstevel@tonic-gate if (CPU->cpu_deadman_countdown-- > 0) 18857c478bd9Sstevel@tonic-gate return; 18867c478bd9Sstevel@tonic-gate 18877c478bd9Sstevel@tonic-gate /* 18887c478bd9Sstevel@tonic-gate * Regardless of whether or not we actually bring the system down, 18897c478bd9Sstevel@tonic-gate * bump the deadman_panics variable. 18907c478bd9Sstevel@tonic-gate * 18917c478bd9Sstevel@tonic-gate * N.B. deadman_panics is incremented once for each CPU that 18927c478bd9Sstevel@tonic-gate * passes through here. It's expected that all the CPUs will 18937c478bd9Sstevel@tonic-gate * detect this condition within one second of each other, so 18947c478bd9Sstevel@tonic-gate * when deadman_enabled is off, deadman_panics will 18957c478bd9Sstevel@tonic-gate * typically be a multiple of the total number of CPUs in 18967c478bd9Sstevel@tonic-gate * the system. 18977c478bd9Sstevel@tonic-gate */ 18987c478bd9Sstevel@tonic-gate atomic_add_32(&deadman_panics, 1); 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate if (!deadman_enabled) { 19017c478bd9Sstevel@tonic-gate CPU->cpu_deadman_countdown = deadman_seconds; 19027c478bd9Sstevel@tonic-gate return; 19037c478bd9Sstevel@tonic-gate } 19047c478bd9Sstevel@tonic-gate 19057c478bd9Sstevel@tonic-gate /* 19067c478bd9Sstevel@tonic-gate * If we're here, we want to bring the system down. 19077c478bd9Sstevel@tonic-gate */ 19087c478bd9Sstevel@tonic-gate panic("deadman: timed out after %d seconds of clock " 19097c478bd9Sstevel@tonic-gate "inactivity", deadman_seconds); 19107c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 19117c478bd9Sstevel@tonic-gate } 19127c478bd9Sstevel@tonic-gate 19137c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19147c478bd9Sstevel@tonic-gate static void 19157c478bd9Sstevel@tonic-gate deadman_online(void *arg, cpu_t *cpu, cyc_handler_t *hdlr, cyc_time_t *when) 19167c478bd9Sstevel@tonic-gate { 19177c478bd9Sstevel@tonic-gate cpu->cpu_deadman_lbolt = 0; 19187c478bd9Sstevel@tonic-gate cpu->cpu_deadman_countdown = deadman_seconds; 19197c478bd9Sstevel@tonic-gate 19207c478bd9Sstevel@tonic-gate hdlr->cyh_func = (cyc_func_t)deadman; 19217c478bd9Sstevel@tonic-gate hdlr->cyh_level = CY_HIGH_LEVEL; 19227c478bd9Sstevel@tonic-gate hdlr->cyh_arg = NULL; 19237c478bd9Sstevel@tonic-gate 19247c478bd9Sstevel@tonic-gate /* 19257c478bd9Sstevel@tonic-gate * Stagger the CPUs so that they don't all run deadman() at 19267c478bd9Sstevel@tonic-gate * the same time. Simplest reason to do this is to make it 19277c478bd9Sstevel@tonic-gate * more likely that only one CPU will panic in case of a 19287c478bd9Sstevel@tonic-gate * timeout. This is (strictly speaking) an aesthetic, not a 19297c478bd9Sstevel@tonic-gate * technical consideration. 19307c478bd9Sstevel@tonic-gate * 19317c478bd9Sstevel@tonic-gate * The interval must be one second in accordance with the 19327c478bd9Sstevel@tonic-gate * code in deadman() above to increase lbolt during panic. 19337c478bd9Sstevel@tonic-gate */ 19347c478bd9Sstevel@tonic-gate when->cyt_when = cpu->cpu_id * (NANOSEC / NCPU); 19357c478bd9Sstevel@tonic-gate when->cyt_interval = NANOSEC; 19367c478bd9Sstevel@tonic-gate } 19377c478bd9Sstevel@tonic-gate 19387c478bd9Sstevel@tonic-gate 19397c478bd9Sstevel@tonic-gate void 19407c478bd9Sstevel@tonic-gate deadman_init(void) 19417c478bd9Sstevel@tonic-gate { 19427c478bd9Sstevel@tonic-gate cyc_omni_handler_t hdlr; 19437c478bd9Sstevel@tonic-gate 19447c478bd9Sstevel@tonic-gate if (deadman_seconds == 0) 19457c478bd9Sstevel@tonic-gate deadman_seconds = snoop_interval / MICROSEC; 19467c478bd9Sstevel@tonic-gate 19477c478bd9Sstevel@tonic-gate if (snooping) 19487c478bd9Sstevel@tonic-gate deadman_enabled = 1; 19497c478bd9Sstevel@tonic-gate 19507c478bd9Sstevel@tonic-gate hdlr.cyo_online = deadman_online; 19517c478bd9Sstevel@tonic-gate hdlr.cyo_offline = NULL; 19527c478bd9Sstevel@tonic-gate hdlr.cyo_arg = NULL; 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 19557c478bd9Sstevel@tonic-gate deadman_cyclic = cyclic_add_omni(&hdlr); 19567c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 19577c478bd9Sstevel@tonic-gate } 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate /* 19607c478bd9Sstevel@tonic-gate * tod_fault() is for updating tod validate mechanism state: 19617c478bd9Sstevel@tonic-gate * (1) TOD_NOFAULT: for resetting the state to 'normal'. 19627c478bd9Sstevel@tonic-gate * currently used for debugging only 19637c478bd9Sstevel@tonic-gate * (2) The following four cases detected by tod validate mechanism: 19647c478bd9Sstevel@tonic-gate * TOD_REVERSED: current tod value is less than previous value. 19657c478bd9Sstevel@tonic-gate * TOD_STALLED: current tod value hasn't advanced. 19667c478bd9Sstevel@tonic-gate * TOD_JUMPED: current tod value advanced too far from previous value. 19677c478bd9Sstevel@tonic-gate * TOD_RATECHANGED: the ratio between average tod delta and 19687c478bd9Sstevel@tonic-gate * average tick delta has changed. 19697c478bd9Sstevel@tonic-gate */ 19707c478bd9Sstevel@tonic-gate enum tod_fault_type 19717c478bd9Sstevel@tonic-gate tod_fault(enum tod_fault_type ftype, int off) 19727c478bd9Sstevel@tonic-gate { 19737c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&tod_lock)); 19747c478bd9Sstevel@tonic-gate 19757c478bd9Sstevel@tonic-gate if (tod_faulted != ftype) { 19767c478bd9Sstevel@tonic-gate switch (ftype) { 19777c478bd9Sstevel@tonic-gate case TOD_NOFAULT: 19787c478bd9Sstevel@tonic-gate plat_tod_fault(TOD_NOFAULT); 19797c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "Restarted tracking " 19807c478bd9Sstevel@tonic-gate "Time of Day clock."); 19817c478bd9Sstevel@tonic-gate tod_faulted = ftype; 19827c478bd9Sstevel@tonic-gate break; 19837c478bd9Sstevel@tonic-gate case TOD_REVERSED: 19847c478bd9Sstevel@tonic-gate case TOD_JUMPED: 19857c478bd9Sstevel@tonic-gate if (tod_faulted == TOD_NOFAULT) { 19867c478bd9Sstevel@tonic-gate plat_tod_fault(ftype); 19877c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Time of Day clock error: " 19887c478bd9Sstevel@tonic-gate "reason [%s by 0x%x]. -- " 19897c478bd9Sstevel@tonic-gate " Stopped tracking Time Of Day clock.", 19907c478bd9Sstevel@tonic-gate tod_fault_table[ftype], off); 19917c478bd9Sstevel@tonic-gate tod_faulted = ftype; 19927c478bd9Sstevel@tonic-gate } 19937c478bd9Sstevel@tonic-gate break; 19947c478bd9Sstevel@tonic-gate case TOD_STALLED: 19957c478bd9Sstevel@tonic-gate case TOD_RATECHANGED: 19967c478bd9Sstevel@tonic-gate if (tod_faulted == TOD_NOFAULT) { 19977c478bd9Sstevel@tonic-gate plat_tod_fault(ftype); 19987c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Time of Day clock error: " 19997c478bd9Sstevel@tonic-gate "reason [%s]. -- " 20007c478bd9Sstevel@tonic-gate " Stopped tracking Time Of Day clock.", 20017c478bd9Sstevel@tonic-gate tod_fault_table[ftype]); 20027c478bd9Sstevel@tonic-gate tod_faulted = ftype; 20037c478bd9Sstevel@tonic-gate } 20047c478bd9Sstevel@tonic-gate break; 20057c478bd9Sstevel@tonic-gate default: 20067c478bd9Sstevel@tonic-gate break; 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate } 20097c478bd9Sstevel@tonic-gate return (tod_faulted); 20107c478bd9Sstevel@tonic-gate } 20117c478bd9Sstevel@tonic-gate 20127c478bd9Sstevel@tonic-gate void 20137c478bd9Sstevel@tonic-gate tod_fault_reset() 20147c478bd9Sstevel@tonic-gate { 20157c478bd9Sstevel@tonic-gate tod_fault_reset_flag = 1; 20167c478bd9Sstevel@tonic-gate } 20177c478bd9Sstevel@tonic-gate 20187c478bd9Sstevel@tonic-gate 20197c478bd9Sstevel@tonic-gate /* 20207c478bd9Sstevel@tonic-gate * tod_validate() is used for checking values returned by tod_get(). 20217c478bd9Sstevel@tonic-gate * Four error cases can be detected by this routine: 20227c478bd9Sstevel@tonic-gate * TOD_REVERSED: current tod value is less than previous. 20237c478bd9Sstevel@tonic-gate * TOD_STALLED: current tod value hasn't advanced. 20247c478bd9Sstevel@tonic-gate * TOD_JUMPED: current tod value advanced too far from previous value. 20257c478bd9Sstevel@tonic-gate * TOD_RATECHANGED: the ratio between average tod delta and 20267c478bd9Sstevel@tonic-gate * average tick delta has changed. 20277c478bd9Sstevel@tonic-gate */ 20287c478bd9Sstevel@tonic-gate time_t 20297c478bd9Sstevel@tonic-gate tod_validate(time_t tod) 20307c478bd9Sstevel@tonic-gate { 20317c478bd9Sstevel@tonic-gate time_t diff_tod; 20327c478bd9Sstevel@tonic-gate hrtime_t diff_tick; 20337c478bd9Sstevel@tonic-gate 20347c478bd9Sstevel@tonic-gate long dtick; 20357c478bd9Sstevel@tonic-gate int dtick_delta; 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate int off = 0; 20387c478bd9Sstevel@tonic-gate enum tod_fault_type tod_bad = TOD_NOFAULT; 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate static int firsttime = 1; 20417c478bd9Sstevel@tonic-gate 20427c478bd9Sstevel@tonic-gate static time_t prev_tod = 0; 20437c478bd9Sstevel@tonic-gate static hrtime_t prev_tick = 0; 20447c478bd9Sstevel@tonic-gate static long dtick_avg = TOD_REF_FREQ; 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate hrtime_t tick = gethrtime(); 20477c478bd9Sstevel@tonic-gate 20487c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&tod_lock)); 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate /* 20517c478bd9Sstevel@tonic-gate * tod_validate_enable is patchable via /etc/system. 2052*2c891a87Ssethg * If TOD is already faulted, or if TOD validation is deferred, 2053*2c891a87Ssethg * there is nothing to do. 20547c478bd9Sstevel@tonic-gate */ 2055*2c891a87Ssethg if ((tod_validate_enable == 0) || (tod_faulted != TOD_NOFAULT) || 2056*2c891a87Ssethg tod_validate_deferred) { 20577c478bd9Sstevel@tonic-gate return (tod); 20587c478bd9Sstevel@tonic-gate } 20597c478bd9Sstevel@tonic-gate 20607c478bd9Sstevel@tonic-gate /* 20617c478bd9Sstevel@tonic-gate * Update prev_tod and prev_tick values for first run 20627c478bd9Sstevel@tonic-gate */ 20637c478bd9Sstevel@tonic-gate if (firsttime) { 20647c478bd9Sstevel@tonic-gate firsttime = 0; 20657c478bd9Sstevel@tonic-gate prev_tod = tod; 20667c478bd9Sstevel@tonic-gate prev_tick = tick; 20677c478bd9Sstevel@tonic-gate return (tod); 20687c478bd9Sstevel@tonic-gate } 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate /* 20717c478bd9Sstevel@tonic-gate * For either of these conditions, we need to reset ourself 20727c478bd9Sstevel@tonic-gate * and start validation from zero since each condition 20737c478bd9Sstevel@tonic-gate * indicates that the TOD will be updated with new value 20747c478bd9Sstevel@tonic-gate * Also, note that tod_needsync will be reset in clock() 20757c478bd9Sstevel@tonic-gate */ 20767c478bd9Sstevel@tonic-gate if (tod_needsync || tod_fault_reset_flag) { 20777c478bd9Sstevel@tonic-gate firsttime = 1; 20787c478bd9Sstevel@tonic-gate prev_tod = 0; 20797c478bd9Sstevel@tonic-gate prev_tick = 0; 20807c478bd9Sstevel@tonic-gate dtick_avg = TOD_REF_FREQ; 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate if (tod_fault_reset_flag) 20837c478bd9Sstevel@tonic-gate tod_fault_reset_flag = 0; 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate return (tod); 20867c478bd9Sstevel@tonic-gate } 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate /* test hook */ 20897c478bd9Sstevel@tonic-gate switch (tod_unit_test) { 20907c478bd9Sstevel@tonic-gate case 1: /* for testing jumping tod */ 20917c478bd9Sstevel@tonic-gate tod += tod_test_injector; 20927c478bd9Sstevel@tonic-gate tod_unit_test = 0; 20937c478bd9Sstevel@tonic-gate break; 20947c478bd9Sstevel@tonic-gate case 2: /* for testing stuck tod bit */ 20957c478bd9Sstevel@tonic-gate tod |= 1 << tod_test_injector; 20967c478bd9Sstevel@tonic-gate tod_unit_test = 0; 20977c478bd9Sstevel@tonic-gate break; 20987c478bd9Sstevel@tonic-gate case 3: /* for testing stalled tod */ 20997c478bd9Sstevel@tonic-gate tod = prev_tod; 21007c478bd9Sstevel@tonic-gate tod_unit_test = 0; 21017c478bd9Sstevel@tonic-gate break; 21027c478bd9Sstevel@tonic-gate case 4: /* reset tod fault status */ 21037c478bd9Sstevel@tonic-gate (void) tod_fault(TOD_NOFAULT, 0); 21047c478bd9Sstevel@tonic-gate tod_unit_test = 0; 21057c478bd9Sstevel@tonic-gate break; 21067c478bd9Sstevel@tonic-gate default: 21077c478bd9Sstevel@tonic-gate break; 21087c478bd9Sstevel@tonic-gate } 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate diff_tod = tod - prev_tod; 21117c478bd9Sstevel@tonic-gate diff_tick = tick - prev_tick; 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate ASSERT(diff_tick >= 0); 21147c478bd9Sstevel@tonic-gate 21157c478bd9Sstevel@tonic-gate if (diff_tod < 0) { 21167c478bd9Sstevel@tonic-gate /* ERROR - tod reversed */ 21177c478bd9Sstevel@tonic-gate tod_bad = TOD_REVERSED; 21187c478bd9Sstevel@tonic-gate off = (int)(prev_tod - tod); 21197c478bd9Sstevel@tonic-gate } else if (diff_tod == 0) { 21207c478bd9Sstevel@tonic-gate /* tod did not advance */ 21217c478bd9Sstevel@tonic-gate if (diff_tick > TOD_STALL_THRESHOLD) { 21227c478bd9Sstevel@tonic-gate /* ERROR - tod stalled */ 21237c478bd9Sstevel@tonic-gate tod_bad = TOD_STALLED; 21247c478bd9Sstevel@tonic-gate } else { 21257c478bd9Sstevel@tonic-gate /* 21267c478bd9Sstevel@tonic-gate * Make sure we don't update prev_tick 21277c478bd9Sstevel@tonic-gate * so that diff_tick is calculated since 21287c478bd9Sstevel@tonic-gate * the first diff_tod == 0 21297c478bd9Sstevel@tonic-gate */ 21307c478bd9Sstevel@tonic-gate return (tod); 21317c478bd9Sstevel@tonic-gate } 21327c478bd9Sstevel@tonic-gate } else { 21337c478bd9Sstevel@tonic-gate /* calculate dtick */ 21347c478bd9Sstevel@tonic-gate dtick = diff_tick / diff_tod; 21357c478bd9Sstevel@tonic-gate 21367c478bd9Sstevel@tonic-gate /* update dtick averages */ 21377c478bd9Sstevel@tonic-gate dtick_avg += ((dtick - dtick_avg) / TOD_FILTER_N); 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate /* 21407c478bd9Sstevel@tonic-gate * Calculate dtick_delta as 21417c478bd9Sstevel@tonic-gate * variation from reference freq in quartiles 21427c478bd9Sstevel@tonic-gate */ 21437c478bd9Sstevel@tonic-gate dtick_delta = (dtick_avg - TOD_REF_FREQ) / 21447c478bd9Sstevel@tonic-gate (TOD_REF_FREQ >> 2); 21457c478bd9Sstevel@tonic-gate 21467c478bd9Sstevel@tonic-gate /* 21477c478bd9Sstevel@tonic-gate * Even with a perfectly functioning TOD device, 21487c478bd9Sstevel@tonic-gate * when the number of elapsed seconds is low the 21497c478bd9Sstevel@tonic-gate * algorithm can calculate a rate that is beyond 21507c478bd9Sstevel@tonic-gate * tolerance, causing an error. The algorithm is 21517c478bd9Sstevel@tonic-gate * inaccurate when elapsed time is low (less than 21527c478bd9Sstevel@tonic-gate * 5 seconds). 21537c478bd9Sstevel@tonic-gate */ 21547c478bd9Sstevel@tonic-gate if (diff_tod > 4) { 21557c478bd9Sstevel@tonic-gate if (dtick < TOD_JUMP_THRESHOLD) { 21567c478bd9Sstevel@tonic-gate /* ERROR - tod jumped */ 21577c478bd9Sstevel@tonic-gate tod_bad = TOD_JUMPED; 21587c478bd9Sstevel@tonic-gate off = (int)diff_tod; 21597c478bd9Sstevel@tonic-gate } else if (dtick_delta) { 21607c478bd9Sstevel@tonic-gate /* ERROR - change in clock rate */ 21617c478bd9Sstevel@tonic-gate tod_bad = TOD_RATECHANGED; 21627c478bd9Sstevel@tonic-gate } 21637c478bd9Sstevel@tonic-gate } 21647c478bd9Sstevel@tonic-gate } 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate if (tod_bad != TOD_NOFAULT) { 21677c478bd9Sstevel@tonic-gate (void) tod_fault(tod_bad, off); 21687c478bd9Sstevel@tonic-gate 21697c478bd9Sstevel@tonic-gate /* 21707c478bd9Sstevel@tonic-gate * Disable dosynctodr since we are going to fault 21717c478bd9Sstevel@tonic-gate * the TOD chip anyway here 21727c478bd9Sstevel@tonic-gate */ 21737c478bd9Sstevel@tonic-gate dosynctodr = 0; 21747c478bd9Sstevel@tonic-gate 21757c478bd9Sstevel@tonic-gate /* 21767c478bd9Sstevel@tonic-gate * Set tod to the correct value from hrestime 21777c478bd9Sstevel@tonic-gate */ 21787c478bd9Sstevel@tonic-gate tod = hrestime.tv_sec; 21797c478bd9Sstevel@tonic-gate } 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate prev_tod = tod; 21827c478bd9Sstevel@tonic-gate prev_tick = tick; 21837c478bd9Sstevel@tonic-gate return (tod); 21847c478bd9Sstevel@tonic-gate } 21857c478bd9Sstevel@tonic-gate 21867c478bd9Sstevel@tonic-gate static void 21877c478bd9Sstevel@tonic-gate calcloadavg(int nrun, uint64_t *hp_ave) 21887c478bd9Sstevel@tonic-gate { 21897c478bd9Sstevel@tonic-gate static int64_t f[3] = { 135, 27, 9 }; 21907c478bd9Sstevel@tonic-gate uint_t i; 21917c478bd9Sstevel@tonic-gate int64_t q, r; 21927c478bd9Sstevel@tonic-gate 21937c478bd9Sstevel@tonic-gate /* 21947c478bd9Sstevel@tonic-gate * Compute load average over the last 1, 5, and 15 minutes 21957c478bd9Sstevel@tonic-gate * (60, 300, and 900 seconds). The constants in f[3] are for 21967c478bd9Sstevel@tonic-gate * exponential decay: 21977c478bd9Sstevel@tonic-gate * (1 - exp(-1/60)) << 13 = 135, 21987c478bd9Sstevel@tonic-gate * (1 - exp(-1/300)) << 13 = 27, 21997c478bd9Sstevel@tonic-gate * (1 - exp(-1/900)) << 13 = 9. 22007c478bd9Sstevel@tonic-gate */ 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate /* 22037c478bd9Sstevel@tonic-gate * a little hoop-jumping to avoid integer overflow 22047c478bd9Sstevel@tonic-gate */ 22057c478bd9Sstevel@tonic-gate for (i = 0; i < 3; i++) { 22067c478bd9Sstevel@tonic-gate q = (hp_ave[i] >> 16) << 7; 22077c478bd9Sstevel@tonic-gate r = (hp_ave[i] & 0xffff) << 7; 22087c478bd9Sstevel@tonic-gate hp_ave[i] += ((nrun - q) * f[i] - ((r * f[i]) >> 16)) >> 4; 22097c478bd9Sstevel@tonic-gate } 22107c478bd9Sstevel@tonic-gate } 2211