Pagina

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

Segmentação (Conceitos Básicos)
PROFESSORES Elmar Uwe Kurt Melcher
Joseana Macêdo Fechine
2
/ -----------------------------------------------
---------------------------------------------
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) (selectorgtgt3)
3
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
/ 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
4
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
struct //CONSERTA O TYPE E O BIT SIZE
dword na byte nb
byte type byte bitsize
c typedef union segment segment_ptr
5
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
/ IDTR e GDTR / struct dtr word
length union gate_ptr
g segment_ptr s
base
6
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
// 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
7
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
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
8
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
/ 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)) desc1
0xE04BF200 // base 0xE0000000,
limitBFFFFh1024768-1ltgt1M desc0
0x0000FFFF // tipo 0xF2, dpl3, read/write
9
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
/ carregar um arquivo executavel / void
carregar(char exename) FILE exefile //
cabecalho do execut vel static struct dword
datasize, codesize, varsize, stacksize
header if((exefilefopen(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)
10
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
//Preenchendo o descritor(seletor) de dados
constantes gdtr.base.ssegidx(0x1048).a.limit
header.datasize-1 //o limite esta  no
cabecalho -1 pois comeca em 0
gdtr.base.ssegidx(0x1048).a.base 0x01989866
//a base do segmento a, um endereco gostoso
gdtr.base.ssegidx(0x1048).b.base 0x01989866
//a base do segmento a, um endereco gostoso
gdtr.base.ssegidx(0x1048).c.type 0xF0 //
dplusuario, permite so leitura
gdtr.base.ssegidx(0x1048).c.bitsize 0x40
// do descritor 32 bits
11
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
//Preenchendo o descritor(seletor) de codigo
gdtr.base.ssegidx(0x1050).a.limit
header.codesize-1 //o codesize est  no
cabecalho, -1 pois comeca em 0
gdtr.base.ssegidx(0x1050).a.base 0x01AA9866
//a base do segmento a, o max FFFFFFF...
gdtr.base.ssegidx(0x1050).b.base 0x01AA9866
//a base do segmento a, o max FFFFFFF...
gdtr.base.ssegidx(0x1050).c.type // 0x98 //
dpl S.O., permite execucao

0xF8 // dplusuario, permite execucao
gdtr.base.ssegidx(0x1050).c.bitsize 0x40
12
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
//Preenchendo o descritor(seletor) de
variaveis gdtr.base.ssegidx(0x1058).a.limit
header.varsize-1 //o limite est  no cabecalho,
-1 pois comeca em 0 gdtr.base.ssegidx(0x1058)
.a.base 0x01BB9866 //a base do segmento a, o
max FFFFFFF... gdtr.base.ssegidx(0x1058).b.
base 0x01BB9866 //a base do segmento a, o max
FFFFFFF... gdtr.base.ssegidx(0x1058).c.type
0xF2 // dplusuario, permite ler e escrever
gdtr.base.ssegidx(0x1058).c.bitsize 0x40
13
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
//Preenchendo o descritor(seletor) de pilha
gdtr.base.ssegidx(0x1060).a.limit
header.stacksize-1 //o limite est  no cabecalho,
-1 pois comeca em 0 gdtr.base.ssegidx(0x1060)
.a.base 0x01CC9866 //a base do segmento a, o
max FFFFFFF... gdtr.base.ssegidx(0x1060).b.
base 0x01CC9866 //a base do segmento a, o max
FFFFFFF... gdtr.base.ssegidx(0x1060).c.type
0xF2 // dplusuario, permite ler e escrever
gdtr.base.ssegidx(0x1060).c.bitsize 0x40
14
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
//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)
15
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
void criaTss() static struct tss estado
//Descritor de Segmento para o TSS
gdtr.base.ssegidx(0x1068).a.limit
sizeof(estado) //o limite do segmento de pilha
gdtr.base.ssegidx(0x1068).a.base estado
// gdtr.base.ssegidx(0x1068).b.base
estado // gdtr.base.ssegidx(0x1068).c.type
0x89 //tipo do segmento. no descriptor do
segmento (p1,dpl00,s0), onde o s tem que ser
8. gdtr.base.ssegidx(0x1068).c.bitsize
0x40 //0/0 do descrittor 32 bist?
16
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
// preenchimento da TSS estado.eflags 0x202
// PSW estado.ldtr 0x828 // eh assim
mesmo estado.iopb sizeof(struct tss) //
todos os seletores com rpl3usuario estado.cs
0x10503 //codigo estado.ds 0x10483
//dados estado.es 0x10583 //variaveis
estado.gs 0x10003 //ram de video estado.ss
0x10603 //Pilha
17
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
// 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.ssegidx(0
x1060).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
18
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
_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)
19
/ -----------------------------------------------
---------------------------------------------
SOFTWARE BASICO - carregador
--------------------------------------------------
-----------------------------------------/
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.gsegidx(0x1070).a.offset
sair gdtr.base.gsegidx(0x1070).b.offset
sair asm mov ax,cs asm mov so_cs,ax
gdtr.base.gsegidx(0x1070).b.selector so_cs
gdtr.base.gsegidx(0x1070).a.params 0
gdtr.base.gsegidx(0x1070).a.type 0xEC
//no test.c (pode ser a 1a instrucao do main)
temos que introduzir asm call 0x10700
20
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 0x10500 // superjump pula para outro
segmento asm jmp 0x10680 // hiperjump pula
para outro contexto (TSS) return 0 //
21
/ -----------------------------------------------
---------------------------------------------
APLICATIVO Test.c ---------------------------
--------------------------------------------------
--------------/
// system call define systemcall asm call
0x10700 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.
22
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 0x106800 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
   0x107000).