856 lines
18 KiB
NASM
Executable File
856 lines
18 KiB
NASM
Executable File
[BITS 16]
|
|
[ORG 0x0]
|
|
|
|
SECTION .text
|
|
push cs
|
|
push cs
|
|
pop ds
|
|
pop es
|
|
mov si,msg0
|
|
call showstr
|
|
;Projection de la FAT12 en mémoire
|
|
mov si,msg1
|
|
call showstr
|
|
call initfat
|
|
call ok
|
|
;Recherche du système
|
|
mov si,msg2
|
|
call showstr
|
|
mov si,System_File
|
|
call search
|
|
call ok
|
|
;Activation du BUS A20
|
|
mov si,msg3
|
|
call showstr
|
|
call EnableA20
|
|
call ok
|
|
;Chargement d'une GDT pour le mode FLAT REAL
|
|
mov si,msg4
|
|
call showstr
|
|
mov eax,cs
|
|
shl eax,4
|
|
mov [GDT.Entry1+2],ax
|
|
mov [GDT.Entry2+2],ax
|
|
shr eax,16
|
|
mov [GDT.Entry1+4],al
|
|
mov [GDT.Entry2+4],al
|
|
mov eax,cs
|
|
shl eax,4
|
|
add eax,gdt0
|
|
mov [GDTR.Address],eax
|
|
lgdt [GDTR]
|
|
call ok
|
|
;Passage en mode FLAT REAL
|
|
mov si,msg5
|
|
call showstr
|
|
cli
|
|
mov eax,cr0
|
|
or al,1
|
|
mov cr0,eax
|
|
jmp short $+2
|
|
mov bx,SYS_DATA_SEL
|
|
mov fs,bx
|
|
mov ds,bx
|
|
mov es,bx
|
|
mov gs,bx
|
|
and al,0FEh
|
|
mov cr0,eax
|
|
jmp short $+2
|
|
mov bx,cs
|
|
mov fs,bx
|
|
mov ds,bx
|
|
mov es,bx
|
|
mov gs,bx
|
|
sti
|
|
call ok
|
|
;Chargement du noyau en 0x30000
|
|
mov si,msg6
|
|
call showstr
|
|
mov ebx,0x300000
|
|
call load
|
|
call ok
|
|
;Chargement du fichier PE
|
|
mov si,msg7
|
|
call showstr
|
|
call initpe
|
|
call ok
|
|
|
|
;suite:
|
|
;mov cx,suite
|
|
;call debug
|
|
mov si,msg8
|
|
call showstr
|
|
cli
|
|
;Passage en mode protégé
|
|
mov al,0x80
|
|
out 0x70,al
|
|
mov eax,cr0
|
|
or al,1
|
|
mov cr0,eax
|
|
;Exécution du code 32 bits
|
|
jmp SYS_CODE_SEL:GoPMode32
|
|
|
|
|
|
Boot_Error:
|
|
mov si,error
|
|
call showstr
|
|
xor ax,ax
|
|
int 16h
|
|
jmp 0xFFFF:0x0
|
|
|
|
ok:
|
|
push si
|
|
push cx
|
|
mov cl,67
|
|
call eol
|
|
mov si,okay
|
|
call showstr
|
|
pop cx
|
|
pop si
|
|
ret
|
|
|
|
;======================INITPE========================
|
|
;Initialise le PE de l'adresse EBX
|
|
;->
|
|
;<- Flag Carry si erreur
|
|
;=====================================================
|
|
initpe:
|
|
pusha
|
|
push es
|
|
xor ax,ax
|
|
mov es,ax
|
|
mov [begin],ebx
|
|
cmp word [es:ebx+ELFheader.Magic],0x457F ; bien l'entete .elf ?
|
|
jne near errorelf
|
|
cmp word [es:ebx+ELFheader.Magic+2],"LF" ; bien l'entete .elf ?
|
|
jne near errorelf
|
|
cmp byte [es:ebx+ELFheader.Computertype],0x1 ; type ok ?
|
|
jne near errorelf
|
|
cmp byte [es:ebx+ELFheader.Endianness],0x1 ; type ok ?
|
|
jne near errorelf
|
|
cmp byte [es:ebx+ELFheader.Original],0x1 ; type ok ?
|
|
jne near errorelf
|
|
cmp byte [es:ebx+ELFheader.OS],0x0 ; type ok ?
|
|
jne near errorelf
|
|
cmp byte [es:ebx+ELFheader.ABI],0x0 ; type ok ?
|
|
jne near errorelf
|
|
cmp byte [es:ebx+ELFheader.Dummy],0x0 ; type ok ?
|
|
jne near errorelf
|
|
mov si,info1
|
|
call showstr
|
|
mov esi,[es:ebx+ELFheader.Entrypoint]
|
|
mov [entriepoint],esi
|
|
mov esi,[es:ebx+ELFheader.Offsetprogram]
|
|
add esi,ebx
|
|
mov [offsetheader],esi
|
|
mov esi,[es:ebx+ELFheader.Offsetsection]
|
|
add esi,ebx
|
|
mov [offsetsection],esi
|
|
mov cx,[es:ebx+ELFheader.Nbprogram]
|
|
mov [cs:nbprogram],cx
|
|
mov cx,[es:ebx+ELFheader.Nbsection]
|
|
mov [cs:nbsection],cx
|
|
xor eax,eax
|
|
mov ax,[es:ebx+ELFheader.Index]
|
|
xor edx,edx
|
|
mov dx,[es:ebx+ELFheader.Sizesection]
|
|
mul edx
|
|
add eax,esi
|
|
mov eax,[es:eax+Sections.Offset]
|
|
add eax,ebx
|
|
mov [cs:symbol],eax
|
|
xor eax,eax
|
|
add ax,[es:ebx+ELFheader.Sizesection]
|
|
add esi,eax
|
|
sections:
|
|
mov edi,esi
|
|
cmp dword [es:edi+Sections.Type],0x00
|
|
jz nothing
|
|
mov esi,info2
|
|
call showstr
|
|
push ds
|
|
push es
|
|
pop ds
|
|
mov esi,[es:edi+Sections.Name]
|
|
add esi,[cs:symbol]
|
|
call showstr
|
|
pop ds
|
|
mov esi,info3
|
|
call showstr
|
|
mov edx,[es:edi+Sections.Offset]
|
|
push cx
|
|
mov cx,32
|
|
call ShowHex
|
|
pop cx
|
|
mov esi,info4
|
|
call showstr
|
|
mov edx,[es:edi+Sections.Size]
|
|
push cx
|
|
mov cx,32
|
|
call ShowHex
|
|
pop cx
|
|
mov esi,info5
|
|
call showstr
|
|
mov edx,[es:edi+Sections.Vadress]
|
|
push cx
|
|
mov cx,32
|
|
call ShowHex
|
|
pop cx
|
|
and dword [es:edi+Sections.Flags],SF_ALLOC
|
|
jne itsok
|
|
mov esi,info6
|
|
call showstr
|
|
jmp itsok2
|
|
itsok:
|
|
mov esi,info10
|
|
call showstr
|
|
call copy2mem
|
|
cmp dword [es:edi+Sections.Type],ST_NOBITS
|
|
jne itsok2
|
|
mov esi,info9
|
|
call showstr
|
|
mov esi,info10
|
|
call showstr
|
|
call zero2mem
|
|
itsok2:
|
|
push cx
|
|
xor cx,cx
|
|
mov edx,[es:edi+Sections.Align]
|
|
mov esi,info8
|
|
call showstr
|
|
nextpower:
|
|
cmp edx,0
|
|
je powerok
|
|
cmp edx,1
|
|
je powerok
|
|
cmp cx,32
|
|
je powerok
|
|
inc cx
|
|
shr edx,1
|
|
jnc nextpower
|
|
powerok:
|
|
mov edx,ecx
|
|
mov cx,4
|
|
call ShowHex
|
|
pop cx
|
|
call showrtn
|
|
mov esi,edi
|
|
nothing:
|
|
add esi,eax
|
|
dec cx
|
|
jnz sections
|
|
mov esi,info7
|
|
call showstr
|
|
mov edx,[cs:entriepoint]
|
|
mov cx,32
|
|
call ShowHex
|
|
clc
|
|
pop es
|
|
popa
|
|
ret
|
|
|
|
errorelf:
|
|
stc
|
|
pop es
|
|
popa
|
|
ret
|
|
|
|
;==========DEBUG===========
|
|
;CX adresse
|
|
;->CX
|
|
;<-
|
|
;==========================
|
|
debug:
|
|
mov esi,info11
|
|
call showstr
|
|
xor edx,edx
|
|
mov dx,cs
|
|
shl edx,4
|
|
add edx,ecx
|
|
mov cx,32
|
|
call ShowHex
|
|
infini:
|
|
jmp infini
|
|
|
|
;==========COPY2MEM===========
|
|
;Copie de es:esi vers es:edi
|
|
;->ES:ESI ES:EDI CX
|
|
;<- Flag
|
|
;=============================
|
|
copy2mem:
|
|
push eax
|
|
push esi
|
|
push edi
|
|
push ecx
|
|
mov esi,[es:edi+Sections.Offset]
|
|
add esi,[cs:begin]
|
|
mov ecx,[es:edi+Sections.Size]
|
|
shr ecx,2
|
|
inc ecx
|
|
mov edi,[es:edi+Sections.Vadress]
|
|
copietomem:
|
|
mov eax,[es:esi]
|
|
mov [es:edi],eax
|
|
add edi,4
|
|
add esi,4
|
|
dec ecx
|
|
jnz copietomem
|
|
pop ecx
|
|
pop edi
|
|
pop esi
|
|
pop eax
|
|
ret
|
|
|
|
;==========ZERO2MEM===========
|
|
;Remise à zero de es:edi
|
|
;->ES:EDI CX
|
|
;<- Flag
|
|
;=============================
|
|
zero2mem:
|
|
push eax
|
|
push esi
|
|
push edi
|
|
push ecx
|
|
mov esi,[es:edi+Sections.Offset]
|
|
add esi,[cs:begin]
|
|
mov ecx,[es:edi+Sections.Size]
|
|
shr ecx,2
|
|
inc ecx
|
|
mov edi,[es:edi+Sections.Vadress]
|
|
mov eax,0
|
|
zerotomem:
|
|
mov [es:edi],eax
|
|
add edi,4
|
|
dec ecx
|
|
jnz zerotomem
|
|
pop ecx
|
|
pop edi
|
|
pop esi
|
|
pop eax
|
|
ret
|
|
|
|
begin dd 0
|
|
entriepoint dd 0
|
|
offsetheader dd 0
|
|
offsetsection dd 0
|
|
nbprogram dw 0
|
|
nbsection dw 0
|
|
symbol dd 0
|
|
|
|
;==========SHOWHEX===========
|
|
;Affiche un nombre hexadécimal EDX de taille CX aprés le curseur
|
|
;-> EDX un entier, CX la taille
|
|
;<-
|
|
;============================
|
|
ShowHex:
|
|
push ax
|
|
push bx
|
|
push cx
|
|
push edx
|
|
push si
|
|
mov ax,cx
|
|
shr ax,2
|
|
sub cx,32
|
|
neg cx
|
|
shl edx,cl
|
|
xor cx,cx
|
|
inc cx
|
|
Hexaize:
|
|
rol edx,4
|
|
mov bx,dx
|
|
and bx,0fh
|
|
mov si,ax
|
|
mov al,[cs:bx+Tab]
|
|
xor bx,bx
|
|
mov ah,0x09
|
|
mov bl,[cs:thecolor]
|
|
int 0x10
|
|
mov ah,0x0E
|
|
int 0x10
|
|
mov ax,si
|
|
dec al
|
|
jnz Hexaize
|
|
pop si
|
|
pop edx
|
|
pop cx
|
|
pop bx
|
|
pop ax
|
|
ret
|
|
Tab db '0123456789ABCDEF'
|
|
|
|
;============EOL=============
|
|
;Va en colonne CX
|
|
;->
|
|
;<- Flag Carry si erreur
|
|
;============================
|
|
eol:
|
|
pusha
|
|
mov bp,cx
|
|
mov ah,03
|
|
xor bx,bx
|
|
int 10h
|
|
mov ah,02
|
|
mov cx,bp
|
|
mov dl,cl
|
|
int 10h
|
|
popa
|
|
ret
|
|
|
|
;============LOAD==============
|
|
;Charge le groupe en mémoire en EBX pour le groupe CX
|
|
;-> CX
|
|
;<- Flag Carry si erreur
|
|
;==============================
|
|
load:
|
|
push ax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
push esi
|
|
push edi
|
|
push fs
|
|
xor edx,edx
|
|
xor ax,ax
|
|
mov fs,ax
|
|
mov si,The_Dot
|
|
mov dx,[Sectors_Size]
|
|
Resume_Loading:
|
|
cmp cx,0x0FF0
|
|
jae Finish_Loading
|
|
push cx
|
|
add cx,word [data]
|
|
mov edi,Buffer
|
|
call ReadSector
|
|
pop cx
|
|
jc near Boot_Error
|
|
call showstr
|
|
push esi
|
|
push ebx
|
|
push cx
|
|
mov esi,Buffer
|
|
mov cx,dx
|
|
shr cx,2
|
|
copie:
|
|
mov eax,[ds:esi]
|
|
mov [fs:ebx],eax
|
|
add ebx,4
|
|
add esi,4
|
|
dec cx
|
|
jnz copie
|
|
pop cx
|
|
pop ebx
|
|
pop esi
|
|
add ebx,edx
|
|
call NextFatGroup
|
|
jc near Boot_Error
|
|
jmp Resume_Loading
|
|
Finish_Loading:
|
|
pop fs
|
|
pop edi
|
|
pop esi
|
|
pop edx
|
|
pop ecx
|
|
pop ebx
|
|
pop ax
|
|
ret
|
|
|
|
;===========INITFAT=============
|
|
;Initialise les variables de la fat
|
|
;->
|
|
;<- Flag Carry si erreur
|
|
;===============================
|
|
initfat:
|
|
pusha
|
|
push ds
|
|
xor ax,ax
|
|
mov ds,ax
|
|
mov si,0x7C0B
|
|
mov di,bootsector
|
|
mov cx, 512
|
|
rep movsb
|
|
pop ds
|
|
mov cx,[Reserved_Sectors]
|
|
add cx,[Sectors_Hidden]
|
|
adc cx,[Sectors_Hidden+2]
|
|
mov bx,[Sectors_Per_Fat]
|
|
mov di,Fat_Buffer
|
|
push bx
|
|
push cx
|
|
readfat:
|
|
call ReadSector
|
|
jc Boot_Error
|
|
inc cx
|
|
add di,[Sectors_Size]
|
|
dec bx
|
|
jnz readfat
|
|
pop cx
|
|
pop bx
|
|
xor ax,ax
|
|
mov al,[Fats_Number]
|
|
mul bx
|
|
add cx,ax
|
|
mov [entries],cx
|
|
mov ax,32
|
|
mul word [Fits_Number]
|
|
div word [Sectors_Size]
|
|
add cx,ax
|
|
sub cx,2
|
|
mov word [data],cx
|
|
popa
|
|
ret
|
|
|
|
;===========SEARCH============
|
|
;Recherche le groupe d'un fichier
|
|
;-> si nom du fichier
|
|
;<- Flag Carry si erreur CX
|
|
;=============================
|
|
search:
|
|
push bx
|
|
push dx
|
|
push di
|
|
mov cx,[entries]
|
|
mov di,Buffer
|
|
call ReadSector
|
|
jc Boot_Error
|
|
xor bx,bx
|
|
Next_Root_Entrie:
|
|
cmp byte [di],0
|
|
je Boot_Error
|
|
push si
|
|
push di
|
|
push cx
|
|
mov cx,32
|
|
rep cmpsb
|
|
pop cx
|
|
pop di
|
|
pop si
|
|
je Found
|
|
add di,32
|
|
add bx,32
|
|
inc dx
|
|
cmp dx,[Fits_Number]
|
|
ja Boot_Error
|
|
cmp bx,[Sectors_Size]
|
|
jb Next_Root_Entrie
|
|
inc cx
|
|
Found:
|
|
mov cx,[di+26+32]
|
|
pop di
|
|
pop dx
|
|
pop bx
|
|
ret
|
|
|
|
;============SHOWRTN============
|
|
;Affiche la chaine de caractère return
|
|
;->
|
|
;<- Flag Carry si erreur
|
|
;===============================
|
|
showrtn:
|
|
push ds
|
|
push ax
|
|
push esi
|
|
mov esi,return
|
|
mov ax,cs
|
|
mov ds,ax
|
|
call showstr
|
|
pop esi
|
|
pop ax
|
|
pop ds
|
|
ret
|
|
|
|
;==============SHOWSTR=============
|
|
;Affiche la chaine de caractère pointé par ds:esi à l'écran
|
|
;-> DS, ESI
|
|
;<- Flag Carry si erreur
|
|
;==================================
|
|
showstr:
|
|
pushad
|
|
xor bh,bh
|
|
nextchar:
|
|
mov al,[ds:esi]
|
|
inc esi
|
|
or al,al
|
|
jz endshow
|
|
cmp al,' '
|
|
jb justchar
|
|
cmp al,'#'
|
|
jne nocolor
|
|
mov al,[ds:esi]
|
|
inc esi
|
|
sub al,'0'
|
|
shl al,3
|
|
mov [cs:thecolor],al
|
|
shr al,2
|
|
add [cs:thecolor],al
|
|
mov al,[ds:esi]
|
|
inc esi
|
|
sub al,'0'
|
|
add [cs:thecolor],al
|
|
jmp nextchar
|
|
nocolor:
|
|
cmp al,'@'
|
|
jne nocolor2
|
|
mov al,[ds:esi]
|
|
inc esi
|
|
sub al,'0'
|
|
shl al,3
|
|
mov cl,al
|
|
shr al,2
|
|
add cl,al
|
|
mov al,[ds:esi]
|
|
inc esi
|
|
sub cl,'0'
|
|
add cl,al
|
|
call eol
|
|
jmp nextchar
|
|
nocolor2:
|
|
xor bx,bx
|
|
mov ah,0x09
|
|
mov bl,[cs:thecolor]
|
|
xor cx,cx
|
|
inc cx
|
|
int 0x10
|
|
justchar:
|
|
mov ah,0x0E
|
|
int 0x10
|
|
jmp nextchar
|
|
endshow:
|
|
popad
|
|
ret
|
|
|
|
;==========READSECTOR============
|
|
;Lit le secteur logique LBA CX et le met en es:di
|
|
;-> CX (limité à 65536 secteurs, soit 32 Mo avec secteur 512 octets)
|
|
;<- Flag Carry si erreur
|
|
;================================
|
|
ReadSector:
|
|
pusha
|
|
mov ax,cx
|
|
xor dx,dx
|
|
div word [Sectors_Per_Track]
|
|
inc dl
|
|
mov bl,dl
|
|
xor dx,dx
|
|
div word [Heads_Number]
|
|
mov dh, [Boot_Drive]
|
|
xchg dl,dh
|
|
mov cx,ax
|
|
xchg cl,ch
|
|
shl cl,6
|
|
or cl, bl
|
|
mov bx,di
|
|
mov si, 4
|
|
mov al, 1
|
|
Read_Again:
|
|
mov ah, 2
|
|
int 0x13
|
|
jnc Read_Done
|
|
dec si
|
|
jnz Read_Again
|
|
Read_Done:
|
|
popa
|
|
ret
|
|
|
|
;============NEXTFATGROUP===========
|
|
;Renvoie en CX le groupe qui succède dans la FAT le groupe CX
|
|
;-> CX
|
|
;<- CX
|
|
;===================================
|
|
NextFatGroup:
|
|
push bx
|
|
push dx
|
|
push di
|
|
mov ax,cx
|
|
mov bx,ax
|
|
and bx,0000000000000001b
|
|
shr ax,1
|
|
mov cx,3
|
|
mul cx
|
|
mov di,Fat_Buffer
|
|
add di,ax
|
|
cmp bx,0
|
|
jnz Even_Group
|
|
Odd_Group:
|
|
mov dx,[di]
|
|
and dx,0x0FFF
|
|
mov cx,dx
|
|
jmp Next_Group_Found
|
|
Even_Group:
|
|
mov dx,[di+1]
|
|
and dx,0xFFF0
|
|
shr dx,4
|
|
mov cx,dx
|
|
Next_Group_Found:
|
|
pop di
|
|
pop dx
|
|
pop bx
|
|
ret
|
|
|
|
;============EnableA20============
|
|
;->
|
|
;<-
|
|
;Ouvre l'autoroute A20
|
|
;=================================
|
|
EnableA20:
|
|
cli
|
|
call ClearKeybBuffer
|
|
call WaitKeybCommand
|
|
mov al,0xd1
|
|
out 0x64,al
|
|
call WaitKeybCommand
|
|
mov al,0xdf
|
|
out 0x60,al
|
|
call WaitKeybCommand
|
|
jmp A20Enabled
|
|
WaitKeybCommand:
|
|
in al,0x64
|
|
test al,0x02
|
|
jnz WaitKeybCommand
|
|
ret
|
|
ClearKeybBuffer:
|
|
in al,0x64
|
|
test al,0x01
|
|
jnz ReadKeyb
|
|
ret
|
|
ReadKeyb:
|
|
in al,0x60
|
|
jmp ClearKeybBuffer
|
|
A20Enabled:
|
|
sti
|
|
ret
|
|
|
|
|
|
;=================================
|
|
;CODE 32 bits mode protégé
|
|
;=================================
|
|
GoPMode32:
|
|
[BITS 32]
|
|
;Initialisation des selecteurs
|
|
mov ax,ALL_DATA_SEL
|
|
mov es,ax
|
|
mov gs,ax
|
|
mov fs,ax
|
|
mov ss,ax
|
|
mov ds,ax
|
|
mov esp,0x3fffff
|
|
push KERNEL_SEL
|
|
push dword [cs:entriepoint]
|
|
;Execution du système
|
|
retf
|
|
|
|
section .data
|
|
|
|
thecolor db 0x07
|
|
msg0 db '#12@20-=< Lancement du Chargeur ELF >=-',0x0A,0x0D,0x0A,0x0D,0
|
|
msg1 db '#07Initialisation de la FAT',0
|
|
msg2 db '#07Recherche du systeme',0
|
|
msg3 db '#07Activation adressage 24 bits',0
|
|
msg4 db '#07Chargement des descripteurs',0
|
|
msg5 db '#07Passage en mode Flat real',0
|
|
msg6 db '#07Chargement du systeme',0
|
|
msg7 db '#07Mise en place format ELF',0
|
|
msg8 db '#07Passage en mode protege',0
|
|
|
|
|
|
info1 db 0x0A,0x0D,'Format ELF i386 reconnu, #08Sections :',0x0A,0x0D,0
|
|
info2 db ' ',0
|
|
info3 db '@12 | ',0
|
|
info4 db ' - ',0
|
|
info5 db ' -> ',0
|
|
info6 db '@35#12NON ALLOUE #08',0
|
|
info7 db 'Point entree en ',0
|
|
info8 db '@48 2**',0
|
|
info9 db '@15#12 VIDE #08',0
|
|
info10 db '@70MEM',0
|
|
info11 db 0x0A,0x0D,'#12Arret debug en ',0
|
|
|
|
return db 0x0A,0x0D,0
|
|
|
|
okay db ' #15[ #10OK #15]',0x0A,0x0D,0
|
|
error db ' #15[#12Erreur#15]',0x0A,0x0D,0x0A,0x0D,' <Appuyez une touche pour redemarrer>',0
|
|
The_Dot db '.',0
|
|
System_File db "As",0,"y",0,"s",0,"t",0,"e",0,0x0F,0,0xB8,"m",0,".",0,"s",0,"y",0,"s",0,0,0,0,0,0xFF,0xFF,0xFF,0xFF
|
|
entries dw 0
|
|
data dw 0
|
|
xy dw 0
|
|
|
|
GDTR:
|
|
.Size: dw GDT_END
|
|
.Address: dd 0
|
|
|
|
gdt0 equ $ ; null entry
|
|
GDT:
|
|
.Entry0: dw 0 ; limit 15:0
|
|
dw 0 ; base 15:0
|
|
db 0 ; base 23:16
|
|
db 0 ; type
|
|
db 0 ; limit 19:16, flags
|
|
db 0 ; base 31:24
|
|
|
|
|
|
SYS_CODE_SEL equ $-gdt0 ; code segment descriptor
|
|
|
|
.Entry1: dw 0xFFFF
|
|
dw 0x0 ; base
|
|
db 0x0 ; base
|
|
db 0x9A ; present, ring 0, code, non-conforming, readable
|
|
db 0xCF ; 32 bit
|
|
db 0
|
|
|
|
|
|
SYS_DATA_SEL equ $-gdt0 ; data segment descriptor
|
|
|
|
.Entry2: dw 0xFFFF
|
|
dw 0x0 ; base
|
|
db 0x0 ; base
|
|
db 0x92 ; present, ring 0, data, expand-up, writable
|
|
db 0xCF ; 32 bit
|
|
db 0
|
|
|
|
|
|
ALL_DATA_SEL equ $-gdt0 ; 4meg data segment descriptor
|
|
|
|
.Entry3: dw 0xFFFF
|
|
dw 0x0 ; base
|
|
db 0x0 ; base
|
|
db 0x92 ; present, ring 0, data, expand-up, writable
|
|
db 0xCF ; 4k pages, 32 bit
|
|
db 0
|
|
|
|
|
|
KERNEL_SEL equ $-gdt0 ; 4g code segment descriptor
|
|
|
|
.Entry4: dw 0xffff
|
|
dw 0x0 ; base
|
|
db 0x0 ; base
|
|
db 0x9A ; present, ring 0, code, non-conforming, readable
|
|
db 0xCF ; 4k pages, 32 bit
|
|
db 0
|
|
|
|
GDT_END equ $-gdt0 -1
|
|
|
|
bootsector equ $
|
|
Sectors_Size dw 0 ;Nombre d'octets/secteur
|
|
Sectors_Per_Cluster db 0 ;Nombre de secteurs/cluster
|
|
Reserved_Sectors dw 0 ;Nombre de secteurs réservé
|
|
Fats_Number db 0 ;Nombre de copies de la FAT
|
|
Fits_Number dw 0 ;Taille du répertoire racine
|
|
Sectors_Per_Disk dw 0 ;Nombre secteurs du volume si < 32 Mo
|
|
Media_Descriptor db 0 ;Descripteur de média
|
|
Sectors_Per_Fat dw 0 ;Nombre secteurs/FAT
|
|
Sectors_Per_Track dw 0 ;Nombre secteurs/piste
|
|
Heads_Number dw 0 ;Nombre de tete de lecture/écriture
|
|
Sectors_Hidden dd 0 ;Nombre de secteurs cachés
|
|
Sectors_Per_Disk2 dd 0 ;Nombre secteurs du volume si > 32 Mo
|
|
Boot_Drive db 0 ;Lecteur de démarrage
|
|
Reserved db 0 ;NA (pour NT seulement)
|
|
Extended_Boot_ID db 0 ;Signature Boot étendu 29h
|
|
|
|
Buffer equ $
|
|
Fat_Buffer equ $+512
|
|
|
|
SECTION .bss
|
|
|
|
%include "elf.h"
|
|
|