src/arch/x86/gdt.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                             *
************************************************************
*       gdt.cpp, version 1.1                               *
************************************************************
*                                                          *
*this file defines the usage of the general descriptor     *
*table under x86                                           *
*                                                          *
*27'04'04- fork from o.05 branch gdt.cpp (1.1)             *
*                                                          *
************************************************************/

#include "src/common/shared.hpp"
#include "src/arch/x86/gdt.hpp"

namespace Arch {
namespace x86 {
namespace GDT {


//variables
gdt_t kernel_gdt;       //the handle for the descriptors

//init gdt to the needs of the kernel
void init()
 {
gdt_t *ptr = &kernel_gdt;
        ptr->init();
/*create descriptors*/
        code_sel_kernel = ptr -> new_sel(0xFFFFF, 0, 0x9A, 0xc0);       /*kernel code*/
        data_sel_kernel = ptr -> new_sel(0xFFFFF, 0, 0x92, 0xc0);       /*kernel data*/
        code_sel_user  = ptr -> new_sel(0xBFFFF, 0, 0xFA, 0xc0)+3;      /*user code, from 0 to 0xc0000000*/
//      code_sel_user  = ptr -> new_sel(0xc0000, 0, 0xFA, 0xc0)+3;      /*user code, from 0 to 0xc0000000*/
        data_sel_user  = ptr -> new_sel(0xBFFFF, 0, 0xF2, 0xc0)+3;      /*user data, from 0 to 0xc0000000*/
//      data_sel_user  = ptr -> new_sel(0xc0000, 0, 0xF2, 0xc0)+3;      /*user data, from 0 to 0xc0000000*/
        tss_sel_kernel = ptr -> new_sel(103, (uint32) &kernel_tss, 0x89, 0x0);  /*kernel tss*/
        tss_sel_kernel_df = ptr -> new_sel(103, (uint32) &kernel_tss_df, 0x89, 0x0);    /*kernel tss for df handling*/
        tss_sel_kernel_sf = ptr -> new_sel(103, (uint32) &kernel_tss_sf, 0x89, 0x0);    /*kernel tss for sf handling*/

/*load the gdtr*/
        ptr -> lgdt();

/*load the kernel tss*/
        __asm__ __volatile__ ("ltr %%ax" : : "a" (tss_sel_kernel) );
         kernel_tss.ss0 = data_sel_kernel;
         kernel_tss.esp0 = (uint32) &temp_tss_stack+0x100;

/*setup the special tss', which guards us from double/stack faults. the ints init setups eip*/
        kernel_tss_sf.ss=kernel_tss_df.ss=data_sel_kernel;
        kernel_tss_sf.esp=kernel_tss_df.esp= (uint32) &temp_tss_stack+0x100;
        kernel_tss_sf.cs=kernel_tss_df.cs = code_sel_kernel;
        kernel_tss_sf.ds=kernel_tss_df.ds = data_sel_kernel;
        kernel_tss_sf.es=kernel_tss_df.es = data_sel_kernel;
        kernel_tss_sf.fs=kernel_tss_df.fs = data_sel_kernel;
        kernel_tss_sf.gs=kernel_tss_df.gs = data_sel_kernel;
        kernel_tss_sf.eflags=kernel_tss_df.eflags = 0;
        asm volatile ("mov %%cr3, %%eax" :"=a" (kernel_tss_df.cr3));
        asm volatile ("mov %%cr3, %%eax" :"=a" (kernel_tss_sf.cr3));
 }

/*gdt selectors*/
uint32 code_sel_kernel = 0;             /*should be 0x08*/
uint32 data_sel_kernel = 0;             /*should be 0x10*/
uint32 code_sel_user = 0;
uint32 data_sel_user = 0;
uint32 tss_sel_kernel = 0;
uint32 tss_sel_kernel_df;       //for double faults
uint32 tss_sel_kernel_sf;       //for stack faults

/*tss' in system*/
tss_t kernel_tss;               /*kernel tss*/
tss_t kernel_tss_df;            /*kernel tss for double fault handling*/
tss_t kernel_tss_sf;            /*kernel tss for stack fault handling*/
char temp_tss_stack[0x100];     /*initial stack in the esp, just in case*/

//init a gdt_t
void gdt_t::init()
 {
        gdtr.s_limit=7;
        gdtr.s_base = gdt;
        segm_count = 0;
 }

//create a new segment and return selector
short gdt_t::new_sel(int limit, int base, char attr, char flags)
 {
        union
         {
                long l;
                short s[2];
                char c[4];
         } uu;

        segm_count++;

        if ((uint32)segm_count+1 >= DEF_MAXSEGMS) return -1;    // no free space left?

        uu.l = base;
        gdt[segm_count].s_base0_15 = uu.s[0];
        gdt[segm_count].s_base16_23 = uu.c[2];
        gdt[segm_count].s_base24_31 = uu.c[3];

        uu.l = limit;
        gdt[segm_count].s_limit0_15 = uu.s[0];
        gdt[segm_count].s_limit16_19 = uu.c[2] + flags; //flags and limit's byte3

        gdt[segm_count].s_attr = attr;

        gdtr.s_limit+=8;                // so the segm is availlable

        return segm_count * 8;
 }

//load the gdt
void gdt_t::lgdt()
 {
        __asm__ __volatile__ ("lgdt (%%ebx)": : "b" ((long) &gdtr) );
        __asm__ __volatile__ (
                                                  ".byte 0xea\n"
                                                  ".int reload_cs\n"
                                                  ".short 0x8\n"                /*HARDCODED DEF_CODE_SEL_KERNEL*/
                                                  "reload_cs:\n"
                                                  "mov $0x10, %ax\n"    /*HARDCODED DEF_DATA_SEL_KERNEL*/
                                                  "mov %ax, %ss\n"
                                                  "mov %ax, %ds\n"
                                                  "mov %ax, %es\n"
                                                  "mov %ax, %fs\n"
                                                  "mov %ax, %gs\n"
                                                 );
 }


   };   /*namespace GDT*/
  };    /*namespace x86*/
 };     /*namespace Arch*/

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

---