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>
|
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");
|
|
|
|
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;
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
2003-11-15 18:33:54 +00:00
|
|
|
struct mtx dont_sleep_in_callout;
|
2003-11-12 22:28:27 +00:00
|
|
|
#endif
|
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
|
|
|
|
|
|
|
/*-
|
2004-04-06 23:08:49 +00:00
|
|
|
* Locked by callout_lock:
|
|
|
|
* curr_callout - If a callout is in progress, it is curr_callout.
|
|
|
|
* If curr_callout is non-NULL, threads waiting on
|
|
|
|
* callout_wait will be woken up as soon as the
|
|
|
|
* relevant callout completes.
|
|
|
|
* wakeup_ctr - Incremented every time a thread wants to wait
|
|
|
|
* for a callout to complete. Modified only when
|
|
|
|
* curr_callout is non-NULL.
|
2004-04-08 02:03:49 +00:00
|
|
|
* wakeup_needed - If a thread is waiting on callout_wait, then
|
|
|
|
* wakeup_needed is nonzero. Increased only when
|
|
|
|
* cutt_callout is non-NULL.
|
2004-04-06 23:08:49 +00:00
|
|
|
*/
|
|
|
|
static struct callout *curr_callout;
|
|
|
|
static int wakeup_ctr;
|
2004-04-08 02:03:49 +00:00
|
|
|
static int wakeup_needed;
|
|
|
|
|
|
|
|
/*-
|
2004-04-06 23:08:49 +00:00
|
|
|
* Locked by callout_wait_lock:
|
|
|
|
* callout_wait - If wakeup_needed is set, callout_wait will be
|
|
|
|
* triggered after the current callout finishes.
|
|
|
|
* wakeup_done_ctr - Set to the current value of wakeup_ctr after
|
|
|
|
* callout_wait is triggered.
|
|
|
|
*/
|
|
|
|
static struct mtx callout_wait_lock;
|
|
|
|
static struct cv callout_wait;
|
|
|
|
static int wakeup_done_ctr;
|
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);
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
2003-11-15 18:33:54 +00:00
|
|
|
mtx_init(&dont_sleep_in_callout, "dont_sleep_in_callout", NULL, MTX_DEF);
|
2003-11-12 22:28:27 +00:00
|
|
|
#endif
|
2004-04-06 23:08:49 +00:00
|
|
|
mtx_init(&callout_wait_lock, "callout_wait_lock", NULL, MTX_DEF);
|
|
|
|
cv_init(&callout_wait, "callout_wait");
|
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;
|
|
|
|
int gcalls;
|
2004-04-06 23:08:49 +00:00
|
|
|
int wakeup_cookie;
|
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;
|
|
|
|
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;
|
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;
|
2000-11-19 06:02:32 +00:00
|
|
|
c_flags = c->c_flags;
|
1997-09-21 22:00:25 +00:00
|
|
|
c->c_func = NULL;
|
1999-03-06 04:46:20 +00:00
|
|
|
if (c->c_flags & CALLOUT_LOCAL_ALLOC) {
|
|
|
|
c->c_flags = CALLOUT_LOCAL_ALLOC;
|
|
|
|
SLIST_INSERT_HEAD(&callfree, c,
|
|
|
|
c_links.sle);
|
|
|
|
} else {
|
|
|
|
c->c_flags =
|
1999-08-30 21:17:07 +00:00
|
|
|
(c->c_flags & ~CALLOUT_PENDING);
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
2004-04-06 23:08:49 +00:00
|
|
|
curr_callout = c;
|
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);
|
2003-06-04 05:25:58 +00:00
|
|
|
if (!(c_flags & CALLOUT_MPSAFE)) {
|
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(&Giant);
|
2003-06-04 05:25:58 +00:00
|
|
|
gcalls++;
|
2004-08-06 21:49:00 +00:00
|
|
|
CTR1(KTR_CALLOUT, "callout %p", c_func);
|
2003-06-04 05:25:58 +00:00
|
|
|
} else {
|
|
|
|
mpcalls++;
|
2004-08-06 21:49:00 +00:00
|
|
|
CTR1(KTR_CALLOUT, "callout mpsafe %p",
|
|
|
|
c_func);
|
2003-06-04 05:25:58 +00:00
|
|
|
}
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
binuptime(&bt1);
|
2003-11-15 18:33:54 +00:00
|
|
|
mtx_lock(&dont_sleep_in_callout);
|
2003-11-12 22:28:27 +00:00
|
|
|
#endif
|
1997-09-21 22:00:25 +00:00
|
|
|
c_func(c_arg);
|
2003-11-12 22:28:27 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
2003-11-15 18:33:54 +00:00
|
|
|
mtx_unlock(&dont_sleep_in_callout);
|
2003-11-12 22:28:27 +00:00
|
|
|
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
|
2000-11-19 06:02:32 +00:00
|
|
|
if (!(c_flags & CALLOUT_MPSAFE))
|
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(&Giant);
|
|
|
|
mtx_lock_spin(&callout_lock);
|
2004-04-06 23:08:49 +00:00
|
|
|
curr_callout = NULL;
|
|
|
|
if (wakeup_needed) {
|
|
|
|
/*
|
|
|
|
* There might be someone waiting
|
|
|
|
* for the callout to complete.
|
|
|
|
*/
|
|
|
|
wakeup_cookie = wakeup_ctr;
|
|
|
|
mtx_unlock_spin(&callout_lock);
|
|
|
|
mtx_lock(&callout_wait_lock);
|
|
|
|
cv_broadcast(&callout_wait);
|
|
|
|
wakeup_done_ctr = wakeup_cookie;
|
|
|
|
mtx_unlock(&callout_wait_lock);
|
|
|
|
mtx_lock_spin(&callout_lock);
|
|
|
|
wakeup_needed = 0;
|
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;
|
|
|
|
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
|
|
|
*
|
1999-08-30 21:17:07 +00:00
|
|
|
* callout_active() - returns truth if callout has not been serviced
|
|
|
|
* 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
|
|
|
*/
|
|
|
|
void
|
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;
|
|
|
|
{
|
|
|
|
|
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
|
|
|
if (c == curr_callout && wakeup_needed) {
|
|
|
|
/*
|
|
|
|
* We're being asked to reschedule a callout which is
|
|
|
|
* currently in progress, and someone has called
|
|
|
|
* callout_drain to kill that callout. Don't reschedule.
|
|
|
|
*/
|
|
|
|
mtx_unlock_spin(&callout_lock);
|
|
|
|
return;
|
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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
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);
|
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;
|
|
|
|
{
|
|
|
|
int wakeup_cookie;
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
* Don't attempt to delete a callout that's not on the queue.
|
|
|
|
*/
|
|
|
|
if (!(c->c_flags & CALLOUT_PENDING)) {
|
1999-08-30 21:17:07 +00:00
|
|
|
c->c_flags &= ~CALLOUT_ACTIVE;
|
2004-04-06 23:08:49 +00:00
|
|
|
if (c == curr_callout && safe) {
|
2004-04-08 02:03:49 +00:00
|
|
|
/* We need to wait until the callout is finished. */
|
2004-04-06 23:08:49 +00:00
|
|
|
wakeup_needed = 1;
|
|
|
|
wakeup_cookie = wakeup_ctr++;
|
|
|
|
mtx_unlock_spin(&callout_lock);
|
|
|
|
mtx_lock(&callout_wait_lock);
|
2004-04-08 02:03:49 +00:00
|
|
|
|
2004-04-06 23:08:49 +00:00
|
|
|
/*
|
|
|
|
* Check to make sure that softclock() didn't
|
|
|
|
* do the wakeup in between our dropping
|
|
|
|
* callout_lock and picking up callout_wait_lock
|
|
|
|
*/
|
|
|
|
if (wakeup_cookie - wakeup_done_ctr > 0)
|
|
|
|
cv_wait(&callout_wait, &callout_wait_lock);
|
|
|
|
|
|
|
|
mtx_unlock(&callout_wait_lock);
|
|
|
|
} else
|
|
|
|
mtx_unlock_spin(&callout_lock);
|
2001-08-10 21:06:59 +00:00
|
|
|
return (0);
|
1999-03-06 04:46:20 +00:00
|
|
|
}
|
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);
|
|
|
|
c->c_func = NULL;
|
|
|
|
|
|
|
|
if (c->c_flags & CALLOUT_LOCAL_ALLOC) {
|
|
|
|
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);
|
2000-11-25 06:22:16 +00:00
|
|
|
if (mpsafe)
|
|
|
|
c->c_flags |= CALLOUT_MPSAFE;
|
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 */
|