Currently, Application Processors (non-boot CPUs) are started by MD code at SI_SUB_CPU, but they are kept waiting in a "pen" until SI_SUB_SMP at which point they are released to run kernel threads. SI_SUB_SMP is one of the last SYSINIT levels, so APs don't enter the scheduler and start running threads until fairly late in the boot. This change moves SI_SUB_SMP up to just before software interrupt threads are created allowing the APs to start executing kernel threads much sooner (before any devices are probed). This allows several initialization routines that need to perform initialization on all CPUs to now perform that initialization in one step rather than having to defer the AP initialization to a second SYSINIT run at SI_SUB_SMP. It also permits all CPUs to be available for handling interrupts before any devices are probed. This last feature fixes a problem on with interrupt vector exhaustion. Specifically, in the old model all device interrupts were routed onto the boot CPU during boot. Later after the APs were released at SI_SUB_SMP, interrupts were redistributed across all CPUs. However, several drivers for multiqueue hardware allocate N interrupts per CPU in the system. In a system with many CPUs, just a few drivers doing this could exhaust the available pool of interrupt vectors on the boot CPU as each driver was allocating N * mp_ncpu vectors on the boot CPU. Now, drivers will allocate interrupts on their desired CPUs during boot meaning that only N interrupts are allocated from the boot CPU instead of N * mp_ncpu. Some other bits of code can also be simplified as smp_started is now true much earlier and will now always be true for these bits of code. This removes the need to treat the single-CPU boot environment as a special case. As a transition aid, the new behavior is available under a new kernel option (EARLY_AP_STARTUP). This will allow the option to be turned off if need be during initial testing. I plan to enable this on x86 by default in a followup commit in the next few days and to have all platforms moved over before 11.0. Once the transition is complete, the option will be removed along with the !EARLY_AP_STARTUP code. These changes have only been tested on x86. Other platform maintainers are encouraged to port their architectures over as well. The main things to check for are any uses of smp_started in MD code that can be simplified and SI_SUB_SMP SYSINITs in MD code that can be removed in the EARLY_AP_STARTUP case (e.g. the interrupt shuffling). PR: kern/199321 Reviewed by: markj, gnn, kib Sponsored by: Netflix
930 lines
23 KiB
C
930 lines
23 KiB
C
/*-
|
|
* Copyright (c) 1982, 1986, 1991, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
* (c) UNIX System Laboratories, Inc.
|
|
* All or some portions of this file are derived from material licensed
|
|
* to the University of California by American Telephone and Telegraph
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)kern_clock.c 8.5 (Berkeley) 1/21/94
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include "opt_kdb.h"
|
|
#include "opt_device_polling.h"
|
|
#include "opt_hwpmc_hooks.h"
|
|
#include "opt_ntp.h"
|
|
#include "opt_watchdog.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/callout.h>
|
|
#include <sys/kdb.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/kthread.h>
|
|
#include <sys/ktr.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/resourcevar.h>
|
|
#include <sys/sched.h>
|
|
#include <sys/sdt.h>
|
|
#include <sys/signalvar.h>
|
|
#include <sys/sleepqueue.h>
|
|
#include <sys/smp.h>
|
|
#include <vm/vm.h>
|
|
#include <vm/pmap.h>
|
|
#include <vm/vm_map.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/interrupt.h>
|
|
#include <sys/limits.h>
|
|
#include <sys/timetc.h>
|
|
|
|
#ifdef GPROF
|
|
#include <sys/gmon.h>
|
|
#endif
|
|
|
|
#ifdef HWPMC_HOOKS
|
|
#include <sys/pmckern.h>
|
|
PMC_SOFT_DEFINE( , , clock, hard);
|
|
PMC_SOFT_DEFINE( , , clock, stat);
|
|
PMC_SOFT_DEFINE_EX( , , clock, prof, \
|
|
cpu_startprofclock, cpu_stopprofclock);
|
|
#endif
|
|
|
|
#ifdef DEVICE_POLLING
|
|
extern void hardclock_device_poll(void);
|
|
#endif /* DEVICE_POLLING */
|
|
|
|
static void initclocks(void *dummy);
|
|
SYSINIT(clocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, initclocks, NULL);
|
|
|
|
/* Spin-lock protecting profiling statistics. */
|
|
static struct mtx time_lock;
|
|
|
|
SDT_PROVIDER_DECLARE(sched);
|
|
SDT_PROBE_DEFINE2(sched, , , tick, "struct thread *", "struct proc *");
|
|
|
|
static int
|
|
sysctl_kern_cp_time(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
int error;
|
|
long cp_time[CPUSTATES];
|
|
#ifdef SCTL_MASK32
|
|
int i;
|
|
unsigned int cp_time32[CPUSTATES];
|
|
#endif
|
|
|
|
read_cpu_time(cp_time);
|
|
#ifdef SCTL_MASK32
|
|
if (req->flags & SCTL_MASK32) {
|
|
if (!req->oldptr)
|
|
return SYSCTL_OUT(req, 0, sizeof(cp_time32));
|
|
for (i = 0; i < CPUSTATES; i++)
|
|
cp_time32[i] = (unsigned int)cp_time[i];
|
|
error = SYSCTL_OUT(req, cp_time32, sizeof(cp_time32));
|
|
} else
|
|
#endif
|
|
{
|
|
if (!req->oldptr)
|
|
return SYSCTL_OUT(req, 0, sizeof(cp_time));
|
|
error = SYSCTL_OUT(req, cp_time, sizeof(cp_time));
|
|
}
|
|
return error;
|
|
}
|
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, cp_time, CTLTYPE_LONG|CTLFLAG_RD|CTLFLAG_MPSAFE,
|
|
0,0, sysctl_kern_cp_time, "LU", "CPU time statistics");
|
|
|
|
static long empty[CPUSTATES];
|
|
|
|
static int
|
|
sysctl_kern_cp_times(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct pcpu *pcpu;
|
|
int error;
|
|
int c;
|
|
long *cp_time;
|
|
#ifdef SCTL_MASK32
|
|
unsigned int cp_time32[CPUSTATES];
|
|
int i;
|
|
#endif
|
|
|
|
if (!req->oldptr) {
|
|
#ifdef SCTL_MASK32
|
|
if (req->flags & SCTL_MASK32)
|
|
return SYSCTL_OUT(req, 0, sizeof(cp_time32) * (mp_maxid + 1));
|
|
else
|
|
#endif
|
|
return SYSCTL_OUT(req, 0, sizeof(long) * CPUSTATES * (mp_maxid + 1));
|
|
}
|
|
for (error = 0, c = 0; error == 0 && c <= mp_maxid; c++) {
|
|
if (!CPU_ABSENT(c)) {
|
|
pcpu = pcpu_find(c);
|
|
cp_time = pcpu->pc_cp_time;
|
|
} else {
|
|
cp_time = empty;
|
|
}
|
|
#ifdef SCTL_MASK32
|
|
if (req->flags & SCTL_MASK32) {
|
|
for (i = 0; i < CPUSTATES; i++)
|
|
cp_time32[i] = (unsigned int)cp_time[i];
|
|
error = SYSCTL_OUT(req, cp_time32, sizeof(cp_time32));
|
|
} else
|
|
#endif
|
|
error = SYSCTL_OUT(req, cp_time, sizeof(long) * CPUSTATES);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, cp_times, CTLTYPE_LONG|CTLFLAG_RD|CTLFLAG_MPSAFE,
|
|
0,0, sysctl_kern_cp_times, "LU", "per-CPU time statistics");
|
|
|
|
#ifdef DEADLKRES
|
|
static const char *blessed[] = {
|
|
"getblk",
|
|
"so_snd_sx",
|
|
"so_rcv_sx",
|
|
NULL
|
|
};
|
|
static int slptime_threshold = 1800;
|
|
static int blktime_threshold = 900;
|
|
static int sleepfreq = 3;
|
|
|
|
static void
|
|
deadlkres(void)
|
|
{
|
|
struct proc *p;
|
|
struct thread *td;
|
|
void *wchan;
|
|
int blkticks, i, slpticks, slptype, tryl, tticks;
|
|
|
|
tryl = 0;
|
|
for (;;) {
|
|
blkticks = blktime_threshold * hz;
|
|
slpticks = slptime_threshold * hz;
|
|
|
|
/*
|
|
* Avoid to sleep on the sx_lock in order to avoid a possible
|
|
* priority inversion problem leading to starvation.
|
|
* If the lock can't be held after 100 tries, panic.
|
|
*/
|
|
if (!sx_try_slock(&allproc_lock)) {
|
|
if (tryl > 100)
|
|
panic("%s: possible deadlock detected on allproc_lock\n",
|
|
__func__);
|
|
tryl++;
|
|
pause("allproc", sleepfreq * hz);
|
|
continue;
|
|
}
|
|
tryl = 0;
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
|
PROC_LOCK(p);
|
|
if (p->p_state == PRS_NEW) {
|
|
PROC_UNLOCK(p);
|
|
continue;
|
|
}
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
|
|
|
thread_lock(td);
|
|
if (TD_ON_LOCK(td)) {
|
|
|
|
/*
|
|
* The thread should be blocked on a
|
|
* turnstile, simply check if the
|
|
* turnstile channel is in good state.
|
|
*/
|
|
MPASS(td->td_blocked != NULL);
|
|
|
|
tticks = ticks - td->td_blktick;
|
|
thread_unlock(td);
|
|
if (tticks > blkticks) {
|
|
|
|
/*
|
|
* Accordingly with provided
|
|
* thresholds, this thread is
|
|
* stuck for too long on a
|
|
* turnstile.
|
|
*/
|
|
PROC_UNLOCK(p);
|
|
sx_sunlock(&allproc_lock);
|
|
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
|
|
__func__, td, tticks);
|
|
}
|
|
} else if (TD_IS_SLEEPING(td) &&
|
|
TD_ON_SLEEPQ(td)) {
|
|
|
|
/*
|
|
* Check if the thread is sleeping on a
|
|
* lock, otherwise skip the check.
|
|
* Drop the thread lock in order to
|
|
* avoid a LOR with the sleepqueue
|
|
* spinlock.
|
|
*/
|
|
wchan = td->td_wchan;
|
|
tticks = ticks - td->td_slptick;
|
|
thread_unlock(td);
|
|
slptype = sleepq_type(wchan);
|
|
if ((slptype == SLEEPQ_SX ||
|
|
slptype == SLEEPQ_LK) &&
|
|
tticks > slpticks) {
|
|
|
|
/*
|
|
* Accordingly with provided
|
|
* thresholds, this thread is
|
|
* stuck for too long on a
|
|
* sleepqueue.
|
|
* However, being on a
|
|
* sleepqueue, we might still
|
|
* check for the blessed
|
|
* list.
|
|
*/
|
|
tryl = 0;
|
|
for (i = 0; blessed[i] != NULL;
|
|
i++) {
|
|
if (!strcmp(blessed[i],
|
|
td->td_wmesg)) {
|
|
tryl = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (tryl != 0) {
|
|
tryl = 0;
|
|
continue;
|
|
}
|
|
PROC_UNLOCK(p);
|
|
sx_sunlock(&allproc_lock);
|
|
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
|
|
__func__, td, tticks);
|
|
}
|
|
} else
|
|
thread_unlock(td);
|
|
}
|
|
PROC_UNLOCK(p);
|
|
}
|
|
sx_sunlock(&allproc_lock);
|
|
|
|
/* Sleep for sleepfreq seconds. */
|
|
pause("-", sleepfreq * hz);
|
|
}
|
|
}
|
|
|
|
static struct kthread_desc deadlkres_kd = {
|
|
"deadlkres",
|
|
deadlkres,
|
|
(struct thread **)NULL
|
|
};
|
|
|
|
SYSINIT(deadlkres, SI_SUB_CLOCKS, SI_ORDER_ANY, kthread_start, &deadlkres_kd);
|
|
|
|
static SYSCTL_NODE(_debug, OID_AUTO, deadlkres, CTLFLAG_RW, 0,
|
|
"Deadlock resolver");
|
|
SYSCTL_INT(_debug_deadlkres, OID_AUTO, slptime_threshold, CTLFLAG_RW,
|
|
&slptime_threshold, 0,
|
|
"Number of seconds within is valid to sleep on a sleepqueue");
|
|
SYSCTL_INT(_debug_deadlkres, OID_AUTO, blktime_threshold, CTLFLAG_RW,
|
|
&blktime_threshold, 0,
|
|
"Number of seconds within is valid to block on a turnstile");
|
|
SYSCTL_INT(_debug_deadlkres, OID_AUTO, sleepfreq, CTLFLAG_RW, &sleepfreq, 0,
|
|
"Number of seconds between any deadlock resolver thread run");
|
|
#endif /* DEADLKRES */
|
|
|
|
void
|
|
read_cpu_time(long *cp_time)
|
|
{
|
|
struct pcpu *pc;
|
|
int i, j;
|
|
|
|
/* Sum up global cp_time[]. */
|
|
bzero(cp_time, sizeof(long) * CPUSTATES);
|
|
CPU_FOREACH(i) {
|
|
pc = pcpu_find(i);
|
|
for (j = 0; j < CPUSTATES; j++)
|
|
cp_time[j] += pc->pc_cp_time[j];
|
|
}
|
|
}
|
|
|
|
#ifdef SW_WATCHDOG
|
|
#include <sys/watchdog.h>
|
|
|
|
static int watchdog_ticks;
|
|
static int watchdog_enabled;
|
|
static void watchdog_fire(void);
|
|
static void watchdog_config(void *, u_int, int *);
|
|
#endif /* SW_WATCHDOG */
|
|
|
|
/*
|
|
* Clock handling routines.
|
|
*
|
|
* This code is written to operate with two timers that run independently of
|
|
* each other.
|
|
*
|
|
* The main timer, running hz times per second, is used to trigger interval
|
|
* timers, timeouts and rescheduling as needed.
|
|
*
|
|
* The second timer handles kernel and user profiling,
|
|
* and does resource use estimation. If the second timer is programmable,
|
|
* it is randomized to avoid aliasing between the two clocks. For example,
|
|
* the randomization prevents an adversary from always giving up the cpu
|
|
* just before its quantum expires. Otherwise, it would never accumulate
|
|
* cpu ticks. The mean frequency of the second timer is stathz.
|
|
*
|
|
* If no second timer exists, stathz will be zero; in this case we drive
|
|
* profiling and statistics off the main clock. This WILL NOT be accurate;
|
|
* do not do it unless absolutely necessary.
|
|
*
|
|
* The statistics clock may (or may not) be run at a higher rate while
|
|
* profiling. This profile clock runs at profhz. We require that profhz
|
|
* be an integral multiple of stathz.
|
|
*
|
|
* If the statistics clock is running fast, it must be divided by the ratio
|
|
* profhz/stathz for statistics. (For profiling, every tick counts.)
|
|
*
|
|
* Time-of-day is maintained using a "timecounter", which may or may
|
|
* not be related to the hardware generating the above mentioned
|
|
* interrupts.
|
|
*/
|
|
|
|
int stathz;
|
|
int profhz;
|
|
int profprocs;
|
|
volatile int ticks;
|
|
int psratio;
|
|
|
|
static DPCPU_DEFINE(int, pcputicks); /* Per-CPU version of ticks. */
|
|
static int global_hardclock_run = 0;
|
|
|
|
/*
|
|
* Initialize clock frequencies and start both clocks running.
|
|
*/
|
|
/* ARGSUSED*/
|
|
static void
|
|
initclocks(dummy)
|
|
void *dummy;
|
|
{
|
|
#ifdef EARLY_AP_STARTUP
|
|
struct proc *p;
|
|
struct thread *td;
|
|
#endif
|
|
register int i;
|
|
|
|
/*
|
|
* Set divisors to 1 (normal case) and let the machine-specific
|
|
* code do its bit.
|
|
*/
|
|
mtx_init(&time_lock, "time lock", NULL, MTX_DEF);
|
|
cpu_initclocks();
|
|
|
|
/*
|
|
* Compute profhz/stathz, and fix profhz if needed.
|
|
*/
|
|
i = stathz ? stathz : hz;
|
|
if (profhz == 0)
|
|
profhz = i;
|
|
psratio = profhz / i;
|
|
#ifdef SW_WATCHDOG
|
|
EVENTHANDLER_REGISTER(watchdog_list, watchdog_config, NULL, 0);
|
|
#endif
|
|
/*
|
|
* Arrange for ticks to wrap 10 minutes after boot to help catch
|
|
* sign problems sooner.
|
|
*/
|
|
ticks = INT_MAX - (hz * 10 * 60);
|
|
|
|
#ifdef EARLY_AP_STARTUP
|
|
/*
|
|
* Fixup the tick counts in any blocked or sleeping threads to
|
|
* account for the jump above.
|
|
*/
|
|
sx_slock(&allproc_lock);
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
|
PROC_LOCK(p);
|
|
if (p->p_state == PRS_NEW) {
|
|
PROC_UNLOCK(p);
|
|
continue;
|
|
}
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
|
thread_lock(td);
|
|
if (TD_ON_LOCK(td)) {
|
|
MPASS(td->td_blktick == 0);
|
|
td->td_blktick = ticks;
|
|
}
|
|
if (TD_ON_SLEEPQ(td)) {
|
|
MPASS(td->td_slptick == 0);
|
|
td->td_slptick = ticks;
|
|
}
|
|
thread_unlock(td);
|
|
}
|
|
PROC_UNLOCK(p);
|
|
}
|
|
sx_sunlock(&allproc_lock);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Each time the real-time timer fires, this function is called on all CPUs.
|
|
* Note that hardclock() calls hardclock_cpu() for the boot CPU, so only
|
|
* the other CPUs in the system need to call this function.
|
|
*/
|
|
void
|
|
hardclock_cpu(int usermode)
|
|
{
|
|
struct pstats *pstats;
|
|
struct thread *td = curthread;
|
|
struct proc *p = td->td_proc;
|
|
int flags;
|
|
|
|
/*
|
|
* Run current process's virtual and profile time, as needed.
|
|
*/
|
|
pstats = p->p_stats;
|
|
flags = 0;
|
|
if (usermode &&
|
|
timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value)) {
|
|
PROC_ITIMLOCK(p);
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0)
|
|
flags |= TDF_ALRMPEND | TDF_ASTPENDING;
|
|
PROC_ITIMUNLOCK(p);
|
|
}
|
|
if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
|
|
PROC_ITIMLOCK(p);
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0)
|
|
flags |= TDF_PROFPEND | TDF_ASTPENDING;
|
|
PROC_ITIMUNLOCK(p);
|
|
}
|
|
thread_lock(td);
|
|
td->td_flags |= flags;
|
|
thread_unlock(td);
|
|
|
|
#ifdef HWPMC_HOOKS
|
|
if (PMC_CPU_HAS_SAMPLES(PCPU_GET(cpuid)))
|
|
PMC_CALL_HOOK_UNLOCKED(curthread, PMC_FN_DO_SAMPLES, NULL);
|
|
if (td->td_intr_frame != NULL)
|
|
PMC_SOFT_CALL_TF( , , clock, hard, td->td_intr_frame);
|
|
#endif
|
|
callout_process(sbinuptime());
|
|
}
|
|
|
|
/*
|
|
* The real-time timer, interrupting hz times per second.
|
|
*/
|
|
void
|
|
hardclock(int usermode, uintfptr_t pc)
|
|
{
|
|
|
|
atomic_add_int(&ticks, 1);
|
|
hardclock_cpu(usermode);
|
|
tc_ticktock(1);
|
|
cpu_tick_calibration();
|
|
/*
|
|
* If no separate statistics clock is available, run it from here.
|
|
*
|
|
* XXX: this only works for UP
|
|
*/
|
|
if (stathz == 0) {
|
|
profclock(usermode, pc);
|
|
statclock(usermode);
|
|
}
|
|
#ifdef DEVICE_POLLING
|
|
hardclock_device_poll(); /* this is very short and quick */
|
|
#endif /* DEVICE_POLLING */
|
|
#ifdef SW_WATCHDOG
|
|
if (watchdog_enabled > 0 && --watchdog_ticks <= 0)
|
|
watchdog_fire();
|
|
#endif /* SW_WATCHDOG */
|
|
}
|
|
|
|
void
|
|
hardclock_cnt(int cnt, int usermode)
|
|
{
|
|
struct pstats *pstats;
|
|
struct thread *td = curthread;
|
|
struct proc *p = td->td_proc;
|
|
int *t = DPCPU_PTR(pcputicks);
|
|
int flags, global, newticks;
|
|
#ifdef SW_WATCHDOG
|
|
int i;
|
|
#endif /* SW_WATCHDOG */
|
|
|
|
/*
|
|
* Update per-CPU and possibly global ticks values.
|
|
*/
|
|
*t += cnt;
|
|
do {
|
|
global = ticks;
|
|
newticks = *t - global;
|
|
if (newticks <= 0) {
|
|
if (newticks < -1)
|
|
*t = global - 1;
|
|
newticks = 0;
|
|
break;
|
|
}
|
|
} while (!atomic_cmpset_int(&ticks, global, *t));
|
|
|
|
/*
|
|
* Run current process's virtual and profile time, as needed.
|
|
*/
|
|
pstats = p->p_stats;
|
|
flags = 0;
|
|
if (usermode &&
|
|
timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value)) {
|
|
PROC_ITIMLOCK(p);
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL],
|
|
tick * cnt) == 0)
|
|
flags |= TDF_ALRMPEND | TDF_ASTPENDING;
|
|
PROC_ITIMUNLOCK(p);
|
|
}
|
|
if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
|
|
PROC_ITIMLOCK(p);
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_PROF],
|
|
tick * cnt) == 0)
|
|
flags |= TDF_PROFPEND | TDF_ASTPENDING;
|
|
PROC_ITIMUNLOCK(p);
|
|
}
|
|
thread_lock(td);
|
|
td->td_flags |= flags;
|
|
thread_unlock(td);
|
|
|
|
#ifdef HWPMC_HOOKS
|
|
if (PMC_CPU_HAS_SAMPLES(PCPU_GET(cpuid)))
|
|
PMC_CALL_HOOK_UNLOCKED(curthread, PMC_FN_DO_SAMPLES, NULL);
|
|
if (td->td_intr_frame != NULL)
|
|
PMC_SOFT_CALL_TF( , , clock, hard, td->td_intr_frame);
|
|
#endif
|
|
/* We are in charge to handle this tick duty. */
|
|
if (newticks > 0) {
|
|
/* Dangerous and no need to call these things concurrently. */
|
|
if (atomic_cmpset_acq_int(&global_hardclock_run, 0, 1)) {
|
|
tc_ticktock(newticks);
|
|
#ifdef DEVICE_POLLING
|
|
/* This is very short and quick. */
|
|
hardclock_device_poll();
|
|
#endif /* DEVICE_POLLING */
|
|
atomic_store_rel_int(&global_hardclock_run, 0);
|
|
}
|
|
#ifdef SW_WATCHDOG
|
|
if (watchdog_enabled > 0) {
|
|
i = atomic_fetchadd_int(&watchdog_ticks, -newticks);
|
|
if (i > 0 && i <= newticks)
|
|
watchdog_fire();
|
|
}
|
|
#endif /* SW_WATCHDOG */
|
|
}
|
|
if (curcpu == CPU_FIRST())
|
|
cpu_tick_calibration();
|
|
}
|
|
|
|
void
|
|
hardclock_sync(int cpu)
|
|
{
|
|
int *t = DPCPU_ID_PTR(cpu, pcputicks);
|
|
|
|
*t = ticks;
|
|
}
|
|
|
|
/*
|
|
* Compute number of ticks in the specified amount of time.
|
|
*/
|
|
int
|
|
tvtohz(tv)
|
|
struct timeval *tv;
|
|
{
|
|
register unsigned long ticks;
|
|
register long sec, usec;
|
|
|
|
/*
|
|
* If the number of usecs in the whole seconds part of the time
|
|
* difference fits in a long, then the total number of usecs will
|
|
* fit in an unsigned long. Compute the total and convert it to
|
|
* ticks, rounding up and adding 1 to allow for the current tick
|
|
* to expire. Rounding also depends on unsigned long arithmetic
|
|
* to avoid overflow.
|
|
*
|
|
* Otherwise, if the number of ticks in the whole seconds part of
|
|
* the time difference fits in a long, then convert the parts to
|
|
* ticks separately and add, using similar rounding methods and
|
|
* overflow avoidance. This method would work in the previous
|
|
* case but it is slightly slower and assumes that hz is integral.
|
|
*
|
|
* Otherwise, round the time difference down to the maximum
|
|
* representable value.
|
|
*
|
|
* If ints have 32 bits, then the maximum value for any timeout in
|
|
* 10ms ticks is 248 days.
|
|
*/
|
|
sec = tv->tv_sec;
|
|
usec = tv->tv_usec;
|
|
if (usec < 0) {
|
|
sec--;
|
|
usec += 1000000;
|
|
}
|
|
if (sec < 0) {
|
|
#ifdef DIAGNOSTIC
|
|
if (usec > 0) {
|
|
sec++;
|
|
usec -= 1000000;
|
|
}
|
|
printf("tvotohz: negative time difference %ld sec %ld usec\n",
|
|
sec, usec);
|
|
#endif
|
|
ticks = 1;
|
|
} else if (sec <= LONG_MAX / 1000000)
|
|
ticks = howmany(sec * 1000000 + (unsigned long)usec, tick) + 1;
|
|
else if (sec <= LONG_MAX / hz)
|
|
ticks = sec * hz
|
|
+ howmany((unsigned long)usec, tick) + 1;
|
|
else
|
|
ticks = LONG_MAX;
|
|
if (ticks > INT_MAX)
|
|
ticks = INT_MAX;
|
|
return ((int)ticks);
|
|
}
|
|
|
|
/*
|
|
* Start profiling on a process.
|
|
*
|
|
* Kernel profiling passes proc0 which never exits and hence
|
|
* keeps the profile clock running constantly.
|
|
*/
|
|
void
|
|
startprofclock(p)
|
|
register struct proc *p;
|
|
{
|
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
if (p->p_flag & P_STOPPROF)
|
|
return;
|
|
if ((p->p_flag & P_PROFIL) == 0) {
|
|
p->p_flag |= P_PROFIL;
|
|
mtx_lock(&time_lock);
|
|
if (++profprocs == 1)
|
|
cpu_startprofclock();
|
|
mtx_unlock(&time_lock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Stop profiling on a process.
|
|
*/
|
|
void
|
|
stopprofclock(p)
|
|
register struct proc *p;
|
|
{
|
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
if (p->p_flag & P_PROFIL) {
|
|
if (p->p_profthreads != 0) {
|
|
while (p->p_profthreads != 0) {
|
|
p->p_flag |= P_STOPPROF;
|
|
msleep(&p->p_profthreads, &p->p_mtx, PPAUSE,
|
|
"stopprof", 0);
|
|
}
|
|
}
|
|
if ((p->p_flag & P_PROFIL) == 0)
|
|
return;
|
|
p->p_flag &= ~P_PROFIL;
|
|
mtx_lock(&time_lock);
|
|
if (--profprocs == 0)
|
|
cpu_stopprofclock();
|
|
mtx_unlock(&time_lock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Statistics clock. Updates rusage information and calls the scheduler
|
|
* to adjust priorities of the active thread.
|
|
*
|
|
* This should be called by all active processors.
|
|
*/
|
|
void
|
|
statclock(int usermode)
|
|
{
|
|
|
|
statclock_cnt(1, usermode);
|
|
}
|
|
|
|
void
|
|
statclock_cnt(int cnt, int usermode)
|
|
{
|
|
struct rusage *ru;
|
|
struct vmspace *vm;
|
|
struct thread *td;
|
|
struct proc *p;
|
|
long rss;
|
|
long *cp_time;
|
|
|
|
td = curthread;
|
|
p = td->td_proc;
|
|
|
|
cp_time = (long *)PCPU_PTR(cp_time);
|
|
if (usermode) {
|
|
/*
|
|
* Charge the time as appropriate.
|
|
*/
|
|
td->td_uticks += cnt;
|
|
if (p->p_nice > NZERO)
|
|
cp_time[CP_NICE] += cnt;
|
|
else
|
|
cp_time[CP_USER] += cnt;
|
|
} else {
|
|
/*
|
|
* Came from kernel mode, so we were:
|
|
* - handling an interrupt,
|
|
* - doing syscall or trap work on behalf of the current
|
|
* user process, or
|
|
* - spinning in the idle loop.
|
|
* Whichever it is, charge the time as appropriate.
|
|
* Note that we charge interrupts to the current process,
|
|
* regardless of whether they are ``for'' that process,
|
|
* so that we know how much of its real time was spent
|
|
* in ``non-process'' (i.e., interrupt) work.
|
|
*/
|
|
if ((td->td_pflags & TDP_ITHREAD) ||
|
|
td->td_intr_nesting_level >= 2) {
|
|
td->td_iticks += cnt;
|
|
cp_time[CP_INTR] += cnt;
|
|
} else {
|
|
td->td_pticks += cnt;
|
|
td->td_sticks += cnt;
|
|
if (!TD_IS_IDLETHREAD(td))
|
|
cp_time[CP_SYS] += cnt;
|
|
else
|
|
cp_time[CP_IDLE] += cnt;
|
|
}
|
|
}
|
|
|
|
/* Update resource usage integrals and maximums. */
|
|
MPASS(p->p_vmspace != NULL);
|
|
vm = p->p_vmspace;
|
|
ru = &td->td_ru;
|
|
ru->ru_ixrss += pgtok(vm->vm_tsize) * cnt;
|
|
ru->ru_idrss += pgtok(vm->vm_dsize) * cnt;
|
|
ru->ru_isrss += pgtok(vm->vm_ssize) * cnt;
|
|
rss = pgtok(vmspace_resident_count(vm));
|
|
if (ru->ru_maxrss < rss)
|
|
ru->ru_maxrss = rss;
|
|
KTR_POINT2(KTR_SCHED, "thread", sched_tdname(td), "statclock",
|
|
"prio:%d", td->td_priority, "stathz:%d", (stathz)?stathz:hz);
|
|
SDT_PROBE2(sched, , , tick, td, td->td_proc);
|
|
thread_lock_flags(td, MTX_QUIET);
|
|
for ( ; cnt > 0; cnt--)
|
|
sched_clock(td);
|
|
thread_unlock(td);
|
|
#ifdef HWPMC_HOOKS
|
|
if (td->td_intr_frame != NULL)
|
|
PMC_SOFT_CALL_TF( , , clock, stat, td->td_intr_frame);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
profclock(int usermode, uintfptr_t pc)
|
|
{
|
|
|
|
profclock_cnt(1, usermode, pc);
|
|
}
|
|
|
|
void
|
|
profclock_cnt(int cnt, int usermode, uintfptr_t pc)
|
|
{
|
|
struct thread *td;
|
|
#ifdef GPROF
|
|
struct gmonparam *g;
|
|
uintfptr_t i;
|
|
#endif
|
|
|
|
td = curthread;
|
|
if (usermode) {
|
|
/*
|
|
* Came from user mode; CPU was in user state.
|
|
* If this process is being profiled, record the tick.
|
|
* if there is no related user location yet, don't
|
|
* bother trying to count it.
|
|
*/
|
|
if (td->td_proc->p_flag & P_PROFIL)
|
|
addupc_intr(td, pc, cnt);
|
|
}
|
|
#ifdef GPROF
|
|
else {
|
|
/*
|
|
* Kernel statistics are just like addupc_intr, only easier.
|
|
*/
|
|
g = &_gmonparam;
|
|
if (g->state == GMON_PROF_ON && pc >= g->lowpc) {
|
|
i = PC_TO_I(g, pc);
|
|
if (i < g->textsize) {
|
|
KCOUNT(g, i) += cnt;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef HWPMC_HOOKS
|
|
if (td->td_intr_frame != NULL)
|
|
PMC_SOFT_CALL_TF( , , clock, prof, td->td_intr_frame);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Return information about system clocks.
|
|
*/
|
|
static int
|
|
sysctl_kern_clockrate(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct clockinfo clkinfo;
|
|
/*
|
|
* Construct clockinfo structure.
|
|
*/
|
|
bzero(&clkinfo, sizeof(clkinfo));
|
|
clkinfo.hz = hz;
|
|
clkinfo.tick = tick;
|
|
clkinfo.profhz = profhz;
|
|
clkinfo.stathz = stathz ? stathz : hz;
|
|
return (sysctl_handle_opaque(oidp, &clkinfo, sizeof clkinfo, req));
|
|
}
|
|
|
|
SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate,
|
|
CTLTYPE_STRUCT|CTLFLAG_RD|CTLFLAG_MPSAFE,
|
|
0, 0, sysctl_kern_clockrate, "S,clockinfo",
|
|
"Rate and period of various kernel clocks");
|
|
|
|
#ifdef SW_WATCHDOG
|
|
|
|
static void
|
|
watchdog_config(void *unused __unused, u_int cmd, int *error)
|
|
{
|
|
u_int u;
|
|
|
|
u = cmd & WD_INTERVAL;
|
|
if (u >= WD_TO_1SEC) {
|
|
watchdog_ticks = (1 << (u - WD_TO_1SEC)) * hz;
|
|
watchdog_enabled = 1;
|
|
*error = 0;
|
|
} else {
|
|
watchdog_enabled = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Handle a watchdog timeout by dumping interrupt information and
|
|
* then either dropping to DDB or panicking.
|
|
*/
|
|
static void
|
|
watchdog_fire(void)
|
|
{
|
|
int nintr;
|
|
uint64_t inttotal;
|
|
u_long *curintr;
|
|
char *curname;
|
|
|
|
curintr = intrcnt;
|
|
curname = intrnames;
|
|
inttotal = 0;
|
|
nintr = sintrcnt / sizeof(u_long);
|
|
|
|
printf("interrupt total\n");
|
|
while (--nintr >= 0) {
|
|
if (*curintr)
|
|
printf("%-12s %20lu\n", curname, *curintr);
|
|
curname += strlen(curname) + 1;
|
|
inttotal += *curintr++;
|
|
}
|
|
printf("Total %20ju\n", (uintmax_t)inttotal);
|
|
|
|
#if defined(KDB) && !defined(KDB_UNATTENDED)
|
|
kdb_backtrace();
|
|
kdb_enter(KDB_WHY_WATCHDOG, "watchdog timeout");
|
|
#else
|
|
panic("watchdog timeout");
|
|
#endif
|
|
}
|
|
|
|
#endif /* SW_WATCHDOG */
|