Awesome new multitasking system and scheduler

5 files changed, 379 insertions, 0 deletions

diff --git a/src/kernel/tasks/process.c b/src/kernel/tasks/process.c
new file mode 100644
index 0000000..5ac4010
--- /dev/null
+++ b/src/kernel/tasks/process.c
@@ -0,0 +1,206 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <kernel/tasks/process.h>
+#include <kernel/tasks/userspace.h>
+#include <kernel/interrupts/interrupts.h>
+#include <kernel/system.h>
+#include <kernel/lib/lib.h>
+#include <kernel/memory/paging.h>
+#include <kernel/memory/alloc.h>
+#include <kernel/timer/timer.h>
+
+uint32_t pid = 0;
+struct process *root;
+struct process *current_proc = NULL;
+
+struct regs hold_root;
+
+extern uint32_t stack_hold;
+
+void scheduler(struct regs *regs)
+{
+	memcpy(&current_proc->registers, regs, sizeof(struct regs));
+
+	debug("Task switch");
+
+	timer_handler(regs);
+
+	current_proc = current_proc->next;
+	if (current_proc == NULL) {
+		current_proc = root;
+	}
+
+	while (current_proc->state == PROC_ASLEEP) {
+		current_proc = current_proc->next;
+		if (current_proc == NULL)
+			current_proc = root;
+	}
+
+	memcpy(regs, &current_proc->registers, sizeof(struct regs));
+	paging_switch_directory(current_proc->cr3);
+}
+
+void process_init(struct process *proc)
+{
+	root = proc;
+	root->pid = pid++;
+	root->next = NULL;
+	root->thread = PROC_ROOT; // Unkillable
+	root->state = PROC_RUNNING;
+
+	current_proc = root;
+	irq_install_handler(0, scheduler);
+	userspace_enter(proc);
+}
+
+void process_kill(uint32_t pid)
+{
+	struct process *proc = process_from_pid(pid);
+
+	if (proc == PID_NOT_FOUND)
+		panic("Can't kill unknown PID");
+
+	// flush(proc->stdout);
+	// flush(proc->stderr);
+	proc->state = PROC_ASLEEP;
+
+	if (proc->parent != NULL) {
+		//warn("Child had parent");
+		//process_wake(proc->parent->pid);
+	}
+}
+
+uint32_t process_spawn(struct process *process)
+{
+	process->next = root->next;
+	root->next = process;
+	process->state = PROC_RUNNING;
+
+	process->parent = current_proc;
+
+	//process_suspend(current_proc->pid);
+
+	return process->pid;
+}
+
+int process_wait_gid(uint32_t gid, int *status)
+{
+	struct process *i = root;
+
+	while (i != NULL) {
+		if (i->gid == gid)
+			if (i->state == PROC_ASLEEP) {
+				*status = i->registers.ebx;
+				return i->pid;
+			}
+
+		i = i->next;
+	}
+
+	return WAIT_OKAY;
+}
+
+int process_wait_pid(uint32_t pid, int *status)
+{
+	struct process *i = current_proc->next;
+
+	while (i != NULL) {
+		if (i->pid == pid) {
+			if (i->state == PROC_ASLEEP) {
+				*status = i->registers.ebx;
+				return i->pid;
+			} else {
+				return WAIT_OKAY;
+			}
+		}
+		i = i->next;
+	}
+
+	return WAIT_ERROR;
+}
+
+void process_suspend(uint32_t pid)
+{
+	struct process *proc = process_from_pid(pid);
+
+	if (proc == PID_NOT_FOUND) {
+		warn("couldn't find PID for suspension");
+		return;
+	}
+
+	proc->state = PROC_ASLEEP;
+}
+
+void process_wake(uint32_t pid)
+{
+	struct process *proc = process_from_pid(pid);
+
+	if (proc == PID_NOT_FOUND)
+		return;
+
+	proc->state = PROC_RUNNING;
+}
+
+uint32_t process_child(struct process *child, uint32_t pid)
+{
+	process_suspend(pid);
+
+	struct process *parent = process_from_pid(pid);
+
+	if (parent == PID_NOT_FOUND) {
+		panic("Child process spawned without parent");
+	}
+
+	child->parent = parent;
+
+	return process_spawn(child);
+}
+
+uint32_t process_fork(uint32_t pid)
+{
+	warn("Fork is not implemented");
+
+	// With struct regs *regs
+	/*struct page_directory *dir = paging_copy_user_directory(current_proc->cr3);
+	struct process *proc = process_make_new();
+	proc->cr3 = dir;
+	memcpy(&proc->registers, regs, sizeof(struct regs));
+	proc->registers.eax = proc->pid;
+	proc->pid = current_proc->pid;
+
+	process_spawn(proc);*/
+	return pid++;
+}
+
+struct process *process_from_pid(uint32_t pid)
+{
+	struct process *proc = root;
+
+	while (proc != NULL) {
+		if (proc->pid == pid)
+			return proc;
+
+		proc = proc->next;
+	}
+
+	return PID_NOT_FOUND;
+}
+
+struct process *process_make_new()
+{
+	struct process *proc = (struct process *)kmalloc_a(sizeof(struct process));
+	proc->registers.cs = 0x1B;
+	proc->registers.ds = 0x23;
+	proc->registers.ss = 0x23;
+	proc->cr3 = paging_make_directory();
+
+	proc->brk = 0x50000000;
+
+	int i;
+	for (i = 0; i < 1024; i++)
+		proc->cr3->tables[i] = paging_root_directory->tables[i];
+
+	proc->pid = pid++;
+
+	return proc;
+}
\ No newline at end of file
diff --git a/src/kernel/tasks/process.h b/src/kernel/tasks/process.h
new file mode 100644
index 0000000..df0f51f
--- /dev/null
+++ b/src/kernel/tasks/process.h
@@ -0,0 +1,71 @@
+#ifndef MELVIX_PROCESS_H
+#define MELVIX_PROCESS_H
+
+#include <stdint.h>
+#include <kernel/memory/paging.h>
+#include <kernel/interrupts/interrupts.h>
+
+struct mmap {
+	uint32_t text;
+	uint32_t bss;
+	uint32_t data;
+	uint32_t stack;
+};
+
+struct process {
+	struct page_directory *cr3;
+	struct regs registers;
+
+	uint32_t pid;
+	uint32_t gid;
+	char *name;
+
+	int state;
+	int thread;
+
+	uint32_t stdint;
+	uint32_t stdout;
+	uint32_t stderr;
+
+	uint32_t brk;
+	uint32_t handlers[6];
+
+	struct process *parent;
+	struct process *next;
+};
+
+void process_kill(uint32_t pid);
+
+uint32_t process_spawn(struct process *process);
+
+void process_suspend(uint32_t pid);
+void process_wake(uint32_t pid);
+uint32_t process_child(struct process *process, uint32_t pid);
+uint32_t process_fork(uint32_t pid);
+
+int process_wait_gid(uint32_t gid, int *status);
+int process_wait_pid(uint32_t pid, int *status);
+
+struct process *process_from_pid(uint32_t pid);
+
+void process_init(struct process *proc);
+
+struct process *process_make_new();
+
+extern struct process *current_proc;
+
+extern uint32_t stack_hold;
+
+#define PID_NOT_FOUND ((struct process *)0xFFFFFFFF)
+
+#define PROC_RUNNING 0
+#define PROC_ASLEEP 1
+
+#define PROC_THREAD 0
+#define PROC_PROC 1
+#define PROC_ROOT 2
+
+#define WAIT_ERROR (-1)
+#define WAIT_OKAY 0
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/tasks/userspace.asm b/src/kernel/tasks/userspace.asm
new file mode 100644
index 0000000..4f79d4d
--- /dev/null
+++ b/src/kernel/tasks/userspace.asm
@@ -0,0 +1,20 @@
+global jump_userspace
+extern hl_cr3
+extern hl_esp
+extern hl_eip
+
+jump_userspace:
+	mov ax, 0x23
+	mov ds, ax
+	mov es, ax
+	mov fs, ax
+	mov gs, ax
+
+	mov eax, dword [hl_esp]
+	push 0x23
+	push eax
+	pushf
+	push 0x1B
+	push dword [hl_eip]
+
+	iret
\ No newline at end of file
diff --git a/src/kernel/tasks/userspace.c b/src/kernel/tasks/userspace.c
new file mode 100644
index 0000000..f8d0472
--- /dev/null
+++ b/src/kernel/tasks/userspace.c
@@ -0,0 +1,65 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <kernel/system.h>
+#include <kernel/tasks/userspace.h>
+#include <kernel/tasks/process.h>
+#include <kernel/memory/paging.h>
+#include <kernel/io/io.h>
+#include <kernel/interrupts/interrupts.h>
+#include <kernel/lib/lib.h>
+
+struct process *proc_bottom = NULL;
+
+uint32_t hl_cr3;
+uint32_t hl_eip;
+uint32_t hl_esp;
+
+uint32_t spawn_child(struct process *child)
+{
+	return (uint32_t)-1;
+}
+
+void userspace_enter(struct process *proc)
+{
+	proc_bottom = proc;
+	proc->next = NULL;
+	hl_eip = proc->registers.eip;
+	hl_esp = proc->registers.esp;
+	paging_switch_directory(proc->cr3);
+
+	current_proc = proc;
+
+	sti();
+	jump_userspace();
+}
+
+void single_yield(struct process *proc, struct regs *regs)
+{
+	memcpy(&proc_bottom->registers, regs, sizeof(struct regs));
+
+	if (proc == proc_bottom)
+		panic("Can't return from parent process");
+
+	proc->next = proc_bottom;
+	proc_bottom = proc;
+
+	memcpy(regs, &proc->registers, sizeof(struct regs));
+	paging_switch_directory(proc->cr3);
+}
+
+uint32_t single_exit(struct regs *regs)
+{
+	//close(current_proc->stdout);
+	//close(current_proc->stderr);
+
+	uint32_t hold = regs->ebx;
+	proc_bottom = proc_bottom->next;
+
+	if (proc_bottom == NULL)
+		panic("Return from process with no parent");
+
+	memcpy(regs, &proc_bottom->registers, sizeof(struct regs));
+	paging_switch_directory(proc_bottom->cr3);
+
+	return hold;
+}
\ No newline at end of file
diff --git a/src/kernel/tasks/userspace.h b/src/kernel/tasks/userspace.h
new file mode 100644
index 0000000..90b64bf
--- /dev/null
+++ b/src/kernel/tasks/userspace.h
@@ -0,0 +1,17 @@
+#ifndef MELVIX_USERSPACE_H
+#define MELVIX_USERSPACE_H
+
+#include <stdint.h>
+#include <kernel/tasks/process.h>
+#include <kernel/interrupts/interrupts.h>
+
+uint32_t spawn_child(struct process *child);
+
+void userspace_enter(struct process *proc);
+
+void single_yield(struct process *proc, struct regs *regs);
+uint32_t single_exit(struct regs *regs);
+
+extern void jump_userspace();
+
+#endif
\ No newline at end of file