Cucumber/Kernel/src/Tier1/CTask.cpp

#include "Tier1/CTask.h"
using namespace cb;

extern "C" {
//    #include "Tier0/physical_alloc.h"
    #include "Tier0/paging.h"
    #include "Tier0/panic.h"
    #include "Tier0/kstdio.h"
};

//#include "Tier1/CScheduler.h"
//#include "Tier1/CTimer.h"

///extern CPageDirectory *g_KernelPageDirectory;
u32 CTaskNextPID = 0;

CTask::CTask(bool User, bool Empty)
{
    m_User = User;
    if (!Empty)
    {
        // CreateDirectory();
        // CreateStack();
        // CopyKernelMemory();
        
        m_CreatedStack = true;
    }
    else
        m_CreatedStack = false;
    
    m_Status = ETS_RUNNING;
    m_PID = CTaskNextPID++;
    m_Priority = ETP_NORMAL;
    m_Owner = 0;
    m_Ring = (User ? ETR_RING3 : ETR_RING0);
}

CTask::~CTask(void)
{
    // if (m_CreatedStack)
    //     physmem_free_page(m_StackStart / (4 * 1024));
}

// void CTask::CreateStack(void)
// {
//     m_StackStart = physmem_allocate_page() * 4 * 1024;
//     m_StackSize = TASK_MAP_STACK_SIZE;
    
//     m_Directory->MapTable(TASK_MAP_STACK_START, m_StackStart, 1, 1);
// }

// void CTask::CreateDirectory(void)
// {
//     m_Directory = new CPageDirectory();
// }

// void CTask::CopyKernelMemory(void)
// {
//     //Copy all the kernel tables...    
//     m_KernelStart = 0xC0000000;
//     m_KernelSize = 0x20000000;
    
//     u32 NumTables = m_KernelSize / (4 * 1024 * 1024);
    
//     for (u32 i = 0; i < NumTables; i++)
//         m_Directory->LinkTable(m_KernelStart + i * 4 * 1024 * 1024,
//                                g_KernelPageDirectory);
    
//     m_Directory->LinkTable(0x00000000, g_KernelPageDirectory);
//     m_Directory->LinkTable(0x00400000, g_KernelPageDirectory);
//     //m_Directory->LinkTable(0x00800000, g_KernelPageDirectory);
//     //m_Directory->LinkTable(0x01000000, g_KernelPageDirectory);
// }

// void CTask::CopyStack(CTask *Source)
// {
//     CPageDirectory *SourcePD = Source->GetPageDirectory();
//     SourcePD->CopyPage(TASK_MAP_STACK_START, m_Directory, m_User, 1);
// }

// CPageDirectory *CTask::GetPageDirectory(void)
// {
//     return m_Directory;
// }

// CTask *CTask::Fork(void)
// {
//     __asm__ volatile("cli");
//     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
//         PANIC("Cannot fork usermode program!");
//     }
    
//     __asm__ volatile("mov %%esp, %0" : "=r"(ESP));
//     __asm__ volatile("mov %%ebp, %0" : "=r"(EBP));
    
//     NewTask->CopyStack(this);
//     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, EIP %x...\n", NewTask->m_PID,
//                 ESP, EBP, ForkPoint);
//         CScheduler::AddTask(NewTask);
        
//         __asm__ volatile("sti");
        
//         return ParentTask;
//     }
//     else
//     {
//         __asm__ volatile("sti");
//         //for(;;){} 
//         return NewTask;
//     }
// }

// void CTask::Dump(void)
// {
//     kprintf("d:%x s:%x b:%x i:%x\n",m_Directory->m_Directory->PhysicalAddress,
//                                       m_ESP, m_EBP, m_EIP);
// }

// __attribute__((optimize("O0"))) void CTask::Yield(void)
// {
// 	//kprintf("Entering NextTask\n");
//     CScheduler::NextTask();
//     //kprintf("returned from NextTask\n");
// }

// void CTask::WaitForSemaphore(T_SEMAPHORE *Semaphore)
// {
//     __asm__ volatile ("cli");
//     m_Status = ETS_WAITING_FOR_SEMAPHORE;
//     m_StatusData = m_Directory->Translate((u32)Semaphore);
    
//     Yield();
//     __asm__ volatile ("sti");
// }

// void CTask::WaitForSemaphore(CSemaphore *Semaphore)
// {
//     __asm__ volatile ("cli");
//     m_Status = ETS_WAITING_FOR_SEMAPHORE;
//     m_StatusData = m_Directory->Translate((u32)Semaphore);
    
//     Yield();
//     __asm__ volatile ("sti");
// }

// void CTask::Disable(void)
// {
//     __asm__ volatile ("cli");
//     m_Status = ETS_DISABLED;
//     Yield();
//     __asm__ volatile ("sti");
// }

// void CTask::Enable(void)
// {
//     __asm__ volatile ("cli");
//     m_Status = ETS_RUNNING;
//     __asm__ volatile ("sti");
// }

// void CTask::Sleep(u32 Ticks)
// {
//     __asm__ volatile ("cli");
//     m_Status = ETS_DISABLED;
//     CTimer::Create(Ticks, 1, WakeUp, (u32)this);
//     Yield();
//     __asm__ volatile ("sti");
// }

// bool CTask::WakeUp(u32 Extra)
// {
//     CTask *Task = (CTask*)Extra;
//     Task->Enable();    
//     return true;
// }