ab08960f64
Change pushcli / popcli so that they can never turn on interrupts unexpectedly. That is, if interrupts are on, then pushcli(); popcli(); turns them off and back on, but if they are off to begin with, then pushcli(); popcli(); is a no-op. I think our fundamental mistake was having a primitive (release and then popcli nee spllo) that could turn interrupts on at unexpected moments instead of being explicit about when we want to start allowing interrupts. With the new semantics, all the manual fiddling of ncli to force interrupts off in certain sections goes away. In return, we must explicitly mark the places where we want to enable interrupts unconditionally, by calling sti(). There is only one: inside the scheduler loop.
94 lines
2.1 KiB
C
94 lines
2.1 KiB
C
#include "types.h"
|
|
#include "defs.h"
|
|
#include "param.h"
|
|
#include "mmu.h"
|
|
#include "proc.h"
|
|
#include "x86.h"
|
|
#include "traps.h"
|
|
#include "spinlock.h"
|
|
|
|
// Interrupt descriptor table (shared by all CPUs).
|
|
struct gatedesc idt[256];
|
|
extern uint vectors[]; // in vectors.S: array of 256 entry pointers
|
|
struct spinlock tickslock;
|
|
int ticks;
|
|
|
|
void
|
|
tvinit(void)
|
|
{
|
|
int i;
|
|
|
|
for(i = 0; i < 256; i++)
|
|
SETGATE(idt[i], 0, SEG_KCODE<<3, vectors[i], 0);
|
|
SETGATE(idt[T_SYSCALL], 0, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
|
|
|
|
initlock(&tickslock, "time");
|
|
}
|
|
|
|
void
|
|
idtinit(void)
|
|
{
|
|
lidt(idt, sizeof(idt));
|
|
}
|
|
|
|
void
|
|
trap(struct trapframe *tf)
|
|
{
|
|
if(tf->trapno == T_SYSCALL){
|
|
if(cp->killed)
|
|
exit();
|
|
cp->tf = tf;
|
|
syscall();
|
|
if(cp->killed)
|
|
exit();
|
|
return;
|
|
}
|
|
|
|
switch(tf->trapno){
|
|
case IRQ_OFFSET + IRQ_TIMER:
|
|
if(cpu() == 0){
|
|
acquire(&tickslock);
|
|
ticks++;
|
|
wakeup(&ticks);
|
|
release(&tickslock);
|
|
}
|
|
lapic_eoi();
|
|
break;
|
|
case IRQ_OFFSET + IRQ_IDE:
|
|
ide_intr();
|
|
lapic_eoi();
|
|
break;
|
|
case IRQ_OFFSET + IRQ_KBD:
|
|
kbd_intr();
|
|
lapic_eoi();
|
|
break;
|
|
case IRQ_OFFSET + IRQ_SPURIOUS:
|
|
cprintf("cpu%d: spurious interrupt at %x:%x\n",
|
|
cpu(), tf->cs, tf->eip);
|
|
lapic_eoi();
|
|
break;
|
|
|
|
default:
|
|
if(cp == 0 || (tf->cs&3) == 0){
|
|
// In kernel, it must be our mistake.
|
|
cprintf("unexpected trap %d from cpu %d eip %x\n",
|
|
tf->trapno, cpu(), tf->eip);
|
|
panic("trap");
|
|
}
|
|
// In user space, assume process misbehaved.
|
|
cprintf("pid %d %s: trap %d err %d on cpu %d eip %x -- kill proc\n",
|
|
cp->pid, cp->name, tf->trapno, tf->err, cpu(), tf->eip);
|
|
cp->killed = 1;
|
|
}
|
|
|
|
// Force process exit if it has been killed and is in user space.
|
|
// (If it is still executing in the kernel, let it keep running
|
|
// until it gets to the regular system call return.)
|
|
if(cp && cp->killed && (tf->cs&3) == DPL_USER)
|
|
exit();
|
|
|
|
// Force process to give up CPU on clock tick.
|
|
// If interrupts were on while locks held, would need to check nlock.
|
|
if(cp && cp->state == RUNNING && tf->trapno == IRQ_OFFSET+IRQ_TIMER)
|
|
yield();
|
|
}
|