src/arch/x86/context.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       context.cpp, version 1.0                           *
************************************************************
*                                                          *
*x86 context datatype, support for multithreading and      *
*multitasking. based on tss'                               *
*                                                          *
*02'05'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/bits.hpp"
#include "src/thread/thread.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/arch/x86/gdt.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/irq.hpp"
#include "src/arch/x86/context.hpp"

// extern "C" void eloziom(int i);
// void eloziom(int i)
//  {
//      kprintf("%x\n", i);
//  }

namespace Thread {

//create a context for the thread
void allocate_context(Thread::thread_t *obj, bool supervisor, uint32 stack, uint32 proc_addr)
 {
uint16 data_sel, code_sel;
        memset(&obj->context, 0, sizeof(context_t));
        obj->context.supervisor=supervisor;
//      obj->context.ksp=(uint32*) ((char*)&obj->context.reg_stack)+Arch::x86::Thread::REG_STACK_SIZE;
        obj->context.ksp=(uint32*) ((char*)Memory::Heap::heap0.malloc(
                                                Arch::x86::Thread::REG_STACK_SIZE, NO_ALIGN, FAC_THREAD|FAC_KSP, NULL)
                                                 + Arch::x86::Thread::REG_STACK_SIZE) ;
        obj->context.isp=(uint32*) ((char*)Memory::Heap::heap0.malloc(0x14, NO_ALIGN, FAC_THREAD|FAC_ISP, NULL) + 0x14) ;
//kernel or user thread? prepare data
        if (supervisor == true)
        {
//              obj->context.tsp=(uint32*) ((char*)Memory::Heap::heap0.malloc(0x1000, NO_ALIGN, FAC_THREAD|FAC_TSP, NULL) + 0x1000) ;
                obj->context.tsp=(uint32*)stack;
                data_sel=Arch::x86::GDT::data_sel_kernel;
                code_sel=Arch::x86::GDT::code_sel_kernel;
        }
        else
        {
                obj->context.tsp=(uint32*) ((char*)Memory::Heap::heap0.malloc(TSP_SIZE,NO_ALIGN, FAC_THREAD|FAC_TSP, NULL) + TSP_SIZE) ;
                data_sel=Arch::x86::GDT::data_sel_user;
                code_sel=Arch::x86::GDT::code_sel_user;
        /*init stack*/
                *(--obj->context.tsp)=data_sel; /*ss*/
                *(--obj->context.tsp)=stack/*0x3000*/;  /*esp*/
        }
/*init stack*/
        *(--obj->context.tsp)=0x200;    /*eflags*/
        *(--obj->context.tsp)=code_sel; /*cs*/
        *(--obj->context.tsp)=proc_addr;/*eip*/
        *(--obj->context.ksp)=(uint32)obj->context.tsp; /*tsp*/
        *(--obj->context.ksp)=0;        /*eax*/
        *(--obj->context.ksp)=0;        /*ecx*/
        *(--obj->context.ksp)=0;        /*edx*/
        *(--obj->context.ksp)=0;        /*ebx*/
        *(--obj->context.ksp)=stack;    /*esp*/
        *(--obj->context.ksp)=0;        /*ebp*/
        *(--obj->context.ksp)=0;        /*esi*/
        *(--obj->context.ksp)=0;        /*edi*/
        *(--obj->context.ksp)=data_sel; /*ds*/
        *(--obj->context.ksp)=data_sel; /*es*/
        *(--obj->context.ksp)=data_sel; /*fs*/
        *(--obj->context.ksp)=data_sel; /*gs*/
 }

namespace Scheduler {
        extern "C" thread_t volatile *current_thread;
        extern bool multitasking_running;
 };     //from src/thread/scheduler.cpp

 };     /*namespace Thread*/

namespace Arch {
namespace x86 {
namespace Thread {

extern "C" void scheduler_wrapper();    //src/thread/sched.s

//init multitasking in the arch
void init(uint32 freq)
 {
/*we will not use chained ints on irq 0*/
        Interr::kernel_idt.set_int(0x20, &scheduler_wrapper, GDT::code_sel_kernel, Interr::DEF_INT_FLAGS);
        Interr::kernel_pic.set_pit_freq(freq);          /*change clock0 int freq */
/*unmask the scheduler irq*/
        Interr::kernel_pic.mask_irq_m (bit_set(Interr::kernel_pic.get_irq_mask_m(), 0, 0));
/*restore interrupts*/  
        while (1) asm volatile ("sti\nhlt");
 }

// //continue execution
// void continue_execution()
//  {
// uint32 *temp=::Thread::Scheduler::current_thread->context.ksp;
//      ::Thread::Scheduler::current_thread->context.ksp=
//              (uint32*)
//              (((char*)&::Thread::Scheduler::current_thread->context.reg_stack)+Arch::x86::Thread::REG_STACK_SIZE);
// /*switch to the register dump, pop registers, save new stack pointer and iret*/
//      __asm__ __volatile__ ("mov %%eax, %%esp\n"
// //                   "popa\n"
//                      "iret\n"
//              : : "a"  (temp));
//      while(1);
//  }
// 
// //save the context
// void save_context()
//  {
// /*switch to the register dump, push registers, save new stack pointer*/
//      __asm__ __volatile__ ("mov %%eax, %%esp\n"
// //                   "pusha\n"
//              : "=a" (::Thread::Scheduler::current_thread->context.ksp)
//              : "a"  (::Thread::Scheduler::current_thread->context.ksp));
//  }
// 
// //load the current_thread's context
// void load_context()
//  {
// //don't have to do much here in software multitasking
//  }


   };   /*namespace Thread*/
  };    /*namespace x86*/
 };     /*namespace Arch*/

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---