Laboratório de Organização e Arquitetura de Computadores

Laboratório de Organização e Arquitetura de Computadores

PROFESSORES: Elmar Uwe Kurt Melcher

Joseana Macêdo Fechine

Segmentação (Conceitos Básicos)

/* --------------------------------------------------------------------------------------------

SOFTWARE BASICO - carregador -------------------------------------------------------------------------------------------

*/#define VIDEOSEL 0x1000

/*** struct and type declarations ***/

typedef unsigned char byte;

typedef unsigned short word;

typedef unsigned int dword;

/* endereco segmentado (endereco logico) */

struct segaddr {

void *addr;

word selector;

};

typedef struct segaddr *segaddr_ptr;

// tornar um seletor um indice da tabela de descritores de segmentos

#define segidx(selector) (selector>>3)

/* --------------------------------------------------------------------------------------------


*/

/* descritor de segmento. Cada sub-estrutura serve para preencher uma parte dos campos do descritor. Devem ser usados na sequencia a, b, c.*/

union segment { /* Nenhum dos itens na, nb deve ser usado. */

struct { // COLOCO BASE E LIMITE OS DEMAIS FICAM ERRADO

dword limit;

dword base;

} a;

struct {

word na;

dword base;

} b;

/* --------------------------------------------------------------------------------------------


*/struct { //CONSERTA O TYPE E O BIT SIZE

dword na;

byte nb;

byte type;

byte bitsize;

} c;

};

typedef union segment *segment_ptr;

/* --------------------------------------------------------------------------------------------


*/

/* IDTR e GDTR */

struct dtr {

word length;

union {

gate_ptr g;

segment_ptr s;

} base;

};

/* --------------------------------------------------------------------------------------------


*/// Tem quase tudo que tem dentro do do processador

//FUNCAO: salvar o contexto do processador

struct tss { /* itens na ate nk sao reservados */

word link, na;

dword esp0; word ss0, nb;

dword esp1; word ss1, nc;

dword esp2; word ss2, nd;

dword cr3; //da paginacao

dword eip; //PC

dword eflags; //PSW

dword eax, ecx, edx, ebx;

dword esp, ebp;

dword esi, edi;

/* --------------------------------------------------------------------------------------------


*/

word es, ne; //Descritores

word cs, nf;

word ss, ng;

word ds, nh;

word fs, ni;

word gs, nj;

word ldtr, nk;

word t;

word iopb;

};

typedef struct tss *tss_ptr;

/* --------------------------------------------------------------------------------------------


*/

/*** declaracoes de variaveis globais ***/

/* interrupt table e global descriptor table */

struct dtr idtr, gdtr;

/* rotina especial para prencher o segmento de video */

void descVideo() {

dword *desc = (dword *)(gdtr.base.s + segidx(VIDEOSEL));

desc[1] = 0xE04BF200; // base = 0xE0000000, limit=BFFFFh=1024*768-1<>1M

desc[0] = 0x0000FFFF; // tipo = 0xF2, dpl=3, read/write

}

/* --------------------------------------------------------------------------------------------


*//* carregar um arquivo executavel */

void carregar(char *exename) {

FILE *exefile;

// cabecalho do execut vel

static struct { dword datasize, codesize, varsize, stacksize; } header;

if((exefile=fopen(exename,"rb"))==NULL) {

fprintf(stderr,"Executavel %s ausente.\n", exename);

exit(1);

}

if(fread(&header, sizeof(header), 1, exefile)!=1) {

fprintf(stderr,"Nao consigo ler o cabecalho do executavel.\n");

exit(1);

}

/* --------------------------------------------------------------------------------------------


*/

//Preenchendo o descritor(seletor) de dados constantes

gdtr.base.s[segidx(0x1048)].a.limit = header.datasize-1; //o limite esta no cabecalho -1 pois comeca em 0

gdtr.base.s[segidx(0x1048)].a.base = 0x01989866; //a base do segmento a, um endereco gostoso

gdtr.base.s[segidx(0x1048)].b.base = 0x01989866; //a base do segmento a, um endereco gostoso

gdtr.base.s[segidx(0x1048)].c.type = 0xF0; // dpl=usuario, permite so leitura

gdtr.base.s[segidx(0x1048)].c.bitsize = 0x40; // do descritor 32 bits

/* --------------------------------------------------------------------------------------------


*/

//Preenchendo o descritor(seletor) de codigo

gdtr.base.s[segidx(0x1050)].a.limit = header.codesize-1; //o codesize est no cabecalho, -1 pois comeca em 0

gdtr.base.s[segidx(0x1050)].a.base = 0x01AA9866; //a base do segmento a, o max ‚ FFFFFFF...

gdtr.base.s[segidx(0x1050)].b.base = 0x01AA9866; //a base do segmento a, o max ‚ FFFFFFF...

gdtr.base.s[segidx(0x1050)].c.type = // 0x98; // dpl = S.O., permite execucao

0xF8; // dpl=usuario, permite execucao

gdtr.base.s[segidx(0x1050)].c.bitsize = 0x40;

/* --------------------------------------------------------------------------------------------


*/

//Preenchendo o descritor(seletor) de variaveis

gdtr.base.s[segidx(0x1058)].a.limit = header.varsize-1; //o limite est no cabecalho, -1 pois comeca em 0

gdtr.base.s[segidx(0x1058)].a.base = 0x01BB9866; //a base do segmento a, o max ‚ FFFFFFF...

gdtr.base.s[segidx(0x1058)].b.base = 0x01BB9866; //a base do segmento a, o max ‚ FFFFFFF...

gdtr.base.s[segidx(0x1058)].c.type = 0xF2; // dpl=usuario, permite ler e escrever


/* --------------------------------------------------------------------------------------------


*/

//Preenchendo o descritor(seletor) de pilha

gdtr.base.s[segidx(0x1060)].a.limit = header.stacksize-1; //o limite est no cabecalho, -1 pois comeca em 0

gdtr.base.s[segidx(0x1060)].a.base = 0x01CC9866; //a base do segmento a, o max ‚ FFFFFFF...

gdtr.base.s[segidx(0x1060)].b.base = 0x01CC9866; //a base do segmento a, o max ‚ FFFFFFF...

gdtr.base.s[segidx(0x1060)].c.type = 0xF2; // dpl=usuario, permite ler e escrever


/* --------------------------------------------------------------------------------------------


*/

//Colocando os dados depois de carregar o cabecalho

if(fread(&0x01989866, header.datasize, 1, exefile)!=1)

{ // fread(end da base, quantidade de dados,= )

fprintf(stderr,"Nao consigo ler os dados.\n");

exit(1);

}

//Colocando o codigo depois de carregar o cabecalho

if(fread(&0x01AA9866, header.codesize, 1, exefile)!=1) {

fprintf(stderr,"Nao consigo ler o codigo.\n");

exit(1);

}

fclose(exefile);

}

/* --------------------------------------------------------------------------------------------


*/

void criaTss() {

static struct tss estado;

//Descritor de Segmento para o TSS

gdtr.base.s[segidx(0x1068)].a.limit = sizeof(estado); //o limite do segmento de pilha

gdtr.base.s[segidx(0x1068)].a.base = &estado; //

gdtr.base.s[segidx(0x1068)].b.base = &estado; //

gdtr.base.s[segidx(0x1068)].c.type = 0x89; //tipo do segmento. no descriptor do segmento (p=1,dpl=00,s=0), onde o s tem que ser 8.

gdtr.base.s[segidx(0x1068)].c.bitsize = 0x40; //0/0 do descrittor 32 bist?

/* --------------------------------------------------------------------------------------------


*/

// preenchimento da TSS

estado.eflags = 0x202; // PSW

estado.ldtr = 0x828; // eh assim mesmo

estado.iopb = sizeof(struct tss);

// todos os seletores com rpl=3=usuario

estado.cs = 0x1050+3; //codigo

estado.ds = 0x1048+3; //dados

estado.es = 0x1058+3; //variaveis

estado.gs = 0x1000+3; //ram de video

estado.ss = 0x1060+3; //Pilha

/* --------------------------------------------------------------------------------------------


*/

// preenchimento da TSS

asm mov eax,cr3; //recuperando o cr3 do SO

estado.cr3 = _EAX ;//estrutura de paginacao, coloco igual ao do SO

estado.eip = 0 ;//codigo do usuario comeca em zero

estado.esp = (word)gdtr.base.s[segidx(0x1060)].a.limit + 1;//topo da pilha, no limite

//para nao travar quando chegar uma interrupcao

estado.esp0 = _ESP;

asm mov ax,ss

estado.ss0 = _EAX ;

/* --------------------------------------------------------------------------------------------


*/

_far void sair(){

asm mov ax,0x930 // garantir espaco total para todos os segmentos

asm mov ds,ax

asm mov es,ax

asm mov fs,ax

exit(0);

}

/* --------------------------------------------------------------------------------------------


*/void criaCallGate() {

static word so_cs; // seletor de codigo do S.O.

// preenchendo o call gate

// sair sera chamada pelo codigo do usuario

gdtr.base.g[segidx(0x1070)].a.offset = &sair;

gdtr.base.g[segidx(0x1070)].b.offset = &sair;

asm mov ax,cs

asm mov [so_cs],ax

gdtr.base.g[segidx(0x1070)].b.selector = so_cs;

gdtr.base.g[segidx(0x1070)].a.params = 0;

gdtr.base.g[segidx(0x1070)].a.type = 0xEC;

//no test.c (pode ser a 1a instrucao do main) temos que introduzir: asm call 0x1070:0

}

int main() {

cadastrar(20111011);

/* Recupera alguns valores do S.O. para ficar em variaveis globais. */

asm sidt [idtr] // armazena inicio da IDT

asm sgdt [gdtr] // armazena inicio da GDT

/* Segmento de video */

descVideo();

initializar(5);

carregar("test"); // carrega o processo de usuario

criaTss();

criaCallGate();

// asm jmp 0x1050:0; // superjump: pula para outro segmento

asm jmp 0x1068:0; // hiperjump: pula para outro contexto (TSS)

return 0; //

}

/* --------------------------------------------------------------------------------------------

APLICATIVO – Test.c -------------------------------------------------------------------------------------------

*/

// system call

#define systemcall asm call 0x1070:0

dword dummy; // definição de uma variavel apenas para preecher o segmento correspondente (32 bits)

// prototipos

void desenhar_fractal();

void main() { // A primeira rotina do programa deve ser o main

desenhar_fractal();

systemcall; // chamada ao S.O.

}

Segmentação - Passos

1. Observar a Tabela da GDT nos endereços 928, 930, .... E 810 (TR - Busy).

2. Observar na Tabela de memória os segmentos de dados e de código (Alt +D, Alt +C).

3. Executar descVideo() e observar na tabela da GDT a posição 1000.

4. Executar carregar(“test”) e observar o conteúdo da GDT em 1048, 1050, 1058, 1060.

5. Executar CriaTSS() e observar o conteúdo da GDT em 1068 (Available, Salva o contexto do aplicativo).

6. Executar CriaCallGate() e observar o conteúdo da GDT em 1070.

7. Executar JMP 0x1068:00 e observar a memória (tamanho do segmento-Aplicativo), 1068 da GDT (Busy) e 810 (Available) e o valor do EIP (0).

8. Executar no aplicativo o systemcall (call 0x1070:00).

Laboratório de Organização e Arquitetura de Computadores

Documents

Transcript of Laboratório de Organização e Arquitetura de Computadores