softint.c revision a1af7ba02a81ee5af0f2cd6b30b99957a93fc605
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/kdi_impl.h>
/*
* Handle software interrupts through 'softcall' mechanism
*
* At present softcall mechanism uses a global list headed by softhead.
* Entries are added to tail and removed from head so as to preserve FIFO
* nature of entries in the softcall list. softcall() takes care of adding
* entries to the softtail.
*
* softint must take care of executing the entries in the FIFO
* order. It could be called simultaneously from multiple cpus, however only
* one instance of softint should process the softcall list, this is
* ensured by
* - the state the variable softcall_state will be at time to time.
* (IDLE->PEND->DRAIN->IDLE)
*
* These states are needed for softcall mechanism since Solaris has only
* one interface(ie. siron ) as of now for
* - raising a soft interrupt architecture independently(ie not through
* setsoftint(..) )
* - to process the softcall queue.
*/
#define NSOFTCALLS 200
/*
* Defined states for softcall processing.
*/
typedef struct softcall {
void (*sc_func)(void *); /* function to call */
void *sc_arg; /* arg to pass to func */
} softcall_t;
static uint_t softcall_state;
/*
* protects softcall lists and control variable softcall_state.
*/
static kmutex_t softcall_lock;
static void (*kdi_softcall_func)(void);
extern void siron(void);
extern void kdi_siron(void);
void
softcall_init(void)
{
softcall_t *sc;
}
}
/*
* Call function func with argument arg
* at some later time at software interrupt priority
*/
void
{
softcall_t *sc;
/*
* protect against cross-calls
*/
/* coalesce identical softcalls */
return;
}
}
panic("too many softcalls");
if (softhead) {
} else {
if (softcall_state == SOFT_DRAIN)
/*
* softint is already running; no need to
* raise a siron. Due to lock protection of
* softhead / softcall state, we know
* that softint() will see the new addition to
* the softhead queue.
*/
else {
siron();
}
}
}
void
kdi_softcall(void (*func)(void))
{
kdi_siron();
}
/*
* Called to process software interrupts take one off queue, call it,
* repeat.
*
* Note queue may change during call; softcall_lock and state variables
* softcall_state ensures that
* -we don't have multiple cpus pulling from the list (thus causing
* a violation of FIFO order).
* -we don't miss a new entry having been added to the head.
* -we don't miss a wakeup.
*/
void
softint(void)
{
softcall_t *sc;
void (*func)();
/*
* Check if we are asked to process the softcall list.
*/
if (softcall_state != SOFT_PEND) {
goto out;
}
for (;;) {
}
break;
}
}
out:
func();
}
}