4. Passer en mode protege

4.1 Pourquoi passer en mode protege ?

• Le mode reel, mode par defaut du microprocesseur, fournit les memes fonctionnalites que le 8086. Cela a plusieurs consequences dont l'une est qu'il n'est possible d'adresser plus d'1 Mo de memoire.
• Le mode protege permet d'exploiter les plus hautes performances du microprocesseur. Ce mode permet l'addressage de 4 Go de memoire et fournit un support pour l'implementation de systemes multitaches et multi-utilisateurs.
• Le mode virtuel est un mode qui permet a des programmes realises pour le 8086 de tourner sur un systeme multi-utilisateurs.

4.2 Comment passer du mode reel au mode protege

	mov eax,cr0
	or ax,1
	mov cr0,eax		; PE mis a 1 (CR0)

4.3 Addressage de la memoire en mode protege

4.3.1 Differents types d'adresses

L'adresse logique, composee d'un selecteur de segment et d'un offset, est directement manipulee par le programmeur quand il veut acceder a un endroit particulier de la memoire. Le selecteur permet de pointer sur un bloc de memoire d'une certaine taille (un segment) et l'offset est un deplacement dans ce bloc par rapport a sa base. L'unite de segmentation transforme cette adresse logique en une adresse lineaire sur 32 bits. L'unite de pagination transforme cette adresse lineaire en une adresse physique. Si la pagination n'est pas activee, l'adresse lineaire correspond a l'adresse physique.
Dans un premier temps, nous allons utiliser uniquement le mecanisme de segmentation. Le mecanisme de pagination est plus delicat a mettre en oeuvre. Par ailleurs, il n'est pas necessaire si l'on n'utilise pas de memoire virtuelle.
Le schema ci-dessous illustre le principe de l'adressage en mode protege :

4.3.2 Le mecanisme de segmentation

4.3.3 Les descripteurs de segments

Les schemas ci-dessous montrent des modeles de descripteurs de segment de code et de segment de donnees :

4.4 A quel moment passer en mode protege ?

4.5 Un programme de boot qui passe en mode protege

%define	BASE	0x100	; 0x0100:0x0 = 0x1000
%define KSIZE	1 

[BITS 16]
[ORG 0x0]

jmp start
%include "UTIL.INC"
start:
	mov [bootdrv],dl	; recuparation de l'unite de boot

; initialisation des segments en 0x07C0
	mov ax,0x07C0
	mov ds,ax
	mov es,ax
	mov ax,0x8000	; stack en 0xFFFF
	mov ss,ax
	mov sp, 0xf000

; affiche un msg
	mov si,msgDebut
	call afficher

; charger le noyau
	xor ax,ax
	int 0x13

	push es
	mov ax,BASE
	mov es,ax
	mov bx,0
	mov ah,2
	mov al,KSIZE
	mov ch,0
	mov cl,2
	mov dh,0
	mov dl,[bootdrv]
	int 0x13
	pop es

; initialisation du pointeur sur la GDT
	mov ax,gdtend	; calcule la limite de GDT
	mov bx,gdt
	sub ax,bx
	mov word [gdtptr],ax

	xor eax,eax		; calcule l'adresse lineaire de GDT
	xor ebx,ebx
	mov ax,ds
	mov ecx,eax
	shl ecx,4
	mov bx,gdt
	add ecx,ebx
	mov dword [gdtptr+2],ecx

; passage en modep
	cli
	lgdt [gdtptr]	; charge la gdt
	mov eax,cr0
	or ax,1
	mov cr0,eax		; PE mis a 1 (CR0)

	jmp next
next:
	mov ax,0x10		; segment de donne
	mov ds,ax
	mov fs,ax
	mov gs,ax
	mov es,ax
	mov ss,ax
	mov esp,0x9F000	

	jmp dword 0x8:0x1000    ; reinitialise le segment de code


;--------------------------------------------------------------------
bootdrv: db 0
msgDebut	db	"Chargement du kernel",13,10,0

;--------------------------------------------------------------------
gdt:
	db 0,0,0,0,0,0,0,0
gdt_cs:
	db 0xFF,0xFF,0x0,0x0,0x0,10011011b,11011111b,0x0
gdt_ds:
	db 0xFF,0xFF,0x0,0x0,0x0,10010011b,11011111b,0x0
gdtend:

;--------------------------------------------------------------------
gdtptr:
	dw	0	; limite
	dd	0	; base


;--------------------------------------------------------------------
;; NOP jusqu'a 510
times 510-($-$$) db 144
dw 0xAA55

Ce programme de secteur de boot ressemble beaucoup a ceux qui ont ete vus precedement.

On stocke le numero de peripherique de boot dans une variable, on initialise les registres relatifs aux segments de code et de donnees puis on affiche un message. Ensuite, on charge le noyau en memoire a l'adresse 0x100.

Avant de commuter en mode protege, il faut initialiser la GDT de facon a ce qu'apres le passage dans le nouveau mode, il n'y ait pas de probleme d'adressage. La GDT doit contenir des descripteurs pour les segments de code, de donnees et de pile. Le code ci-dessous declare et initialise la GDT :

gdt:
	db 0,0,0,0,0,0,0,0
gdt_cs:
	db 0xFF,0xFF,0x0,0x0,0x0,10011011b,11011111b,0x0
gdt_ds:
	db 0xFF,0xFF,0x0,0x0,0x0,10010011b,11011111b,0x0
gdtend:

On remarque que la base de ces segments est a 0 et que leur limite est de 0xFFFFF (c'est un nombre de pages, puisque le bit G est a 1).

Reprenons le deroulement du programme.
On a affiche un message et le noyau est charge en memoire a l'adresse 0x1000. On peut commencer le passage du mode reel vers le mode protege !

On commence par inhiber les interruptions. Cela est necessaire car comme le systeme d'adressage change, les routines appelees par les interruptions ne sont plus valides. Il faudra les reprogrammer. On inhibe les interruptions avec l'instruction 'cli'.

	cli

gdtptr:
	dw	0	; limite
	dd	0	; base

	; initialisation du pointeur sur la GDT
	mov ax,gdtend	; calcule la limite de GDT
	mov bx,gdt
	sub ax,bx
	mov word [gdtptr],ax

	xor eax,eax		; calcule l'adresse lineaire de GDT
	xor ebx,ebx
	mov ax,ds
	mov ecx,eax
	shl ecx,4
	mov bx,gdt
	add ecx,ebx
	mov dword [gdtptr+2],ecx

	lgdt [gdtptr]	; charge la gdt

; passage en modep
	mov eax,cr0
	or ax,1
	mov cr0,eax		; PE mis a 1 (CR0)

	jmp next
next:

	mov ax,0x10		; segment de donne
	mov ds,ax
	mov fs,ax
	mov gs,ax
	mov es,ax

	mov ss,ax
	mov esp,0x9F000	

	jmp dword 0x8:0x1000

4.6 Un noyau tres simple

4.6.1 Le code

[BITS 32]
[ORG 0x1000]

; Affichage d'un message par ecriture dans la RAM video
mov byte [0xB8000],'H'
mov byte [0xB8001],0x57
mov byte [0xB8002],'E'
mov byte [0xB8003],0x57
mov byte [0xB8004],'L'
mov byte [0xB8005],0x57
mov byte [0xB8006],'L'
mov byte [0xB8007],0x57
mov byte [0xB8008],'O'
mov byte [0xB8009],0x57

end:
	jmp end

Ce noyau affiche un message et boucle ensuite indefiniment. A ce stade, les routines du BIOS permettant d'afficher des caracteres a l'ecran ne sont plus utilisables. Pour afficher un message, le seul moyen que nous avons est d'ecrire nous memes nos propres routines d'affichage.

4.6.2 Afficher quelque chose a l'ecran

Le schema ci-dessous montre comment sont codes les attribus d'un caractere :

Le code suivant affiche le caractere 'H' en blanc sur fond magenta en haut a gauche de l'ecran.

mov byte [0xB8000],'H'
mov byte [0xB8001],0x57