1994-05-24 10:09:53 +00:00
|
|
|
/*-
|
2017-11-20 19:43:44 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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.
|
2016-09-15 13:16:20 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2007-05-28 21:50:54 +00:00
|
|
|
#include "opt_kdb.h"
|
2005-10-05 10:09:17 +00:00
|
|
|
#include "opt_device_polling.h"
|
2005-06-24 00:16:57 +00:00
|
|
|
#include "opt_hwpmc_hooks.h"
|
1999-03-11 15:09:51 +00:00
|
|
|
#include "opt_ntp.h"
|
2003-06-26 09:50:52 +00:00
|
|
|
#include "opt_watchdog.h"
|
1999-03-11 15:09:51 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/callout.h>
|
2004-07-10 21:36:01 +00:00
|
|
|
#include <sys/kdb.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
2010-01-09 01:46:38 +00:00
|
|
|
#include <sys/kthread.h>
|
2001-10-11 17:53:43 +00:00
|
|
|
#include <sys/ktr.h>
|
2010-01-09 01:46:38 +00:00
|
|
|
#include <sys/lock.h>
|
2000-10-20 07:58:15 +00:00
|
|
|
#include <sys/mutex.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/proc.h>
|
2003-02-17 02:19:58 +00:00
|
|
|
#include <sys/resource.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/resourcevar.h>
|
2002-10-12 05:32:24 +00:00
|
|
|
#include <sys/sched.h>
|
2012-05-15 01:30:25 +00:00
|
|
|
#include <sys/sdt.h>
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/signalvar.h>
|
2010-01-09 01:46:38 +00:00
|
|
|
#include <sys/sleepqueue.h>
|
2001-04-27 19:28:25 +00:00
|
|
|
#include <sys/smp.h>
|
1994-08-27 16:14:39 +00:00
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/sysctl.h>
|
2000-10-25 05:19:40 +00:00
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/interrupt.h>
|
2003-04-29 13:36:06 +00:00
|
|
|
#include <sys/limits.h>
|
2002-09-04 10:15:19 +00:00
|
|
|
#include <sys/timetc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#ifdef GPROF
|
|
|
|
#include <sys/gmon.h>
|
|
|
|
#endif
|
|
|
|
|
2005-05-30 06:29:29 +00:00
|
|
|
#ifdef HWPMC_HOOKS
|
|
|
|
#include <sys/pmckern.h>
|
2012-03-28 20:58:30 +00:00
|
|
|
PMC_SOFT_DEFINE( , , clock, hard);
|
|
|
|
PMC_SOFT_DEFINE( , , clock, stat);
|
2013-03-05 10:18:48 +00:00
|
|
|
PMC_SOFT_DEFINE_EX( , , clock, prof, \
|
|
|
|
cpu_startprofclock, cpu_stopprofclock);
|
2005-05-30 06:29:29 +00:00
|
|
|
#endif
|
|
|
|
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
extern void hardclock_device_poll(void);
|
|
|
|
#endif /* DEVICE_POLLING */
|
1997-12-08 23:00:24 +00:00
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static void initclocks(void *dummy);
|
2008-03-16 10:58:09 +00:00
|
|
|
SYSINIT(clocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, initclocks, NULL);
|
1995-08-28 09:19:25 +00:00
|
|
|
|
2007-05-20 22:11:50 +00:00
|
|
|
/* Spin-lock protecting profiling statistics. */
|
2007-06-09 19:41:14 +00:00
|
|
|
static struct mtx time_lock;
|
2007-05-20 22:11:50 +00:00
|
|
|
|
2012-05-15 01:30:25 +00:00
|
|
|
SDT_PROVIDER_DECLARE(sched);
|
2013-11-26 08:46:27 +00:00
|
|
|
SDT_PROBE_DEFINE2(sched, , , tick, "struct thread *", "struct proc *");
|
2012-05-15 01:30:25 +00:00
|
|
|
|
2005-06-30 07:49:22 +00:00
|
|
|
static int
|
|
|
|
sysctl_kern_cp_time(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error;
|
2007-11-29 06:34:30 +00:00
|
|
|
long cp_time[CPUSTATES];
|
2005-06-30 17:17:29 +00:00
|
|
|
#ifdef SCTL_MASK32
|
2005-06-30 07:49:22 +00:00
|
|
|
int i;
|
|
|
|
unsigned int cp_time32[CPUSTATES];
|
2007-11-29 06:34:30 +00:00
|
|
|
#endif
|
2006-04-17 20:14:51 +00:00
|
|
|
|
2007-11-29 06:34:30 +00:00
|
|
|
read_cpu_time(cp_time);
|
|
|
|
#ifdef SCTL_MASK32
|
2005-06-30 17:17:29 +00:00
|
|
|
if (req->flags & SCTL_MASK32) {
|
2005-06-30 07:49:22 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-05-18 12:03:43 +00:00
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, cp_time, CTLTYPE_LONG|CTLFLAG_RD|CTLFLAG_MPSAFE,
|
2005-06-30 07:49:22 +00:00
|
|
|
0,0, sysctl_kern_cp_time, "LU", "CPU time statistics");
|
2000-11-20 00:44:58 +00:00
|
|
|
|
2007-11-29 06:34:30 +00:00
|
|
|
static long empty[CPUSTATES];
|
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_kern_cp_times(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct pcpu *pcpu;
|
|
|
|
int error;
|
2007-11-29 08:38:22 +00:00
|
|
|
int c;
|
2007-11-29 06:34:30 +00:00
|
|
|
long *cp_time;
|
|
|
|
#ifdef SCTL_MASK32
|
|
|
|
unsigned int cp_time32[CPUSTATES];
|
2007-11-29 08:38:22 +00:00
|
|
|
int i;
|
2007-11-29 06:34:30 +00:00
|
|
|
#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;
|
|
|
|
}
|
|
|
|
|
2009-05-18 12:03:43 +00:00
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, cp_times, CTLTYPE_LONG|CTLFLAG_RD|CTLFLAG_MPSAFE,
|
2007-11-29 06:34:30 +00:00
|
|
|
0,0, sysctl_kern_cp_times, "LU", "per-CPU time statistics");
|
|
|
|
|
2010-01-09 01:46:38 +00:00
|
|
|
#ifdef DEADLKRES
|
2010-04-11 16:06:09 +00:00
|
|
|
static const char *blessed[] = {
|
2010-04-19 23:40:46 +00:00
|
|
|
"getblk",
|
2010-04-11 16:06:09 +00:00
|
|
|
"so_snd_sx",
|
|
|
|
"so_rcv_sx",
|
|
|
|
NULL
|
|
|
|
};
|
2010-01-09 01:46:38 +00:00
|
|
|
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;
|
2010-04-11 16:06:09 +00:00
|
|
|
int blkticks, i, slpticks, slptype, tryl, tticks;
|
2010-01-09 01:46:38 +00:00
|
|
|
|
|
|
|
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++;
|
2010-11-02 18:34:31 +00:00
|
|
|
pause("allproc", sleepfreq * hz);
|
2010-01-09 01:46:38 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
tryl = 0;
|
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
|
|
|
PROC_LOCK(p);
|
2011-04-06 17:47:22 +00:00
|
|
|
if (p->p_state == PRS_NEW) {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
continue;
|
|
|
|
}
|
2010-01-09 01:46:38 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
2010-07-07 12:00:11 +00:00
|
|
|
|
2010-01-09 01:46:38 +00:00
|
|
|
thread_lock(td);
|
2013-06-28 15:55:30 +00:00
|
|
|
if (TD_ON_LOCK(td)) {
|
2010-01-09 01:46:38 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The thread should be blocked on a
|
|
|
|
* turnstile, simply check if the
|
|
|
|
* turnstile channel is in good state.
|
|
|
|
*/
|
|
|
|
MPASS(td->td_blocked != NULL);
|
2010-04-11 16:06:09 +00:00
|
|
|
|
2010-01-09 01:46:38 +00:00
|
|
|
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);
|
|
|
|
}
|
2010-07-07 12:00:11 +00:00
|
|
|
} else if (TD_IS_SLEEPING(td) &&
|
2013-06-28 15:55:30 +00:00
|
|
|
TD_ON_SLEEPQ(td)) {
|
2010-04-11 16:06:09 +00:00
|
|
|
|
2010-01-09 01:46:38 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
2010-04-11 16:06:09 +00:00
|
|
|
* However, being on a
|
|
|
|
* sleepqueue, we might still
|
|
|
|
* check for the blessed
|
|
|
|
* list.
|
2010-01-09 01:46:38 +00:00
|
|
|
*/
|
2010-04-11 16:06:09 +00:00
|
|
|
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;
|
|
|
|
}
|
2010-01-09 01:46:38 +00:00
|
|
|
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. */
|
2010-11-02 18:34:31 +00:00
|
|
|
pause("-", sleepfreq * hz);
|
2010-01-09 01:46:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct kthread_desc deadlkres_kd = {
|
|
|
|
"deadlkres",
|
|
|
|
deadlkres,
|
|
|
|
(struct thread **)NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
SYSINIT(deadlkres, SI_SUB_CLOCKS, SI_ORDER_ANY, kthread_start, &deadlkres_kd);
|
|
|
|
|
2011-11-07 15:43:11 +00:00
|
|
|
static SYSCTL_NODE(_debug, OID_AUTO, deadlkres, CTLFLAG_RW, 0,
|
|
|
|
"Deadlock resolver");
|
2010-01-09 01:46:38 +00:00
|
|
|
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 */
|
|
|
|
|
2007-11-29 06:34:30 +00:00
|
|
|
void
|
|
|
|
read_cpu_time(long *cp_time)
|
|
|
|
{
|
|
|
|
struct pcpu *pc;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
/* Sum up global cp_time[]. */
|
|
|
|
bzero(cp_time, sizeof(long) * CPUSTATES);
|
2010-06-11 18:46:34 +00:00
|
|
|
CPU_FOREACH(i) {
|
2007-11-29 06:34:30 +00:00
|
|
|
pc = pcpu_find(i);
|
|
|
|
for (j = 0; j < CPUSTATES; j++)
|
|
|
|
cp_time[j] += pc->pc_cp_time[j];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-28 20:56:35 +00:00
|
|
|
#ifdef SW_WATCHDOG
|
|
|
|
#include <sys/watchdog.h>
|
2003-06-26 09:50:52 +00:00
|
|
|
|
2004-02-28 20:56:35 +00:00
|
|
|
static int watchdog_ticks;
|
2003-06-26 09:50:52 +00:00
|
|
|
static int watchdog_enabled;
|
2004-02-28 20:56:35 +00:00
|
|
|
static void watchdog_fire(void);
|
|
|
|
static void watchdog_config(void *, u_int, int *);
|
|
|
|
#endif /* SW_WATCHDOG */
|
2003-06-26 09:50:52 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Clock handling routines.
|
|
|
|
*
|
1998-03-16 10:19:12 +00:00
|
|
|
* This code is written to operate with two timers that run independently of
|
|
|
|
* each other.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
1998-03-16 10:19:12 +00:00
|
|
|
* The main timer, running hz times per second, is used to trigger interval
|
|
|
|
* timers, timeouts and rescheduling as needed.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
1998-03-16 10:19:12 +00:00
|
|
|
* 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
|
1998-02-20 16:36:17 +00:00
|
|
|
* just before its quantum expires. Otherwise, it would never accumulate
|
|
|
|
* cpu ticks. The mean frequency of the second timer is stathz.
|
1998-03-16 10:19:12 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* The statistics clock may (or may not) be run at a higher rate while
|
1998-03-16 10:19:12 +00:00
|
|
|
* 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.)
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
1998-02-20 16:36:17 +00:00
|
|
|
* Time-of-day is maintained using a "timecounter", which may or may
|
|
|
|
* not be related to the hardware generating the above mentioned
|
|
|
|
* interrupts.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
int stathz;
|
|
|
|
int profhz;
|
2003-02-03 17:53:15 +00:00
|
|
|
int profprocs;
|
2013-01-28 19:38:13 +00:00
|
|
|
volatile int ticks;
|
2003-02-03 17:53:15 +00:00
|
|
|
int psratio;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2010-11-22 19:32:54 +00:00
|
|
|
static DPCPU_DEFINE(int, pcputicks); /* Per-CPU version of ticks. */
|
2016-07-27 11:49:41 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
static int devpoll_run = 0;
|
|
|
|
#endif
|
2010-05-24 11:40:49 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Initialize clock frequencies and start both clocks running.
|
|
|
|
*/
|
1995-08-28 09:19:25 +00:00
|
|
|
/* ARGSUSED*/
|
|
|
|
static void
|
2017-05-17 00:34:34 +00:00
|
|
|
initclocks(void *dummy)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2017-05-17 00:34:34 +00:00
|
|
|
int i;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set divisors to 1 (normal case) and let the machine-specific
|
|
|
|
* code do its bit.
|
|
|
|
*/
|
Implement new event timers infrastructure. It provides unified APIs for
writing event timer drivers, for choosing best possible drivers by machine
independent code and for operating them to supply kernel with hardclock(),
statclock() and profclock() events in unified fashion on various hardware.
Infrastructure provides support for both per-CPU (independent for every CPU
core) and global timers in periodic and one-shot modes. MI management code
at this moment uses only periodic mode, but one-shot mode use planned for
later, as part of tickless kernel project.
For this moment infrastructure used on i386 and amd64 architectures. Other
archs are welcome to follow, while their current operation should not be
affected.
This patch updates existing drivers (i8254, RTC and LAPIC) for the new
order, and adds event timers support into the HPET driver. These drivers
have different capabilities:
LAPIC - per-CPU timer, supports periodic and one-shot operation, may
freeze in C3 state, calibrated on first use, so may be not exactly precise.
HPET - depending on hardware can work as per-CPU or global, supports
periodic and one-shot operation, usually provides several event timers.
i8254 - global, limited to periodic mode, because same hardware used also
as time counter.
RTC - global, supports only periodic mode, set of frequencies in Hz
limited by powers of 2.
Depending on hardware capabilities, drivers preferred in following orders,
either LAPIC, HPETs, i8254, RTC or HPETs, LAPIC, i8254, RTC.
User may explicitly specify wanted timers via loader tunables or sysctls:
kern.eventtimer.timer1 and kern.eventtimer.timer2.
If requested driver is unavailable or unoperational, system will try to
replace it. If no more timers available or "NONE" specified for second,
system will operate using only one timer, multiplying it's frequency by few
times and uing respective dividers to honor hz, stathz and profhz values,
set during initial setup.
2010-06-20 21:33:29 +00:00
|
|
|
mtx_init(&time_lock, "time lock", NULL, MTX_DEF);
|
2007-05-23 17:27:01 +00:00
|
|
|
cpu_initclocks();
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute profhz/stathz, and fix profhz if needed.
|
|
|
|
*/
|
|
|
|
i = stathz ? stathz : hz;
|
|
|
|
if (profhz == 0)
|
|
|
|
profhz = i;
|
|
|
|
psratio = profhz / i;
|
2004-02-28 20:56:35 +00:00
|
|
|
#ifdef SW_WATCHDOG
|
|
|
|
EVENTHANDLER_REGISTER(watchdog_list, watchdog_config, NULL, 0);
|
Add an EARLY_AP_STARTUP option to start APs earlier during boot.
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
2016-05-14 18:22:52 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2001-04-27 19:28:25 +00:00
|
|
|
/*
|
2003-02-03 17:53:15 +00:00
|
|
|
* Each time the real-time timer fires, this function is called on all CPUs.
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
* Note that hardclock() calls hardclock_cpu() for the boot CPU, so only
|
2003-02-03 17:53:15 +00:00
|
|
|
* the other CPUs in the system need to call this function.
|
2001-04-27 19:28:25 +00:00
|
|
|
*/
|
|
|
|
void
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
hardclock_cpu(int usermode)
|
2001-04-27 19:28:25 +00:00
|
|
|
{
|
|
|
|
struct pstats *pstats;
|
2003-02-03 17:53:15 +00:00
|
|
|
struct thread *td = curthread;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
2007-09-17 05:31:39 +00:00
|
|
|
int flags;
|
2001-04-27 19:28:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Run current process's virtual and profile time, as needed.
|
|
|
|
*/
|
2006-10-26 21:42:22 +00:00
|
|
|
pstats = p->p_stats;
|
2007-09-17 05:31:39 +00:00
|
|
|
flags = 0;
|
2006-10-26 21:42:22 +00:00
|
|
|
if (usermode &&
|
Commit 5/14 of sched_lock decomposition.
- Protect the cp_time tick counts with atomics instead of a global lock.
There will only be one atomic per tick and this allows all processors
to execute softclock concurrently.
- In softclock, protect access to rusage and td_*tick data with the
thread_lock(), expanding the scope of the thread lock over the whole
function.
- Do some creative re-arranging in hardclock() to avoid excess locking.
- Protect the p_timer fields with the per-process spinlock.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-04 23:53:06 +00:00
|
|
|
timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value)) {
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMLOCK(p);
|
2007-09-17 05:31:39 +00:00
|
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0)
|
|
|
|
flags |= TDF_ALRMPEND | TDF_ASTPENDING;
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMUNLOCK(p);
|
2006-10-26 21:42:22 +00:00
|
|
|
}
|
Commit 5/14 of sched_lock decomposition.
- Protect the cp_time tick counts with atomics instead of a global lock.
There will only be one atomic per tick and this allows all processors
to execute softclock concurrently.
- In softclock, protect access to rusage and td_*tick data with the
thread_lock(), expanding the scope of the thread lock over the whole
function.
- Do some creative re-arranging in hardclock() to avoid excess locking.
- Protect the p_timer fields with the per-process spinlock.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-04 23:53:06 +00:00
|
|
|
if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMLOCK(p);
|
2007-09-17 05:31:39 +00:00
|
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0)
|
|
|
|
flags |= TDF_PROFPEND | TDF_ASTPENDING;
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMUNLOCK(p);
|
2006-10-26 21:42:22 +00:00
|
|
|
}
|
Commit 5/14 of sched_lock decomposition.
- Protect the cp_time tick counts with atomics instead of a global lock.
There will only be one atomic per tick and this allows all processors
to execute softclock concurrently.
- In softclock, protect access to rusage and td_*tick data with the
thread_lock(), expanding the scope of the thread lock over the whole
function.
- Do some creative re-arranging in hardclock() to avoid excess locking.
- Protect the p_timer fields with the per-process spinlock.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-04 23:53:06 +00:00
|
|
|
thread_lock(td);
|
2007-09-17 05:31:39 +00:00
|
|
|
td->td_flags |= flags;
|
Commit 5/14 of sched_lock decomposition.
- Protect the cp_time tick counts with atomics instead of a global lock.
There will only be one atomic per tick and this allows all processors
to execute softclock concurrently.
- In softclock, protect access to rusage and td_*tick data with the
thread_lock(), expanding the scope of the thread lock over the whole
function.
- Do some creative re-arranging in hardclock() to avoid excess locking.
- Protect the p_timer fields with the per-process spinlock.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-04 23:53:06 +00:00
|
|
|
thread_unlock(td);
|
2005-05-30 06:29:29 +00:00
|
|
|
|
2012-03-28 20:58:30 +00:00
|
|
|
#ifdef HWPMC_HOOKS
|
2005-05-30 06:29:29 +00:00
|
|
|
if (PMC_CPU_HAS_SAMPLES(PCPU_GET(cpuid)))
|
|
|
|
PMC_CALL_HOOK_UNLOCKED(curthread, PMC_FN_DO_SAMPLES, NULL);
|
2012-03-28 20:58:30 +00:00
|
|
|
if (td->td_intr_frame != NULL)
|
|
|
|
PMC_SOFT_CALL_TF( , , clock, hard, td->td_intr_frame);
|
2005-05-30 06:29:29 +00:00
|
|
|
#endif
|
- Make callout(9) tickless, relying on eventtimers(4) as backend for
precise time event generation. This greatly improves granularity of
callouts which are not anymore constrained to wait next tick to be
scheduled.
- Extend the callout KPI introducing a set of callout_reset_sbt* functions,
which take a sbintime_t as timeout argument. The new KPI also offers a
way for consumers to specify precision tolerance they allow, so that
callout can coalesce events and reduce number of interrupts as well as
potentially avoid scheduling a SWI thread.
- Introduce support for dispatching callouts directly from hardware
interrupt context, specifying an additional flag. This feature should be
used carefully, as long as interrupt context has some limitations
(e.g. no sleeping locks can be held).
- Enhance mechanisms to gather informations about callwheel, introducing
a new sysctl to obtain stats.
This change breaks the KBI. struct callout fields has been changed, in
particular 'int ticks' (4 bytes) has been replaced with 'sbintime_t'
(8 bytes) and another 'sbintime_t' field was added for precision.
Together with: mav
Reviewed by: attilio, bde, luigi, phk
Sponsored by: Google Summer of Code 2012, iXsystems inc.
Tested by: flo (amd64, sparc64), marius (sparc64), ian (arm),
markj (amd64), mav, Fabian Keil
2013-03-04 11:09:56 +00:00
|
|
|
callout_process(sbinuptime());
|
2001-04-27 19:28:25 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* The real-time timer, interrupting hz times per second.
|
|
|
|
*/
|
|
|
|
void
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
hardclock(int usermode, uintfptr_t pc)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2013-01-28 19:38:13 +00:00
|
|
|
atomic_add_int(&ticks, 1);
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
hardclock_cpu(usermode);
|
2010-09-14 08:48:06 +00:00
|
|
|
tc_ticktock(1);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
cpu_tick_calibration();
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If no separate statistics clock is available, run it from here.
|
2001-04-27 19:28:25 +00:00
|
|
|
*
|
|
|
|
* XXX: this only works for UP
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2003-02-03 17:53:15 +00:00
|
|
|
if (stathz == 0) {
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
profclock(usermode, pc);
|
|
|
|
statclock(usermode);
|
2003-02-03 17:53:15 +00:00
|
|
|
}
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2002-02-11 23:56:18 +00:00
|
|
|
hardclock_device_poll(); /* this is very short and quick */
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#endif /* DEVICE_POLLING */
|
2004-02-28 20:56:35 +00:00
|
|
|
#ifdef SW_WATCHDOG
|
|
|
|
if (watchdog_enabled > 0 && --watchdog_ticks <= 0)
|
2003-06-26 09:50:52 +00:00
|
|
|
watchdog_fire();
|
2004-02-28 20:56:35 +00:00
|
|
|
#endif /* SW_WATCHDOG */
|
1997-09-21 22:00:25 +00:00
|
|
|
}
|
|
|
|
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
void
|
2012-03-10 14:57:21 +00:00
|
|
|
hardclock_cnt(int cnt, int usermode)
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
{
|
|
|
|
struct pstats *pstats;
|
|
|
|
struct thread *td = curthread;
|
|
|
|
struct proc *p = td->td_proc;
|
|
|
|
int *t = DPCPU_PTR(pcputicks);
|
2010-09-14 04:57:30 +00:00
|
|
|
int flags, global, newticks;
|
|
|
|
#ifdef SW_WATCHDOG
|
|
|
|
int i;
|
|
|
|
#endif /* SW_WATCHDOG */
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)) {
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMLOCK(p);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL],
|
|
|
|
tick * cnt) == 0)
|
|
|
|
flags |= TDF_ALRMPEND | TDF_ASTPENDING;
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMUNLOCK(p);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
}
|
|
|
|
if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMLOCK(p);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_PROF],
|
|
|
|
tick * cnt) == 0)
|
|
|
|
flags |= TDF_PROFPEND | TDF_ASTPENDING;
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_ITIMUNLOCK(p);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
}
|
2016-05-18 03:55:54 +00:00
|
|
|
if (flags != 0) {
|
|
|
|
thread_lock(td);
|
|
|
|
td->td_flags |= flags;
|
|
|
|
thread_unlock(td);
|
|
|
|
}
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
|
|
|
|
#ifdef HWPMC_HOOKS
|
|
|
|
if (PMC_CPU_HAS_SAMPLES(PCPU_GET(cpuid)))
|
|
|
|
PMC_CALL_HOOK_UNLOCKED(curthread, PMC_FN_DO_SAMPLES, NULL);
|
2012-03-28 20:58:30 +00:00
|
|
|
if (td->td_intr_frame != NULL)
|
|
|
|
PMC_SOFT_CALL_TF( , , clock, hard, td->td_intr_frame);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
#endif
|
|
|
|
/* We are in charge to handle this tick duty. */
|
|
|
|
if (newticks > 0) {
|
2016-07-27 11:49:41 +00:00
|
|
|
tc_ticktock(newticks);
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2016-07-27 11:49:41 +00:00
|
|
|
/* Dangerous and no need to call these things concurrently. */
|
|
|
|
if (atomic_cmpset_acq_int(&devpoll_run, 0, 1)) {
|
2010-09-14 04:57:30 +00:00
|
|
|
/* This is very short and quick. */
|
|
|
|
hardclock_device_poll();
|
2016-07-27 11:49:41 +00:00
|
|
|
atomic_store_rel_int(&devpoll_run, 0);
|
2010-09-14 04:57:30 +00:00
|
|
|
}
|
2016-07-27 11:49:41 +00:00
|
|
|
#endif /* DEVICE_POLLING */
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
#ifdef SW_WATCHDOG
|
|
|
|
if (watchdog_enabled > 0) {
|
2010-09-14 04:57:30 +00:00
|
|
|
i = atomic_fetchadd_int(&watchdog_ticks, -newticks);
|
|
|
|
if (i > 0 && i <= newticks)
|
Refactor timer management code with priority to one-shot operation mode.
The main goal of this is to generate timer interrupts only when there is
some work to do. When CPU is busy interrupts are generating at full rate
of hz + stathz to fullfill scheduler and timekeeping requirements. But
when CPU is idle, only minimum set of interrupts (down to 8 interrupts per
second per CPU now), needed to handle scheduled callouts is executed.
This allows significantly increase idle CPU sleep time, increasing effect
of static power-saving technologies. Also it should reduce host CPU load
on virtualized systems, when guest system is idle.
There is set of tunables, also available as writable sysctls, allowing to
control wanted event timer subsystem behavior:
kern.eventtimer.timer - allows to choose event timer hardware to use.
On x86 there is up to 4 different kinds of timers. Depending on whether
chosen timer is per-CPU, behavior of other options slightly differs.
kern.eventtimer.periodic - allows to choose periodic and one-shot
operation mode. In periodic mode, current timer hardware taken as the only
source of time for time events. This mode is quite alike to previous kernel
behavior. One-shot mode instead uses currently selected time counter
hardware to schedule all needed events one by one and program timer to
generate interrupt exactly in specified time. Default value depends of
chosen timer capabilities, but one-shot mode is preferred, until other is
forced by user or hardware.
kern.eventtimer.singlemul - in periodic mode specifies how much times
higher timer frequency should be, to not strictly alias hardclock() and
statclock() events. Default values are 2 and 4, but could be reduced to 1
if extra interrupts are unwanted.
kern.eventtimer.idletick - makes each CPU to receive every timer interrupt
independently of whether they busy or not. By default this options is
disabled. If chosen timer is per-CPU and runs in periodic mode, this option
has no effect - all interrupts are generating.
As soon as this patch modifies cpu_idle() on some platforms, I have also
refactored one on x86. Now it makes use of MONITOR/MWAIT instrunctions
(if supported) under high sleep/wakeup rate, as fast alternative to other
methods. It allows SMP scheduler to wake up sleeping CPUs much faster
without using IPI, significantly increasing performance on some highly
task-switching loads.
Tested by: many (on i386, amd64, sparc64 and powerc)
H/W donated by: Gheorghe Ardelean
Sponsored by: iXsystems, Inc.
2010-09-13 07:25:35 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1998-03-30 09:56:58 +00:00
|
|
|
* Compute number of ticks in the specified amount of time.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
int
|
2017-05-17 00:34:34 +00:00
|
|
|
tvtohz(struct timeval *tv)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2017-05-17 00:34:34 +00:00
|
|
|
unsigned long ticks;
|
|
|
|
long sec, usec;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1994-12-12 11:58:46 +00:00
|
|
|
* 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.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
1994-12-12 11:58:46 +00:00
|
|
|
* 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.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1998-03-30 09:56:58 +00:00
|
|
|
sec = tv->tv_sec;
|
|
|
|
usec = tv->tv_usec;
|
1994-12-12 11:58:46 +00:00
|
|
|
if (usec < 0) {
|
|
|
|
sec--;
|
|
|
|
usec += 1000000;
|
|
|
|
}
|
|
|
|
if (sec < 0) {
|
|
|
|
#ifdef DIAGNOSTIC
|
1998-03-16 10:19:12 +00:00
|
|
|
if (usec > 0) {
|
1998-02-20 16:36:17 +00:00
|
|
|
sec++;
|
|
|
|
usec -= 1000000;
|
|
|
|
}
|
1998-03-30 09:56:58 +00:00
|
|
|
printf("tvotohz: negative time difference %ld sec %ld usec\n",
|
1994-12-12 11:58:46 +00:00
|
|
|
sec, usec);
|
|
|
|
#endif
|
|
|
|
ticks = 1;
|
|
|
|
} else if (sec <= LONG_MAX / 1000000)
|
2016-04-26 15:38:17 +00:00
|
|
|
ticks = howmany(sec * 1000000 + (unsigned long)usec, tick) + 1;
|
1994-12-12 11:58:46 +00:00
|
|
|
else if (sec <= LONG_MAX / hz)
|
|
|
|
ticks = sec * hz
|
2016-04-26 15:38:17 +00:00
|
|
|
+ howmany((unsigned long)usec, tick) + 1;
|
1994-12-12 11:58:46 +00:00
|
|
|
else
|
|
|
|
ticks = LONG_MAX;
|
|
|
|
if (ticks > INT_MAX)
|
|
|
|
ticks = INT_MAX;
|
1998-10-06 23:17:44 +00:00
|
|
|
return ((int)ticks);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start profiling on a process.
|
|
|
|
*
|
|
|
|
* Kernel profiling passes proc0 which never exits and hence
|
|
|
|
* keeps the profile clock running constantly.
|
|
|
|
*/
|
|
|
|
void
|
2017-05-17 00:34:34 +00:00
|
|
|
startprofclock(struct proc *p)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2003-04-22 20:54:04 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
|
|
if (p->p_flag & P_STOPPROF)
|
2003-02-08 02:58:16 +00:00
|
|
|
return;
|
2003-04-22 20:54:04 +00:00
|
|
|
if ((p->p_flag & P_PROFIL) == 0) {
|
|
|
|
p->p_flag |= P_PROFIL;
|
Implement new event timers infrastructure. It provides unified APIs for
writing event timer drivers, for choosing best possible drivers by machine
independent code and for operating them to supply kernel with hardclock(),
statclock() and profclock() events in unified fashion on various hardware.
Infrastructure provides support for both per-CPU (independent for every CPU
core) and global timers in periodic and one-shot modes. MI management code
at this moment uses only periodic mode, but one-shot mode use planned for
later, as part of tickless kernel project.
For this moment infrastructure used on i386 and amd64 architectures. Other
archs are welcome to follow, while their current operation should not be
affected.
This patch updates existing drivers (i8254, RTC and LAPIC) for the new
order, and adds event timers support into the HPET driver. These drivers
have different capabilities:
LAPIC - per-CPU timer, supports periodic and one-shot operation, may
freeze in C3 state, calibrated on first use, so may be not exactly precise.
HPET - depending on hardware can work as per-CPU or global, supports
periodic and one-shot operation, usually provides several event timers.
i8254 - global, limited to periodic mode, because same hardware used also
as time counter.
RTC - global, supports only periodic mode, set of frequencies in Hz
limited by powers of 2.
Depending on hardware capabilities, drivers preferred in following orders,
either LAPIC, HPETs, i8254, RTC or HPETs, LAPIC, i8254, RTC.
User may explicitly specify wanted timers via loader tunables or sysctls:
kern.eventtimer.timer1 and kern.eventtimer.timer2.
If requested driver is unavailable or unoperational, system will try to
replace it. If no more timers available or "NONE" specified for second,
system will operate using only one timer, multiplying it's frequency by few
times and uing respective dividers to honor hz, stathz and profhz values,
set during initial setup.
2010-06-20 21:33:29 +00:00
|
|
|
mtx_lock(&time_lock);
|
2003-02-03 17:53:15 +00:00
|
|
|
if (++profprocs == 1)
|
|
|
|
cpu_startprofclock();
|
Implement new event timers infrastructure. It provides unified APIs for
writing event timer drivers, for choosing best possible drivers by machine
independent code and for operating them to supply kernel with hardclock(),
statclock() and profclock() events in unified fashion on various hardware.
Infrastructure provides support for both per-CPU (independent for every CPU
core) and global timers in periodic and one-shot modes. MI management code
at this moment uses only periodic mode, but one-shot mode use planned for
later, as part of tickless kernel project.
For this moment infrastructure used on i386 and amd64 architectures. Other
archs are welcome to follow, while their current operation should not be
affected.
This patch updates existing drivers (i8254, RTC and LAPIC) for the new
order, and adds event timers support into the HPET driver. These drivers
have different capabilities:
LAPIC - per-CPU timer, supports periodic and one-shot operation, may
freeze in C3 state, calibrated on first use, so may be not exactly precise.
HPET - depending on hardware can work as per-CPU or global, supports
periodic and one-shot operation, usually provides several event timers.
i8254 - global, limited to periodic mode, because same hardware used also
as time counter.
RTC - global, supports only periodic mode, set of frequencies in Hz
limited by powers of 2.
Depending on hardware capabilities, drivers preferred in following orders,
either LAPIC, HPETs, i8254, RTC or HPETs, LAPIC, i8254, RTC.
User may explicitly specify wanted timers via loader tunables or sysctls:
kern.eventtimer.timer1 and kern.eventtimer.timer2.
If requested driver is unavailable or unoperational, system will try to
replace it. If no more timers available or "NONE" specified for second,
system will operate using only one timer, multiplying it's frequency by few
times and uing respective dividers to honor hz, stathz and profhz values,
set during initial setup.
2010-06-20 21:33:29 +00:00
|
|
|
mtx_unlock(&time_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop profiling on a process.
|
|
|
|
*/
|
|
|
|
void
|
2017-05-17 00:34:34 +00:00
|
|
|
stopprofclock(struct proc *p)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2003-02-08 02:58:16 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
2003-04-22 20:54:04 +00:00
|
|
|
if (p->p_flag & P_PROFIL) {
|
|
|
|
if (p->p_profthreads != 0) {
|
2014-11-10 14:11:17 +00:00
|
|
|
while (p->p_profthreads != 0) {
|
|
|
|
p->p_flag |= P_STOPPROF;
|
2003-04-22 20:54:04 +00:00
|
|
|
msleep(&p->p_profthreads, &p->p_mtx, PPAUSE,
|
2003-12-23 02:36:43 +00:00
|
|
|
"stopprof", 0);
|
2014-11-10 14:11:17 +00:00
|
|
|
}
|
2003-02-08 02:58:16 +00:00
|
|
|
}
|
2004-05-03 00:48:11 +00:00
|
|
|
if ((p->p_flag & P_PROFIL) == 0)
|
|
|
|
return;
|
2003-04-22 20:54:04 +00:00
|
|
|
p->p_flag &= ~P_PROFIL;
|
Implement new event timers infrastructure. It provides unified APIs for
writing event timer drivers, for choosing best possible drivers by machine
independent code and for operating them to supply kernel with hardclock(),
statclock() and profclock() events in unified fashion on various hardware.
Infrastructure provides support for both per-CPU (independent for every CPU
core) and global timers in periodic and one-shot modes. MI management code
at this moment uses only periodic mode, but one-shot mode use planned for
later, as part of tickless kernel project.
For this moment infrastructure used on i386 and amd64 architectures. Other
archs are welcome to follow, while their current operation should not be
affected.
This patch updates existing drivers (i8254, RTC and LAPIC) for the new
order, and adds event timers support into the HPET driver. These drivers
have different capabilities:
LAPIC - per-CPU timer, supports periodic and one-shot operation, may
freeze in C3 state, calibrated on first use, so may be not exactly precise.
HPET - depending on hardware can work as per-CPU or global, supports
periodic and one-shot operation, usually provides several event timers.
i8254 - global, limited to periodic mode, because same hardware used also
as time counter.
RTC - global, supports only periodic mode, set of frequencies in Hz
limited by powers of 2.
Depending on hardware capabilities, drivers preferred in following orders,
either LAPIC, HPETs, i8254, RTC or HPETs, LAPIC, i8254, RTC.
User may explicitly specify wanted timers via loader tunables or sysctls:
kern.eventtimer.timer1 and kern.eventtimer.timer2.
If requested driver is unavailable or unoperational, system will try to
replace it. If no more timers available or "NONE" specified for second,
system will operate using only one timer, multiplying it's frequency by few
times and uing respective dividers to honor hz, stathz and profhz values,
set during initial setup.
2010-06-20 21:33:29 +00:00
|
|
|
mtx_lock(&time_lock);
|
2003-02-03 17:53:15 +00:00
|
|
|
if (--profprocs == 0)
|
|
|
|
cpu_stopprofclock();
|
Implement new event timers infrastructure. It provides unified APIs for
writing event timer drivers, for choosing best possible drivers by machine
independent code and for operating them to supply kernel with hardclock(),
statclock() and profclock() events in unified fashion on various hardware.
Infrastructure provides support for both per-CPU (independent for every CPU
core) and global timers in periodic and one-shot modes. MI management code
at this moment uses only periodic mode, but one-shot mode use planned for
later, as part of tickless kernel project.
For this moment infrastructure used on i386 and amd64 architectures. Other
archs are welcome to follow, while their current operation should not be
affected.
This patch updates existing drivers (i8254, RTC and LAPIC) for the new
order, and adds event timers support into the HPET driver. These drivers
have different capabilities:
LAPIC - per-CPU timer, supports periodic and one-shot operation, may
freeze in C3 state, calibrated on first use, so may be not exactly precise.
HPET - depending on hardware can work as per-CPU or global, supports
periodic and one-shot operation, usually provides several event timers.
i8254 - global, limited to periodic mode, because same hardware used also
as time counter.
RTC - global, supports only periodic mode, set of frequencies in Hz
limited by powers of 2.
Depending on hardware capabilities, drivers preferred in following orders,
either LAPIC, HPETs, i8254, RTC or HPETs, LAPIC, i8254, RTC.
User may explicitly specify wanted timers via loader tunables or sysctls:
kern.eventtimer.timer1 and kern.eventtimer.timer2.
If requested driver is unavailable or unoperational, system will try to
replace it. If no more timers available or "NONE" specified for second,
system will operate using only one timer, multiplying it's frequency by few
times and uing respective dividers to honor hz, stathz and profhz values,
set during initial setup.
2010-06-20 21:33:29 +00:00
|
|
|
mtx_unlock(&time_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-06-01 01:12:45 +00:00
|
|
|
* Statistics clock. Updates rusage information and calls the scheduler
|
|
|
|
* to adjust priorities of the active thread.
|
|
|
|
*
|
2003-02-03 17:53:15 +00:00
|
|
|
* This should be called by all active processors.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
void
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
statclock(int usermode)
|
2012-03-10 14:57:21 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
statclock_cnt(1, usermode);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
statclock_cnt(int cnt, int usermode)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1996-07-30 16:59:22 +00:00
|
|
|
struct rusage *ru;
|
|
|
|
struct vmspace *vm;
|
2003-02-03 17:53:15 +00:00
|
|
|
struct thread *td;
|
|
|
|
struct proc *p;
|
|
|
|
long rss;
|
2007-11-29 06:34:30 +00:00
|
|
|
long *cp_time;
|
1994-08-27 16:14:39 +00:00
|
|
|
|
2003-02-03 17:53:15 +00:00
|
|
|
td = curthread;
|
|
|
|
p = td->td_proc;
|
|
|
|
|
2007-11-29 06:34:30 +00:00
|
|
|
cp_time = (long *)PCPU_PTR(cp_time);
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
if (usermode) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1999-11-27 14:37:34 +00:00
|
|
|
* Charge the time as appropriate.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2012-03-10 14:57:21 +00:00
|
|
|
td->td_uticks += cnt;
|
2004-06-16 00:26:31 +00:00
|
|
|
if (p->p_nice > NZERO)
|
2012-03-10 14:57:21 +00:00
|
|
|
cp_time[CP_NICE] += cnt;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2012-03-10 14:57:21 +00:00
|
|
|
cp_time[CP_USER] += cnt;
|
1994-05-24 10:09:53 +00:00
|
|
|
} 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.
|
|
|
|
*/
|
Reorganize the interrupt handling code a bit to make a few things cleaner
and increase flexibility to allow various different approaches to be tried
in the future.
- Split struct ithd up into two pieces. struct intr_event holds the list
of interrupt handlers associated with interrupt sources.
struct intr_thread contains the data relative to an interrupt thread.
Currently we still provide a 1:1 relationship of events to threads
with the exception that events only have an associated thread if there
is at least one threaded interrupt handler attached to the event. This
means that on x86 we no longer have 4 bazillion interrupt threads with
no handlers. It also means that interrupt events with only INTR_FAST
handlers no longer have an associated thread either.
- Renamed struct intrhand to struct intr_handler to follow the struct
intr_foo naming convention. This did require renaming the powerpc
MD struct intr_handler to struct ppc_intr_handler.
- INTR_FAST no longer implies INTR_EXCL on all architectures except for
powerpc. This means that multiple INTR_FAST handlers can attach to the
same interrupt and that INTR_FAST and non-INTR_FAST handlers can attach
to the same interrupt. Sharing INTR_FAST handlers may not always be
desirable, but having sio(4) and uhci(4) fight over an IRQ isn't fun
either. Drivers can always still use INTR_EXCL to ask for an interrupt
exclusively. The way this sharing works is that when an interrupt
comes in, all the INTR_FAST handlers are executed first, and if any
threaded handlers exist, the interrupt thread is scheduled afterwards.
This type of layout also makes it possible to investigate using interrupt
filters ala OS X where the filter determines whether or not its companion
threaded handler should run.
- Aside from the INTR_FAST changes above, the impact on MD interrupt code
is mostly just 's/ithread/intr_event/'.
- A new MI ddb command 'show intrs' walks the list of interrupt events
dumping their state. It also has a '/v' verbose switch which dumps
info about all of the handlers attached to each event.
- We currently don't destroy an interrupt thread when the last threaded
handler is removed because it would suck for things like ppbus(8)'s
braindead behavior. The code is present, though, it is just under
#if 0 for now.
- Move the code to actually execute the threaded handlers for an interrrupt
event into a separate function so that ithread_loop() becomes more
readable. Previously this code was all in the middle of ithread_loop()
and indented halfway across the screen.
- Made struct intr_thread private to kern_intr.c and replaced td_ithd
with a thread private flag TDP_ITHREAD.
- In statclock, check curthread against idlethread directly rather than
curthread's proc against idlethread's proc. (Not really related to intr
changes)
Tested on: alpha, amd64, i386, sparc64
Tested on: arm, ia64 (older version of patch by cognet and marcel)
2005-10-25 19:48:48 +00:00
|
|
|
if ((td->td_pflags & TDP_ITHREAD) ||
|
|
|
|
td->td_intr_nesting_level >= 2) {
|
2012-03-10 14:57:21 +00:00
|
|
|
td->td_iticks += cnt;
|
|
|
|
cp_time[CP_INTR] += cnt;
|
2000-09-07 01:33:02 +00:00
|
|
|
} else {
|
2012-03-10 14:57:21 +00:00
|
|
|
td->td_pticks += cnt;
|
|
|
|
td->td_sticks += cnt;
|
2007-03-08 06:44:34 +00:00
|
|
|
if (!TD_IS_IDLETHREAD(td))
|
2012-03-10 14:57:21 +00:00
|
|
|
cp_time[CP_SYS] += cnt;
|
2000-09-07 01:33:02 +00:00
|
|
|
else
|
2012-03-10 14:57:21 +00:00
|
|
|
cp_time[CP_IDLE] += cnt;
|
2000-09-07 01:33:02 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-09-12 18:57:59 +00:00
|
|
|
|
|
|
|
/* Update resource usage integrals and maximums. */
|
2004-07-02 03:48:09 +00:00
|
|
|
MPASS(p->p_vmspace != NULL);
|
|
|
|
vm = p->p_vmspace;
|
2007-06-01 01:12:45 +00:00
|
|
|
ru = &td->td_ru;
|
2012-03-10 14:57:21 +00:00
|
|
|
ru->ru_ixrss += pgtok(vm->vm_tsize) * cnt;
|
|
|
|
ru->ru_idrss += pgtok(vm->vm_dsize) * cnt;
|
|
|
|
ru->ru_isrss += pgtok(vm->vm_ssize) * cnt;
|
2004-07-02 03:48:09 +00:00
|
|
|
rss = pgtok(vmspace_resident_count(vm));
|
|
|
|
if (ru->ru_maxrss < rss)
|
|
|
|
ru->ru_maxrss = rss;
|
2009-01-17 07:17:57 +00:00
|
|
|
KTR_POINT2(KTR_SCHED, "thread", sched_tdname(td), "statclock",
|
|
|
|
"prio:%d", td->td_priority, "stathz:%d", (stathz)?stathz:hz);
|
2012-05-15 01:30:25 +00:00
|
|
|
SDT_PROBE2(sched, , , tick, td, td->td_proc);
|
2007-11-29 06:34:30 +00:00
|
|
|
thread_lock_flags(td, MTX_QUIET);
|
2012-03-10 14:57:21 +00:00
|
|
|
for ( ; cnt > 0; cnt--)
|
|
|
|
sched_clock(td);
|
Commit 5/14 of sched_lock decomposition.
- Protect the cp_time tick counts with atomics instead of a global lock.
There will only be one atomic per tick and this allows all processors
to execute softclock concurrently.
- In softclock, protect access to rusage and td_*tick data with the
thread_lock(), expanding the scope of the thread lock over the whole
function.
- Do some creative re-arranging in hardclock() to avoid excess locking.
- Protect the p_timer fields with the per-process spinlock.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-04 23:53:06 +00:00
|
|
|
thread_unlock(td);
|
2012-03-28 20:58:30 +00:00
|
|
|
#ifdef HWPMC_HOOKS
|
|
|
|
if (td->td_intr_frame != NULL)
|
|
|
|
PMC_SOFT_CALL_TF( , , clock, stat, td->td_intr_frame);
|
|
|
|
#endif
|
2001-04-27 19:28:25 +00:00
|
|
|
}
|
2000-10-06 02:20:21 +00:00
|
|
|
|
2001-04-27 19:28:25 +00:00
|
|
|
void
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
profclock(int usermode, uintfptr_t pc)
|
2012-03-10 14:57:21 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
profclock_cnt(1, usermode, pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
profclock_cnt(int cnt, int usermode, uintfptr_t pc)
|
2001-04-27 19:28:25 +00:00
|
|
|
{
|
2003-02-03 17:53:15 +00:00
|
|
|
struct thread *td;
|
|
|
|
#ifdef GPROF
|
|
|
|
struct gmonparam *g;
|
2005-12-16 22:11:52 +00:00
|
|
|
uintfptr_t i;
|
2003-02-03 17:53:15 +00:00
|
|
|
#endif
|
2001-04-27 19:28:25 +00:00
|
|
|
|
2003-02-17 09:55:10 +00:00
|
|
|
td = curthread;
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
if (usermode) {
|
2003-02-03 17:53:15 +00:00
|
|
|
/*
|
|
|
|
* Came from user mode; CPU was in user state.
|
|
|
|
* If this process is being profiled, record the tick.
|
2003-02-08 02:58:16 +00:00
|
|
|
* if there is no related user location yet, don't
|
|
|
|
* bother trying to count it.
|
2003-02-03 17:53:15 +00:00
|
|
|
*/
|
2003-04-22 20:54:04 +00:00
|
|
|
if (td->td_proc->p_flag & P_PROFIL)
|
2012-03-10 14:57:21 +00:00
|
|
|
addupc_intr(td, pc, cnt);
|
2003-02-03 17:53:15 +00:00
|
|
|
}
|
|
|
|
#ifdef GPROF
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* Kernel statistics are just like addupc_intr, only easier.
|
|
|
|
*/
|
|
|
|
g = &_gmonparam;
|
Tweak how the MD code calls the fooclock() methods some. Instead of
passing a pointer to an opaque clockframe structure and requiring the
MD code to supply CLKF_FOO() macros to extract needed values out of the
opaque structure, just pass the needed values directly. In practice this
means passing the pair (usermode, pc) to hardclock() and profclock() and
passing the boolean (usermode) to hardclock_cpu() and hardclock_process().
Other details:
- Axe clockframe and CLKF_FOO() macros on all architectures. Basically,
all the archs were taking a trapframe and converting it into a clockframe
one way or another. Now they can just extract the PC and usermode values
directly out of the trapframe and pass it to fooclock().
- Renamed hardclock_process() to hardclock_cpu() as the latter is more
accurate.
- On Alpha, we now run profclock() at hz (profhz == hz) rather than at
the slower stathz.
- On Alpha, for the TurboLaser machines that don't have an 8254
timecounter, call hardclock() directly. This removes an extra
conditional check from every clock interrupt on Alpha on the BSP.
There is probably room for even further pruning here by changing Alpha
to use the simplified timecounter we use on x86 with the lapic timer
since we don't get interrupts from the 8254 on Alpha anyway.
- On x86, clkintr() shouldn't ever be called now unless using_lapic_timer
is false, so add a KASSERT() to that affect and remove a condition
to slightly optimize the non-lapic case.
- Change prototypeof arm_handler_execute() so that it's first arg is a
trapframe pointer rather than a void pointer for clarity.
- Use KCOUNT macro in profclock() to lookup the kernel profiling bucket.
Tested on: alpha, amd64, arm, i386, ia64, sparc64
Reviewed by: bde (mostly)
2005-12-22 22:16:09 +00:00
|
|
|
if (g->state == GMON_PROF_ON && pc >= g->lowpc) {
|
|
|
|
i = PC_TO_I(g, pc);
|
2003-02-03 17:53:15 +00:00
|
|
|
if (i < g->textsize) {
|
2012-03-10 14:57:21 +00:00
|
|
|
KCOUNT(g, i) += cnt;
|
2003-02-03 17:53:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2013-02-26 18:13:42 +00:00
|
|
|
#ifdef HWPMC_HOOKS
|
|
|
|
if (td->td_intr_frame != NULL)
|
|
|
|
PMC_SOFT_CALL_TF( , , clock, prof, td->td_intr_frame);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return information about system clocks.
|
|
|
|
*/
|
1995-11-08 08:48:36 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_kern_clockrate(SYSCTL_HANDLER_ARGS)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct clockinfo clkinfo;
|
|
|
|
/*
|
|
|
|
* Construct clockinfo structure.
|
|
|
|
*/
|
2002-05-05 04:33:09 +00:00
|
|
|
bzero(&clkinfo, sizeof(clkinfo));
|
1994-05-24 10:09:53 +00:00
|
|
|
clkinfo.hz = hz;
|
|
|
|
clkinfo.tick = tick;
|
|
|
|
clkinfo.profhz = profhz;
|
|
|
|
clkinfo.stathz = stathz ? stathz : hz;
|
1995-11-12 19:52:09 +00:00
|
|
|
return (sysctl_handle_opaque(oidp, &clkinfo, sizeof clkinfo, req));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1994-09-18 20:40:01 +00:00
|
|
|
|
2009-05-18 12:03:43 +00:00
|
|
|
SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate,
|
|
|
|
CTLTYPE_STRUCT|CTLFLAG_RD|CTLFLAG_MPSAFE,
|
2001-12-16 16:07:20 +00:00
|
|
|
0, 0, sysctl_kern_clockrate, "S,clockinfo",
|
|
|
|
"Rate and period of various kernel clocks");
|
2003-06-26 09:50:52 +00:00
|
|
|
|
2004-02-28 20:56:35 +00:00
|
|
|
#ifdef SW_WATCHDOG
|
2003-06-26 09:50:52 +00:00
|
|
|
|
2004-02-28 20:56:35 +00:00
|
|
|
static void
|
2006-12-15 21:44:49 +00:00
|
|
|
watchdog_config(void *unused __unused, u_int cmd, int *error)
|
2004-02-28 20:56:35 +00:00
|
|
|
{
|
|
|
|
u_int u;
|
|
|
|
|
2004-02-28 22:01:19 +00:00
|
|
|
u = cmd & WD_INTERVAL;
|
2006-12-15 21:44:49 +00:00
|
|
|
if (u >= WD_TO_1SEC) {
|
2004-02-28 20:56:35 +00:00
|
|
|
watchdog_ticks = (1 << (u - WD_TO_1SEC)) * hz;
|
|
|
|
watchdog_enabled = 1;
|
2006-12-15 21:44:49 +00:00
|
|
|
*error = 0;
|
2004-02-28 20:56:35 +00:00
|
|
|
} else {
|
|
|
|
watchdog_enabled = 0;
|
|
|
|
}
|
2003-06-26 09:50:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle a watchdog timeout by dumping interrupt information and
|
2007-05-28 21:50:54 +00:00
|
|
|
* then either dropping to DDB or panicking.
|
2003-06-26 09:50:52 +00:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
watchdog_fire(void)
|
|
|
|
{
|
|
|
|
int nintr;
|
2010-06-21 09:55:56 +00:00
|
|
|
uint64_t inttotal;
|
2003-06-26 09:50:52 +00:00
|
|
|
u_long *curintr;
|
|
|
|
char *curname;
|
|
|
|
|
|
|
|
curintr = intrcnt;
|
|
|
|
curname = intrnames;
|
|
|
|
inttotal = 0;
|
2011-09-27 09:30:20 +00:00
|
|
|
nintr = sintrcnt / sizeof(u_long);
|
2006-04-17 20:14:51 +00:00
|
|
|
|
2003-06-26 09:50:52 +00:00
|
|
|
printf("interrupt total\n");
|
|
|
|
while (--nintr >= 0) {
|
|
|
|
if (*curintr)
|
|
|
|
printf("%-12s %20lu\n", curname, *curintr);
|
|
|
|
curname += strlen(curname) + 1;
|
|
|
|
inttotal += *curintr++;
|
|
|
|
}
|
2003-06-27 08:35:05 +00:00
|
|
|
printf("Total %20ju\n", (uintmax_t)inttotal);
|
2007-05-28 21:50:54 +00:00
|
|
|
|
|
|
|
#if defined(KDB) && !defined(KDB_UNATTENDED)
|
|
|
|
kdb_backtrace();
|
2007-12-25 17:52:02 +00:00
|
|
|
kdb_enter(KDB_WHY_WATCHDOG, "watchdog timeout");
|
2007-05-28 21:50:54 +00:00
|
|
|
#else
|
2003-06-26 09:50:52 +00:00
|
|
|
panic("watchdog timeout");
|
2007-05-28 21:50:54 +00:00
|
|
|
#endif
|
2003-06-26 09:50:52 +00:00
|
|
|
}
|
|
|
|
|
2004-02-28 20:56:35 +00:00
|
|
|
#endif /* SW_WATCHDOG */
|