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.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)kern_clock.c 8.5 (Berkeley) 1/21/94
|
|
|
|
*/
|
|
|
|
|
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>
|
2001-03-28 09:17:56 +00:00
|
|
|
#include <sys/lock.h>
|
2001-10-11 17:53:43 +00:00
|
|
|
#include <sys/ktr.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>
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/signalvar.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>
|
|
|
|
#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);
|
1995-08-28 09:19:25 +00:00
|
|
|
SYSINIT(clocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, initclocks, NULL)
|
|
|
|
|
1994-08-18 22:36:09 +00:00
|
|
|
/* Some of these don't belong here, but it's easiest to concentrate them. */
|
1997-12-08 23:00:24 +00:00
|
|
|
long cp_time[CPUSTATES];
|
1994-08-18 22:36:09 +00:00
|
|
|
|
2007-05-20 22:11:50 +00:00
|
|
|
/* Spin-lock protecting profiling statistics. */
|
|
|
|
struct mtx time_lock;
|
|
|
|
|
2005-06-30 07:49:22 +00:00
|
|
|
static int
|
|
|
|
sysctl_kern_cp_time(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error;
|
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];
|
2006-04-17 20:14:51 +00:00
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-04-17 20:14:51 +00:00
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, cp_time, CTLTYPE_LONG|CTLFLAG_RD,
|
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
|
|
|
|
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;
|
1994-05-24 10:09:53 +00:00
|
|
|
int ticks;
|
2003-02-03 17:53:15 +00:00
|
|
|
int psratio;
|
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
|
1995-12-02 17:11:20 +00:00
|
|
|
initclocks(dummy)
|
|
|
|
void *dummy;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set divisors to 1 (normal case) and let the machine-specific
|
|
|
|
* code do its bit.
|
|
|
|
*/
|
2007-05-20 22:11:50 +00:00
|
|
|
mtx_init(&time_lock, "time lock", NULL, MTX_SPIN);
|
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);
|
|
|
|
#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;
|
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
|
|
|
int ast;
|
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;
|
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
|
|
|
ast = 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)) {
|
|
|
|
PROC_SLOCK(p);
|
|
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0) {
|
|
|
|
p->p_sflag |= PS_ALRMPEND;
|
|
|
|
ast = 1;
|
|
|
|
}
|
|
|
|
PROC_SUNLOCK(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)) {
|
|
|
|
PROC_SLOCK(p);
|
|
|
|
if (itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0) {
|
|
|
|
p->p_sflag |= PS_PROFPEND;
|
|
|
|
ast = 1;
|
|
|
|
}
|
|
|
|
PROC_SUNLOCK(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);
|
|
|
|
sched_tick();
|
|
|
|
if (ast)
|
|
|
|
td->td_flags |= TDF_ASTPENDING;
|
|
|
|
thread_unlock(td);
|
2005-05-30 06:29:29 +00:00
|
|
|
|
|
|
|
#ifdef HWPMC_HOOKS
|
|
|
|
if (PMC_CPU_HAS_SAMPLES(PCPU_GET(cpuid)))
|
|
|
|
PMC_CALL_HOOK_UNLOCKED(curthread, PMC_FN_DO_SAMPLES, NULL);
|
|
|
|
#endif
|
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
|
|
|
{
|
2000-11-19 06:02:32 +00:00
|
|
|
int need_softclock = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
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);
|
1998-03-16 10:19:12 +00:00
|
|
|
|
2002-09-04 10:15:19 +00:00
|
|
|
tc_ticktock();
|
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
|
|
|
}
|
1994-05-24 10:09:53 +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 */
|
1998-01-14 20:48:16 +00:00
|
|
|
|
1998-03-16 10:19:12 +00:00
|
|
|
/*
|
|
|
|
* Process callouts at a very low cpu priority, so we don't keep the
|
|
|
|
* relatively high clock interrupt priority any longer than necessary.
|
|
|
|
*/
|
2001-11-15 19:54:48 +00:00
|
|
|
mtx_lock_spin_flags(&callout_lock, MTX_QUIET);
|
2000-11-19 06:02:32 +00:00
|
|
|
ticks++;
|
2006-06-14 03:14:26 +00:00
|
|
|
if (!TAILQ_EMPTY(&callwheel[ticks & callwheelmask])) {
|
2000-11-19 06:02:32 +00:00
|
|
|
need_softclock = 1;
|
1998-03-16 10:19:12 +00:00
|
|
|
} else if (softticks + 1 == ticks)
|
|
|
|
++softticks;
|
2001-11-15 19:54:48 +00:00
|
|
|
mtx_unlock_spin_flags(&callout_lock, MTX_QUIET);
|
2000-11-19 06:02:32 +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
|
|
|
* swi_sched acquires the thread lock, so we don't want to call it
|
|
|
|
* with callout_lock held; incorrect locking order.
|
2000-11-19 06:02:32 +00:00
|
|
|
*/
|
|
|
|
if (need_softclock)
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(softclock_ih, 0);
|
2003-06-26 09:50:52 +00:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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
|
1998-03-30 09:56:58 +00:00
|
|
|
tvtohz(tv)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct timeval *tv;
|
|
|
|
{
|
1994-12-12 11:58:46 +00:00
|
|
|
register unsigned long ticks;
|
|
|
|
register 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)
|
|
|
|
ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1))
|
|
|
|
/ tick + 1;
|
|
|
|
else if (sec <= LONG_MAX / hz)
|
|
|
|
ticks = sec * hz
|
|
|
|
+ ((unsigned long)usec + (tick - 1)) / tick + 1;
|
|
|
|
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
|
|
|
|
startprofclock(p)
|
|
|
|
register struct proc *p;
|
|
|
|
{
|
|
|
|
|
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;
|
2007-05-20 22:11:50 +00:00
|
|
|
mtx_lock_spin(&time_lock);
|
2003-02-03 17:53:15 +00:00
|
|
|
if (++profprocs == 1)
|
|
|
|
cpu_startprofclock();
|
2007-05-20 22:11:50 +00:00
|
|
|
mtx_unlock_spin(&time_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop profiling on a process.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
stopprofclock(p)
|
|
|
|
register struct proc *p;
|
|
|
|
{
|
|
|
|
|
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) {
|
|
|
|
p->p_flag |= P_STOPPROF;
|
|
|
|
while (p->p_profthreads != 0)
|
|
|
|
msleep(&p->p_profthreads, &p->p_mtx, PPAUSE,
|
2003-12-23 02:36:43 +00:00
|
|
|
"stopprof", 0);
|
2003-04-22 20:54:04 +00:00
|
|
|
p->p_flag &= ~P_STOPPROF;
|
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;
|
2007-05-20 22:11:50 +00:00
|
|
|
mtx_lock_spin(&time_lock);
|
2003-02-03 17:53:15 +00:00
|
|
|
if (--profprocs == 0)
|
|
|
|
cpu_stopprofclock();
|
2007-05-20 22:11:50 +00:00
|
|
|
mtx_unlock_spin(&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)
|
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;
|
1994-08-27 16:14:39 +00:00
|
|
|
|
2003-02-03 17:53:15 +00:00
|
|
|
td = curthread;
|
|
|
|
p = td->td_proc;
|
|
|
|
|
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_flags(td, MTX_QUIET);
|
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
|
|
|
*/
|
2006-10-26 21:42:22 +00:00
|
|
|
#ifdef KSE
|
2003-06-15 00:31:24 +00:00
|
|
|
if (p->p_flag & P_SA)
|
2003-02-17 05:14:26 +00:00
|
|
|
thread_statclock(1);
|
2006-10-26 21:42:22 +00:00
|
|
|
#endif
|
2006-02-11 09:33:07 +00:00
|
|
|
td->td_uticks++;
|
2004-06-16 00:26:31 +00:00
|
|
|
if (p->p_nice > NZERO)
|
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
|
|
|
atomic_add_long(&cp_time[CP_NICE], 1);
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
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
|
|
|
atomic_add_long(&cp_time[CP_USER], 1);
|
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) {
|
2006-02-11 09:33:07 +00:00
|
|
|
td->td_iticks++;
|
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
|
|
|
atomic_add_long(&cp_time[CP_INTR], 1);
|
2000-09-07 01:33:02 +00:00
|
|
|
} else {
|
2006-10-26 21:42:22 +00:00
|
|
|
#ifdef KSE
|
2003-06-15 00:31:24 +00:00
|
|
|
if (p->p_flag & P_SA)
|
2003-02-17 05:14:26 +00:00
|
|
|
thread_statclock(0);
|
2006-10-26 21:42:22 +00:00
|
|
|
#endif
|
2006-02-08 08:09:17 +00:00
|
|
|
td->td_pticks++;
|
2006-02-11 09:33:07 +00:00
|
|
|
td->td_sticks++;
|
2007-03-08 06:44:34 +00:00
|
|
|
if (!TD_IS_IDLETHREAD(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
|
|
|
atomic_add_long(&cp_time[CP_SYS], 1);
|
2000-09-07 01:33:02 +00:00
|
|
|
else
|
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
|
|
|
atomic_add_long(&cp_time[CP_IDLE], 1);
|
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;
|
2004-07-02 03:48:09 +00:00
|
|
|
ru->ru_ixrss += pgtok(vm->vm_tsize);
|
|
|
|
ru->ru_idrss += pgtok(vm->vm_dsize);
|
|
|
|
ru->ru_isrss += pgtok(vm->vm_ssize);
|
|
|
|
rss = pgtok(vmspace_resident_count(vm));
|
|
|
|
if (ru->ru_maxrss < rss)
|
|
|
|
ru->ru_maxrss = rss;
|
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
|
|
|
CTR4(KTR_SCHED, "statclock: %p(%s) prio %d stathz %d",
|
|
|
|
td, td->td_proc->p_comm, td->td_priority, (stathz)?stathz:hz);
|
|
|
|
sched_clock(td);
|
|
|
|
thread_unlock(td);
|
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)
|
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)
|
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
|
|
|
addupc_intr(td, pc, 1);
|
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) {
|
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
|
|
|
KCOUNT(g, i)++;
|
2003-02-03 17:53:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#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
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate, CTLTYPE_STRUCT|CTLFLAG_RD,
|
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;
|
|
|
|
u_int64_t inttotal;
|
|
|
|
u_long *curintr;
|
|
|
|
char *curname;
|
|
|
|
|
|
|
|
curintr = intrcnt;
|
|
|
|
curname = intrnames;
|
|
|
|
inttotal = 0;
|
|
|
|
nintr = eintrcnt - intrcnt;
|
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();
|
|
|
|
kdb_enter("watchdog timeout");
|
|
|
|
#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 */
|