These functions are used to register and schedule software interrupt handlers.
Software interrupt handlers are attached to a software interrupt thread, just
as hardware interrupt handlers are attached to a hardware interrupt thread.
Multiple handlers can be attached to the same thread.
Software interrupt handlers can be used to queue up less critical processing
inside of hardware interrupt handlers so that the work can be done at a later
Software interrupt threads are different from other kernel threads in that they
are treated as an interrupt thread.
This means that time spent executing these threads is counted as interrupt
time, and that they can be run via a lightweight context switch.
function is used to add a new software interrupt handler to a specified
argument is an optional pointer to a
.Vt struct intr_event
If this argument points to an existing event that holds a list of
interrupt handlers, then this handler will be attached to that event.
Otherwise a new event will be created, and if
then the pointer at that address to will be modified to point to the
newly created event.
argument is used to associate a name with a specific handler.
This name is appended to the name of the software interrupt thread that this
handler is attached to.
argument is the function that will be executed when the handler is scheduled
parameter will be passed in as the only parameter to
when the function is executed.
value specifies the priority of this interrupt handler relative to other
software interrupt handlers.
If an interrupt event is created, then this value is used as the vector,
argument is used to specify the attributes of a handler such as
argument points to a
.Vt void *
This cookie will be set to a value that uniquely identifies this handler,
and is used to schedule the handler for execution later on.
function is used to teardown an interrupt handler pointed to by the
It detaches the interrupt handler from the associated interrupt event
and frees its memory.
function is used to schedule an interrupt handler and its associated thread to
argument specifies which software interrupt handler should be scheduled to run.
argument specifies how and when the handler should be run and is a mask of one
or more of the following flags:
Specifies that the kernel should mark the specified handler as needing to run,
but the kernel should not schedule the software interrupt thread to run.
will be executed the next time that the software interrupt thread runs after
being scheduled by another event.
Attaching a handler to the clock software interrupt thread and using this flag
when scheduling a software interrupt handler can be used to implement the
functionality performed by
in earlier versions of
variables contain pointers to the software interrupt handlers for the tty and
clock software interrupts, respectively.
is used to hang tty software interrupt handlers off of the same thread.
is used to hang delayed handlers off of the clock software interrupt thread so
that the functionality of
can be obtained in conjunction with
handler cookie is used to schedule software interrupt threads to run for the