Working again!

include/Tier1/CPageDirectory.h

@@ -6,8 +6,6 @@ extern "C" {
     #include "Tier0/paging.h"
 };
 
-#include "Tier1/CKernel.h"
-
 // This is more-or less just a C++ wrapper for T_PGAE_DIRECTORY.
 namespace cb {
     class CPageDirectory {
@@ -20,7 +18,7 @@ namespace cb {
             
             // A bitmap precising whether a table is owned by the page directory
             // (== can we delete it when we delete the directory itself)
-            u32 m_OwnerBitmap[32];
+            volatile u32 m_OwnerBitmap[32];
             
             // Check whether a table is owned by us
             bool IsTableOurs(u32 Virtual);

include/Tier1/CTask.h

@@ -2,8 +2,8 @@
 #define __CTASK_H__
 
 #include "types.h"
-#include "Tier1/CPageDirectory.h"
 #include "Tier1/CKernel.h"
+#include "Tier1/CPageDirectory.h"
 
 // Task memory map...
 //              _______________________
@@ -97,9 +97,9 @@ namespace cb {
             ETaskPriority m_Priority;
             ETaskRing m_Ring;
             bool m_User;
-            u32 m_PID;
+            volatile u32 m_PID;
             
-            u32 m_ESP, m_EIP, m_EBP;
+            volatile u32 m_ESP, m_EIP, m_EBP;
             
             u32 m_HeapStart;
             u32 m_HeapSize;
@@ -136,8 +136,7 @@ namespace cb {
             
             inline u32 GetPageDirectoryPhysicalAddress(void)
             {
-                //return m_Directory->m_Directory->PhysicalAddress;
+                return m_Directory->m_Directory->PhysicalAddress;
-                return 0;
             }
             
             inline void SetESP(u32 ESP) { m_ESP = ESP; }

include/Tier1/IScheduler.h

@@ -2,6 +2,7 @@
 #define __ISCHEDULER_H__
 
 #include "Tier1/CTask.h"
+#include "Tier0/semaphore.h"
 
 namespace cb {
     class IScheduler {
@@ -10,6 +11,8 @@ namespace cb {
             virtual void AddTask(CTask *Task) = 0;
             virtual void NextTask(void) = 0;
             virtual CTask *GetCurrentTask(void) = 0;
+            virtual void AcquireSemaphore(T_SEMAPHORE *Semaphore) = 0;
+            virtual void ReleaseSemaphore(T_SEMAPHORE *Semaphore) = 0;
     };
 };
 

src/Tier0/kstdio.c

@@ -64,7 +64,7 @@ void kputi(s32 Number)
 
 void kprintf(const s8 *szFormat, ...)
 {
-    semaphore_acquire(&ScreenWriteLock);
+    //semaphore_acquire(&ScreenWriteLock);
     va_list ap;
     va_start(ap, szFormat);
     
@@ -112,7 +112,7 @@ void kprintf(const s8 *szFormat, ...)
     }
     
     va_end(ap);
-    semaphore_release(&ScreenWriteLock);
+    //semaphore_release(&ScreenWriteLock);
 }
 
 void kscroll_up(void)
@@ -199,6 +199,7 @@ void kdump(u8 *bData, u32 Length)
 
 void kputch(s8 Character)
 {
+    semaphore_acquire(&ScreenWriteLock);
     volatile u8 *VideoMemory = (u8 *)0xC00B8000;
     u16 Offset = (g_kstdio_cur_y * 80 + g_kstdio_cur_x) << 1;
 
@@ -213,6 +214,7 @@ void kputch(s8 Character)
         else
             kmove_cursor(g_kstdio_cur_x + 1, g_kstdio_cur_y);
     }
+    semaphore_release(&ScreenWriteLock);
 }
 
 void kputs(const s8 *szString)

src/Tier1/CKernel.cpp

@@ -54,6 +54,7 @@ void CKernel::Start(void)
     m_DriverManager->LoadNew();
     
     CTask *KernelTask = CreateKernelTask();
+    kprintf("[i] Kernel task has TID %i.\n", KernelTask->GetPID());
     CScheduler::AddTask(KernelTask);
     CScheduler::Enable();
     
@@ -61,11 +62,10 @@ void CKernel::Start(void)
     
     CTask *ParentTask = CScheduler::GetCurrentTask();    
     CTask *NewTask = ParentTask->Fork();
-    
     if (NewTask == ParentTask)
     {
         for (;;) {
-            for (volatile u32 i = 0; i < 350; i++)
+            for (volatile u32 i = 0; i < 3500; i++)
             {
                 for (volatile u32 j = 0; j < 650; j++){}
             }
@@ -75,7 +75,7 @@ void CKernel::Start(void)
     else
     {
         for (;;) {
-            for (volatile u32 i = 0; i < 350; i++)
+            for (volatile u32 i = 0; i < 3500; i++)
             {
                 for (volatile u32 j = 0; j < 650; j++){}
             }

src/Tier1/CPageDirectory.cpp

@@ -10,6 +10,8 @@ extern "C" {
     #include "Tier0/kstdio.h"
 };
 
+#include "Tier1/CKernel.h"
+
 CPageDirectory *g_KernelPageDirectory;
 
 CPageDirectory::CPageDirectory(bool Empty)

src/Tier1/CRoundRobinScheduler.cpp

@@ -14,7 +14,6 @@ void CRoundRobinScheduler::Enable(bool Enabled)
 
 __attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
 {
-    __asm__ volatile("cli");
     volatile u32 NewEBP, NewESP, NewEIP, EBP, ESP, Directory;
     
     if (m_TaskQueue.GetSize() == 0)
@@ -27,14 +26,18 @@ __attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
         m_TaskQueuePosition = 0;
     CTask *NextTask = m_TaskQueue[m_TaskQueuePosition];
     
+    if (m_CurrentTask->GetPID() == NextTask->GetPID())
+        return;
+    
+    //kprintf("[i] %i -> %i (%x)\n", m_CurrentTask->GetPID(), NextTask->GetPID(), NextTask);
+    
     // Read task details
     NewEBP = NextTask->GetEBP();
     NewESP = NextTask->GetESP();
     NewEIP = NextTask->GetEIP();
-    
     if (!NewEIP || !NewESP || !NewEBP)
     {
-        kprintf("[i] no wai\n");
+        //kprintf("null %x %x %x\n", NewEIP, NewESP, NewEBP);
         return;
     }
     
@@ -46,7 +49,6 @@ __attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
     
     // Return point
     volatile u32 ReturnPoint = ctask_geteip();
-    //kprintf("return point %x\n", ReturnPoint);
     
     if (ReturnPoint == 0xFEEDFACE)
     {
@@ -55,7 +57,6 @@ __attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
     }
     
     m_CurrentTask->SetEIP(ReturnPoint);
-    
     // Switch to next task
     m_CurrentTask = NextTask;
     
@@ -79,9 +80,9 @@ __attribute__((optimize("O0"))) void CRoundRobinScheduler::NextTask(void)
 
 void CRoundRobinScheduler::AddTask(CTask *Task)
 {
-    __asm__ volatile("cli");
     m_TaskQueue.Push(Task);
-    __asm__ volatile("sti");
+    if (m_TaskQueue.GetSize() == 1)
+        m_CurrentTask = Task;
 }
 
 CTask *CRoundRobinScheduler::GetCurrentTask(void)

src/Tier1/CScheduler.cpp

@@ -9,7 +9,7 @@ extern "C" {
     #include "Tier0/kstdio.h"
 }
 
-CScheduler g_Scheduler;
+volatile CScheduler g_Scheduler;
 
 CScheduler::CScheduler(void)
 {
@@ -20,6 +20,7 @@ CScheduler::CScheduler(void)
 void CScheduler::AddTask(CTask *Task)
 {
     __asm__ volatile("cli");
+    kprintf("[i] Adding task %i (%x)\n", Task->GetPID(), Task);
     g_Scheduler.m_CurrentScheduler->AddTask(Task);
     __asm__ volatile("sti");
 }
@@ -31,7 +32,7 @@ CTask *CScheduler::GetCurrentTask(void)
 
 void CScheduler::Enable(void)
 {
-    u32 Divisor = 100;
+    u32 Divisor = 0xFFFFFFFF;
     koutb(0x43, 0x36);
     u8 Low = (u8)(Divisor & 0xFF);
     u8 High = (u8)((Divisor >> 8) & 0xFF);
@@ -41,7 +42,10 @@ void CScheduler::Enable(void)
     interrupts_setup_irq(0x00, (void*)CScheduler::TimerTick);
 }
 
-void CScheduler::TimerTick(T_ISR_REGISTERS R)
+__attribute__((optimize("O0"))) void CScheduler::TimerTick(T_ISR_REGISTERS R)
 {
+    __asm__ volatile("cli");
     g_Scheduler.m_CurrentScheduler->NextTask();
+    interrupts_irq_finish(0);
+    __asm__ volatile("sti");
 }

src/Tier1/CTask.cpp

@@ -84,14 +84,12 @@ CPageDirectory *CTask::GetPageDirectory(void)
 CTask *CTask::Fork(void)
 {
     __asm__ volatile("cli");
-    u32 ESP, EBP;
+    volatile u32 ESP, EBP;
     
     CTask *ParentTask = CScheduler::GetCurrentTask();
-    
     CTask *NewTask = new CTask(m_User);
     NewTask->m_Owner = m_Owner;
     NewTask->m_Ring = m_Ring;
-    
     if (m_User)
     {
         //TODO: Write code for userland
@@ -102,15 +100,16 @@ CTask *CTask::Fork(void)
     __asm__ volatile("mov %%ebp, %0" : "=r"(EBP));
     
     NewTask->CopyStack(this);
-    u32 ForkPoint = ctask_geteip();
+    volatile u32 ForkPoint = ctask_geteip();
+    
     
     if (CScheduler::GetCurrentTask() == ParentTask)
     {
         NewTask->m_ESP = ESP;
         NewTask->m_EBP = EBP;
         NewTask->m_EIP = ForkPoint;
-        kprintf("[i] Forked: TID %i, ESP %x, EBP %x...\n", NewTask->m_PID,
+        kprintf("[i] Forked: TID %i, ESP %x, EBP %x, EIP %x...\n", NewTask->m_PID,
-                ESP, EBP);
+                ESP, EBP, ForkPoint);
         CScheduler::AddTask(NewTask);
         
         __asm__ volatile("sti");
@@ -119,7 +118,7 @@ CTask *CTask::Fork(void)
     }
     else
     {
-        __asm__ volatile("sti");;
+        __asm__ volatile("sti");
         //for(;;){} 
         return NewTask;
     }