Huge scheduler rewrite and other things

5 files changed, 176 insertions, 162 deletions

diff --git a/kernel/features/io.c b/kernel/features/io.c
index 28388ae..8126ccf 100644
--- a/kernel/features/io.c
+++ b/kernel/features/io.c
@@ -5,7 +5,7 @@
 #include <def.h>
 #include <drivers/bga.h>
 #include <drivers/cpu.h>
-#include <drivers/interrupts.h>
+#include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <drivers/timer.h>
 #include <drivers/vbe.h>
diff --git a/kernel/features/load.c b/kernel/features/load.c
index 1059240..4951351 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -14,13 +14,11 @@ res elf_load(const char *name, struct proc *proc)
 	if (!memory_readable(name))
 		return -EFAULT;
 
-	stac();
 	char path[64] = { "/apps/" };
-	strlcat(path, name, sizeof(path));
-	strlcpy(proc->dir, path, sizeof(proc->dir));
-	strlcat(path, "/exec", sizeof(path));
-	strlcpy(proc->name, name, sizeof(proc->name));
-	clac();
+	strlcat_user(path, name, sizeof(path));
+	strlcpy_user(proc->dir, path, sizeof(proc->dir));
+	strlcat_user(path, "/exec", sizeof(path));
+	strlcpy_user(proc->name, name, sizeof(proc->name));
 
 	struct stat s = { 0 };
 	memory_bypass_enable();
@@ -30,11 +28,11 @@ res elf_load(const char *name, struct proc *proc)
 		return stat;
 
 	struct elf_header header = { 0 };
-	stac();
 	memory_bypass_enable();
+	stac();
 	res read = vfs_read(path, &header, 0, sizeof(header));
-	memory_bypass_disable();
 	clac();
+	memory_bypass_disable();
 	if (read < 0)
 		return read;
 	if (read != sizeof(header))
@@ -124,22 +122,6 @@ res elf_load(const char *name, struct proc *proc)
 		}
 		memory_bypass_disable();
 
-		// TODO: Use section and symbol name for logging or something? (e.g. in page fault handler)
-		/* u32 offset = section_strings.offset + section.name; */
-		/* if (offset >= s.size) */
-		/* 	return -ENOEXEC; */
-		/* memory_bypass_enable(); */
-		/* char name[64] = { 0 }; // Max length? */
-		/* if (vfs_read(path, &name, offset, sizeof(name)) != sizeof(name)) { */
-		/* 	memory_bypass_disable(); */
-		/* 	return -ENOEXEC; */
-		/* } */
-		/* memory_bypass_disable(); */
-		/* printf("%d\n", section.name); */
-		/* if (section.type == ELF_SECTION_TYPE_SYMTAB) { */
-		/* } else if (section.type == ELF_SECTION_TYPE_STRTAB && i != header.shstrndx) { */
-		/* } */
-
 		// Remap readonly sections
 		if (!(section.flags & ELF_SECTION_FLAG_WRITE) && section.addr &&
 		    memory_is_user((void *)section.addr)) {
@@ -149,26 +131,8 @@ res elf_load(const char *name, struct proc *proc)
 		}
 	}
 
-	struct page_dir *prev;
-	memory_backup_dir(&prev);
-	memory_switch_dir(proc->page_dir);
-
-	// Allocate user stack with readonly lower and upper page boundary
-	u32 user_stack = (u32)memory_alloc_with_boundary(proc->page_dir, PROC_STACK_SIZE,
-							 MEMORY_CLEAR | MEMORY_USER);
-
-	// Allocate kernel stack with readonly lower and upper page boundary
-	u32 kernel_stack =
-		(u32)memory_alloc_with_boundary(proc->page_dir, PROC_STACK_SIZE, MEMORY_CLEAR);
-
-	proc->stack.user = user_stack + PROC_STACK_SIZE;
-	proc->stack.kernel = kernel_stack + PROC_STACK_SIZE;
-	proc->regs.esp = proc->stack.kernel;
-	proc->regs.ebp = proc->stack.user;
-	proc->regs.useresp = proc->stack.user;
-	proc->regs.eip = header.entry + rand_off;
 	proc->entry = header.entry + rand_off;
+	proc_make_regs(proc);
 
-	memory_switch_dir(prev);
 	return EOK;
 }
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index 227ba0a..0137256 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -14,6 +14,7 @@
 
 PROTECTED static struct page_dir kernel_dir ALIGNED(PAGE_SIZE) = { 0 };
 static struct page_table kernel_tables[PAGE_KERNEL_COUNT] ALIGNED(PAGE_SIZE) = { 0 };
+static struct page_dir *current_dir = NULL;
 
 extern u32 kernel_rw_start;
 extern u32 kernel_rw_end;
@@ -66,14 +67,15 @@ static const char *page_fault_section(u32 addr)
 	return section;
 }
 
-void page_fault_handler(struct regs *r)
+static void page_fault_handler(u32 esp)
 {
+	struct int_frame *frame = (struct int_frame *)esp;
 	print("--- PAGE FAULT! ---\n");
 
 	// Check error code
-	const char *type = (r->err_code & 1) ? "present" : "non-present";
-	const char *operation = (r->err_code & 2) ? "write" : "read";
-	const char *super = (r->err_code & 4) ? "User" : "Super";
+	const char *type = (frame->err_code & 1) ? "present" : "non-present";
+	const char *operation = (frame->err_code & 2) ? "write" : "read";
+	const char *super = (frame->err_code & 4) ? "User" : "Super";
 
 	// Check cr2 address (virtual and physical)
 	u32 vaddr;
@@ -87,16 +89,13 @@ void page_fault_handler(struct regs *r)
 	printf("%s process tried to %s a %s page at [vaddr=%x; paddr=%x]\n", super, operation, type,
 	       vaddr, paddr);
 
-	if (proc && vaddr > proc->regs.ebp - PROC_STACK_SIZE - PAGE_SIZE &&
-	    vaddr < proc->regs.ebp + PAGE_SIZE)
+	if (proc && vaddr > proc->stack.user_ptr - PROC_STACK_SIZE - PAGE_SIZE &&
+	    vaddr < proc->stack.user_ptr + PAGE_SIZE)
 		print("Probably a stack overflow\n");
 
 	printf("Sections: [vaddr_section=%s; paddr_section=%s; eip_section=%s]\n",
-	       page_fault_section(vaddr), page_fault_section(paddr), page_fault_section(r->eip));
-
-	/* printf("%b\n", virtual_entry(dir, vaddr)->uint); */
-
-	isr_panic(r);
+	       page_fault_section(vaddr), page_fault_section(paddr),
+	       page_fault_section(frame->eip));
 }
 
 /**
@@ -424,8 +423,18 @@ void *memory_alloc(struct page_dir *dir, u32 size, u32 flags)
 		goto err;
 	}
 
-	if (flags & MEMORY_CLEAR)
-		memset_user((void *)vaddr, 0, size);
+	if (flags & MEMORY_CLEAR) {
+		// TODO: Neater solution
+		if (dir == current_dir) {
+			memset_user((void *)vaddr, 0, size);
+		} else {
+			struct page_dir *bak;
+			memory_backup_dir(&bak);
+			memory_switch_dir(dir);
+			memset_user((void *)vaddr, 0, size);
+			memory_switch_dir(bak);
+		}
+	}
 
 	return (void *)vaddr;
 
@@ -587,6 +596,7 @@ res memory_sys_shaccess(struct page_dir *dir, u32 id, u32 *addr, u32 *size)
 
 void memory_switch_dir(struct page_dir *dir)
 {
+	current_dir = dir;
 	paging_switch_dir(virtual_to_physical(&kernel_dir, (u32)dir));
 }
 
@@ -760,4 +770,6 @@ CLEAR void memory_install(void)
 	paging_enable();
 
 	memory_objects = list_new();
+
+	int_trap_handler_add(14, page_fault_handler);
 }
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index 8fc922e..ce33495 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -27,24 +27,26 @@ PROTECTED static struct list *proc_list_idle = NULL;
 
 // TODO: Use less memcpy and only copy relevant registers
 // TODO: 20 priority queues (https://www.kernel.org/doc/html/latest/scheduler/sched-nice-design.html)
-HOT FLATTEN void scheduler(struct regs *regs)
+HOT FLATTEN u32 scheduler(u32 esp)
 {
 	spinlock(&locked);
 
-	if (RING(regs) == 3)
-		PROC(current)->ticks.user++;
-	else
-		PROC(current)->ticks.kernel++;
+	if (!current) {
+		current = idle_proc;
+		locked = 0;
+		return PROC(current)->stack.kernel_ptr;
+	}
 
 	if (PROC(current)->quantum.cnt >= PROC(current)->quantum.val) {
 		PROC(current)->quantum.cnt = 0;
 	} else {
 		PROC(current)->quantum.cnt++;
 		locked = 0;
-		return;
+		return esp;
 	}
 
-	memcpy(&PROC(current)->regs, regs, sizeof(*regs));
+	fpu_save(PROC(current));
+	PROC(current)->stack.kernel_ptr = esp;
 
 	if (current->next) {
 		current = current->next;
@@ -54,17 +56,21 @@ HOT FLATTEN void scheduler(struct regs *regs)
 		current = idle_proc;
 	}
 
-	tss_set_stack(PROC(current)->stack.kernel);
 	memory_switch_dir(PROC(current)->page_dir);
-	memcpy(regs, &PROC(current)->regs, sizeof(*regs));
+	tss_set_stack(PROC(current)->stack.kernel_ptr);
+	fpu_restore(PROC(current));
 
 #if DEBUG_SCHEDULER
-	if (current != idle_proc)
+	if (current != idle_proc) {
+		struct int_frame_user *frame =
+			(struct int_frame_user *)PROC(current)->stack.kernel_ptr;
 		printf("%s (%d): eip %x esp %x useresp %x\n", PROC(current)->name,
-		       PROC(current)->pid, regs->eip, regs->esp, regs->useresp);
+		       PROC(current)->pid, frame->eip, frame->esp, frame->useresp);
+	}
 #endif
 
 	locked = 0;
+	return PROC(current)->stack.kernel_ptr;
 }
 
 void proc_print(void)
@@ -151,7 +157,7 @@ void proc_state(struct proc *proc, enum proc_state state)
 	// else: Nothing to do!
 }
 
-void proc_exit(struct proc *proc, struct regs *r, s32 status)
+void proc_exit(struct proc *proc, s32 status)
 {
 	assert(proc != idle_proc->data);
 
@@ -162,8 +168,8 @@ void proc_exit(struct proc *proc, struct regs *r, s32 status)
 	}
 
 	if (current->data == proc) {
-		current = idle_proc;
-		memcpy(r, &PROC(idle_proc)->regs, sizeof(*r));
+		memory_switch_dir(virtual_kernel_dir());
+		current = NULL;
 	}
 
 	printf("Process %s (%d) exited with status %d (%s)\n",
@@ -188,28 +194,46 @@ void proc_exit(struct proc *proc, struct regs *r, s32 status)
 	stack_destroy(proc->messages);
 	list_destroy(proc->memory); // TODO: Decrement memory ref links
 	virtual_destroy_dir(proc->page_dir);
-
+	memset(proc, 0, sizeof(*proc));
 	free(proc);
 
-	proc_yield_regs(r);
+	proc_yield();
+	assert_not_reached();
 }
 
 void proc_yield(void)
 {
-	// TODO: Fix yielding without debug mode (File size?! Regs?! IDK?!)
-	proc_reset_quantum(PROC(current));
-	__asm__ volatile("int $127");
+	__asm__ volatile("int $129");
 }
 
-void proc_yield_regs(struct regs *r)
+void proc_stack_user_push(struct proc *proc, const void *data, u32 size)
 {
-	proc_reset_quantum(PROC(current));
-	scheduler(r);
+	struct page_dir *prev;
+	memory_backup_dir(&prev);
+	memory_switch_dir(proc->page_dir);
+
+	proc->stack.user_ptr -= size;
+	memcpy_user((void *)proc->stack.user_ptr, data, size);
+
+	memory_switch_dir(prev);
+}
+
+void proc_stack_kernel_push(struct proc *proc, const void *data, u32 size)
+{
+	struct page_dir *prev;
+	memory_backup_dir(&prev);
+	memory_switch_dir(proc->page_dir);
+
+	proc->stack.kernel_ptr -= size;
+	memcpy_user((void *)proc->stack.kernel_ptr, data, size);
+
+	memory_switch_dir(prev);
 }
 
 struct proc *proc_make(enum proc_priv priv)
 {
 	struct proc *proc = zalloc(sizeof(*proc));
+	fpu_init(proc);
 	proc->pid = current_pid++;
 	proc->priv = priv;
 	proc->messages = stack_new();
@@ -219,35 +243,55 @@ struct proc *proc_make(enum proc_priv priv)
 	proc->quantum.val = PROC_QUANTUM;
 	proc->quantum.cnt = 0;
 
-	// Init regs
-	u8 is_kernel = priv == PROC_PRIV_KERNEL;
-	u32 data = is_kernel ? GDT_SUPER_DATA_OFFSET : GDT_USER_DATA_OFFSET;
-	u32 code = is_kernel ? GDT_SUPER_CODE_OFFSET : GDT_USER_CODE_OFFSET;
-	proc->regs.gs = data;
-	proc->regs.fs = data;
-	proc->regs.es = data;
-	proc->regs.ds = data;
-	proc->regs.ss = data;
-	proc->regs.cs = code;
-	proc->regs.eflags = EFLAGS_ALWAYS | EFLAGS_INTERRUPTS;
-
-	list_add(proc_list_running, proc);
-
 	return proc;
 }
 
-void proc_stack_push(struct proc *proc, u32 data)
+void proc_make_regs(struct proc *proc)
 {
-	struct page_dir *prev;
-	memory_backup_dir(&prev);
-	memory_switch_dir(proc->page_dir);
+	struct int_frame_user frame = { 0 };
 
-	proc->regs.useresp -= sizeof(data);
-	stac();
-	*(u32 *)proc->regs.useresp = data;
-	clac();
+	assert(proc->entry);
+	frame.eip = proc->entry;
 
-	memory_switch_dir(prev);
+	// Allocate user stack with readonly lower and upper page boundary
+	u32 user_stack = (u32)memory_alloc_with_boundary(proc->page_dir, PROC_STACK_SIZE,
+							 MEMORY_CLEAR | MEMORY_USER);
+
+	// Allocate kernel stack with readonly lower and upper page boundary
+	u32 kernel_stack =
+		(u32)memory_alloc_with_boundary(proc->page_dir, PROC_STACK_SIZE, MEMORY_CLEAR);
+
+	proc->stack.user = user_stack + PROC_STACK_SIZE;
+	proc->stack.user_ptr = proc->stack.user;
+
+	proc->stack.kernel = kernel_stack + PROC_STACK_SIZE;
+	proc->stack.kernel_ptr = proc->stack.kernel;
+
+	frame.esp = proc->stack.kernel;
+	frame.ebp = proc->stack.kernel;
+	frame.useresp = proc->stack.user;
+
+	// Init regs
+	u8 is_kernel = proc->priv == PROC_PRIV_KERNEL;
+	u32 data = is_kernel ? GDT_SUPER_DATA_OFFSET : GDT_USER_DATA_OFFSET;
+	u32 code = is_kernel ? GDT_SUPER_CODE_OFFSET : GDT_USER_CODE_OFFSET;
+	frame.gs = data;
+	frame.fs = data;
+	frame.es = data;
+	frame.ds = data;
+	frame.ss = data;
+	frame.cs = code;
+	frame.eflags = EFLAGS_ALWAYS | EFLAGS_INTERRUPTS;
+
+	// Push frame as the values get popped (see int.asm)
+	proc_stack_kernel_push(proc, &frame, sizeof(frame));
+
+	// Push argc and argv // TODO
+	u32 arg = 0;
+	proc_stack_user_push(proc, &arg, sizeof(arg));
+	proc_stack_user_push(proc, &arg, sizeof(arg));
+
+	list_add(proc_list_running, proc);
 }
 
 // TODO: Procfs needs a simpler interface structure (memcmp and everything sucks)
@@ -331,8 +375,6 @@ void proc_init(void)
 	if (proc_list_running)
 		panic("Already initialized processes!");
 
-	cli();
-	scheduler_enable();
 	proc_list_running = list_new();
 	proc_list_blocked = list_new();
 	proc_list_idle = list_new();
@@ -354,8 +396,6 @@ void proc_init(void)
 	// TODO: Reimplement hlt privileges in idle proc (SMEP!)
 	struct proc *kernel_proc = proc_make(PROC_PRIV_NONE);
 	assert(elf_load("idle", kernel_proc) == EOK);
-	proc_stack_push(kernel_proc, 0);
-	proc_stack_push(kernel_proc, 0);
 	kernel_proc->state = PROC_BLOCKED;
 	kernel_proc->quantum.val = 0;
 	kernel_proc->quantum.cnt = 0;
@@ -365,12 +405,10 @@ void proc_init(void)
 	// Init proc (root)
 	struct proc *init = proc_make(PROC_PRIV_ROOT);
 	assert(elf_load("init", init) == EOK);
-	proc_stack_push(init, 0);
-	proc_stack_push(init, 0);
 	current = list_first_data(proc_list_running, init);
 
-	_eip = init->regs.eip;
-	_esp = init->regs.useresp;
+	_eip = init->entry;
+	_esp = init->stack.user_ptr;
 
 	// We'll shortly jump to usermode. Clear and protect every secret!
 	memory_user_hook();
@@ -381,6 +419,5 @@ void proc_init(void)
 
 	// You're waiting for a train. A train that will take you far away...
 	proc_jump_userspace();
-
-	panic("Returned from limbo!\n");
+	assert_not_reached();
 }
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index 9efb849..93355db 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -1,7 +1,7 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
 #include <drivers/cpu.h>
-#include <drivers/interrupts.h>
+#include <drivers/int.h>
 #include <drivers/timer.h>
 #include <errno.h>
 #include <fs.h>
@@ -15,103 +15,106 @@
 #include <sys.h>
 #include <syscall.h>
 
-static void syscall_handler(struct regs *r)
+static u32 syscall_handler(u32 esp)
 {
-	enum sys num = r->eax;
+	struct int_frame_user *frame = (struct int_frame_user *)esp;
+	enum sys num = frame->eax;
 
-	/* printf("[SYSCALL] %d from %s\n", num, proc_current()->name); */
+#if DEBUG_SYSCALLS
+	printf("[SYSCALL] %d from %s\n", num, proc_current()->name);
+#endif
 
 	switch (num) {
 	// Memory operations
 	case SYS_ALLOC: {
-		r->eax = memory_sys_alloc(proc_current()->page_dir, r->ebx, (u32 *)r->ecx,
-					  (u32 *)r->edx, (u8)r->esi);
+		frame->eax = memory_sys_alloc(proc_current()->page_dir, frame->ebx,
+					      (u32 *)frame->ecx, (u32 *)frame->edx, (u8)frame->esi);
 		break;
 	}
 	case SYS_FREE: {
-		r->eax = memory_sys_free(proc_current()->page_dir, r->ebx);
+		frame->eax = memory_sys_free(proc_current()->page_dir, frame->ebx);
 		break;
 	}
 	case SYS_SHACCESS: {
-		r->eax = memory_sys_shaccess(proc_current()->page_dir, r->ebx, (u32 *)r->ecx,
-					     (u32 *)r->edx);
+		frame->eax = memory_sys_shaccess(proc_current()->page_dir, frame->ebx,
+						 (u32 *)frame->ecx, (u32 *)frame->edx);
 		break;
 	}
 
 	// File operations
 	case SYS_STAT: {
-		r->eax = vfs_stat((char *)r->ebx, (struct stat *)r->ecx);
+		frame->eax = vfs_stat((char *)frame->ebx, (struct stat *)frame->ecx);
 		break;
 	}
 	case SYS_READ: {
-		r->eax = vfs_read((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
+		frame->eax =
+			vfs_read((char *)frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
 		break;
 	}
 	case SYS_WRITE: {
-		r->eax = vfs_write((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
+		frame->eax =
+			vfs_write((char *)frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
 		break;
 	}
 
 	// I/O operations
 	case SYS_IOPOLL: {
-		r->eax = io_poll((void *)r->ebx);
+		frame->eax = io_poll((void *)frame->ebx);
 		break;
 	}
 	case SYS_IOREAD: {
-		res ready = io_ready(r->ebx);
+		res ready = io_ready(frame->ebx);
 		if (ready == -EAGAIN) {
-			io_block(r->ebx, proc_current());
+			io_block(frame->ebx, proc_current());
 		} else if (ready != EOK) {
-			r->eax = ready;
+			frame->eax = ready;
 			break;
 		}
-		r->eax = io_read(r->ebx, (void *)r->ecx, r->edx, r->esi);
+		frame->eax = io_read(frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
 		break;
 	}
 	case SYS_IOWRITE: {
-		r->eax = io_write(r->ebx, (void *)r->ecx, r->edx, r->esi);
+		frame->eax = io_write(frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
 		break;
 	}
 	case SYS_IOCONTROL: {
-		r->eax = io_control(r->ebx, r->ecx, (void *)r->edx, (void *)r->esi, (void *)r->edi);
+		frame->eax = io_control(frame->ebx, frame->ecx, (void *)frame->edx,
+					(void *)frame->esi, (void *)frame->edi);
 		break;
 	}
 
 	// Process operations
 	case SYS_EXEC: {
-		char *path = (char *)r->ebx;
+		char *path = (char *)frame->ebx;
 		struct proc *proc = proc_make(PROC_PRIV_NONE);
-		r->eax = (u32)elf_load(path, proc);
-		if (r->eax != EOK) {
-			proc_exit(proc, r, -r->eax);
-		} else {
-			// TODO: Reimplement argc,argv
-			proc_stack_push(proc, 0);
-			proc_yield_regs(r);
-		}
+		frame->eax = (u32)elf_load(path, proc);
+		if (frame->eax != EOK)
+			proc_exit(proc, -frame->eax);
+		else
+			proc_yield();
 		break;
 	}
 	case SYS_EXIT: {
-		r->eax = EOK;
-		proc_exit(proc_current(), r, (s32)r->ebx);
+		frame->eax = EOK;
+		proc_exit(proc_current(), (s32)frame->ebx);
 		break;
 	}
 	case SYS_YIELD: {
-		r->eax = EOK;
-		proc_yield_regs(r);
+		frame->eax = EOK;
+		proc_yield();
 		break;
 	}
 
 	// System operations
 	case SYS_BOOT: { // TODO: Move
-		if (r->ebx != SYS_BOOT_MAGIC) {
-			r->eax = -EINVAL;
+		if (frame->ebx != SYS_BOOT_MAGIC) {
+			frame->eax = -EINVAL;
 			break;
 		}
 		if (!proc_super()) {
-			r->eax = -EACCES;
+			frame->eax = -EACCES;
 		}
-		switch (r->ecx) {
+		switch (frame->ecx) {
 		case SYS_BOOT_REBOOT:
 			print("Rebooting...\n");
 			outb(0x64, 0xfe);
@@ -126,38 +129,36 @@ static void syscall_handler(struct regs *r)
 			__asm__ volatile("cli\nud2");
 			break;
 		default:
-			r->eax = -EINVAL;
+			frame->eax = -EINVAL;
 		}
 		break;
 	}
 
 	case SYS_MIN:
 	case SYS_MAX:
-		r->eax = -EINVAL;
+		frame->eax = -EINVAL;
 		break;
 
-	// TODO: Reimplement network functions using VFS
 	default: {
-		r->eax = -EINVAL;
+		frame->eax = -EINVAL;
 		printf("Unknown syscall %d!\n", num);
 		break;
 	}
 	}
+
+	return esp;
 }
 
-// For kernel syscalls (internal)
-static void syscall_special_handler(struct regs *r)
+// Internal scheduler (=> yield) call
+static u32 syscall_special_handler(u32 esp)
 {
-	if (RING(r) != 0)
-		return;
-
-	scheduler(r);
+	if (proc_current())
+		proc_reset_quantum(proc_current());
+	return scheduler(esp);
 }
 
 CLEAR void syscall_init(void)
 {
-	idt_set_gate(0x7f, (u32)isr127, 0x08, 0x8e);
-	idt_set_gate(0x80, (u32)isr128, 0x08, 0xee);
-	isr_install_handler(0x7f, syscall_special_handler);
-	isr_install_handler(0x80, syscall_handler);
+	int_special_handler_add(0, syscall_handler);
+	int_special_handler_add(1, syscall_special_handler);
 }