Buid 0.1.1.19

Kernel/debug/commands.c

@@ -20,10 +20,11 @@ string ConsoleCommands[] =
 	"reboot",
 	"restart",
 	"dir",
-	"cat"
+	"cat",
+	"task"
 };
 
-int32 ConsoleCommandsCount = 13;
+int32 ConsoleCommandsCount = 14;
 
 /*****************************************
  *  osver - get os info                  *
@@ -335,3 +336,31 @@ void CommandCat (string argv[], int32 argc)
 	kfree(buffer);
 	VfsClose(&f);
 }
+
+#include <tasking.h>
+void task()
+{
+	Point p = {5, 1};
+	uint32 t = 0;
+
+	while (1)
+	{
+		ConsoleCursorGoto(p);
+		ConsoleWrite("Hello world! %u ", t++);
+	}
+}
+
+void CommandTask()
+{
+	ConsoleClear();
+	TaskCreate(task);
+
+	Point p = {5, 2};
+	uint32 t = 0;
+
+	while (1)
+	{
+		ConsoleCursorGoto(p);
+		ConsoleWrite("%#Hello world! %u ", ColorLightBlue, t++);
+	}
+}

Kernel/debug/console.c

@@ -76,6 +76,7 @@ loop:
 		case 10: SystemReboot(); break;
 		case 11: CommandDir(params, count); break;
 		case 12: CommandCat(params, count); break;
+		case 13: CommandTask(); break;
 
 		default: ConsoleWrite ("%#! Command %#%s%# was not implemented (yet)!\n",
 				Color(0,ColorLightRed), Color(0,ColorWhite), params[0], Color(0,ColorLightRed)); break;

Kernel/hal/clock/clock.c

@@ -6,6 +6,8 @@
 volatile TimeSystem _internal_time;
 uint32 _internal_frequency_hz;
 
+extern void TaskSwitch ();
+
 void TimeHandler(_RegsStack32* UNUSED(r))
 {
 	if (_internal_frequency_hz == 0) return;
@@ -16,4 +18,6 @@ void TimeHandler(_RegsStack32* UNUSED(r))
 		_internal_time.Date++;
 		_internal_time.Time-=MILISECONDS_IN_DAY;
 	}
+
+	TaskSwitch();
 }

Kernel/include/tasking.h

@@ -0,0 +1,27 @@
+/*
+ * tasking.h
+ *
+ *  Created on: Sep 8, 2011
+ *      Author: Tiberiu
+ */
+
+#ifndef TASKING_H_
+#define TASKING_H_
+
+#include <types.h>
+#include <memory-add.h>
+
+typedef struct _Task {
+	uint32 Pid;
+	uint32 Esp, Ebp; // Stack
+	PageDirectory* Pd;
+	uint32 StackLowerBase;
+	uint32 StackUpperBase;
+	struct _Task* Next;
+} Task;
+
+extern void TaskInitialize();
+extern void TaskSwitch ();
+extern void TaskCreate (void (*func)());
+
+#endif /* TASKING_H_ */

Kernel/include/version.h

@@ -1 +1 @@
-#define OS_BUILD "0.1.0.629"
+#define OS_BUILD "0.1.1.19"

Kernel/main.c

@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include <memory.h>
 #include <multiboot.h>
+#include <tasking.h>
 
 extern uint32 _end;
 
@@ -29,6 +30,8 @@ void k_main(MultibootInfo* info)
 	MemoryTempInitialize(KernelEnd);
 	MemoryInitialize(info);
 
+	TaskInitialize();
+
 	HalInitialize();
 	luxInitrdInstall(info);
 

Kernel/tasking/tasking-multi.c

@@ -0,0 +1,103 @@
+/*
+ * tasking-multi.c
+ *
+ *  Created on: Sep 8, 2011
+ *      Author: Tiberiu
+ */
+
+#include <tasking.h>
+#include <memory-add.h>
+
+Task* TaskList;
+Task* CurrentTask;
+uint32 NextPid = 1;
+
+void TaskSwitch ()
+{
+	if (!TaskList) return;
+
+	// Save context
+	asm volatile ("mov %%esp, %0" : "=r"(CurrentTask->Esp));	// Stack pointer
+	asm volatile ("mov %%ebp, %0" : "=r"(CurrentTask->Ebp)); // Base pointer
+	CurrentTask->Pd = CurrentDirectory;
+
+	// Next task
+	CurrentTask = (!CurrentTask->Next) ? TaskList : CurrentTask->Next ;
+
+	// Switch context
+	PagingSwitchDirectory(CurrentTask->Pd);
+	asm volatile ("mov %0, %%esp" : : "r"(CurrentTask->Esp));	// Stack pointer
+	asm volatile ("mov %0, %%ebp" : : "r"(CurrentTask->Ebp)); // Base pointer
+}
+
+// Fallback for new tasks
+void TaskEnd ()
+{
+	// Find parent of current task
+	if (CurrentTask->Pid == TaskList->Pid) TaskList = TaskList->Next;
+
+	else {
+		Task* t = TaskList;
+		while (t->Next && t->Next->Pid != CurrentTask->Pid) t = t->Next;
+
+		t->Next = CurrentTask->Next;
+	}
+
+	// Free allocated space
+	kfree((void*)CurrentTask->StackLowerBase);
+	kfree(CurrentTask);
+
+	// Wait for next task
+	for (;;) ;
+}
+
+void TaskCreate (void (*func)())
+{
+	// Create a new task
+	Task* t = kmalloc(sizeof(Task));
+
+	// Set up data
+	t->StackLowerBase = (uint32) kmalloc(0x1000);	// Allocate some space for new stack
+	t->StackUpperBase = t->StackLowerBase + 0x1000;
+	t->Next = NULL;
+	t->Pd = KernelDirectory;
+	t->Pid = NextPid++;
+
+	// Set up stack
+	*(uint32 *) (t->StackUpperBase - 0x4) = (uint32) TaskEnd; // Fallback function
+	t->Ebp = (uint32) t->StackUpperBase;
+
+	_RegsStack32* regs = (_RegsStack32*) (t->StackUpperBase - 0x4 - sizeof(_RegsStack32));
+
+	asm volatile ("mov %%ss, %0" : "=r" (regs->ss));
+	asm volatile ("mov %%cs, %0" : "=r" (regs->cs));
+	asm volatile ("pushf; pop %0" : "=r" (regs->eflags));
+	asm volatile ("mov %%esi, %0" : "=r" (regs->esi));
+	asm volatile ("mov %%edi, %0" : "=r" (regs->edi));
+	asm volatile ("mov %%gs, %0" : "=r" (regs->gs));
+	asm volatile ("mov %%fs, %0" : "=r" (regs->fs));
+	asm volatile ("mov %%es, %0" : "=r" (regs->es));
+	asm volatile ("mov %%ds, %0" : "=r" (regs->ds));
+	regs->eax = regs->ebx = regs->ecx = regs->edx = 0;
+	regs->eip = (uint32)func;
+	regs->useresp = t->StackUpperBase-0x4;
+	regs->esp = t->StackUpperBase - 40;
+	regs->ebp = t->Ebp = t->StackUpperBase;
+
+	// Add the task to the list
+	Task* last = TaskList;
+	while (last && last->Next) last = last->Next;
+	if (last) last->Next = t;
+}
+
+void TaskInitialize()
+{
+	Task* t = kmalloc(sizeof(Task));
+
+	t->Pid = NextPid++;
+	t->Pd = KernelDirectory;
+	t->Esp = t->Ebp = 0;
+	t->Next = NULL;
+
+	TaskList = CurrentTask = t;
+}