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$");
|
|
|
|
|
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
|
|
|
|
|
|
|
#include <machine/cpu.h>
|
|
|
|
|
|
|
|
#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
|
|
|
|
2000-11-20 00:44:58 +00:00
|
|
|
SYSCTL_OPAQUE(_kern, OID_AUTO, cp_time, CTLFLAG_RD, &cp_time, sizeof(cp_time),
|
|
|
|
"LU", "CPU time statistics");
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
cpu_initclocks();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
* Note that hardclock() calls hardclock_process() for the boot CPU, so only
|
|
|
|
* the other CPUs in the system need to call this function.
|
2001-04-27 19:28:25 +00:00
|
|
|
*/
|
|
|
|
void
|
2003-02-03 17:53:15 +00:00
|
|
|
hardclock_process(frame)
|
|
|
|
register struct clockframe *frame;
|
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;
|
2001-04-27 19:28:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Run current process's virtual and profile time, as needed.
|
|
|
|
*/
|
2003-02-03 17:53:15 +00:00
|
|
|
mtx_lock_spin_flags(&sched_lock, MTX_QUIET);
|
2003-06-15 00:31:24 +00:00
|
|
|
if (p->p_flag & P_SA) {
|
2001-09-12 08:38:13 +00:00
|
|
|
/* XXXKSE What to do? */
|
|
|
|
} else {
|
|
|
|
pstats = p->p_stats;
|
2003-02-03 17:53:15 +00:00
|
|
|
if (CLKF_USERMODE(frame) &&
|
2001-09-12 08:38:13 +00:00
|
|
|
timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value) &&
|
|
|
|
itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0) {
|
|
|
|
p->p_sflag |= PS_ALRMPEND;
|
2003-02-17 09:55:10 +00:00
|
|
|
td->td_flags |= TDF_ASTPENDING;
|
2001-09-12 08:38:13 +00:00
|
|
|
}
|
|
|
|
if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value) &&
|
|
|
|
itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0) {
|
|
|
|
p->p_sflag |= PS_PROFPEND;
|
2003-02-17 09:55:10 +00:00
|
|
|
td->td_flags |= TDF_ASTPENDING;
|
2001-09-12 08:38:13 +00:00
|
|
|
}
|
|
|
|
}
|
2003-02-03 17:53:15 +00:00
|
|
|
mtx_unlock_spin_flags(&sched_lock, MTX_QUIET);
|
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
|
|
|
|
hardclock(frame)
|
|
|
|
register struct clockframe *frame;
|
|
|
|
{
|
2000-11-19 06:02:32 +00:00
|
|
|
int need_softclock = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-12-29 08:39:57 +00:00
|
|
|
CTR0(KTR_CLK, "hardclock fired");
|
2003-02-03 17:53:15 +00:00
|
|
|
hardclock_process(frame);
|
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) {
|
|
|
|
profclock(frame);
|
1994-05-24 10:09:53 +00:00
|
|
|
statclock(frame);
|
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++;
|
1998-03-16 10:19:12 +00:00
|
|
|
if (TAILQ_FIRST(&callwheel[ticks & callwheelmask]) != NULL) {
|
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
|
|
|
|
|
|
|
/*
|
2001-02-09 17:46:35 +00:00
|
|
|
* swi_sched acquires sched_lock, so we don't want to call it with
|
2000-11-19 06:02:32 +00:00
|
|
|
* callout_lock held; incorrect locking order.
|
|
|
|
*/
|
|
|
|
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;
|
|
|
|
{
|
|
|
|
|
2001-01-24 10:43:25 +00:00
|
|
|
/*
|
|
|
|
* XXX; Right now sched_lock protects statclock(), but perhaps
|
|
|
|
* it should be protected later on by a time_lock, which would
|
|
|
|
* cover psdiv, etc. as well.
|
|
|
|
*/
|
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) {
|
|
|
|
mtx_lock_spin(&sched_lock);
|
|
|
|
p->p_flag |= P_PROFIL;
|
2003-02-03 17:53:15 +00:00
|
|
|
if (++profprocs == 1)
|
|
|
|
cpu_startprofclock();
|
2003-04-22 20:54:04 +00:00
|
|
|
mtx_unlock_spin(&sched_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
|
|
|
mtx_lock_spin(&sched_lock);
|
|
|
|
p->p_flag &= ~P_PROFIL;
|
2003-02-03 17:53:15 +00:00
|
|
|
if (--profprocs == 0)
|
|
|
|
cpu_stopprofclock();
|
2003-04-22 20:54:04 +00:00
|
|
|
mtx_unlock_spin(&sched_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-02-03 17:53:15 +00:00
|
|
|
* Statistics clock. Grab profile sample, and if divider reaches 0,
|
|
|
|
* do process and kernel statistics. Most of the statistics are only
|
1999-11-27 14:37:34 +00:00
|
|
|
* used by user-level statistics programs. The main exceptions are
|
2004-10-05 18:51:11 +00:00
|
|
|
* ke->ke_uticks, p->p_rux.rux_sticks, p->p_rux.rux_iticks, and p->p_estcpu.
|
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
|
2003-02-03 17:53:15 +00:00
|
|
|
statclock(frame)
|
|
|
|
register struct clockframe *frame;
|
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;
|
|
|
|
|
|
|
|
mtx_lock_spin_flags(&sched_lock, MTX_QUIET);
|
|
|
|
if (CLKF_USERMODE(frame)) {
|
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
|
|
|
*/
|
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);
|
2004-10-05 18:51:11 +00:00
|
|
|
p->p_rux.rux_uticks++;
|
2004-06-16 00:26:31 +00:00
|
|
|
if (p->p_nice > NZERO)
|
1994-05-24 10:09:53 +00:00
|
|
|
cp_time[CP_NICE]++;
|
|
|
|
else
|
|
|
|
cp_time[CP_USER]++;
|
|
|
|
} 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.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
if ((td->td_ithd != NULL) || td->td_intr_nesting_level >= 2) {
|
2004-10-05 18:51:11 +00:00
|
|
|
p->p_rux.rux_iticks++;
|
1994-05-24 10:09:53 +00:00
|
|
|
cp_time[CP_INTR]++;
|
2000-09-07 01:33:02 +00:00
|
|
|
} else {
|
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);
|
2003-02-17 02:19:58 +00:00
|
|
|
td->td_sticks++;
|
2004-10-05 18:51:11 +00:00
|
|
|
p->p_rux.rux_sticks++;
|
2001-09-12 08:38:13 +00:00
|
|
|
if (p != PCPU_GET(idlethread)->td_proc)
|
2000-09-07 01:33:02 +00:00
|
|
|
cp_time[CP_SYS]++;
|
|
|
|
else
|
|
|
|
cp_time[CP_IDLE]++;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2004-12-26 00:14:21 +00:00
|
|
|
CTR4(KTR_SCHED, "statclock: %p(%s) prio %d stathz %d",
|
|
|
|
td, td->td_proc->p_comm, td->td_priority, (stathz)?stathz:hz);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-10-16 08:39:15 +00:00
|
|
|
sched_clock(td);
|
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_stats != NULL);
|
|
|
|
MPASS(p->p_vmspace != NULL);
|
|
|
|
vm = p->p_vmspace;
|
|
|
|
ru = &p->p_stats->p_ru;
|
|
|
|
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;
|
2003-02-03 17:53:15 +00:00
|
|
|
mtx_unlock_spin_flags(&sched_lock, MTX_QUIET);
|
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
|
2003-02-03 17:53:15 +00:00
|
|
|
profclock(frame)
|
2001-04-27 19:28:25 +00:00
|
|
|
register struct clockframe *frame;
|
|
|
|
{
|
2003-02-03 17:53:15 +00:00
|
|
|
struct thread *td;
|
|
|
|
#ifdef GPROF
|
|
|
|
struct gmonparam *g;
|
|
|
|
int i;
|
|
|
|
#endif
|
2001-04-27 19:28:25 +00:00
|
|
|
|
2003-02-17 09:55:10 +00:00
|
|
|
td = curthread;
|
2003-02-03 17:53:15 +00:00
|
|
|
if (CLKF_USERMODE(frame)) {
|
|
|
|
/*
|
|
|
|
* 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)
|
2003-02-17 09:55:10 +00:00
|
|
|
addupc_intr(td, CLKF_PC(frame), 1);
|
2003-02-03 17:53:15 +00:00
|
|
|
}
|
|
|
|
#ifdef GPROF
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* Kernel statistics are just like addupc_intr, only easier.
|
|
|
|
*/
|
|
|
|
g = &_gmonparam;
|
|
|
|
if (g->state == GMON_PROF_ON) {
|
|
|
|
i = CLKF_PC(frame) - g->lowpc;
|
|
|
|
if (i < g->textsize) {
|
|
|
|
i /= HISTFRACTION * sizeof(*g->kcount);
|
|
|
|
g->kcount[i]++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#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
|
|
|
|
watchdog_config(void *unused __unused, u_int cmd, int *err)
|
|
|
|
{
|
|
|
|
u_int u;
|
|
|
|
|
2004-02-28 22:01:19 +00:00
|
|
|
u = cmd & WD_INTERVAL;
|
|
|
|
if (cmd && u >= WD_TO_1SEC) {
|
2004-02-28 20:56:35 +00:00
|
|
|
u = cmd & WD_INTERVAL;
|
|
|
|
watchdog_ticks = (1 << (u - WD_TO_1SEC)) * hz;
|
|
|
|
watchdog_enabled = 1;
|
|
|
|
*err = 0;
|
|
|
|
} else {
|
|
|
|
watchdog_enabled = 0;
|
|
|
|
}
|
2003-06-26 09:50:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle a watchdog timeout by dumping interrupt information and
|
|
|
|
* then either dropping to DDB or panicing.
|
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
|
|
|
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);
|
2003-06-26 09:50:52 +00:00
|
|
|
|
2004-07-10 21:36:01 +00:00
|
|
|
#ifdef KDB
|
|
|
|
kdb_backtrace();
|
|
|
|
kdb_enter("watchdog timeout");
|
|
|
|
#else
|
2003-06-26 09:50:52 +00:00
|
|
|
panic("watchdog timeout");
|
2004-07-10 21:36:01 +00:00
|
|
|
#endif /* KDB */
|
2003-06-26 09:50:52 +00:00
|
|
|
}
|
|
|
|
|
2004-02-28 20:56:35 +00:00
|
|
|
#endif /* SW_WATCHDOG */
|