Lines Matching full:interrupt
55 * (TT 0x40..0x4F, TL>0) Interrupt Level N Handler (N == 1..15)
57 * %g4 - interrupt request level
99 wr %g5, CLEAR_SOFTINT ! clear interrupt on this pil
126 ! clear the iv_pending flag for this interrupt request
138 ! %g1 - interrupt handler at TL==0
168 .asciz "!interrupt 0x%x at level %d not serviced"
192 * so, there is another interrupt to process. The caller must call
196 * and other actions which need to occur after invocation of an interrupt
204 * os3 - if set, another interrupt needs to be processed
346 * Handle an interrupt in a new thread.
372 ! See if we are interrupting another interrupt thread.
379 ! We have interrupted an interrupt thread. Take a timestamp,
385 ! We came in on top of an interrupt thread that had no timestamp.
386 ! This could happen if, for instance, an interrupt thread which had
394 ! A high-level interrupt in current_thread() interrupting here
403 ! a new, later timestamp there after running a high-level interrupt,
420 ! We now know that a valid interval for the interrupted interrupt
445 ! Get set to run interrupt thread.
446 ! There should always be an interrupt thread since we allocate one
450 ! of events here -- in particular that t->t_lwp of the interrupt thread
453 ldn [%o2 + CPU_INTR_THREAD], %o3 ! interrupt thread pool
457 ! Set bit for this level in CPU's active interrupt bitmask.
488 ! Threads on the interrupt thread free list could have state already
505 ldn [%o3 + T_STACK], %o4 ! interrupt stack pointer
511 ldsh [%o4 + %lo(intr_pri)], %o4 ! grab base interrupt priority
523 ! If a high-level interrupt occurred while we were attempting to store
562 ! higher effective pil because a higher-level interrupt may have
592 ! The problem is that a high-level interrupt could arrive at any time.
614 ! interrupt. Above we have set t_intr_start to %tick, not 0. This
615 ! means a high-level interrupt can arrive and update the same stats
646 ! for each interrupt handler we invoke. If we hit INTRCNT_LIMIT, then
649 ! until hitting the non-interrupt thread, which will then in turn
650 ! preempt itself allowing the interrupt processing to resume. Finally,
654 ! won't ever re-enter the scheduler, and the interrupt will be forever
717 ! Clear bit for this level in CPU's interrupt active bitmask.
742 ! then the interrupt was never blocked and the return is fairly
749 ! link the thread back onto the interrupt thread pool
766 ! If we pinned an interrupt thread, store its starting timestamp.
778 ! If a high-level interrupt occurred while we were attempting to store
799 ! An interrupt returned on what was once (and still might be)
800 ! an interrupt thread stack, but the interrupted process is no longer
801 ! there. This means the interrupt must have blocked.
807 ! All traps below DISP_LEVEL are disabled here, but the mondo interrupt
838 ! Put thread back on the interrupt thread list.
872 ! Put thread on either the interrupt pool or the free pool and
900 * Handle an interrupt in the current thread
958 ! Set bit for this level in CPU's active interrupt bitmask.
982 ! See if we are interrupting another high-level interrupt.
988 ! We have interrupted another high-level interrupt. Find its PIL,
993 ! o2 = PIL of this interrupt
998 ! interrupted high-level interrupt.
1078 ! Another high-level interrupt is active below this one, so
1079 ! there is no need to check for an interrupt thread. That will be
1080 ! done by the lowest priority high-level interrupt active.
1084 ! If we haven't interrupted another high-level interrupt, we may be
1085 ! interrupting a low level interrupt thread. If so, compute its interval
1092 ! We have interrupted an interrupt thread. Take timestamp, compute
1097 ! the accounting for the underlying interrupt thread.
1129 ! Handle high-level interrupts on separate interrupt stack.
1216 ! Clear bit for this level in CPU's interrupt active bitmask.
1302 ! We found another high-level interrupt active below the one that just
1306 ! interrupted high-level interrupt.
1337 ! Another high-level interrupt is active below this one, so
1338 ! there is no need to check for an interrupt thread. That will be
1339 ! done by the lowest priority high-level interrupt active.
1343 ! If we haven't interrupted another high-level interrupt, we may have
1344 ! interrupted a low level interrupt thread. If so, store a starting
1404 * Return a thread's interrupt level.
1405 * Since this isn't saved anywhere but in %l4 on interrupt entry, we
1408 * Caller 'swears' that this really is an interrupt thread.
1477 wrpr %g0, %g1, %pstate ! disable interrupt
1541 wrpr %l1, %pstate ! disable interrupt
1543 ! We have a pointer to an interrupt vector data structure.
1633 ! We have a pointer to an interrupt vector data structure.
1740 ! We have an interrupt number. Fetch the interrupt vector requests
1741 ! from the interrupt vector table for a given interrupt number and
1927 * Set CPU's base SPL level, based on which interrupt levels are active.
1950 ! Determine highest interrupt level active. Several could be blocked
1972 ! highest interrupt level number active is in %l6
1994 * kthread_id_t from; interrupt thread
2012 ! restore registers from the base of the stack of the interrupt thread.
2068 * intr_get_time() is a resource for interrupt handlers to determine how
2069 * much time has been spent handling the current interrupt. Such a function
2071 * processing of an interrupt, thus making direct comparisons of %tick by
2073 * current interrupt handler.
2075 * The caller must be calling from an interrupt handler running at a pil
2079 * The first time intr_get_time() is called while handling an interrupt,
2080 * it returns the time since the interrupt handler was invoked. Subsequent
2097 * by a call to intr_get_time(). At the start of interrupt processing,
2098 * [0] and [1] will be equal (or nearly so). As the interrupt consumes
2102 * Finally, when the interrupt completes, [1] is updated to the same as [0].
2106 * intr_get_time() works much like a higher level interrupt arriving. It
2113 * In the normal handling of interrupts, after an interrupt handler returns
2120 * interrupt, they update the lower pil's [0] to show time spent in the
2123 * called. Time spent in the higher-pil interrupt will not be returned in
2124 * the next intr_get_time() call from the original interrupt, because
2125 * the higher-pil interrupt's time is accumulated in intrstat[higherpil][].
2212 ! cpu_m.intrstat[pil][1], which is either when the interrupt was
2238 .asciz "intr_get_time(): not called from an interrupt thread"