Huge scheduler rewrite and other things

10 files changed, 470 insertions, 451 deletions

diff --git a/kernel/drivers/cpu.c b/kernel/drivers/cpu.c
index 8694fc2..44091a3 100644
--- a/kernel/drivers/cpu.c
+++ b/kernel/drivers/cpu.c
@@ -7,6 +7,10 @@
 #include <mem.h>
 #include <print.h>
 
+/**
+ * Serial in/out
+ */
+
 u8 inb(u16 port)
 {
 	u8 value;
@@ -43,6 +47,10 @@ void outl(u16 port, u32 data)
 	__asm__ volatile("outl %0, %1" ::"a"(data), "Nd"(port));
 }
 
+/**
+ * Special register manipulation
+ */
+
 CLEAR u32 cr0_get(void)
 {
 	u32 cr0;
@@ -79,18 +87,39 @@ CLEAR void cr4_set(u32 cr4)
 	__asm__ volatile("movl %%eax, %%cr4" ::"a"(cr4));
 }
 
-static void fpu_handler(struct regs *r)
+/**
+ * FPU
+ */
+
+PROTECTED static u8 fpu_initial[512] ALIGNED(16);
+static u8 fpu_regs[512] ALIGNED(16);
+
+static void fpu_handler(void)
 {
-	UNUSED(r);
 	__asm__ volatile("clts");
 }
 
-static u8 fpu_state[512] ALIGNED(16);
-void fpu_restore(void)
+void fpu_init(struct proc *proc)
+{
+	memcpy(&proc->fpu, &fpu_initial, sizeof(fpu_initial));
+}
+
+void fpu_save(struct proc *proc)
+{
+	__asm__ volatile("fxsave (%0)" ::"r"(fpu_regs));
+	memcpy(&proc->fpu, &fpu_regs, sizeof(fpu_regs));
+}
+
+void fpu_restore(struct proc *proc)
 {
-	__asm__ volatile("fxrstor (%0)" ::"r"(fpu_state));
+	memcpy(&fpu_regs, &proc->fpu, sizeof(proc->fpu));
+	__asm__ volatile("fxrstor (%0)" ::"r"(fpu_regs));
 }
 
+/**
+ * CPU features
+ */
+
 CLEAR static struct cpuid cpuid(u32 code)
 {
 	u32 a, b, c, d;
@@ -129,8 +158,10 @@ CLEAR void cpu_enable_features(void)
 
 	// Enable SSE
 	if (cpu_features.edx & CPUID_FEAT_EDX_SSE) {
+		__asm__ volatile("clts");
 		cr0_set(cr0_get() & ~(1 << 2));
 		cr0_set(cr0_get() | (1 << 1));
+		cr0_set(cr0_get() | (1 << 5));
 		cr4_set(cr4_get() | (3 << 9));
 	} else {
 		panic("No SSE support!\n");
@@ -139,8 +170,8 @@ CLEAR void cpu_enable_features(void)
 	// Enable FPU
 	if (cpu_features.edx & CPUID_FEAT_EDX_FPU) {
 		__asm__ volatile("fninit");
-		__asm__ volatile("fxsave %0" : "=m"(fpu_state));
-		irq_install_handler(7, fpu_handler);
+		__asm__ volatile("fxsave %0" : "=m"(fpu_initial));
+		int_event_handler_add(7, fpu_handler);
 	} else {
 		panic("No FPU support!\n");
 	}
@@ -177,6 +208,10 @@ CLEAR void cpu_enable_features(void)
 	}
 }
 
+/**
+ * SMAP
+ */
+
 void clac(void)
 {
 	if (cpu_extended_features.ebx & CPUID_EXT_FEAT_EBX_SMAP)
@@ -188,13 +223,3 @@ void stac(void)
 	if (cpu_extended_features.ebx & CPUID_EXT_FEAT_EBX_SMAP)
 		__asm__ volatile("stac" ::: "cc");
 }
-
-CLEAR void cli(void)
-{
-	__asm__ volatile("cli");
-}
-
-CLEAR void sti(void)
-{
-	__asm__ volatile("sti");
-}
diff --git a/kernel/drivers/int.asm b/kernel/drivers/int.asm
new file mode 100644
index 0000000..30e9eb0
--- /dev/null
+++ b/kernel/drivers/int.asm
@@ -0,0 +1,162 @@
+; MIT License, Copyright (c) 2021 Marvin Borner
+
+%macro INT_REGISTER 1
+dd int%1
+%endmacro
+
+%macro INT_ERR 1
+int%1:
+	push %1
+	jmp int_common
+%endmacro
+
+%macro INT_NOERR 1
+int%1:
+	push 0
+	push %1
+	jmp int_common
+%endmacro
+
+%macro INT_SYSCALL 1
+int%1:
+	push 0
+	push %1
+	jmp int_common
+%endmacro
+
+extern int_handler
+int_common:
+	cld
+
+	pushad
+	push ds
+	push es
+	push fs
+	push gs
+
+	mov ax, 0x10
+	mov ds, ax
+	mov es, ax
+	mov fs, ax
+	mov gs, ax
+
+	push esp
+	call int_handler
+	mov esp, eax
+
+	pop gs
+	pop fs
+	pop es
+	pop ds
+	popad
+
+	add esp, 8
+	iret
+
+INT_NOERR 0
+INT_NOERR 1
+INT_NOERR 2
+INT_NOERR 3
+INT_NOERR 4
+INT_NOERR 5
+INT_NOERR 6
+INT_NOERR 7
+INT_ERR   8
+INT_NOERR 9
+INT_ERR   10
+INT_ERR   11
+INT_ERR   12
+INT_ERR   13
+INT_ERR   14
+INT_NOERR 15
+INT_NOERR 16
+INT_ERR 17
+INT_NOERR 18
+INT_NOERR 19
+INT_NOERR 20
+INT_NOERR 21
+INT_NOERR 22
+INT_NOERR 23
+INT_NOERR 24
+INT_NOERR 25
+INT_NOERR 26
+INT_NOERR 27
+INT_NOERR 28
+INT_NOERR 29
+INT_ERR   30
+INT_NOERR 31
+
+INT_NOERR 32
+INT_NOERR 33
+INT_NOERR 34
+INT_NOERR 35
+INT_NOERR 36
+INT_NOERR 37
+INT_NOERR 38
+INT_NOERR 39
+INT_NOERR 40
+INT_NOERR 41
+INT_NOERR 42
+INT_NOERR 43
+INT_NOERR 44
+INT_NOERR 45
+INT_NOERR 46
+INT_NOERR 47
+
+INT_SYSCALL 128
+INT_NOERR 129
+
+global int_table
+int_table:
+	INT_REGISTER 0
+	INT_REGISTER 1
+	INT_REGISTER 2
+	INT_REGISTER 3
+	INT_REGISTER 4
+	INT_REGISTER 5
+	INT_REGISTER 6
+	INT_REGISTER 7
+	INT_REGISTER 8
+	INT_REGISTER 9
+	INT_REGISTER 10
+	INT_REGISTER 11
+	INT_REGISTER 12
+	INT_REGISTER 13
+	INT_REGISTER 14
+	INT_REGISTER 15
+	INT_REGISTER 16
+	INT_REGISTER 17
+	INT_REGISTER 18
+	INT_REGISTER 19
+	INT_REGISTER 20
+	INT_REGISTER 21
+	INT_REGISTER 22
+	INT_REGISTER 23
+	INT_REGISTER 24
+	INT_REGISTER 25
+	INT_REGISTER 26
+	INT_REGISTER 27
+	INT_REGISTER 28
+	INT_REGISTER 29
+	INT_REGISTER 30
+	INT_REGISTER 31
+
+	INT_REGISTER 32
+	INT_REGISTER 33
+	INT_REGISTER 34
+	INT_REGISTER 35
+	INT_REGISTER 36
+	INT_REGISTER 37
+	INT_REGISTER 38
+	INT_REGISTER 39
+	INT_REGISTER 40
+	INT_REGISTER 41
+	INT_REGISTER 42
+	INT_REGISTER 43
+	INT_REGISTER 44
+	INT_REGISTER 45
+	INT_REGISTER 46
+	INT_REGISTER 47
+
+	INT_REGISTER 128
+	INT_REGISTER 129
diff --git a/kernel/drivers/int.c b/kernel/drivers/int.c
new file mode 100644
index 0000000..47a2699
--- /dev/null
+++ b/kernel/drivers/int.c
@@ -0,0 +1,187 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <assert.h>
+#include <def.h>
+#include <drivers/int.h>
+#include <drivers/pic.h>
+#include <drivers/serial.h>
+
+/**
+ * IDT
+ */
+
+PROTECTED extern u32 int_table[];
+PROTECTED static struct idt_entry idt[256] = { 0 };
+PROTECTED static struct idt_ptr idt_ptr = { 0 };
+
+CLEAR void idt_install(void)
+{
+	idt_ptr.size = sizeof(idt) - 1;
+	idt_ptr.base = &idt;
+
+	for (u8 i = 0; i < 3; i++)
+		idt[i] = IDT_ENTRY(int_table[i], 0x08, INT_GATE);
+
+	idt[3] = IDT_ENTRY(int_table[3], 0x08, INT_TRAP);
+	idt[4] = IDT_ENTRY(int_table[4], 0x08, INT_TRAP);
+
+	for (u8 i = 5; i < 48; i++)
+		idt[i] = IDT_ENTRY(int_table[i], 0x08, INT_GATE);
+
+	idt[128] = IDT_ENTRY(int_table[48], 0x08, INT_GATE | INT_USER);
+	idt[129] = IDT_ENTRY(int_table[49], 0x08, INT_GATE);
+
+	__asm__ volatile("lidt %0" : : "m"(idt_ptr));
+}
+
+/**
+ * Exception (trap) handling
+ */
+
+PROTECTED const char *int_trap_names[32] = {
+	"Division By Zero",
+	"Debug",
+	"Non Maskable Interrupt",
+	"Breakpoint",
+	"Into Detected Overflow",
+	"Out of Bounds",
+	"Invalid Opcode",
+	"No Coprocessor",
+
+	"Double Fault",
+	"Coprocessor Segment Overrun",
+	"Bad TSS",
+	"Segment Not Present",
+	"Stack Fault",
+	"General Protection Fault",
+	"Page Fault",
+	"Unknown Interrupt",
+
+	"Coprocessor Fault",
+	"Alignment Check",
+	"Machine Check",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+};
+
+PROTECTED static void (*int_trap_handlers[16])(u32 esp) = { 0 };
+
+CLEAR void int_trap_handler_add(u32 int_no, void (*handler)(u32 esp))
+{
+	assert(int_no < COUNT(int_trap_handlers));
+	int_trap_handlers[int_no] = handler;
+}
+
+static void int_trap_handler(struct int_frame *frame)
+{
+	static u8 faulting = 0;
+	faulting++;
+
+	if (faulting == 2) {
+		// Fall back to serial driver
+		serial_print("Double fault, halting immediatly\n");
+		while (1)
+			__asm__ volatile("cli\nhlt");
+	}
+
+	assert(frame->int_no < COUNT(int_trap_handlers));
+	void (*handler)(u32 esp) = int_trap_handlers[frame->int_no];
+	if (handler)
+		handler((u32)frame);
+
+	printf("%s Exception (code %x) at 0x%x (ring %d), exiting!\n",
+	       int_trap_names[frame->int_no], frame->err_code, frame->eip, RING(frame));
+	struct proc *proc = proc_current();
+	if (proc) {
+		printf("\t-> Exception occurred in %s at addr 0x%x (offset 0x%x)\n", proc->name,
+		       frame->eip, frame->eip - proc->entry);
+		printf("\t\t-> Process: [entry: %x, kstack: %x, esp %x, ustack: %x]\n", proc->entry,
+		       proc->stack.kernel, frame->esp, proc->stack.user);
+		proc_exit(proc, 1);
+		faulting--;
+	} else {
+		while (1)
+			__asm__ volatile("cli\nhlt");
+	}
+}
+
+/**
+ * Event handling
+ */
+
+PROTECTED static void (*int_event_handlers[16])(void) = { 0 };
+
+CLEAR void int_event_handler_add(u32 int_no, void (*handler)(void))
+{
+	assert(int_no < COUNT(int_event_handlers));
+	int_event_handlers[int_no] = handler;
+}
+
+#include <mm.h>
+static u32 int_event_handler(struct int_frame *frame)
+{
+	u32 int_no = frame->int_no - 32;
+	assert(int_no < COUNT(int_event_handlers));
+	void (*handler)(void) = int_event_handlers[int_no];
+	if (handler)
+		handler();
+
+	if (!int_no)
+		return scheduler((u32)frame);
+	return (u32)frame;
+}
+
+/**
+ * Special interrupts (e.g. syscall, yield)
+ */
+
+PROTECTED static u32 (*int_special_handlers[16])(u32 esp) = { 0 };
+
+CLEAR void int_special_handler_add(u32 int_no, u32 (*handler)(u32 esp))
+{
+	assert(int_no < COUNT(int_event_handlers));
+	int_special_handlers[int_no] = handler;
+}
+
+static u32 int_special_handler(struct int_frame *frame)
+{
+	u32 int_no = frame->int_no - 128;
+	assert(int_no < COUNT(int_event_handlers));
+	u32 (*handler)(u32 esp) = int_special_handlers[int_no];
+	if (handler)
+		return handler((u32)frame);
+	return (u32)frame;
+}
+
+/**
+ * Universal handler
+ */
+
+u32 int_handler(u32 esp);
+u32 int_handler(u32 esp)
+{
+	struct int_frame *frame = (struct int_frame *)esp;
+	if (frame->int_no < 32)
+		int_trap_handler(frame);
+	else if (frame->int_no < 48)
+		esp = int_event_handler(frame);
+	else if (frame->int_no >= 128 && frame->int_no < 144)
+		esp = int_special_handler(frame);
+	else
+		panic("Unknown interrupt: %d\n", frame->int_no);
+
+	pic_ack(frame->int_no);
+	return esp;
+}
diff --git a/kernel/drivers/interrupts.asm b/kernel/drivers/interrupts.asm
deleted file mode 100644
index 18cf007..0000000
--- a/kernel/drivers/interrupts.asm
+++ /dev/null
@@ -1,140 +0,0 @@
-; MIT License, Copyright (c) 2020 Marvin Borner
-
-; IRQ
-
-%macro IRQ 2
-  global irq%1
-  irq%1:
-	push byte 0
-	push byte %2
-	jmp irq_common_stub
-%endmacro
-
-IRQ 0, 32
-IRQ 1, 33
-IRQ 2, 34
-IRQ 3, 35
-IRQ 4, 36
-IRQ 5, 37
-IRQ 6, 38
-IRQ 7, 39
-IRQ 8, 40
-IRQ 9, 41
-IRQ 10, 42
-IRQ 11, 43
-IRQ 12, 44
-IRQ 13, 45
-IRQ 14, 46
-IRQ 15, 47
-
-extern irq_handler
-irq_common_stub:
-	pusha
-
-	push ds
-	push es
-	push fs
-	push gs
-
-	mov ax, 0x10
-	mov ds, ax
-	mov es, ax
-	mov fs, ax
-	mov gs, ax
-	cld
-
-	push esp
-	call irq_handler
-	add esp, 4
-
-	pop gs
-	pop fs
-	pop es
-	pop ds
-	popa
-
-	add esp, 8
-	sti
-	iret
-
-; ISR
-
-%macro ISR_NOERRCODE 1
-	global isr%1
-	isr%1:
-		push byte 0
-		push %1
-		jmp isr_common_stub
-%endmacro
-
-%macro ISR_ERRCODE 1
-	global isr%1
-	isr%1:
-		push byte %1
-		jmp isr_common_stub
-%endmacro
-
-ISR_NOERRCODE 0
-ISR_NOERRCODE 1
-ISR_NOERRCODE 2
-ISR_NOERRCODE 3
-ISR_NOERRCODE 4
-ISR_NOERRCODE 5
-ISR_NOERRCODE 6
-ISR_NOERRCODE 7
-ISR_ERRCODE   8
-ISR_NOERRCODE 9
-ISR_ERRCODE   10
-ISR_ERRCODE   11
-ISR_ERRCODE   12
-ISR_ERRCODE   13
-ISR_ERRCODE   14
-ISR_NOERRCODE 15
-ISR_NOERRCODE 16
-ISR_NOERRCODE 17
-ISR_NOERRCODE 18
-ISR_NOERRCODE 19
-ISR_NOERRCODE 20
-ISR_NOERRCODE 21
-ISR_NOERRCODE 22
-ISR_NOERRCODE 23
-ISR_NOERRCODE 24
-ISR_NOERRCODE 25
-ISR_NOERRCODE 26
-ISR_NOERRCODE 27
-ISR_NOERRCODE 28
-ISR_NOERRCODE 29
-ISR_NOERRCODE 30
-ISR_NOERRCODE 31
-ISR_NOERRCODE 127
-ISR_NOERRCODE 128
-
-extern isr_handler
-isr_common_stub:
-	pusha
-
-	push ds
-	push es
-	push fs
-	push gs
-
-	mov ax, 0x10
-	mov ds, ax
-	mov es, ax
-	mov fs, ax
-	mov gs, ax
-	cld
-
-	push esp
-	call isr_handler
-	add esp, 4
-
-	pop gs
-	pop fs
-	pop es
-	pop ds
-	popa
-
-	add esp, 8
-	sti
-	iret
diff --git a/kernel/drivers/interrupts.c b/kernel/drivers/interrupts.c
deleted file mode 100644
index 39a59a0..0000000
--- a/kernel/drivers/interrupts.c
+++ /dev/null
@@ -1,261 +0,0 @@
-// MIT License, Copyright (c) 2020 Marvin Borner
-// TODO: Remove some magic numbers
-
-#include <assert.h>
-#include <def.h>
-#include <drivers/cpu.h>
-#include <drivers/interrupts.h>
-#include <drivers/serial.h>
-#include <mem.h>
-#include <mm.h>
-#include <print.h>
-#include <proc.h>
-
-/**
- * IDT
- */
-
-PROTECTED static struct idt_entry idt[256] = { 0 };
-PROTECTED static struct idt_ptr idt_ptr = { 0 };
-
-CLEAR void idt_set_gate(u8 num, u32 base, u16 sel, u8 flags)
-{
-	// Specify the interrupt routine's base address
-	idt[num].base_low = (u16)(base & 0xffff);
-	idt[num].base_high = (u16)((base >> 16) & 0xffff);
-
-	// Set selector/segment of IDT entry
-	idt[num].sel = sel;
-	idt[num].always0 = 0;
-	idt[num].flags = flags;
-}
-
-// Install IDT
-CLEAR static void idt_install(void)
-{
-	// Set IDT pointer and limit
-	idt_ptr.limit = sizeof(idt) - 1;
-	idt_ptr.base = &idt;
-
-	// Clear IDT by setting memory cells to 0
-	memset(&idt, 0, sizeof(idt));
-
-	__asm__ volatile("lidt %0" : : "m"(idt_ptr));
-}
-
-/**
- * IRQ
- */
-
-PROTECTED static void (*irq_routines[16])(struct regs *) = { 0 };
-
-// Install IRQ handler
-CLEAR void irq_install_handler(int irq, void (*handler)(struct regs *r))
-{
-	irq_routines[irq] = handler;
-}
-
-// Remove IRQ handler
-CLEAR void irq_uninstall_handler(int irq)
-{
-	irq_routines[irq] = 0;
-}
-
-// Remap the IRQ table
-CLEAR static void irq_remap(void)
-{
-	outb(0x20, 0x11);
-	outb(0xa0, 0x11);
-	outb(0x21, 0x20);
-	outb(0xa1, 0x28);
-	outb(0x21, 0x04);
-	outb(0xa1, 0x02);
-	outb(0x21, 0x01);
-	outb(0xa1, 0x01);
-	outb(0x21, 0x00);
-	outb(0xa1, 0x00);
-}
-
-// Handle IRQ ISRs
-void irq_handler(struct regs *r);
-void irq_handler(struct regs *r)
-{
-	void (*handler)(struct regs * r);
-
-	// Execute custom handler if exists
-	handler = irq_routines[r->int_no - 32];
-	if (handler)
-		handler(r);
-
-	// Send EOI to second (slave) PIC
-	if (r->int_no >= 40)
-		outb(0xa0, 0x20);
-
-	// Send EOI to master PIC
-	outb(0x20, 0x20);
-}
-
-// Map ISRs to the correct entries in the IDT
-CLEAR static void irq_install(void)
-{
-	irq_remap();
-
-	idt_set_gate(32, (u32)irq0, 0x08, 0x8e);
-	idt_set_gate(33, (u32)irq1, 0x08, 0x8e);
-	idt_set_gate(34, (u32)irq2, 0x08, 0x8e);
-	idt_set_gate(35, (u32)irq3, 0x08, 0x8e);
-	idt_set_gate(36, (u32)irq4, 0x08, 0x8e);
-	idt_set_gate(37, (u32)irq5, 0x08, 0x8e);
-	idt_set_gate(38, (u32)irq6, 0x08, 0x8e);
-	idt_set_gate(39, (u32)irq7, 0x08, 0x8e);
-
-	idt_set_gate(40, (u32)irq8, 0x08, 0x8e);
-	idt_set_gate(41, (u32)irq9, 0x08, 0x8e);
-	idt_set_gate(42, (u32)irq10, 0x08, 0x8e);
-	idt_set_gate(43, (u32)irq11, 0x08, 0x8e);
-	idt_set_gate(44, (u32)irq12, 0x08, 0x8e);
-	idt_set_gate(45, (u32)irq13, 0x08, 0x8e);
-	idt_set_gate(46, (u32)irq14, 0x08, 0x8e);
-	idt_set_gate(47, (u32)irq15, 0x08, 0x8e);
-}
-
-/**
- * ISR
- */
-
-PROTECTED static void (*isr_routines[256])(struct regs *) = { 0 };
-
-PROTECTED const char *isr_exceptions[32] = {
-	"Division By Zero",
-	"Debug",
-	"Non Maskable Interrupt",
-	"Breakpoint",
-	"Into Detected Overflow",
-	"Out of Bounds",
-	"Invalid Opcode",
-	"No Coprocessor",
-
-	"Double Fault",
-	"Coprocessor Segment Overrun",
-	"Bad TSS",
-	"Segment Not Present",
-	"Stack Fault",
-	"General Protection Fault",
-	"Page Fault",
-	"Unknown Interrupt",
-
-	"Coprocessor Fault",
-	"Alignment Check",
-	"Machine Check",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-	"Reserved",
-};
-
-CLEAR void isr_install_handler(int isr, void (*handler)(struct regs *r))
-{
-	isr_routines[isr] = handler;
-}
-
-CLEAR void isr_uninstall_handler(int isr)
-{
-	isr_routines[isr] = 0;
-}
-
-void isr_panic(struct regs *r)
-{
-	printf("%s Exception (code %x) at 0x%x (ring %d), exiting!\n", isr_exceptions[r->int_no],
-	       r->err_code, r->eip, RING(r));
-	struct proc *proc = proc_current();
-	if (proc) {
-		printf("\t-> Exception occurred in %s at addr 0x%x (offset 0x%x)\n", proc->name,
-		       r->eip, r->eip - proc->entry);
-		printf("\t\t-> Process: [entry: %x, kstack: %x, esp %x, ustack: %x, uesp %x]\n",
-		       proc->entry, proc->stack.kernel, r->esp, proc->stack.user, r->useresp);
-		proc_exit(proc, r, 1);
-	} else {
-		__asm__ volatile("cli\nhlt");
-	}
-	proc_yield_regs(r);
-}
-
-void isr_handler(struct regs *r);
-void isr_handler(struct regs *r)
-{
-	assert(r->int_no < sizeof(isr_routines));
-
-	// Execute fault handler if exists
-	void (*handler)(struct regs * r) = isr_routines[r->int_no];
-	if (handler)
-		handler(r);
-	else
-		isr_panic(r);
-}
-
-CLEAR static void isr_install(void)
-{
-	idt_set_gate(0, (u32)isr0, 0x08, 0x8e);
-	idt_set_gate(1, (u32)isr1, 0x08, 0x8e);
-	idt_set_gate(2, (u32)isr2, 0x08, 0x8e);
-	idt_set_gate(3, (u32)isr3, 0x08, 0x8e);
-	idt_set_gate(4, (u32)isr4, 0x08, 0x8e);
-	idt_set_gate(5, (u32)isr5, 0x08, 0x8e);
-	idt_set_gate(6, (u32)isr6, 0x08, 0x8e);
-	idt_set_gate(7, (u32)isr7, 0x08, 0x8e);
-
-	idt_set_gate(8, (u32)isr8, 0x08, 0x8e);
-	idt_set_gate(9, (u32)isr9, 0x08, 0x8e);
-	idt_set_gate(10, (u32)isr10, 0x08, 0x8e);
-	idt_set_gate(11, (u32)isr11, 0x08, 0x8e);
-	idt_set_gate(12, (u32)isr12, 0x08, 0x8e);
-	idt_set_gate(13, (u32)isr13, 0x08, 0x8e);
-	idt_set_gate(14, (u32)isr14, 0x08, 0x8e);
-	idt_set_gate(15, (u32)isr15, 0x08, 0x8e);
-
-	idt_set_gate(16, (u32)isr16, 0x08, 0x8e);
-	idt_set_gate(17, (u32)isr17, 0x08, 0x8e);
-	idt_set_gate(18, (u32)isr18, 0x08, 0x8e);
-	idt_set_gate(19, (u32)isr19, 0x08, 0x8e);
-	idt_set_gate(20, (u32)isr20, 0x08, 0x8e);
-	idt_set_gate(21, (u32)isr21, 0x08, 0x8e);
-	idt_set_gate(22, (u32)isr22, 0x08, 0x8e);
-	idt_set_gate(23, (u32)isr23, 0x08, 0x8e);
-
-	idt_set_gate(24, (u32)isr24, 0x08, 0x8e);
-	idt_set_gate(25, (u32)isr25, 0x08, 0x8e);
-	idt_set_gate(26, (u32)isr26, 0x08, 0x8e);
-	idt_set_gate(27, (u32)isr27, 0x08, 0x8e);
-	idt_set_gate(28, (u32)isr28, 0x08, 0x8e);
-	idt_set_gate(29, (u32)isr29, 0x08, 0x8e);
-	idt_set_gate(30, (u32)isr30, 0x08, 0x8e);
-	idt_set_gate(31, (u32)isr31, 0x08, 0x8e);
-
-	// Set default routines
-	for (u32 i = 0; i < 256; i++)
-		isr_routines[i] = isr_panic;
-
-	// Set page fault handler
-	isr_install_handler(14, page_fault_handler);
-}
-
-/**
- * Combined
- */
-
-CLEAR void interrupts_install(void)
-{
-	idt_install();
-	isr_install();
-	irq_install();
-}
diff --git a/kernel/drivers/pic.c b/kernel/drivers/pic.c
new file mode 100644
index 0000000..55ecfd6
--- /dev/null
+++ b/kernel/drivers/pic.c
@@ -0,0 +1,66 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <def.h>
+#include <drivers/cpu.h>
+#include <drivers/pic.h>
+
+#define PIC1 0x20
+#define PIC1_COMMAND PIC1
+#define PIC1_OFFSET 0x20
+#define PIC1_DATA (PIC1 + 1)
+
+#define PIC2 0xa0
+#define PIC2_COMMAND PIC2
+#define PIC2_OFFSET 0x28
+#define PIC2_DATA (PIC2 + 1)
+
+#define ICW1_ICW4 0x01
+#define ICW1_INIT 0x10
+
+INLINE void pic_wait(void)
+{
+	__asm__ volatile("jmp 1f\n\t"
+			 "1:\n\t"
+			 "    jmp 2f\n\t"
+			 "2:");
+}
+
+CLEAR void pic_install(void)
+{
+	// Initialize
+	outb(PIC1_COMMAND, ICW1_INIT | ICW1_ICW4);
+	pic_wait();
+	outb(PIC2_COMMAND, ICW1_INIT | ICW1_ICW4);
+	pic_wait();
+
+	// Remap
+	outb(PIC1_DATA, PIC1_OFFSET);
+	pic_wait();
+	outb(PIC2_DATA, PIC2_OFFSET);
+	pic_wait();
+
+	outb(PIC1_DATA, 0x04);
+	pic_wait();
+	outb(PIC2_DATA, 0x02);
+	pic_wait();
+
+	// Set 8086 mode
+	outb(PIC1_DATA, 0x01);
+	pic_wait();
+	outb(PIC2_DATA, 0x01);
+	pic_wait();
+
+	outb(PIC1_DATA, 0x00);
+	pic_wait();
+	outb(PIC2_DATA, 0x00);
+	pic_wait();
+}
+
+void pic_ack(u32 int_no)
+{
+	if (int_no >= 40) {
+		outb(PIC2, 0x20);
+	}
+
+	outb(PIC1, 0x20);
+}
diff --git a/kernel/drivers/ps2/keyboard.c b/kernel/drivers/ps2/keyboard.c
index bf1a520..3516a7e 100644
--- a/kernel/drivers/ps2/keyboard.c
+++ b/kernel/drivers/ps2/keyboard.c
@@ -2,7 +2,7 @@
 
 #include <def.h>
 #include <drivers/cpu.h>
-#include <drivers/interrupts.h>
+#include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <errno.h>
 #include <io.h>
@@ -18,9 +18,8 @@ PROTECTED static struct stack *queue = NULL;
 static struct event_keyboard *event = NULL;
 static int state = 0;
 static int merged = 0;
-static void keyboard_handler(struct regs *r)
+static void keyboard_handler(void)
 {
-	UNUSED(r);
 	u8 scancode = ps2_read_data();
 
 	// TODO: Support more than two-byte scancodes
@@ -73,7 +72,7 @@ CLEAR void ps2_keyboard_install(u8 device)
 {
 	UNUSED(device);
 
-	irq_install_handler(1, keyboard_handler);
+	int_event_handler_add(1, keyboard_handler);
 
 	queue = stack_new();
 	struct io_dev *dev = zalloc(sizeof(*dev));
diff --git a/kernel/drivers/ps2/mouse.c b/kernel/drivers/ps2/mouse.c
index 680183d..ab20c90 100644
--- a/kernel/drivers/ps2/mouse.c
+++ b/kernel/drivers/ps2/mouse.c
@@ -2,7 +2,7 @@
 
 #include <assert.h>
 #include <drivers/cpu.h>
-#include <drivers/interrupts.h>
+#include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <errno.h>
 #include <io.h>
@@ -36,9 +36,8 @@ static void mouse_finish(void)
 	io_unblock(IO_MOUSE);
 }
 
-static void mouse_handler(struct regs *r)
+static void mouse_handler(void)
 {
-	UNUSED(r);
 	switch (mouse_cycle) {
 	case 0:
 		mouse_byte[0] = ps2_read_data();
@@ -139,7 +138,7 @@ CLEAR void ps2_mouse_install(u8 device)
 {
 	ps2_mouse_enable(device);
 
-	irq_install_handler(12, mouse_handler);
+	int_event_handler_add(12, mouse_handler);
 
 	queue = stack_new();
 	struct io_dev *dev = zalloc(sizeof(*dev));
diff --git a/kernel/drivers/timer.c b/kernel/drivers/timer.c
index 3ddc229..44d66f3 100644
--- a/kernel/drivers/timer.c
+++ b/kernel/drivers/timer.c
@@ -2,7 +2,7 @@
 
 #include <def.h>
 #include <drivers/cpu.h>
-#include <drivers/interrupts.h>
+#include <drivers/int.h>
 #include <drivers/rtc.h>
 #include <drivers/timer.h>
 #include <io.h>
@@ -10,7 +10,6 @@
 #include <proc.h>
 
 static u32 timer_ticks = 0;
-PROTECTED static u8 call_scheduler = 0;
 
 CLEAR static void timer_phase(int hz)
 {
@@ -25,36 +24,20 @@ u32 timer_get(void)
 	return timer_ticks;
 }
 
-void timer_handler(struct regs *r)
+static void timer_handler(void)
 {
 	if (timer_ticks >= U32_MAX)
 		timer_ticks = 0;
 	else
 		timer_ticks++;
-
-	if (call_scheduler)
-		scheduler(r);
 }
 
 // "Delay" function with CPU sleep
 void timer_wait(u32 ticks)
 {
 	u32 eticks = timer_ticks + ticks;
-	while (timer_ticks < eticks) {
+	while (timer_ticks < eticks)
 		__asm__ volatile("sti\nhlt\ncli");
-	}
-}
-
-CLEAR void scheduler_enable(void)
-{
-	call_scheduler = 1;
-	irq_install_handler(0, timer_handler);
-}
-
-CLEAR void scheduler_disable(void)
-{
-	call_scheduler = 0;
-	irq_install_handler(0, timer_handler);
 }
 
 static struct timer timer_struct(void)
@@ -85,7 +68,7 @@ CLEAR void timer_install(void)
 	/* hpet_install(10000); // TODO: Find optimal femtosecond period */
 	/* if (!hpet) */
 	timer_phase(1000);
-	irq_install_handler(0, timer_handler);
+	int_event_handler_add(0, timer_handler);
 
 	struct io_dev *dev = zalloc(sizeof(*dev));
 	dev->read = timer_read;
diff --git a/kernel/drivers/vmware.c b/kernel/drivers/vmware.c
index 169865f..24f56a0 100644
--- a/kernel/drivers/vmware.c
+++ b/kernel/drivers/vmware.c
@@ -2,7 +2,7 @@
 // VMWare extensions/backdoors for better VM integration
 
 #include <def.h>
-#include <drivers/interrupts.h>
+#include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <drivers/vmware.h>
 #include <io.h>
@@ -94,9 +94,8 @@ CLEAR static void vmware_mouse_enable(void)
 	vmware_out(&command);
 }
 
-static void vmware_mouse_handler(struct regs *r)
+static void vmware_mouse_handler(void)
 {
-	UNUSED(r);
 	ps2_read_data(); // Unused, for PS/2 compatibility
 
 	struct vmware_command command = { .b.bx = 0, .c.command = VMMOUSE_STATUS };
@@ -150,7 +149,7 @@ CLEAR void vmware_mouse_install(u8 device)
 	ps2_mouse_enable(device);
 
 	vmware_mouse_enable();
-	irq_install_handler(12, vmware_mouse_handler);
+	int_event_handler_add(12, vmware_mouse_handler);
 
 	queue = stack_new();
 	struct io_dev *dev = zalloc(sizeof(*dev));