Lines Matching defs:it
42 * long time on i86pc the 8259A was the only way to handle interrupts and it
91 * programming it through a series of wrmsrs. This has important semantic
109 * splr() to raise the priority level and splx() to lower it. One should not
114 * LOCK_LEVEL (0xa on i86pc). If a thread is above LOCK_LEVEL it _must_ not
129 * driver that interacts with the 8259A and 8254. In general, it is not used
135 * pcplusmp driver because it gives us much more flexibility with respect to
159 * is through the cli and sti instructions. These clear the IF flag and set it,
167 * will either deliver it immediately (if interrupts are not in progress) or it
168 * will deliver it once the current interrupt processing has issued an EOI. The
176 * once it has set the TPR, so higher priority interrupts can come in while
200 * spin lock. If the interrupt has a lot of work to do, it must generate a
317 * This is not just important, it's necessary. If the interrupt thread blocked,
330 * case, it does not use the TPR at all. Instead, it only uses the IF flag
339 * The one special case where the apix code uses the TPR is when it calls
493 * it assists in debugging when asserts that interrupts are enabled trip.
521 * (and *must* switch to it), non-zero if we are already on that stack.
618 * non-zero if there are more (in which case we should stay on it).
707 kthread_t *t, *volatile it;
741 it = cpu->cpu_intr_thread;
742 cpu->cpu_intr_thread = it->t_link;
743 it->t_intr = t;
744 it->t_lwp = t->t_lwp;
748 * preset to TS_ONPROC, but it helps in debugging if
751 it->t_state = TS_ONPROC;
753 cpu->cpu_thread = it; /* new curthread on this cpu */
754 it->t_pil = (uchar_t)pil;
755 it->t_pri = intr_pri + (pri_t)pil;
756 it->t_intr_start = now;
758 return (it->t_stk);
774 kthread_t *it = cpu->cpu_thread; /* curthread */
779 pil = it->t_pil;
782 ASSERT(it->t_intr_start != 0);
783 intrtime = now - it->t_intr_start;
793 * fairly simple. Otherwise it isn't.
795 if ((t = it->t_intr) == NULL) {
821 it->t_state = TS_FREE;
825 it->t_link = cpu->cpu_intr_thread;
826 cpu->cpu_intr_thread = it;
835 it->t_link = cpu->cpu_intr_thread;
836 cpu->cpu_intr_thread = it;
837 it->t_state = TS_FREE;
859 * it returns the time since the interrupt handler was invoked. Subsequent
891 * and the code in intr_thread() updates intrstat[pil][0], it then sets
944 kthread_t *t, *volatile it;
966 * it looks like it would be simpler to disable preemption there.
970 * being cleared was actually set; if it wasn't, it rechecks
998 it = cpu->cpu_intr_thread;
999 cpu->cpu_intr_thread = it->t_link;
1016 it->t_lwp = t->t_lwp;
1017 it->t_state = TS_ONPROC;
1022 * Set interrupted thread's T_SP because if it is the idle thread,
1029 it->t_intr = t;
1030 cpu->cpu_thread = it;
1041 it->t_pil = (uchar_t)pil;
1042 it->t_pri = (pri_t)pil + intr_pri;
1043 it->t_intr_start = now;
1045 return (it->t_stk);
1052 kthread_t *t, *it;
1057 it = cpu->cpu_thread;
1058 pil = it->t_pil;
1064 intrtime = now - it->t_intr_start;
1071 * fairly simple. Otherwise it isn't.
1073 if ((t = it->t_intr) == NULL) {
1079 it->t_state = TS_FREE;
1080 it->t_link = cpu->cpu_intr_thread;
1081 cpu->cpu_intr_thread = it;
1088 it->t_link = cpu->cpu_intr_thread;
1089 cpu->cpu_intr_thread = it;
1090 it->t_state = TS_FREE;
1111 kthread_t *it, /* interrupt thread */
1116 ASSERT(it->t_flag & T_INTR_THREAD);
1120 return (it->t_pil);
1200 * An interrupt thread is ending a time slice, so compute the interval it
1216 * it (i.e. it blocked at some point in its past) has finished running
1284 * there may not be a return from it if the interrupt thread blocked.
1303 * there may not be a return from it if the interrupt thread blocked.
1359 * If it's a softint go do it now.
1376 * Bail if it is a spurious interrupt
1534 * even though it seems we're raising the priority, it could be set