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.
|
|
|
|
*
|
1999-03-06 04:46:20 +00:00
|
|
|
* From: @(#)kern_clock.c 8.5 (Berkeley) 1/21/94
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1998-02-15 14:15:21 +00:00
|
|
|
#include <sys/callout.h>
|
2004-04-06 23:08:49 +00:00
|
|
|
#include <sys/condvar.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
2004-08-06 21:49:00 +00:00
|
|
|
#include <sys/ktr.h>
|
2001-03-28 09:17:56 +00:00
|
|
|
#include <sys/lock.h>
|
2000-11-16 21:20:52 +00:00
|
|
|
#include <sys/mutex.h>
|
2005-09-15 20:20:36 +00:00
|
|
|
#include <sys/proc.h>
|
2007-06-26 21:42:01 +00:00
|
|
|
#include <sys/sleepqueue.h>
|
2003-06-04 05:25:58 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-06-04 05:25:58 +00:00
|
|
|
static int avg_depth;
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, to_avg_depth, CTLFLAG_RD, &avg_depth, 0,
|
|
|
|
"Average number of items examined per softclock call. Units = 1/1000");
|
|
|
|
static int avg_gcalls;
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, to_avg_gcalls, CTLFLAG_RD, &avg_gcalls, 0,
|
|
|
|
"Average number of Giant callouts made per softclock call. Units = 1/1000");
|
2005-02-07 02:47:33 +00:00
|
|
|
static int avg_mtxcalls;
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, to_avg_mtxcalls, CTLFLAG_RD, &avg_mtxcalls, 0,
|
|
|
|
"Average number of mtx callouts made per softclock call. Units = 1/1000");
|
2003-06-04 05:25:58 +00:00
|
|
|
static int avg_mpcalls;
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, to_avg_mpcalls, CTLFLAG_RD, &avg_mpcalls, 0,
|
|
|
|
"Average number of MP callouts made per softclock call. Units = 1/1000");
|
1998-02-15 14:15:21 +00:00
|
|
|
/*
|
|
|
|
* TODO:
|
|
|
|
* allocate more timeout table slots when table overflows.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Exported to machdep.c and/or kern_clock.c. */
|
1997-09-21 22:00:25 +00:00
|
|
|
struct callout *callout;
|
|
|
|
struct callout_list callfree;
|
|
|
|
int callwheelsize, callwheelbits, callwheelmask;
|
|
|
|
struct callout_tailq *callwheel;
|
1998-02-15 14:15:21 +00:00
|
|
|
int softticks; /* Like ticks, but for softclock(). */
|
2003-06-20 08:39:04 +00:00
|
|
|
struct mtx callout_lock;
|
1994-08-18 22:36:09 +00:00
|
|
|
|
1997-09-21 22:00:25 +00:00
|
|
|
static struct callout *nextsoftcheck; /* Next callout to be checked. */
|
2004-04-08 02:03:49 +00:00
|
|
|
|
2005-01-07 03:25:45 +00:00
|
|
|
/**
|
2004-04-06 23:08:49 +00:00
|
|
|
* Locked by callout_lock:
|
|
|
|
* curr_callout - If a callout is in progress, it is curr_callout.
|
2006-02-23 19:13:12 +00:00
|
|
|
* If curr_callout is non-NULL, threads waiting in
|
|
|
|
* callout_drain() will be woken up as soon as the
|
2004-04-06 23:08:49 +00:00
|
|
|
* relevant callout completes.
|
2005-02-07 02:47:33 +00:00
|
|
|
* curr_cancelled - Changing to 1 with both callout_lock and c_mtx held
|
|
|
|
* guarantees that the current callout will not run.
|
|
|
|
* The softclock() function sets this to 0 before it
|
|
|
|
* drops callout_lock to acquire c_mtx, and it calls
|
2006-02-23 19:13:12 +00:00
|
|
|
* the handler only if curr_cancelled is still 0 after
|
2005-02-07 02:47:33 +00:00
|
|
|
* c_mtx is successfully acquired.
|
2006-02-23 19:13:12 +00:00
|
|
|
* callout_wait - If a thread is waiting in callout_drain(), then
|
|
|
|
* callout_wait is nonzero. Set only when
|
2004-04-06 23:08:49 +00:00
|
|
|
* curr_callout is non-NULL.
|
|
|
|
*/
|
|
|
|
static struct callout *curr_callout;
|
2005-02-07 02:47:33 +00:00
|
|
|
static int curr_cancelled;
|
2006-02-23 19:13:12 +00:00
|
|
|
static int callout_wait;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-08-22 04:07:27 +00:00
|
|
|
/*
|
|
|
|
* kern_timeout_callwheel_alloc() - kernel low level callwheel initialization
|
|
|
|
*
|
|
|
|
* This code is called very early in the kernel initialization sequence,
|
|
|
|
* and may be called more then once.
|
|
|
|
*/
|
|
|
|
caddr_t
|
|
|
|
kern_timeout_callwheel_alloc(caddr_t v)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Calculate callout wheel size
|
|
|
|
*/
|
|
|
|
for (callwheelsize = 1, callwheelbits = 0;
|
|
|
|
callwheelsize < ncallout;
|
|
|
|
callwheelsize <<= 1, ++callwheelbits)
|
|
|
|
;
|
|
|
|
callwheelmask = callwheelsize - 1;
|
|
|
|
|
|
|
|
callout = (struct callout *)v;
|
|
|
|
v = (caddr_t)(callout + ncallout);
|
|
|
|
callwheel = (struct callout_tailq *)v;
|
|
|
|
v = (caddr_t)(callwheel + callwheelsize);
|
|
|
|
return(v);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* kern_timeout_callwheel_init() - initialize previously reserved callwheel
|
|
|
|
* space.
|
|
|
|
*
|
|
|
|
* This code is called just once, after the space reserved for the
|
|
|
|
* callout wheel has been finalized.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
kern_timeout_callwheel_init(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
SLIST_INIT(&callfree);
|
|
|
|
for (i = 0; i < ncallout; i++) {
|
|
|
|
callout_init(&callout[i], 0);
|
|
|
|
callout[i].c_flags = CALLOUT_LOCAL_ALLOC;
|
|
|
|
SLIST_INSERT_HEAD(&callfree, &callout[i], c_links.sle);
|
|
|
|
}
|
|
|
|
for (i = 0; i < callwheelsize; i++) {
|
|
|
|
TAILQ_INIT(&callwheel[i]);
|
|
|
|
}
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&callout_lock, "callout", NULL, MTX_SPIN | MTX_RECURSE);
|
2001-08-22 04:07:27 +00:00
|
|
|
}
|
|
|
|
|
1997-09-21 22:00:25 +00:00
|
|
|
/*
|
|
|
|
* The callout mechanism is based on the work of Adam M. Costello and
|
|
|
|
* George Varghese, published in a technical report entitled "Redesigning
|
|
|
|
* the BSD Callout and Timer Facilities" and modified slightly for inclusion
|
|
|
|
* in FreeBSD by Justin T. Gibbs. The original work on the data structures
|
2004-04-25 04:10:17 +00:00
|
|
|
* used in this implementation was published by G. Varghese and T. Lauck in
|
1997-09-21 22:00:25 +00:00
|
|
|
* the paper "Hashed and Hierarchical Timing Wheels: Data Structures for
|
|
|
|
* the Efficient Implementation of a Timer Facility" in the Proceedings of
|
|
|
|
* the 11th ACM Annual Symposium on Operating Systems Principles,
|
|
|
|
* Austin, Texas Nov 1987.
|
|
|
|
*/
|
1998-01-10 13:16:26 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Software (low priority) clock interrupt.
|
|
|
|
* Run periodic events from timeout queue.
|
|
|
|
*/
|
|
|
|
void
|
2000-10-25 05:19:40 +00:00
|
|
|
softclock(void *dummy)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-09-04 20:05:00 +00:00
|
|
|
struct callout *c;
|
|
|
|
struct callout_tailq *bucket;
|
|
|
|
int curticks;
|
|
|
|
int steps; /* #steps since we last allowed interrupts */
|
2003-06-04 05:25:58 +00:00
|
|
|
int depth;
|
|
|
|
int mpcalls;
|
2005-02-07 02:47:33 +00:00
|
|
|
int mtxcalls;
|
2003-06-04 05:25:58 +00:00
|
|
|
int gcalls;
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
struct bintime bt1, bt2;
|
|
|
|
struct timespec ts2;
|
|
|
|
static uint64_t maxdt = 36893488147419102LL; /* 2 msec */
|
2003-12-07 20:03:28 +00:00
|
|
|
static timeout_t *lastfunc;
|
2003-11-12 22:28:27 +00:00
|
|
|
#endif
|
1998-01-10 13:16:26 +00:00
|
|
|
|
1998-02-15 14:15:21 +00:00
|
|
|
#ifndef MAX_SOFTCLOCK_STEPS
|
|
|
|
#define MAX_SOFTCLOCK_STEPS 100 /* Maximum allowed value of steps. */
|
|
|
|
#endif /* MAX_SOFTCLOCK_STEPS */
|
1997-09-21 22:00:25 +00:00
|
|
|
|
2003-06-04 05:25:58 +00:00
|
|
|
mpcalls = 0;
|
2005-02-07 02:47:33 +00:00
|
|
|
mtxcalls = 0;
|
2003-06-04 05:25:58 +00:00
|
|
|
gcalls = 0;
|
|
|
|
depth = 0;
|
1997-09-21 22:00:25 +00:00
|
|
|
steps = 0;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
1997-09-21 22:00:25 +00:00
|
|
|
while (softticks != ticks) {
|
1997-09-24 16:39:27 +00:00
|
|
|
softticks++;
|
|
|
|
/*
|
|
|
|
* softticks may be modified by hard clock, so cache
|
|
|
|
* it while we work on a given bucket.
|
|
|
|
*/
|
|
|
|
curticks = softticks;
|
|
|
|
bucket = &callwheel[curticks & callwheelmask];
|
|
|
|
c = TAILQ_FIRST(bucket);
|
1997-09-21 22:00:25 +00:00
|
|
|
while (c) {
|
2003-06-04 05:25:58 +00:00
|
|
|
depth++;
|
1997-09-24 16:39:27 +00:00
|
|
|
if (c->c_time != curticks) {
|
1997-09-21 22:00:25 +00:00
|
|
|
c = TAILQ_NEXT(c, c_links.tqe);
|
|
|
|
++steps;
|
|
|
|
if (steps >= MAX_SOFTCLOCK_STEPS) {
|
|
|
|
nextsoftcheck = c;
|
1997-09-24 16:39:27 +00:00
|
|
|
/* Give interrupts a chance. */
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2001-08-10 01:36:25 +00:00
|
|
|
; /* nothing */
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
1997-09-21 22:00:25 +00:00
|
|
|
c = nextsoftcheck;
|
|
|
|
steps = 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
void (*c_func)(void *);
|
|
|
|
void *c_arg;
|
2005-02-07 02:47:33 +00:00
|
|
|
struct mtx *c_mtx;
|
2000-11-19 06:02:32 +00:00
|
|
|
int c_flags;
|
1997-09-21 22:00:25 +00:00
|
|
|
|
|
|
|
nextsoftcheck = TAILQ_NEXT(c, c_links.tqe);
|
1997-09-24 16:39:27 +00:00
|
|
|
TAILQ_REMOVE(bucket, c, c_links.tqe);
|
1997-09-21 22:00:25 +00:00
|
|
|
c_func = c->c_func;
|
|
|
|
c_arg = c->c_arg;
|
2005-02-07 02:47:33 +00:00
|
|
|
c_mtx = c->c_mtx;
|
2000-11-19 06:02:32 +00:00
|
|
|
c_flags = c->c_flags;
|
1999-03-06 04:46:20 +00:00
|
|
|
if (c->c_flags & CALLOUT_LOCAL_ALLOC) {
|
2005-01-19 20:34:46 +00:00
|
|
|
c->c_func = NULL;
|
1999-03-06 04:46:20 +00:00
|
|
|
c->c_flags = CALLOUT_LOCAL_ALLOC;
|
|
|
|
SLIST_INSERT_HEAD(&callfree, c,
|
|
|
|
c_links.sle);
|
2005-02-11 00:14:00 +00:00
|
|
|
curr_callout = NULL;
|
1999-03-06 04:46:20 +00:00
|
|
|
} else {
|
|
|
|
c->c_flags =
|
1999-08-30 21:17:07 +00:00
|
|
|
(c->c_flags & ~CALLOUT_PENDING);
|
2005-02-11 00:14:00 +00:00
|
|
|
curr_callout = c;
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
2005-02-07 02:47:33 +00:00
|
|
|
curr_cancelled = 0;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2005-02-07 02:47:33 +00:00
|
|
|
if (c_mtx != NULL) {
|
|
|
|
mtx_lock(c_mtx);
|
|
|
|
/*
|
|
|
|
* The callout may have been cancelled
|
|
|
|
* while we switched locks.
|
|
|
|
*/
|
|
|
|
if (curr_cancelled) {
|
|
|
|
mtx_unlock(c_mtx);
|
2006-02-23 19:13:12 +00:00
|
|
|
goto skip;
|
2005-02-07 02:47:33 +00:00
|
|
|
}
|
|
|
|
/* The callout cannot be stopped now. */
|
|
|
|
curr_cancelled = 1;
|
|
|
|
|
|
|
|
if (c_mtx == &Giant) {
|
|
|
|
gcalls++;
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT,
|
|
|
|
"callout %p func %p arg %p",
|
|
|
|
c, c_func, c_arg);
|
2005-02-07 02:47:33 +00:00
|
|
|
} else {
|
|
|
|
mtxcalls++;
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT, "callout mtx"
|
|
|
|
" %p func %p arg %p",
|
|
|
|
c, c_func, c_arg);
|
2005-02-07 02:47:33 +00:00
|
|
|
}
|
2003-06-04 05:25:58 +00:00
|
|
|
} else {
|
|
|
|
mpcalls++;
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT,
|
|
|
|
"callout mpsafe %p func %p arg %p",
|
|
|
|
c, c_func, c_arg);
|
2003-06-04 05:25:58 +00:00
|
|
|
}
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
binuptime(&bt1);
|
|
|
|
#endif
|
2005-09-15 20:09:08 +00:00
|
|
|
THREAD_NO_SLEEPING();
|
1997-09-21 22:00:25 +00:00
|
|
|
c_func(c_arg);
|
2005-09-15 20:09:08 +00:00
|
|
|
THREAD_SLEEPING_OK();
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
binuptime(&bt2);
|
|
|
|
bintime_sub(&bt2, &bt1);
|
|
|
|
if (bt2.frac > maxdt) {
|
2003-12-07 20:03:28 +00:00
|
|
|
if (lastfunc != c_func ||
|
|
|
|
bt2.frac > maxdt * 2) {
|
|
|
|
bintime2timespec(&bt2, &ts2);
|
|
|
|
printf(
|
|
|
|
"Expensive timeout(9) function: %p(%p) %jd.%09ld s\n",
|
|
|
|
c_func, c_arg,
|
|
|
|
(intmax_t)ts2.tv_sec,
|
|
|
|
ts2.tv_nsec);
|
|
|
|
}
|
2003-11-12 22:28:27 +00:00
|
|
|
maxdt = bt2.frac;
|
2003-12-07 20:03:28 +00:00
|
|
|
lastfunc = c_func;
|
2003-11-12 22:28:27 +00:00
|
|
|
}
|
|
|
|
#endif
|
2005-02-07 02:47:33 +00:00
|
|
|
if ((c_flags & CALLOUT_RETURNUNLOCKED) == 0)
|
|
|
|
mtx_unlock(c_mtx);
|
2006-02-23 19:13:12 +00:00
|
|
|
skip:
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
2004-04-06 23:08:49 +00:00
|
|
|
curr_callout = NULL;
|
2006-02-23 19:13:12 +00:00
|
|
|
if (callout_wait) {
|
2004-04-06 23:08:49 +00:00
|
|
|
/*
|
2006-02-23 19:13:12 +00:00
|
|
|
* There is someone waiting
|
2004-04-06 23:08:49 +00:00
|
|
|
* for the callout to complete.
|
|
|
|
*/
|
2006-02-23 19:13:12 +00:00
|
|
|
callout_wait = 0;
|
2007-06-26 21:42:01 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
|
|
|
wakeup(&callout_wait);
|
|
|
|
mtx_lock_spin(&callout_lock);
|
2004-04-08 02:03:49 +00:00
|
|
|
}
|
1997-09-21 22:00:25 +00:00
|
|
|
steps = 0;
|
|
|
|
c = nextsoftcheck;
|
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-06-04 05:25:58 +00:00
|
|
|
avg_depth += (depth * 1000 - avg_depth) >> 8;
|
|
|
|
avg_mpcalls += (mpcalls * 1000 - avg_mpcalls) >> 8;
|
2005-02-07 02:47:33 +00:00
|
|
|
avg_mtxcalls += (mtxcalls * 1000 - avg_mtxcalls) >> 8;
|
2003-06-04 05:25:58 +00:00
|
|
|
avg_gcalls += (gcalls * 1000 - avg_gcalls) >> 8;
|
1997-09-21 22:00:25 +00:00
|
|
|
nextsoftcheck = NULL;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* timeout --
|
|
|
|
* Execute a function after a specified length of time.
|
|
|
|
*
|
|
|
|
* untimeout --
|
|
|
|
* Cancel previous timeout function call.
|
|
|
|
*
|
1997-09-21 22:00:25 +00:00
|
|
|
* callout_handle_init --
|
|
|
|
* Initialize a handle so that using it with untimeout is benign.
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* See AT&T BCI Driver Reference Manual for specification. This
|
1997-09-21 22:00:25 +00:00
|
|
|
* implementation differs from that one in that although an
|
|
|
|
* identification value is returned from timeout, the original
|
|
|
|
* arguments to timeout as well as the identifier are used to
|
|
|
|
* identify entries for untimeout.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-09-21 22:00:25 +00:00
|
|
|
struct callout_handle
|
|
|
|
timeout(ftn, arg, to_ticks)
|
1998-02-25 06:13:32 +00:00
|
|
|
timeout_t *ftn;
|
1994-05-24 10:09:53 +00:00
|
|
|
void *arg;
|
2000-11-25 06:22:16 +00:00
|
|
|
int to_ticks;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-09-21 22:00:25 +00:00
|
|
|
struct callout *new;
|
|
|
|
struct callout_handle handle;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/* Fill in the next free callout structure. */
|
1997-09-21 22:00:25 +00:00
|
|
|
new = SLIST_FIRST(&callfree);
|
|
|
|
if (new == NULL)
|
|
|
|
/* XXX Attempt to malloc first */
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("timeout table full");
|
1997-09-21 22:00:25 +00:00
|
|
|
SLIST_REMOVE_HEAD(&callfree, c_links.sle);
|
1999-03-06 04:46:20 +00:00
|
|
|
|
|
|
|
callout_reset(new, to_ticks, ftn, arg);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-09-21 22:00:25 +00:00
|
|
|
handle.callout = new;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
1997-09-21 22:00:25 +00:00
|
|
|
return (handle);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1997-09-21 22:00:25 +00:00
|
|
|
untimeout(ftn, arg, handle)
|
1998-02-25 06:13:32 +00:00
|
|
|
timeout_t *ftn;
|
1994-05-24 10:09:53 +00:00
|
|
|
void *arg;
|
1997-09-21 22:00:25 +00:00
|
|
|
struct callout_handle handle;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
1997-09-21 22:00:25 +00:00
|
|
|
/*
|
|
|
|
* Check for a handle that was initialized
|
|
|
|
* by callout_handle_init, but never used
|
|
|
|
* for a real timeout.
|
|
|
|
*/
|
|
|
|
if (handle.callout == NULL)
|
|
|
|
return;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
1999-03-06 04:46:20 +00:00
|
|
|
if (handle.callout->c_func == ftn && handle.callout->c_arg == arg)
|
|
|
|
callout_stop(handle.callout);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1997-09-21 22:00:25 +00:00
|
|
|
void
|
|
|
|
callout_handle_init(struct callout_handle *handle)
|
|
|
|
{
|
|
|
|
handle->callout = NULL;
|
|
|
|
}
|
|
|
|
|
1999-03-06 04:46:20 +00:00
|
|
|
/*
|
|
|
|
* New interface; clients allocate their own callout structures.
|
|
|
|
*
|
|
|
|
* callout_reset() - establish or change a timeout
|
|
|
|
* callout_stop() - disestablish a timeout
|
|
|
|
* callout_init() - initialize a callout structure so that it can
|
|
|
|
* safely be passed to callout_reset() and callout_stop()
|
|
|
|
*
|
1999-08-30 21:17:07 +00:00
|
|
|
* <sys/callout.h> defines three convenience macros:
|
1999-03-06 04:46:20 +00:00
|
|
|
*
|
2005-01-19 19:46:35 +00:00
|
|
|
* callout_active() - returns truth if callout has not been stopped,
|
|
|
|
* drained, or deactivated since the last time the callout was
|
|
|
|
* reset.
|
1999-08-30 21:17:07 +00:00
|
|
|
* callout_pending() - returns truth if callout is still waiting for timeout
|
|
|
|
* callout_deactivate() - marks the callout as having been serviced
|
1999-03-06 04:46:20 +00:00
|
|
|
*/
|
2005-09-08 14:20:39 +00:00
|
|
|
int
|
2000-11-25 06:22:16 +00:00
|
|
|
callout_reset(c, to_ticks, ftn, arg)
|
1999-03-06 04:46:20 +00:00
|
|
|
struct callout *c;
|
|
|
|
int to_ticks;
|
2002-03-19 21:25:46 +00:00
|
|
|
void (*ftn)(void *);
|
1999-03-06 04:46:20 +00:00
|
|
|
void *arg;
|
|
|
|
{
|
2005-09-08 14:20:39 +00:00
|
|
|
int cancelled = 0;
|
1999-03-06 04:46:20 +00:00
|
|
|
|
2005-02-07 02:47:33 +00:00
|
|
|
#ifdef notyet /* Some callers of timeout() do not hold Giant. */
|
|
|
|
if (c->c_mtx != NULL)
|
|
|
|
mtx_assert(c->c_mtx, MA_OWNED);
|
|
|
|
#endif
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
2005-02-07 02:47:33 +00:00
|
|
|
if (c == curr_callout) {
|
2004-04-06 23:08:49 +00:00
|
|
|
/*
|
|
|
|
* We're being asked to reschedule a callout which is
|
2005-02-07 02:47:33 +00:00
|
|
|
* currently in progress. If there is a mutex then we
|
|
|
|
* can cancel the callout if it has not really started.
|
2004-04-06 23:08:49 +00:00
|
|
|
*/
|
2005-02-07 02:47:33 +00:00
|
|
|
if (c->c_mtx != NULL && !curr_cancelled)
|
2005-09-08 14:20:39 +00:00
|
|
|
cancelled = curr_cancelled = 1;
|
2006-02-23 19:13:12 +00:00
|
|
|
if (callout_wait) {
|
2005-02-07 02:47:33 +00:00
|
|
|
/*
|
|
|
|
* Someone has called callout_drain to kill this
|
|
|
|
* callout. Don't reschedule.
|
|
|
|
*/
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR4(KTR_CALLOUT, "%s %p func %p arg %p",
|
|
|
|
cancelled ? "cancelled" : "failed to cancel",
|
|
|
|
c, c->c_func, c->c_arg);
|
2005-02-07 02:47:33 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2005-09-08 14:20:39 +00:00
|
|
|
return (cancelled);
|
2005-02-07 02:47:33 +00:00
|
|
|
}
|
2004-04-08 02:03:49 +00:00
|
|
|
}
|
2004-08-06 02:44:58 +00:00
|
|
|
if (c->c_flags & CALLOUT_PENDING) {
|
|
|
|
if (nextsoftcheck == c) {
|
|
|
|
nextsoftcheck = TAILQ_NEXT(c, c_links.tqe);
|
|
|
|
}
|
|
|
|
TAILQ_REMOVE(&callwheel[c->c_time & callwheelmask], c,
|
|
|
|
c_links.tqe);
|
|
|
|
|
2005-09-08 14:20:39 +00:00
|
|
|
cancelled = 1;
|
|
|
|
|
2004-08-06 02:44:58 +00:00
|
|
|
/*
|
|
|
|
* Part of the normal "stop a pending callout" process
|
|
|
|
* is to clear the CALLOUT_ACTIVE and CALLOUT_PENDING
|
|
|
|
* flags. We're not going to bother doing that here,
|
|
|
|
* because we're going to be setting those flags ten lines
|
|
|
|
* after this point, and we're holding callout_lock
|
|
|
|
* between now and then.
|
|
|
|
*/
|
|
|
|
}
|
1999-03-06 04:46:20 +00:00
|
|
|
|
|
|
|
/*
|
2001-08-10 01:36:25 +00:00
|
|
|
* We could unlock callout_lock here and lock it again before the
|
|
|
|
* TAILQ_INSERT_TAIL, but there's no point since doing this setup
|
|
|
|
* doesn't take much time.
|
1999-03-06 04:46:20 +00:00
|
|
|
*/
|
|
|
|
if (to_ticks <= 0)
|
|
|
|
to_ticks = 1;
|
|
|
|
|
|
|
|
c->c_arg = arg;
|
2000-11-25 06:22:16 +00:00
|
|
|
c->c_flags |= (CALLOUT_ACTIVE | CALLOUT_PENDING);
|
1999-03-06 04:46:20 +00:00
|
|
|
c->c_func = ftn;
|
|
|
|
c->c_time = ticks + to_ticks;
|
|
|
|
TAILQ_INSERT_TAIL(&callwheel[c->c_time & callwheelmask],
|
|
|
|
c, c_links.tqe);
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR5(KTR_CALLOUT, "%sscheduled %p func %p arg %p in %d",
|
|
|
|
cancelled ? "re" : "", c, c->c_func, c->c_arg, to_ticks);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2005-09-08 14:20:39 +00:00
|
|
|
|
|
|
|
return (cancelled);
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
|
|
|
|
2004-04-06 23:08:49 +00:00
|
|
|
int
|
|
|
|
_callout_stop_safe(c, safe)
|
|
|
|
struct callout *c;
|
|
|
|
int safe;
|
|
|
|
{
|
2007-08-31 19:01:30 +00:00
|
|
|
int use_mtx, sq_locked;
|
2005-02-07 02:47:33 +00:00
|
|
|
|
|
|
|
if (!safe && c->c_mtx != NULL) {
|
|
|
|
#ifdef notyet /* Some callers do not hold Giant for Giant-locked callouts. */
|
|
|
|
mtx_assert(c->c_mtx, MA_OWNED);
|
|
|
|
use_mtx = 1;
|
|
|
|
#else
|
|
|
|
use_mtx = mtx_owned(c->c_mtx);
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
use_mtx = 0;
|
|
|
|
}
|
2004-04-06 23:08:49 +00:00
|
|
|
|
2007-08-31 19:01:30 +00:00
|
|
|
sq_locked = 0;
|
|
|
|
again:
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
1999-03-06 04:46:20 +00:00
|
|
|
/*
|
2006-02-23 19:13:12 +00:00
|
|
|
* If the callout isn't pending, it's not on the queue, so
|
|
|
|
* don't attempt to remove it from the queue. We can try to
|
|
|
|
* stop it by other means however.
|
1999-03-06 04:46:20 +00:00
|
|
|
*/
|
|
|
|
if (!(c->c_flags & CALLOUT_PENDING)) {
|
1999-08-30 21:17:07 +00:00
|
|
|
c->c_flags &= ~CALLOUT_ACTIVE;
|
2006-02-23 19:13:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If it wasn't on the queue and it isn't the current
|
|
|
|
* callout, then we can't stop it, so just bail.
|
|
|
|
*/
|
2005-02-07 02:47:33 +00:00
|
|
|
if (c != curr_callout) {
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT, "failed to stop %p func %p arg %p",
|
|
|
|
c, c->c_func, c->c_arg);
|
2005-02-07 02:47:33 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2007-08-31 19:01:30 +00:00
|
|
|
if (sq_locked)
|
|
|
|
sleepq_release(&callout_wait);
|
2005-02-07 02:47:33 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2004-04-08 02:03:49 +00:00
|
|
|
|
2006-02-23 19:13:12 +00:00
|
|
|
if (safe) {
|
2004-04-06 23:08:49 +00:00
|
|
|
/*
|
2006-02-23 19:13:12 +00:00
|
|
|
* The current callout is running (or just
|
|
|
|
* about to run) and blocking is allowed, so
|
|
|
|
* just wait for the current invocation to
|
|
|
|
* finish.
|
2004-04-06 23:08:49 +00:00
|
|
|
*/
|
2006-02-23 19:13:12 +00:00
|
|
|
while (c == curr_callout) {
|
2007-06-26 21:42:01 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use direct calls to sleepqueue interface
|
|
|
|
* instead of cv/msleep in order to avoid
|
|
|
|
* a LOR between callout_lock and sleepqueue
|
|
|
|
* chain spinlocks. This piece of code
|
|
|
|
* emulates a msleep_spin() call actually.
|
2007-08-31 19:01:30 +00:00
|
|
|
*
|
|
|
|
* If we already have the sleepqueue chain
|
|
|
|
* locked, then we can safely block. If we
|
|
|
|
* don't already have it locked, however,
|
|
|
|
* we have to drop the callout_lock to lock
|
|
|
|
* it. This opens several races, so we
|
|
|
|
* restart at the beginning once we have
|
|
|
|
* both locks. If nothing has changed, then
|
|
|
|
* we will end up back here with sq_locked
|
|
|
|
* set.
|
2007-06-26 21:42:01 +00:00
|
|
|
*/
|
2007-08-31 19:01:30 +00:00
|
|
|
if (!sq_locked) {
|
|
|
|
mtx_unlock_spin(&callout_lock);
|
|
|
|
sleepq_lock(&callout_wait);
|
|
|
|
sq_locked = 1;
|
|
|
|
goto again;
|
2007-06-26 21:42:01 +00:00
|
|
|
}
|
2007-08-31 19:01:30 +00:00
|
|
|
|
2006-02-23 19:13:12 +00:00
|
|
|
callout_wait = 1;
|
2007-06-26 21:42:01 +00:00
|
|
|
DROP_GIANT();
|
|
|
|
mtx_unlock_spin(&callout_lock);
|
|
|
|
sleepq_add(&callout_wait,
|
|
|
|
&callout_lock.lock_object, "codrain",
|
|
|
|
SLEEPQ_SLEEP, 0);
|
|
|
|
sleepq_wait(&callout_wait);
|
2007-08-31 19:01:30 +00:00
|
|
|
sq_locked = 0;
|
2007-06-26 21:42:01 +00:00
|
|
|
|
|
|
|
/* Reacquire locks previously released. */
|
|
|
|
PICKUP_GIANT();
|
|
|
|
mtx_lock_spin(&callout_lock);
|
2006-02-23 19:13:12 +00:00
|
|
|
}
|
2005-02-07 02:47:33 +00:00
|
|
|
} else if (use_mtx && !curr_cancelled) {
|
2006-02-23 19:13:12 +00:00
|
|
|
/*
|
|
|
|
* The current callout is waiting for it's
|
|
|
|
* mutex which we hold. Cancel the callout
|
|
|
|
* and return. After our caller drops the
|
|
|
|
* mutex, the callout will be skipped in
|
|
|
|
* softclock().
|
|
|
|
*/
|
2005-02-07 02:47:33 +00:00
|
|
|
curr_cancelled = 1;
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT, "cancelled %p func %p arg %p",
|
|
|
|
c, c->c_func, c->c_arg);
|
2005-02-07 02:47:33 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2007-08-31 19:01:30 +00:00
|
|
|
KASSERT(!sq_locked, ("sleepqueue chain locked"));
|
2005-02-07 02:47:33 +00:00
|
|
|
return (1);
|
2006-02-23 19:13:12 +00:00
|
|
|
}
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT, "failed to stop %p func %p arg %p",
|
|
|
|
c, c->c_func, c->c_arg);
|
2006-02-23 19:13:12 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2007-08-31 19:01:30 +00:00
|
|
|
KASSERT(!sq_locked, ("sleepqueue chain still locked"));
|
2001-08-10 21:06:59 +00:00
|
|
|
return (0);
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
2007-08-31 19:01:30 +00:00
|
|
|
if (sq_locked)
|
|
|
|
sleepq_release(&callout_wait);
|
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
c->c_flags &= ~(CALLOUT_ACTIVE | CALLOUT_PENDING);
|
1999-03-06 04:46:20 +00:00
|
|
|
|
|
|
|
if (nextsoftcheck == c) {
|
|
|
|
nextsoftcheck = TAILQ_NEXT(c, c_links.tqe);
|
|
|
|
}
|
|
|
|
TAILQ_REMOVE(&callwheel[c->c_time & callwheelmask], c, c_links.tqe);
|
|
|
|
|
2006-10-11 14:57:03 +00:00
|
|
|
CTR3(KTR_CALLOUT, "cancelled %p func %p arg %p",
|
|
|
|
c, c->c_func, c->c_arg);
|
|
|
|
|
1999-03-06 04:46:20 +00:00
|
|
|
if (c->c_flags & CALLOUT_LOCAL_ALLOC) {
|
2005-01-19 21:15:58 +00:00
|
|
|
c->c_func = NULL;
|
1999-03-06 04:46:20 +00:00
|
|
|
SLIST_INSERT_HEAD(&callfree, c, c_links.sle);
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
2001-08-10 21:06:59 +00:00
|
|
|
return (1);
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2000-11-25 06:22:16 +00:00
|
|
|
callout_init(c, mpsafe)
|
1999-03-06 04:46:20 +00:00
|
|
|
struct callout *c;
|
2000-11-25 06:22:16 +00:00
|
|
|
int mpsafe;
|
1999-03-06 04:46:20 +00:00
|
|
|
{
|
1999-03-06 22:27:02 +00:00
|
|
|
bzero(c, sizeof *c);
|
2005-02-07 02:47:33 +00:00
|
|
|
if (mpsafe) {
|
|
|
|
c->c_mtx = NULL;
|
|
|
|
c->c_flags = CALLOUT_RETURNUNLOCKED;
|
|
|
|
} else {
|
|
|
|
c->c_mtx = &Giant;
|
|
|
|
c->c_flags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
callout_init_mtx(c, mtx, flags)
|
|
|
|
struct callout *c;
|
|
|
|
struct mtx *mtx;
|
|
|
|
int flags;
|
|
|
|
{
|
|
|
|
bzero(c, sizeof *c);
|
|
|
|
c->c_mtx = mtx;
|
2007-09-15 12:33:24 +00:00
|
|
|
KASSERT((flags & ~(CALLOUT_RETURNUNLOCKED)) == 0,
|
2005-02-07 02:47:33 +00:00
|
|
|
("callout_init_mtx: bad flags %d", flags));
|
|
|
|
/* CALLOUT_RETURNUNLOCKED makes no sense without a mutex. */
|
|
|
|
KASSERT(mtx != NULL || (flags & CALLOUT_RETURNUNLOCKED) == 0,
|
|
|
|
("callout_init_mtx: CALLOUT_RETURNUNLOCKED with no mutex"));
|
2007-09-15 12:33:24 +00:00
|
|
|
c->c_flags = flags & (CALLOUT_RETURNUNLOCKED);
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
|
|
|
|
1997-12-23 16:32:35 +00:00
|
|
|
#ifdef APM_FIXUP_CALLTODO
|
|
|
|
/*
|
|
|
|
* Adjust the kernel calltodo timeout list. This routine is used after
|
|
|
|
* an APM resume to recalculate the calltodo timer list values with the
|
|
|
|
* number of hz's we have been sleeping. The next hardclock() will detect
|
|
|
|
* that there are fired timers and run softclock() to execute them.
|
|
|
|
*
|
|
|
|
* Please note, I have not done an exhaustive analysis of what code this
|
|
|
|
* might break. I am motivated to have my select()'s and alarm()'s that
|
|
|
|
* have expired during suspend firing upon resume so that the applications
|
|
|
|
* which set the timer can do the maintanence the timer was for as close
|
|
|
|
* as possible to the originally intended time. Testing this code for a
|
|
|
|
* week showed that resuming from a suspend resulted in 22 to 25 timers
|
|
|
|
* firing, which seemed independant on whether the suspend was 2 hours or
|
|
|
|
* 2 days. Your milage may vary. - Ken Key <key@cs.utk.edu>
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
adjust_timeout_calltodo(time_change)
|
|
|
|
struct timeval *time_change;
|
|
|
|
{
|
|
|
|
register struct callout *p;
|
|
|
|
unsigned long delta_ticks;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* How many ticks were we asleep?
|
1998-05-17 20:08:05 +00:00
|
|
|
* (stolen from tvtohz()).
|
1997-12-23 16:32:35 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Don't do anything */
|
|
|
|
if (time_change->tv_sec < 0)
|
|
|
|
return;
|
|
|
|
else if (time_change->tv_sec <= LONG_MAX / 1000000)
|
|
|
|
delta_ticks = (time_change->tv_sec * 1000000 +
|
|
|
|
time_change->tv_usec + (tick - 1)) / tick + 1;
|
|
|
|
else if (time_change->tv_sec <= LONG_MAX / hz)
|
|
|
|
delta_ticks = time_change->tv_sec * hz +
|
|
|
|
(time_change->tv_usec + (tick - 1)) / tick + 1;
|
|
|
|
else
|
|
|
|
delta_ticks = LONG_MAX;
|
|
|
|
|
|
|
|
if (delta_ticks > INT_MAX)
|
|
|
|
delta_ticks = INT_MAX;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now rip through the timer calltodo list looking for timers
|
|
|
|
* to expire.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* don't collide with softclock() */
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&callout_lock);
|
1997-12-23 16:32:35 +00:00
|
|
|
for (p = calltodo.c_next; p != NULL; p = p->c_next) {
|
|
|
|
p->c_time -= delta_ticks;
|
|
|
|
|
|
|
|
/* Break if the timer had more time on it than delta_ticks */
|
|
|
|
if (p->c_time > 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* take back the ticks the timer didn't use (p->c_time <= 0) */
|
|
|
|
delta_ticks = -p->c_time;
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&callout_lock);
|
1997-12-23 16:32:35 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* APM_FIXUP_CALLTODO */
|