1997-05-26 14:37:43 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 1997, Stefan Esser <se@freebsd.org>
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* 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 unmodified, 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.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1997-05-26 14:37:43 +00:00
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
1998-06-11 07:23:59 +00:00
|
|
|
|
1998-11-10 09:16:29 +00:00
|
|
|
#include <sys/param.h>
|
2000-09-13 18:33:25 +00:00
|
|
|
#include <sys/bus.h>
|
|
|
|
|
#include <sys/rtprio.h>
|
1997-05-26 14:37:43 +00:00
|
|
|
#include <sys/systm.h>
|
1997-06-02 08:19:06 +00:00
|
|
|
#include <sys/interrupt.h>
|
2000-10-05 23:09:57 +00:00
|
|
|
#include <sys/kernel.h>
|
|
|
|
|
#include <sys/kthread.h>
|
|
|
|
|
#include <sys/ktr.h>
|
2001-03-28 09:17:56 +00:00
|
|
|
#include <sys/lock.h>
|
2000-10-05 23:09:57 +00:00
|
|
|
#include <sys/malloc.h>
|
2000-10-20 07:58:15 +00:00
|
|
|
#include <sys/mutex.h>
|
2000-10-05 23:09:57 +00:00
|
|
|
#include <sys/proc.h>
|
2001-02-20 10:25:29 +00:00
|
|
|
#include <sys/random.h>
|
2001-02-09 17:42:43 +00:00
|
|
|
#include <sys/resourcevar.h>
|
2001-06-01 13:23:28 +00:00
|
|
|
#include <sys/sysctl.h>
|
2000-10-05 23:09:57 +00:00
|
|
|
#include <sys/unistd.h>
|
|
|
|
|
#include <sys/vmmeter.h>
|
|
|
|
|
#include <machine/atomic.h>
|
|
|
|
|
#include <machine/cpu.h>
|
2000-10-25 05:19:40 +00:00
|
|
|
#include <machine/md_var.h>
|
2001-02-09 17:42:43 +00:00
|
|
|
#include <machine/stdarg.h>
|
1997-05-26 14:37:43 +00:00
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
#include <net/netisr.h> /* prototype for legacy_setsoftnet */
|
1998-08-11 15:08:13 +00:00
|
|
|
|
2001-02-20 10:25:29 +00:00
|
|
|
struct int_entropy {
|
|
|
|
|
struct proc *proc;
|
|
|
|
|
int vector;
|
|
|
|
|
};
|
|
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
void *net_ih;
|
|
|
|
|
void *vm_ih;
|
|
|
|
|
void *softclock_ih;
|
|
|
|
|
struct ithd *clk_ithd;
|
|
|
|
|
struct ithd *tty_ithd;
|
2000-10-05 23:09:57 +00:00
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
static MALLOC_DEFINE(M_ITHREAD, "ithread", "Interrupt Threads");
|
|
|
|
|
|
|
|
|
|
static void ithread_update(struct ithd *);
|
|
|
|
|
static void ithread_loop(void *);
|
|
|
|
|
static void start_softintr(void *);
|
|
|
|
|
static void swi_net(void *);
|
|
|
|
|
|
|
|
|
|
u_char
|
|
|
|
|
ithread_priority(enum intr_type flags)
|
2000-09-13 18:33:25 +00:00
|
|
|
{
|
2001-02-09 17:42:43 +00:00
|
|
|
u_char pri;
|
2000-09-13 18:33:25 +00:00
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
flags &= (INTR_TYPE_TTY | INTR_TYPE_BIO | INTR_TYPE_NET |
|
2001-06-16 22:42:19 +00:00
|
|
|
INTR_TYPE_CAM | INTR_TYPE_MISC | INTR_TYPE_CLK | INTR_TYPE_AV);
|
2000-09-13 18:33:25 +00:00
|
|
|
switch (flags) {
|
2001-02-09 17:42:43 +00:00
|
|
|
case INTR_TYPE_TTY:
|
2000-09-13 18:33:25 +00:00
|
|
|
pri = PI_TTYLOW;
|
|
|
|
|
break;
|
|
|
|
|
case INTR_TYPE_BIO:
|
|
|
|
|
/*
|
|
|
|
|
* XXX We need to refine this. BSD/OS distinguishes
|
|
|
|
|
* between tape and disk priorities.
|
|
|
|
|
*/
|
|
|
|
|
pri = PI_DISK;
|
|
|
|
|
break;
|
|
|
|
|
case INTR_TYPE_NET:
|
|
|
|
|
pri = PI_NET;
|
|
|
|
|
break;
|
|
|
|
|
case INTR_TYPE_CAM:
|
|
|
|
|
pri = PI_DISK; /* XXX or PI_CAM? */
|
|
|
|
|
break;
|
2001-06-16 22:42:19 +00:00
|
|
|
case INTR_TYPE_AV: /* Audio/video */
|
|
|
|
|
pri = PI_AV;
|
|
|
|
|
break;
|
2001-02-09 17:42:43 +00:00
|
|
|
case INTR_TYPE_CLK:
|
|
|
|
|
pri = PI_REALTIME;
|
|
|
|
|
break;
|
2000-09-13 18:33:25 +00:00
|
|
|
case INTR_TYPE_MISC:
|
|
|
|
|
pri = PI_DULL; /* don't care */
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2001-02-09 17:42:43 +00:00
|
|
|
/* We didn't specify an interrupt level. */
|
2000-09-13 18:33:25 +00:00
|
|
|
panic("ithread_priority: no interrupt type in flags");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return pri;
|
|
|
|
|
}
|
|
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
/*
|
|
|
|
|
* Regenerate the name (p_comm) and priority for a threaded interrupt thread.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
ithread_update(struct ithd *ithd)
|
|
|
|
|
{
|
|
|
|
|
struct intrhand *ih;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
2001-02-09 17:42:43 +00:00
|
|
|
struct proc *p;
|
|
|
|
|
int entropy;
|
|
|
|
|
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_assert(&ithd->it_lock, MA_OWNED);
|
2001-09-12 08:38:13 +00:00
|
|
|
td = ithd->it_td;
|
|
|
|
|
if (td == NULL)
|
2001-02-09 17:42:43 +00:00
|
|
|
return;
|
2001-09-12 08:38:13 +00:00
|
|
|
p = td->td_proc;
|
2001-02-09 17:42:43 +00:00
|
|
|
|
|
|
|
|
strncpy(p->p_comm, ithd->it_name, sizeof(ithd->it_name));
|
|
|
|
|
ih = TAILQ_FIRST(&ithd->it_handlers);
|
|
|
|
|
if (ih == NULL) {
|
2002-04-11 21:03:35 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
2002-02-11 20:37:54 +00:00
|
|
|
td->td_priority = PRI_MAX_ITHD;
|
2002-04-11 21:03:35 +00:00
|
|
|
td->td_base_pri = PRI_MAX_ITHD;
|
|
|
|
|
mtx_unlock_spin(&sched_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
ithd->it_flags &= ~IT_ENTROPY;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
entropy = 0;
|
2002-04-11 21:03:35 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
2002-02-11 20:37:54 +00:00
|
|
|
td->td_priority = ih->ih_pri;
|
|
|
|
|
td->td_base_pri = ih->ih_pri;
|
2002-04-11 21:03:35 +00:00
|
|
|
mtx_unlock_spin(&sched_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
TAILQ_FOREACH(ih, &ithd->it_handlers, ih_next) {
|
|
|
|
|
if (strlen(p->p_comm) + strlen(ih->ih_name) + 1 <
|
|
|
|
|
sizeof(p->p_comm)) {
|
|
|
|
|
strcat(p->p_comm, " ");
|
|
|
|
|
strcat(p->p_comm, ih->ih_name);
|
|
|
|
|
} else if (strlen(p->p_comm) + 1 == sizeof(p->p_comm)) {
|
|
|
|
|
if (p->p_comm[sizeof(p->p_comm) - 2] == '+')
|
|
|
|
|
p->p_comm[sizeof(p->p_comm) - 2] = '*';
|
|
|
|
|
else
|
|
|
|
|
p->p_comm[sizeof(p->p_comm) - 2] = '+';
|
|
|
|
|
} else
|
|
|
|
|
strcat(p->p_comm, "+");
|
|
|
|
|
if (ih->ih_flags & IH_ENTROPY)
|
|
|
|
|
entropy++;
|
|
|
|
|
}
|
2001-02-20 10:25:29 +00:00
|
|
|
if (entropy)
|
2001-02-09 17:42:43 +00:00
|
|
|
ithd->it_flags |= IT_ENTROPY;
|
|
|
|
|
else
|
|
|
|
|
ithd->it_flags &= ~IT_ENTROPY;
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR2(KTR_INTR, "%s: updated %s\n", __func__, p->p_comm);
|
2001-02-09 17:42:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
ithread_create(struct ithd **ithread, int vector, int flags,
|
|
|
|
|
void (*disable)(int), void (*enable)(int), const char *fmt, ...)
|
|
|
|
|
{
|
|
|
|
|
struct ithd *ithd;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
2001-02-09 17:42:43 +00:00
|
|
|
struct proc *p;
|
|
|
|
|
int error;
|
|
|
|
|
va_list ap;
|
|
|
|
|
|
2001-02-20 10:25:29 +00:00
|
|
|
/* The only valid flag during creation is IT_SOFT. */
|
|
|
|
|
if ((flags & ~IT_SOFT) != 0)
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
ithd = malloc(sizeof(struct ithd), M_ITHREAD, M_WAITOK | M_ZERO);
|
|
|
|
|
ithd->it_vector = vector;
|
|
|
|
|
ithd->it_disable = disable;
|
|
|
|
|
ithd->it_enable = enable;
|
|
|
|
|
ithd->it_flags = flags;
|
|
|
|
|
TAILQ_INIT(&ithd->it_handlers);
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&ithd->it_lock, "ithread", NULL, MTX_DEF);
|
2001-02-09 17:42:43 +00:00
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
|
vsnprintf(ithd->it_name, sizeof(ithd->it_name), fmt, ap);
|
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
|
|
error = kthread_create(ithread_loop, ithd, &p, RFSTOPPED | RFHIGHPID,
|
2001-03-24 06:26:47 +00:00
|
|
|
"%s", ithd->it_name);
|
2001-02-09 17:42:43 +00:00
|
|
|
if (error) {
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_destroy(&ithd->it_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
free(ithd, M_ITHREAD);
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
2002-02-07 20:58:47 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(p); /* XXXKSE */
|
2002-02-11 20:37:54 +00:00
|
|
|
td->td_ksegrp->kg_pri_class = PRI_ITHD;
|
|
|
|
|
td->td_priority = PRI_MAX_ITHD;
|
2001-02-09 17:42:43 +00:00
|
|
|
p->p_stat = SWAIT;
|
2001-09-12 08:38:13 +00:00
|
|
|
ithd->it_td = td;
|
|
|
|
|
td->td_ithd = ithd;
|
2001-02-09 17:42:43 +00:00
|
|
|
if (ithread != NULL)
|
|
|
|
|
*ithread = ithd;
|
|
|
|
|
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR2(KTR_INTR, "%s: created %s", __func__, ithd->it_name);
|
2001-02-09 17:42:43 +00:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
ithread_destroy(struct ithd *ithread)
|
|
|
|
|
{
|
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
|
|
|
|
struct proc *p;
|
2001-05-17 22:43:26 +00:00
|
|
|
if (ithread == NULL)
|
2001-02-09 17:42:43 +00:00
|
|
|
return (EINVAL);
|
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
td = ithread->it_td;
|
|
|
|
|
p = td->td_proc;
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_lock(&ithread->it_lock);
|
|
|
|
|
if (!TAILQ_EMPTY(&ithread->it_handlers)) {
|
|
|
|
|
mtx_unlock(&ithread->it_lock);
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
}
|
2001-02-09 17:42:43 +00:00
|
|
|
ithread->it_flags |= IT_DEAD;
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (p->p_stat == SWAIT) {
|
|
|
|
|
p->p_stat = SRUN; /* XXXKSE */
|
|
|
|
|
setrunqueue(td);
|
2001-02-09 17:42:43 +00:00
|
|
|
}
|
|
|
|
|
mtx_unlock_spin(&sched_lock);
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_unlock(&ithread->it_lock);
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR2(KTR_INTR, "%s: killing %s", __func__, ithread->it_name);
|
2001-02-09 17:42:43 +00:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
ithread_add_handler(struct ithd* ithread, const char *name,
|
|
|
|
|
driver_intr_t handler, void *arg, u_char pri, enum intr_type flags,
|
|
|
|
|
void **cookiep)
|
|
|
|
|
{
|
|
|
|
|
struct intrhand *ih, *temp_ih;
|
|
|
|
|
|
|
|
|
|
if (ithread == NULL || name == NULL || handler == NULL)
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
if ((flags & INTR_FAST) !=0)
|
|
|
|
|
flags |= INTR_EXCL;
|
|
|
|
|
|
|
|
|
|
ih = malloc(sizeof(struct intrhand), M_ITHREAD, M_WAITOK | M_ZERO);
|
|
|
|
|
ih->ih_handler = handler;
|
|
|
|
|
ih->ih_argument = arg;
|
|
|
|
|
ih->ih_name = name;
|
|
|
|
|
ih->ih_ithread = ithread;
|
|
|
|
|
ih->ih_pri = pri;
|
|
|
|
|
if (flags & INTR_FAST)
|
|
|
|
|
ih->ih_flags = IH_FAST | IH_EXCLUSIVE;
|
|
|
|
|
else if (flags & INTR_EXCL)
|
|
|
|
|
ih->ih_flags = IH_EXCLUSIVE;
|
|
|
|
|
if (flags & INTR_MPSAFE)
|
|
|
|
|
ih->ih_flags |= IH_MPSAFE;
|
|
|
|
|
if (flags & INTR_ENTROPY)
|
|
|
|
|
ih->ih_flags |= IH_ENTROPY;
|
|
|
|
|
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_lock(&ithread->it_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
if ((flags & INTR_EXCL) !=0 && !TAILQ_EMPTY(&ithread->it_handlers))
|
|
|
|
|
goto fail;
|
|
|
|
|
if (!TAILQ_EMPTY(&ithread->it_handlers) &&
|
|
|
|
|
(TAILQ_FIRST(&ithread->it_handlers)->ih_flags & IH_EXCLUSIVE) != 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
TAILQ_FOREACH(temp_ih, &ithread->it_handlers, ih_next)
|
|
|
|
|
if (temp_ih->ih_pri > ih->ih_pri)
|
|
|
|
|
break;
|
|
|
|
|
if (temp_ih == NULL)
|
|
|
|
|
TAILQ_INSERT_TAIL(&ithread->it_handlers, ih, ih_next);
|
|
|
|
|
else
|
|
|
|
|
TAILQ_INSERT_BEFORE(temp_ih, ih, ih_next);
|
|
|
|
|
ithread_update(ithread);
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_unlock(&ithread->it_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
|
|
|
|
|
if (cookiep != NULL)
|
|
|
|
|
*cookiep = ih;
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR3(KTR_INTR, "%s: added %s to %s", __func__, ih->ih_name,
|
2001-02-22 02:14:08 +00:00
|
|
|
ithread->it_name);
|
2001-02-09 17:42:43 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
|
|
fail:
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_unlock(&ithread->it_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
free(ih, M_ITHREAD);
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
ithread_remove_handler(void *cookie)
|
|
|
|
|
{
|
|
|
|
|
struct intrhand *handler = (struct intrhand *)cookie;
|
|
|
|
|
struct ithd *ithread;
|
|
|
|
|
#ifdef INVARIANTS
|
|
|
|
|
struct intrhand *ih;
|
|
|
|
|
#endif
|
|
|
|
|
|
2001-02-20 10:25:29 +00:00
|
|
|
if (handler == NULL)
|
2001-02-09 17:42:43 +00:00
|
|
|
return (EINVAL);
|
2001-02-22 00:23:56 +00:00
|
|
|
ithread = handler->ih_ithread;
|
|
|
|
|
KASSERT(ithread != NULL,
|
2001-02-20 10:25:29 +00:00
|
|
|
("interrupt handler \"%s\" has a NULL interrupt thread",
|
|
|
|
|
handler->ih_name));
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR3(KTR_INTR, "%s: removing %s from %s", __func__, handler->ih_name,
|
2001-02-22 02:14:08 +00:00
|
|
|
ithread->it_name);
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_lock(&ithread->it_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
#ifdef INVARIANTS
|
|
|
|
|
TAILQ_FOREACH(ih, &ithread->it_handlers, ih_next)
|
2001-02-20 10:25:29 +00:00
|
|
|
if (ih == handler)
|
|
|
|
|
goto ok;
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_unlock(&ithread->it_lock);
|
2001-02-20 10:25:29 +00:00
|
|
|
panic("interrupt handler \"%s\" not found in interrupt thread \"%s\"",
|
|
|
|
|
ih->ih_name, ithread->it_name);
|
|
|
|
|
ok:
|
2001-02-09 17:42:43 +00:00
|
|
|
#endif
|
2001-02-22 02:18:32 +00:00
|
|
|
/*
|
|
|
|
|
* If the interrupt thread is already running, then just mark this
|
|
|
|
|
* handler as being dead and let the ithread do the actual removal.
|
|
|
|
|
*/
|
|
|
|
|
mtx_lock_spin(&sched_lock);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (ithread->it_td->td_proc->p_stat != SWAIT) {
|
2001-02-22 02:18:32 +00:00
|
|
|
handler->ih_flags |= IH_DEAD;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Ensure that the thread will process the handler list
|
|
|
|
|
* again and remove this handler if it has already passed
|
|
|
|
|
* it on the list.
|
|
|
|
|
*/
|
|
|
|
|
ithread->it_need = 1;
|
2001-05-17 22:43:26 +00:00
|
|
|
} else
|
2001-02-22 02:18:32 +00:00
|
|
|
TAILQ_REMOVE(&ithread->it_handlers, handler, ih_next);
|
|
|
|
|
mtx_unlock_spin(&sched_lock);
|
2001-05-17 22:43:26 +00:00
|
|
|
if ((handler->ih_flags & IH_DEAD) != 0)
|
|
|
|
|
msleep(handler, &ithread->it_lock, PUSER, "itrmh", 0);
|
|
|
|
|
ithread_update(ithread);
|
|
|
|
|
mtx_unlock(&ithread->it_lock);
|
|
|
|
|
free(handler, M_ITHREAD);
|
2001-02-09 17:42:43 +00:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2001-02-20 10:25:29 +00:00
|
|
|
int
|
|
|
|
|
ithread_schedule(struct ithd *ithread, int do_switch)
|
|
|
|
|
{
|
|
|
|
|
struct int_entropy entropy;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
2001-02-20 10:25:29 +00:00
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If no ithread or no handlers, then we have a stray interrupt.
|
|
|
|
|
*/
|
|
|
|
|
if ((ithread == NULL) || TAILQ_EMPTY(&ithread->it_handlers))
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If any of the handlers for this ithread claim to be good
|
|
|
|
|
* sources of entropy, then gather some.
|
|
|
|
|
*/
|
|
|
|
|
if (harvest.interrupt && ithread->it_flags & IT_ENTROPY) {
|
|
|
|
|
entropy.vector = ithread->it_vector;
|
2001-09-12 08:38:13 +00:00
|
|
|
entropy.proc = curthread->td_proc;;
|
2001-02-20 10:25:29 +00:00
|
|
|
random_harvest(&entropy, sizeof(entropy), 2, 0,
|
|
|
|
|
RANDOM_INTERRUPT);
|
|
|
|
|
}
|
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
td = ithread->it_td;
|
|
|
|
|
p = td->td_proc;
|
2001-03-02 05:33:03 +00:00
|
|
|
KASSERT(p != NULL, ("ithread %s has no process", ithread->it_name));
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR4(KTR_INTR, "%s: pid %d: (%s) need = %d", __func__, p->p_pid, p->p_comm,
|
2001-02-20 10:25:29 +00:00
|
|
|
ithread->it_need);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Set it_need to tell the thread to keep running if it is already
|
|
|
|
|
* running. Then, grab sched_lock and see if we actually need to
|
|
|
|
|
* put this thread on the runqueue. If so and the do_switch flag is
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
* true and it is safe to switch, then switch to the ithread
|
|
|
|
|
* immediately. Otherwise, set the needresched flag to guarantee
|
|
|
|
|
* that this ithread will run before any userland processes.
|
2001-02-20 10:25:29 +00:00
|
|
|
*/
|
|
|
|
|
ithread->it_need = 1;
|
|
|
|
|
mtx_lock_spin(&sched_lock);
|
|
|
|
|
if (p->p_stat == SWAIT) {
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR2(KTR_INTR, "%s: setrunqueue %d", __func__, p->p_pid);
|
2001-02-20 10:25:29 +00:00
|
|
|
p->p_stat = SRUN;
|
2001-09-12 08:38:13 +00:00
|
|
|
setrunqueue(td); /* XXXKSE */
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
if (do_switch && curthread->td_critnest == 1 &&
|
|
|
|
|
curthread->td_proc->p_stat == SRUN) {
|
2001-09-12 08:38:13 +00:00
|
|
|
if (curthread != PCPU_GET(idlethread))
|
|
|
|
|
setrunqueue(curthread);
|
|
|
|
|
curthread->td_proc->p_stats->p_ru.ru_nivcsw++;
|
2001-02-20 10:25:29 +00:00
|
|
|
mi_switch();
|
|
|
|
|
} else
|
2001-09-12 08:38:13 +00:00
|
|
|
curthread->td_kse->ke_flags |= KEF_NEEDRESCHED;
|
2001-02-20 10:25:29 +00:00
|
|
|
} else {
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR4(KTR_INTR, "%s: pid %d: it_need %d, state %d",
|
|
|
|
|
__func__, p->p_pid, ithread->it_need, p->p_stat);
|
2001-02-20 10:25:29 +00:00
|
|
|
}
|
|
|
|
|
mtx_unlock_spin(&sched_lock);
|
|
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
int
|
|
|
|
|
swi_add(struct ithd **ithdp, const char *name, driver_intr_t handler,
|
|
|
|
|
void *arg, int pri, enum intr_type flags, void **cookiep)
|
2000-10-25 05:19:40 +00:00
|
|
|
{
|
|
|
|
|
struct ithd *ithd;
|
2001-02-09 17:42:43 +00:00
|
|
|
int error;
|
2000-10-25 05:19:40 +00:00
|
|
|
|
2001-02-20 10:25:29 +00:00
|
|
|
if (flags & (INTR_FAST | INTR_ENTROPY))
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
ithd = (ithdp != NULL) ? *ithdp : NULL;
|
|
|
|
|
|
2001-02-20 10:25:29 +00:00
|
|
|
if (ithd != NULL) {
|
|
|
|
|
if ((ithd->it_flags & IT_SOFT) == 0)
|
|
|
|
|
return(EINVAL);
|
|
|
|
|
} else {
|
2001-02-09 17:42:43 +00:00
|
|
|
error = ithread_create(&ithd, pri, IT_SOFT, NULL, NULL,
|
|
|
|
|
"swi%d:", pri);
|
2000-10-25 05:19:40 +00:00
|
|
|
if (error)
|
2001-02-09 17:42:43 +00:00
|
|
|
return (error);
|
|
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
if (ithdp != NULL)
|
|
|
|
|
*ithdp = ithd;
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
2001-02-12 00:20:08 +00:00
|
|
|
return (ithread_add_handler(ithd, name, handler, arg,
|
|
|
|
|
(pri * RQ_PPQ) + PI_SOFT, flags, cookiep));
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2000-10-25 05:19:40 +00:00
|
|
|
* Schedule a heavyweight software interrupt process.
|
2000-10-05 23:09:57 +00:00
|
|
|
*/
|
2000-10-25 05:19:40 +00:00
|
|
|
void
|
2001-02-09 17:42:43 +00:00
|
|
|
swi_sched(void *cookie, int flags)
|
2000-10-05 23:09:57 +00:00
|
|
|
{
|
2001-02-09 17:42:43 +00:00
|
|
|
struct intrhand *ih = (struct intrhand *)cookie;
|
|
|
|
|
struct ithd *it = ih->ih_ithread;
|
2001-02-20 10:25:29 +00:00
|
|
|
int error;
|
2000-10-05 23:09:57 +00:00
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
atomic_add_int(&cnt.v_intr, 1); /* one more global interrupt */
|
|
|
|
|
|
2001-02-09 17:42:43 +00:00
|
|
|
CTR3(KTR_INTR, "swi_sched pid %d(%s) need=%d",
|
2001-09-12 08:38:13 +00:00
|
|
|
it->it_td->td_proc->p_pid, it->it_td->td_proc->p_comm, it->it_need);
|
2000-10-05 23:09:57 +00:00
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
/*
|
2001-02-20 10:25:29 +00:00
|
|
|
* Set ih_need for this handler so that if the ithread is already
|
|
|
|
|
* running it will execute this handler on the next pass. Otherwise,
|
|
|
|
|
* it will execute it the next time it runs.
|
2000-10-25 05:19:40 +00:00
|
|
|
*/
|
2001-02-09 17:42:43 +00:00
|
|
|
atomic_store_rel_int(&ih->ih_need, 1);
|
|
|
|
|
if (!(flags & SWI_DELAY)) {
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
error = ithread_schedule(it, !cold);
|
2001-02-20 10:25:29 +00:00
|
|
|
KASSERT(error == 0, ("stray software interrupt"));
|
2000-10-25 05:19:40 +00:00
|
|
|
}
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2001-02-09 17:42:43 +00:00
|
|
|
* This is the main code for interrupt threads.
|
2000-10-05 23:09:57 +00:00
|
|
|
*/
|
2000-10-25 05:19:40 +00:00
|
|
|
void
|
2001-02-09 17:42:43 +00:00
|
|
|
ithread_loop(void *arg)
|
2000-10-05 23:09:57 +00:00
|
|
|
{
|
2001-02-09 17:42:43 +00:00
|
|
|
struct ithd *ithd; /* our thread context */
|
2000-10-25 05:19:40 +00:00
|
|
|
struct intrhand *ih; /* and our interrupt handler chain */
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
2001-02-09 17:42:43 +00:00
|
|
|
struct proc *p;
|
2000-10-25 05:19:40 +00:00
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
td = curthread;
|
|
|
|
|
p = td->td_proc;
|
2001-02-09 17:42:43 +00:00
|
|
|
ithd = (struct ithd *)arg; /* point to myself */
|
2001-09-12 08:38:13 +00:00
|
|
|
KASSERT(ithd->it_td == td && td->td_ithd == ithd,
|
2001-12-10 05:40:12 +00:00
|
|
|
("%s: ithread and proc linkage out of sync", __func__));
|
2000-10-05 23:09:57 +00:00
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
/*
|
|
|
|
|
* As long as we have interrupts outstanding, go through the
|
|
|
|
|
* list of handlers, giving each one a go at it.
|
|
|
|
|
*/
|
2000-10-05 23:09:57 +00:00
|
|
|
for (;;) {
|
2001-02-09 17:42:43 +00:00
|
|
|
/*
|
|
|
|
|
* If we are an orphaned thread, then just die.
|
|
|
|
|
*/
|
|
|
|
|
if (ithd->it_flags & IT_DEAD) {
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR3(KTR_INTR, "%s: pid %d: (%s) exiting", __func__,
|
2001-02-09 17:42:43 +00:00
|
|
|
p->p_pid, p->p_comm);
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_ithd = NULL;
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_destroy(&ithd->it_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
mtx_lock(&Giant);
|
|
|
|
|
free(ithd, M_ITHREAD);
|
|
|
|
|
kthread_exit(0);
|
|
|
|
|
}
|
|
|
|
|
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR4(KTR_INTR, "%s: pid %d: (%s) need=%d", __func__,
|
2001-02-09 17:42:43 +00:00
|
|
|
p->p_pid, p->p_comm, ithd->it_need);
|
|
|
|
|
while (ithd->it_need) {
|
2000-10-25 05:19:40 +00:00
|
|
|
/*
|
|
|
|
|
* Service interrupts. If another interrupt
|
|
|
|
|
* arrives while we are running, they will set
|
|
|
|
|
* it_need to denote that we should make
|
|
|
|
|
* another pass.
|
|
|
|
|
*/
|
2001-02-09 17:42:43 +00:00
|
|
|
atomic_store_rel_int(&ithd->it_need, 0);
|
2001-02-22 02:18:32 +00:00
|
|
|
restart:
|
2001-02-09 17:42:43 +00:00
|
|
|
TAILQ_FOREACH(ih, &ithd->it_handlers, ih_next) {
|
|
|
|
|
if (ithd->it_flags & IT_SOFT && !ih->ih_need)
|
2000-10-25 05:19:40 +00:00
|
|
|
continue;
|
2001-02-09 17:42:43 +00:00
|
|
|
atomic_store_rel_int(&ih->ih_need, 0);
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR6(KTR_INTR,
|
|
|
|
|
"%s: pid %d ih=%p: %p(%p) flg=%x", __func__,
|
2000-10-25 05:19:40 +00:00
|
|
|
p->p_pid, (void *)ih,
|
|
|
|
|
(void *)ih->ih_handler, ih->ih_argument,
|
|
|
|
|
ih->ih_flags);
|
|
|
|
|
|
2001-02-22 02:18:32 +00:00
|
|
|
if ((ih->ih_flags & IH_DEAD) != 0) {
|
2001-05-17 22:43:26 +00:00
|
|
|
mtx_lock(&ithd->it_lock);
|
2001-02-22 02:18:32 +00:00
|
|
|
TAILQ_REMOVE(&ithd->it_handlers, ih,
|
|
|
|
|
ih_next);
|
2001-05-17 22:43:26 +00:00
|
|
|
wakeup(ih);
|
|
|
|
|
mtx_unlock(&ithd->it_lock);
|
2001-02-22 02:18:32 +00:00
|
|
|
goto restart;
|
|
|
|
|
}
|
2001-05-17 22:43:26 +00:00
|
|
|
if ((ih->ih_flags & IH_MPSAFE) == 0)
|
|
|
|
|
mtx_lock(&Giant);
|
2000-10-25 05:19:40 +00:00
|
|
|
ih->ih_handler(ih->ih_argument);
|
2001-02-09 17:42:43 +00:00
|
|
|
if ((ih->ih_flags & IH_MPSAFE) == 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(&Giant);
|
2000-10-25 05:19:40 +00:00
|
|
|
}
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
2000-10-25 05:19:40 +00:00
|
|
|
|
2000-10-05 23:09:57 +00:00
|
|
|
/*
|
|
|
|
|
* Processed all our interrupts. Now get the sched
|
2000-10-25 05:19:40 +00:00
|
|
|
* lock. This may take a while and it_need may get
|
2000-10-05 23:09:57 +00:00
|
|
|
* set again, so we have to check it again.
|
|
|
|
|
*/
|
2000-11-15 22:05:23 +00:00
|
|
|
mtx_assert(&Giant, MA_NOTOWNED);
|
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(&sched_lock);
|
2001-02-09 17:42:43 +00:00
|
|
|
if (!ithd->it_need) {
|
|
|
|
|
/*
|
|
|
|
|
* Should we call this earlier in the loop above?
|
|
|
|
|
*/
|
|
|
|
|
if (ithd->it_enable != NULL)
|
|
|
|
|
ithd->it_enable(ithd->it_vector);
|
2000-10-25 05:19:40 +00:00
|
|
|
p->p_stat = SWAIT; /* we're idle */
|
2001-06-25 18:27:33 +00:00
|
|
|
p->p_stats->p_ru.ru_nvcsw++;
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR2(KTR_INTR, "%s: pid %d: done", __func__, p->p_pid);
|
2000-10-05 23:09:57 +00:00
|
|
|
mi_switch();
|
2001-12-10 05:40:12 +00:00
|
|
|
CTR2(KTR_INTR, "%s: pid %d: resumed", __func__, p->p_pid);
|
2000-10-05 23:09:57 +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_unlock_spin(&sched_lock);
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2000-10-25 05:19:40 +00:00
|
|
|
* Start standard software interrupt threads
|
2000-10-05 23:09:57 +00:00
|
|
|
*/
|
2000-10-25 05:19:40 +00:00
|
|
|
static void
|
2001-02-09 17:42:43 +00:00
|
|
|
start_softintr(void *dummy)
|
2000-10-25 05:19:40 +00:00
|
|
|
{
|
2001-02-09 17:42:43 +00:00
|
|
|
|
|
|
|
|
if (swi_add(NULL, "net", swi_net, NULL, SWI_NET, 0, &net_ih) ||
|
|
|
|
|
swi_add(&clk_ithd, "clock", softclock, NULL, SWI_CLOCK,
|
|
|
|
|
INTR_MPSAFE, &softclock_ih) ||
|
|
|
|
|
swi_add(NULL, "vm", swi_vm, NULL, SWI_VM, 0, &vm_ih))
|
|
|
|
|
panic("died while creating standard software ithreads");
|
2001-02-20 10:25:29 +00:00
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
PROC_LOCK(clk_ithd->it_td->td_proc);
|
|
|
|
|
clk_ithd->it_td->td_proc->p_flag |= P_NOLOAD;
|
|
|
|
|
PROC_UNLOCK(clk_ithd->it_td->td_proc);
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
2001-02-09 17:42:43 +00:00
|
|
|
SYSINIT(start_softintr, SI_SUB_SOFTINTR, SI_ORDER_FIRST, start_softintr, NULL)
|
2000-10-05 23:09:57 +00:00
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
void
|
2001-02-09 17:42:43 +00:00
|
|
|
legacy_setsoftnet(void)
|
2000-10-25 05:19:40 +00:00
|
|
|
{
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(net_ih, 0);
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
|
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
/*
|
|
|
|
|
* XXX: This should really be in the network code somewhere and installed
|
|
|
|
|
* via a SI_SUB_SOFINTR, SI_ORDER_MIDDLE sysinit.
|
|
|
|
|
*/
|
2002-03-19 21:25:46 +00:00
|
|
|
void (*netisrs[32])(void);
|
2001-09-03 03:24:31 +00:00
|
|
|
volatile unsigned int netisr; /* scheduling bits for network */
|
2000-10-05 23:09:57 +00:00
|
|
|
|
2000-12-05 00:36:00 +00:00
|
|
|
int
|
|
|
|
|
register_netisr(num, handler)
|
|
|
|
|
int num;
|
|
|
|
|
netisr_t *handler;
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
if (num < 0 || num >= (sizeof(netisrs)/sizeof(*netisrs)) ) {
|
|
|
|
|
printf("register_netisr: bad isr number: %d\n", num);
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
}
|
|
|
|
|
netisrs[num] = handler;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
unregister_netisr(num)
|
|
|
|
|
int num;
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
if (num < 0 || num >= (sizeof(netisrs)/sizeof(*netisrs)) ) {
|
|
|
|
|
printf("unregister_netisr: bad isr number: %d\n", num);
|
|
|
|
|
return (EINVAL);
|
|
|
|
|
}
|
|
|
|
|
netisrs[num] = NULL;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2002-03-09 08:02:52 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
|
void netisr_pollmore(void);
|
|
|
|
|
#endif
|
|
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
static void
|
|
|
|
|
swi_net(void *dummy)
|
2000-10-05 23:09:57 +00:00
|
|
|
{
|
2000-10-25 05:19:40 +00:00
|
|
|
u_int bits;
|
|
|
|
|
int i;
|
2000-10-05 23:09:57 +00:00
|
|
|
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
|
for (;;) {
|
|
|
|
|
int pollmore;
|
|
|
|
|
#endif
|
2000-10-25 05:19:40 +00:00
|
|
|
bits = atomic_readandclear_int(&netisr);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
|
if (bits == 0)
|
|
|
|
|
return;
|
|
|
|
|
pollmore = bits & (1 << NETISR_POLL);
|
|
|
|
|
#endif
|
2000-10-25 05:19:40 +00:00
|
|
|
while ((i = ffs(bits)) != 0) {
|
|
|
|
|
i--;
|
2000-12-31 01:31:55 +00:00
|
|
|
if (netisrs[i] != NULL)
|
|
|
|
|
netisrs[i]();
|
|
|
|
|
else
|
|
|
|
|
printf("swi_net: unregistered isr number: %d.\n", i);
|
2000-10-25 05:19:40 +00:00
|
|
|
bits &= ~(1 << i);
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
|
if (pollmore)
|
2002-02-11 23:56:18 +00:00
|
|
|
netisr_pollmore();
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
2000-10-05 23:09:57 +00:00
|
|
|
}
|
2001-06-01 13:23:28 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Sysctls used by systat and others: hw.intrnames and hw.intrcnt.
|
|
|
|
|
* The data for this machine dependent, and the declarations are in machine
|
|
|
|
|
* dependent code. The layout of intrnames and intrcnt however is machine
|
|
|
|
|
* independent.
|
|
|
|
|
*
|
|
|
|
|
* We do not know the length of intrcnt and intrnames at compile time, so
|
|
|
|
|
* calculate things at run time.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
sysctl_intrnames(SYSCTL_HANDLER_ARGS)
|
|
|
|
|
{
|
|
|
|
|
return (sysctl_handle_opaque(oidp, intrnames, eintrnames - intrnames,
|
|
|
|
|
req));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SYSCTL_PROC(_hw, OID_AUTO, intrnames, CTLTYPE_OPAQUE | CTLFLAG_RD,
|
|
|
|
|
NULL, 0, sysctl_intrnames, "", "Interrupt Names");
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
sysctl_intrcnt(SYSCTL_HANDLER_ARGS)
|
|
|
|
|
{
|
|
|
|
|
return (sysctl_handle_opaque(oidp, intrcnt,
|
|
|
|
|
(char *)eintrcnt - (char *)intrcnt, req));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SYSCTL_PROC(_hw, OID_AUTO, intrcnt, CTLTYPE_OPAQUE | CTLFLAG_RD,
|
|
|
|
|
NULL, 0, sysctl_intrcnt, "", "Interrupt Counts");
|
