Pépin OS - Réaliser son propre système

Une partie du noyau est codée en assembleur i386 et le reste est codé en langage C. La maîtrise de ce dernier ainsi que la connaissance des notions de base en assembleur sont donc un préalable à la compréhension de ce tutoriel.

Même si les notions importantes relatives à l'architecture i386 sont expliquées ici au fur et à mesure, la lecture des documents suivants est fortement recommandée.

Toutes les informations relatives à l'architecture Intel et à certains microcontrôleurs sont téléchargeables :

• Manuels (c)Intel
• 8259A - Programmable Interrupt Controller

Les spécifications permettant d'écrire un noyau respectant le standard Multiboot :

• http://en.wikipedia.org/wiki/Multiboot_Specification

Concernant le format ELF :

• https://fr.wikipedia.org/wiki/Executable_and_Linking_Format

• nasm est un excellent assembleur open source.
• gcc est un compilateur portable et performant.
• Bochs est un émulateur d'architecture i386 complet qui est très pratique pour tracer le fonctionnement des premiers kernels. Cela permet de les déboguer plus facilement.

jmp start
    %include "UTIL.INC"
    start:

Le programme commence par un saut à l'adresse start. La directive include ajoute au code du noyau le contenu du fichier UTIL.INC qui contient le code de la fonction afficher vue précédemment.

; récupération de l'unité de boot
    mov [bootdrv], dl

Cette instruction met dans une variable un nombre servant à identifier le périphérique de boot (ici le lecteur de disquettes). Cette variable sera réutilisée plus tard pour indiquer à partir de quel périphérique doit être chargé le noyau.

; 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

Le bout de code ci-dessus charge le noyau en mémoire en faisant appel à l'interruption 0x13 du BIOS qui permet de copier un ou plusieurs secteurs d'une disquette en mémoire. Dans notre cas, le noyau se situe au début du second secteur de la disquette et le programme recopie ce secteur à l'adresse 0x1000 en RAM. Notez que le choix de cette adresse est arbitraire et on aurait très bien pu choisir une autre valeur.

La variable KSIZE définit le nombre de secteurs à charger pour que tout le noyau soit bien recopié en mémoire. Ce premier noyau, qui est décrit dans la partie suivante, est très court (pas plus de 100 octets). On peut donc se contenter de mettre la valeur de KSIZE à 1 pour copier un seul secteur.

; saut vers le noyau
    jmp dword BASE:0

Ensuite, une instruction de saut donne la main au code du noyau.

Le microprocesseur d'un PC possède trois modes de fonctionnement :

• le mode réel, qui est le mode par défaut, fournit les mêmes fonctionnalités que le 8086. Mais cela a certaines conséquences comme l'impossibilité d'adresser plus de 1 Mo de mémoire ;
• le mode protégé (voir aussi sur Wikipédia) permet d'exploiter la totalité des possibilités du microprocesseur, avec notamment l'adressage de toute la mémoire et le support pour l'implémentation de systèmes multitâches et multiutilisateurs ;
• le mode virtuel est un mode particulier très peu utilisé.

Notre objectif étant de réaliser un noyau multiutilisateur, multitâche et pouvant adresser toute la mémoire, il nous faudra basculer le microprocesseur en mode protégé. Mais cela a d'importantes conséquences pour le programmeur :

• le mécanisme d'adressage en mode protégé est très différent de celui en mode réel ;
• le jeu d'instruction n'est plus sur 16 bits, mais sur 32 bits et 64 bits sur les processeurs actuellement utilisés ;
• il n'est pas possible avec ce mode de s'appuyer sur les routines du BIOS pour accéder aux périphériques. Tous les drivers sont donc à réécrire !

Passer du mode réel au mode protégé est très simple, il suffit de mettre le bit 0 du registre CR0 à 1 :

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

Mais si cela suffit pour changer de mode, cela ne suffit pas à ce qu'un programme continue de fonctionner une fois le mode protégé établi. Pourquoi ? L'adressage en mode protégé, qui diffère de l'adressage en mode réel, s'appuie sur des structures qui doivent être correctement initialisées lors du changement de mode pour que le processeur continue d'adresser correctement la mémoire (et notamment le segment de données, la pile et le pointeur d'instruction).

En mode protégé, il existe pour le programmeur trois types d'adresses :

• l'adresse logique est directement manipulée par le programmeur. Elle est composée à partir d'un sélecteur de segment et d'un offset ;
• cette adresse logique est transformée par l'unité de segmentation en une adresse linéaire, sur 32 bits ;
• cette adresse linéaire est transformée par l'unité de pagination en une adresse physique. Si la pagination n'est pas activée, l'adresse linéaire correspond à l'adresse physique.

Le schéma ci-dessous résume le principe de l'adressage en mode protégé :

Dans un premier temps, nous allons utiliser uniquement le mécanisme de segmentation sans le mécanisme de pagination, plus délicat à mettre en œuvre.

Une adresse logique est constituée par un sélecteur de segment et un offset. Le sélecteur sélectionne un bloc mémoire d'une certaine taille, appelé segment, qui définit en quelque sorte l'espace de travail du programme. L'offset est un déplacement par rapport au début de ce bloc.

Un segment est décrit par une structure de 64 bits appelée descripteur de segment qui précise :

• sa base, l'endroit en mémoire où commence le segment ;
• sa limite, la taille du segment exprimée en octets ou en blocs de 4 ko ;
• son type (code, données, pile ou autre).

Les descripteurs sont stockés dans la Global Descriptor Table (GDT). Cette table peut résider n'importe où en mémoire. Son adresse en mémoire physique est renseignée au processeur grâce à un registre particulier : le GDTR :

Le sélecteur de segment est un registre de 16 bits directement manipulé par le programmeur qui pointe sur un descripteur de segment dans la GDT et indique de ce fait dans quel segment on se situe. Ces registres sont bien connus de ceux qui ont déjà programmé en mode réel :

• CS est le sélecteur de segment de code ;
• DS est le sélecteur de segment de données ;
• ES, FS et GS sont des sélecteurs de segments généraux ;
• SS est le sélecteur de segment de pile.

Le sélecteur pointe sur un descripteur qui donne l'adresse où commence le segment. En ajoutant l'offset à cette base, on obtient une adresse linéaire sur 32 bits :

Le schéma ci-dessous décrit la structure générale d'un descripteur de segment :

• la base, sur 32 bits, est l'adresse linéaire où débute le segment en mémoire ;
• la limite, sur 20 bits, définit la longueur du segment ;
• si le bit G est à 0, la limite est exprimée en octets, sinon, elle est exprimée en nombre de pages de 4 ko ;
• le bit D/B précise la taille des instructions et des données manipulées. Il est mis à 1 pour 32 bits ;
• le bit AVL est librement disponible ;
• le bit P est utilisé pour déterminer si le segment est présent en mémoire physique. Il est à 1 si c'est le cas ;
• le DPL indique le niveau de privilège du segment. Le niveau 0 correspond au mode super-utilisateur ;
• le bit S est mis à 1 pour un descripteur de segment et à 0 pour un descripteur système (un genre particulier de descripteur que nous verrons plus tard) ;
• le type définit le type de segment (code, données ou pile).

IV-B-3-a. Descripteur d'un segment de code▲

IV-B-3-b. Descripteur d'un segment de données▲

Il est possible de passer en mode protégé à plusieurs moments : lors de l'exécution du secteur de boot ou du noyau. Notre noyau va utiliser un jeu d'instructions sur 32 bits, seulement utilisable en mode protégé. Le plus simple est donc de passer en mode protégé pendant le boot, avant que le noyau ne s'exécute. Il est cependant possible que ce soit le noyau qui effectue la commutation, mais cela complique inutilement son écriture, car le code du noyau doit alors être en partie sur 16 bits et en partie sur 32 bits.

?fine BASE    0x100  ; 0x0100:0x0 = 0x1000
?fine KSIZE   50     ; nombre de secteurs à charger

[BITS 16]
[ORG 0x0]

jmp start
%include "UTIL.INC"
start:

; 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

; récupération de l'unité de boot
    mov [bootdrv], dl    

; 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 linéaire 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    ; réinitialise 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

IV-C-2-a. Que fait exactement ce programme ?▲

IV-C-2-b. Passer en mode protégé▲

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

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

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

; désactivation des interruptions
    cli

; charge la gdt
    lgdt [gdtptr]

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

jmp gdt_next
next:

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

; la pile
    mov ss, ax
    mov esp, 0x9F000

; réinitialise le segment de code
    jmp dword 0x8:0x1000

La mémoire vidéo est mappée en mémoire à l'adresse physique 0xB8000. On peut donc afficher des informations en manipulant directement les octets débutant à cette adresse :

• la console d'affichage comprend 25 lignes et 80 colonnes.
• chaque caractère est décrit par 2 octets. Le premier contient le code ASCII du caractère à afficher et le suivant contient ses attributs (couleur, clignotement…)

Les attributs sont codés de la façon suivante :

Par exemple, le code suivant affiche le caractère 'H' en blanc sur fond magenta en haut à gauche de l'écran :

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

Le fichier screen.c contient des fonctions permettant d'afficher des caractères à l'écran :

#include "types.h"

#define RAMSCREEN 0xB8000       /* début de la mémoire vidéo */
#define SIZESCREEN 0xFA0        /* 4000, nombres d'octets d'une page texte */
#define SCREENLIM 0xB8FA0

char kX = 0;                    /* position courante du curseur à l'écran */
char kY = 17;
char kattr = 0x0E;              /* attributs vidéo des caractères à afficher */


/* 
 * 'scrollup' scrolle l'écran (la console mappée en ram) vers le haut
 * de n lignes (de 0 a 25).
 */
void scrollup(unsigned int n)
{
        unsigned char *video, *tmp;

        for (video = (unsigned char *) RAMSCREEN;
             video < (unsigned char *) SCREENLIM; video += 2) {
                tmp = (unsigned char *) (video + n * 160);

                if (tmp < (unsigned char *) SCREENLIM) {
                        *video = *tmp;
                        *(video + 1) = *(tmp + 1);
                } else {
                        *video = 0;
                        *(video + 1) = 0x07;
                }
        }

        kY -= n;
        if (kY < 0)
                kY = 0;
}

void putcar(uchar c)
{
        unsigned char *video;
        int i;

        if (c == 10) {          /* CR-NL */
                kX = 0;
                kY++;
        } else if (c == 9) {    /* TAB */
                kX = kX + 8 - (kX % 8);
        } else if (c == 13) {   /* CR */
                kX = 0;
        } else {                /* autres caractères */
                video = (unsigned char *) (RAMSCREEN + 2 * kX + 160 * kY);
                *video = c;
                *(video + 1) = kattr;

                kX++;
                if (kX > 79) {
                        kX = 0;
                        kY++;
                }
        }

        if (kY > 24)
                scrollup(kY - 24);
}

/*
 * 'print' affiche à l'écran, à la position courante du curseur, une chaîne
 * de caractères terminée par \0.
 */
void print(char *string)
{
        while (*string != 0) {  /* tant que le caractère est différent de 0x0 */
                putcar(*string);
                string++;
        }
}

• Les variables kX et kY stockent en mémoire l'emplacement du curseur a l'écran. La variable kattr contient les attributs vidéo des caractères affichés.
• La fonction scrollup() prend en argument un entier n et scrolle l'écran de n lignes.
• La fonction putcar() affiche un caractère à l'écran.
• La fonction print() affiche une chaîne de caractères.

Notez que certains types ont été définis dans le fichier types.h :

#ifndef _I386_TYPE_
#define _I386_TYPE_

typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned char uchar;

#endif

Le code du noyau ci-dessous fait appel aux fonctions d'affichage définies ci-dessus. Cet exemple est assez intéressant, car il montre comment un programme en assembleur fait appel à une fonction écrite en C (ce sujet est développé dans l'annexe sur la compilation séparée en assembleur sous UnixAnnexe A : Compilation séparée en assembleur sous Unix) :

[BITS 32]

EXTERN scrollup, print
GLOBAL _start

_start:

    mov  eax, msg
    push eax
    call print
    pop  eax

    mov  eax, msg2
    push eax
    call print
    pop  eax

    mov  eax, 2
    push eax
    call scrollup

end:
    jmp end

msg  db 'un premier message', 10, 0
msg2 db 'un deuxième message', 10, 0

Par rapport aux précédents noyaux, on note surtout :

• l'absence de directive ORG, qui sert au calcul des adresses en fonction de l'endroit où le code est relogé. Ce calcul est maintenant réalisé par le linker ld ;
• la présence du point d'entrée _start, indispensable à ld.

gcc -c screen.c
nasm -f elf -o kernel.o kernel.asm
ld --oformat binary -Ttext 1000 kernel.o screen.o -o kernel

L'option -Ttext indique l'adresse linéaire à partir de laquelle le code commence. Par défaut, ld suppose que le code commence à l'adresse 0x0. Ici, ce paramètre est indispensable, car le code du noyau est recopié par le secteur de boot en 0x1000. La même fonctionnalité était implémentée par la directive [ORG 0x1000] dans les noyaux précédents en assembleur.

L'option -Tdata, qui sert à indiquer l'offset de début de la section de données, n'est pas utilisée. Par défaut, le linker considère que la zone de données suit la zone de texte (on remarque qu'elle est relogée une page mémoire plus loin).

extern void scrollup(unsigned int);
extern void print(char *);

extern kY;
extern kattr;

void _start(void)
{
        kY = 18;
        kattr = 0x5E;
        print("un message\n");

        kattr = 0x4E;
        print("un autre message\n");

        scrollup(2);

        while (1);
}

Le code du noyau en C reprend de façon fidèle le code exprimé plus haut en assembleur.

Il affiche un message, initialise la nouvelle GDT et la charge en mémoire. Après avoir réinitialisé la pile, le noyau passe la main à la fonction main() qui affiche un message et boucle indéfiniment :

#include "types.h"
#include "gdt.h"
#include "screen.h"

int main(void);

void _start(void)
{
        kY = 18;
        kattr = 0x5E;
        print("kernel : loading new gdt...\n");

        /* initialisation de la GDT et des segments */
        init_gdt();

        /* Initialisation du pointeur de pile %esp */
        asm("   movw $0x18, %ax \n \
                movw %ax, %ss \n \
                movl $0x20000, %esp");

        main();
}

int main(void)
{
        kattr = 0x4E;
        print("kernel : new gdt loaded !\n");

        while (1);
}

VI-B-2-a. Les descripteurs de segment en C▲

/* Descripteur de segment */
struct gdtdesc {
    u16 lim0_15;    
    u16 base0_15;
    u8 base16_23;
    u8 acces;
    u8 lim16_19 : 4;
    u8 other : 4;
    u8 base24_31;
} __attribute__ ((packed));

/* Registre GDTR */
struct gdtr {
    u16 limite ;
    u32 base ;
} __attribute__ ((packed));

#ifndef _I386_TYPE_
#define _I386_TYPE_

typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned char uchar;

#endif

VI-B-2-b. La fonction init_gdt()▲

#include "types.h"
#include "lib.h"

#define __GDT__
#include "gdt.h"


/*
 * 'init_desc' initialise un descripteur de segment situe en gdt ou en ldt.
 * 'desc' est l'adresse linéaire du descripteur à initialiser.
 */
void init_gdt_desc(u32 base, u32 limite, u8 acces, u8 other,
                   struct gdtdesc *desc)
{
        desc->lim0_15 = (limite & 0xffff);
        desc->base0_15 = (base & 0xffff);
        desc->base16_23 = (base & 0xff0000) >> 16;
        desc->acces = acces;
        desc->lim16_19 = (limite & 0xf0000) >> 16;
        desc->other = (other & 0xf);
        desc->base24_31 = (base & 0xff000000) >> 24;
        return;
}

/*
 * Cette fonction initialise la GDT après que le kernel soit chargé 
 * en mémoire. Une GDT est déjà opérationnelle, mais c'est celle qui
 * a été initialisée par le secteur de boot et qui ne correspond
 * pas forcement à celle que l'on souhaite.
 */
void init_gdt(void)
{

        /* initialisation des descripteurs de segment */
        init_gdt_desc(0x0, 0x0, 0x0, 0x0, &kgdt[0]);
        init_gdt_desc(0x0, 0xFFFFF, 0x9B, 0x0D, &kgdt[1]);      /* code */
        init_gdt_desc(0x0, 0xFFFFF, 0x93, 0x0D, &kgdt[2]);      /* data */
        init_gdt_desc(0x0, 0x0, 0x97, 0x0D, &kgdt[3]);          /* stack */

        /* initialisation de la structure pour GDTR */
        kgdtr.limite = GDTSIZE * 8;
        kgdtr.base = GDTBASE;

        /* recopie de la GDT à son adresse */
        memcpy((char *) kgdtr.base, (char *) kgdt, kgdtr.limite);

        /* chargement du registre GDTR */
        asm("lgdtl (kgdtr)");

        /* initialisation des segments */
        asm("   movw $0x10, %ax \n \
            movw %ax, %ds       \n \
            movw %ax, %es       \n \
            movw %ax, %fs       \n \
            movw %ax, %gs       \n \
            ljmp $0x08, $next   \n \
            next:               \n");
}

init_gdt_desc(0x0, 0xFFFFF, 0x9B, 0x0D, &kgdt[1]);      /* code */
init_gdt_desc(0x0, 0xFFFFF, 0x93, 0x0D, &kgdt[2]);      /* data */
init_gdt_desc(0x0, 0x0, 0x97, 0x0D, &kgdt[3]);          /* stack */

/* recopie de la GDT a son adresse */
memcpy((char *) kgdtr.base, (char *) kgdt, kgdtr.limite);

/* chargement du registre GDTR */
asm("lgdtl (kgdtr)");

/* initialisation des segments */
 asm("   movw $0x10, %ax        \n \
         movw %ax, %ds  \n \
         movw %ax, %es  \n \
         movw %ax, %fs  \n \
         movw %ax, %gs  \n \
         ljmp $0x08, $next      \n \
         next:          \n");

/* initialisation de la GDT et des segments */
init_gdt();

/* Initialisation du pointeur de pile %esp */
asm("   movw $0x18, %ax \n \
        movw %ax, %ss \n \
        movl $0x20000, %esp");

main();

Après avoir initialisé la GDT, la pile est initialisée pour pointer en 0x20000. Cette adresse est arbitraire, j'aurais pu choisir autre chose… mais attention à prendre une valeur où la pile ne risque pas de corrompre le code ou des données !

Après ces initialisations, une fonction main() est appelée. La création d'une nouvelle fonction peut sembler luxueuse quand on voit ce qu'elle réalise : juste afficher un messager et boucler indéfiniment. N'aurait-on pas pu placer l'intégralité du code dans la fonction _start() ? Non, car l'appel à la fonction print est réalisé par gcc de cette façon :

movl    $.LC1, (%esp)
call    print

On remarque que le passage d'argument ne se fait pas par un push, mais par un mov qui écrit l'adresse de la chaîne de caractères à afficher directement en 0x20000, ce qui est au-delà du sommet de la pile ! En principe, pour passer un paramètre à une fonction, un compilateur doit utiliser push qui décrémente d'abord la valeur de esp avant d'écrire sur la pile, mais gcc procède autrement en réservant au début de la fonction suffisamment de place sur la pile. Mais comme nous avons modifié entretemps la structure de la pile, et donc de la frame associée à la fonction _start, cela ne peut plus fonctionner ! La fonction main() permet de repartir sur une frameAnnexe D - Gérer les arguments sur la pile avec les Stack Frame propre.

Quand on presse ou qu'on relâche une touche du clavier d'un PC, le contrôleur du clavier envoie une interruption à un chipset chargé de multiplexer les interruptions : le contrôleur d'interruptions. Si l'interruption en question n'est pas masquée, le contrôleur déclenche une interruption matérielle pour prévenir le processeur. Le processeur exécute alors une routine pour traiter l'événement (touche pressée ou relâchée). En général, cette routine va interroger le contrôleur du clavier pour savoir quelle touche a été pressée (ou relâchée), puis il va éventuellement afficher le caractère correspondant et/ou le stocker dans un buffer. Une fois la routine de traitement de caractère terminée, la tâche interrompue peut reprendre.

Les interruptions matérielles peuvent être vues comme des sonnettes tirées par les périphériques pour prévenir le processeur que quelque chose se passe. Mais si chaque périphérique pouvait envoyer directement un signal au processeur, il faudrait sur celui-ci autant de broches que de périphériques. Le contrôleur d'interruption programmable (PIC, Programmable interrupt controler) est un chipset qui permet d'éviter cela en multiplexant les requêtes d'interruption envoyées par les périphériques. Le 8259A est l'un des premiers PIC développés par Intel.

Chaque 8259A peut gérer les interruptions de 8 périphériques, mais la plupart des PC ont deux contrôleurs cascadés entre eux, ce qui leur permet de gérer jusqu'à 14 périphériques. Le second contrôleur (esclave) est chaîné au premier (contrôleur maître). Un contrôleur peut réaliser des fonctions plus complexes que la simple transmission d'interruptions : il peut masquer des interruptions et définir des priorités de traitement.

Quand un périphérique transmet au 8259A une requête pour une interruption, celle-ci subit un traitement complexe :

1. Le registre IMR (Interrupt Mask Register) interne au contrôleur permet de masquer certaines interruptions. Si l'interruption est masquée, on ne la traite pas ;
2. Le registre IRR (Interrupt Request Register) est chargé de gérer les priorités entre interruptions au cas où plusieurs d'entre elles surviennent en même temps. La requête avec la plus haute priorité est évaluée ;
3. Le 8259A signale au processeur la demande d'interruption. La requête faite par le contrôleur au processeur est appelée IRQ (Interrupt Request) ;
4. Le processeur acquitte ce signal puis demande au contrôleur, par un autre signal, le numéro de l'interruption demandée afin de déclencher la bonne routine ISR ;
5. Le contrôleur dépose sur le bus de données un octet, le vecteur d'interruption ;
6. Une fois la routine terminée, le processeur doit envoyer au contrôleur un signal pour l'avertir que le traitement de l'interruption est terminé.

Il est possible de paramétrer les deux PIC d'un PC en écrivant dans leurs registres internes via les ports d'entrée/sortie du processeur. On accède au contrôleur maître via les ports 0x20 et 0x21 et au contrôleur esclave via les ports 0xA0 et 0xA1. En écrivant sur ces ports, on envoie au contrôleur des données qui seront inscrites dans l'un de ses registres.

Il y a deux types de registres :

• les registres ICW (Initialization Command Word), qui réinitialisent le contrôleur ;
• les registres OCW (Operation Control Word), qui permettent de paramétrer certaines fonctions du contrôleur une fois que celui-ci a été réinitialisé.

Pour réinitialiser un contrôleur, il faut remplir les registres d'initialisation ICW1, ICW2, ICW3 et ICW4 en respectant cet ordre. Après avoir transmis les données pour le registre ICW1, le contrôleur attend une valeur à mettre dans le registre ICW2 et ainsi de suite. S'il n'y a qu'un seul contrôleur, ce n'est pas la peine de renseigner les registres ICW3 et ICW4.

Les registres OCW peuvent être remplis à n'importe quel moment après l'initialisation des PIC. Le registre OCW1 permet notamment de masquer et démasquer les interruptions.

VII-B-3-a. Registres ICW▲

|0|0|0|1|x|0|x|x|
         |   | +--- avec ICW4 (1) ou sans (0)
         |   +----- un seul contrôleur (1), ou cascadés (0)
         +--------- déclenchement par niveau (level) (1) ou par front (edge) (0)

mov al, 0x11  ; Initialisation de ICW1
out 0x20, al  ; maître
out 0xA0, al  ; esclave

|x|x|x|x|x|0|0|0|  
 | | | | |
 +----------------- adresse de base des vecteurs d'interruption

mov al, 0x20
out 0x21, al  ; maître, vecteur de départ = 32
mov al, 0x70  
out 0xA1, al  ; esclave, vecteur de départ = 96

|x|x|x|x|x|x|x|x|  pour le maître
 | | | | | | | |
 +------------------ contrôleur esclave rattaché à la broche d'interruption (1), ou non (0)

|0|0|0|0|0|x|x|x|  pour l'esclave
           | | |
           +-------- Identifiant de l'esclave, qui correspond au numéro de broche IR sur le maître

mov al, 0x04 ; maître
out 0x21, al
mov al, 0x02 ; esclave
out 0xA1, al

|0|0|0|x|x|x|x|1|
       | | | +------ mode "automatic end of interrupt" AEOI (1)
       | | +-------- mode bufferisé esclave (0) ou maître (1)
       | +---------- mode bufferisé (1)
       +------------ mode "fully nested" (1)

mov al, 0x01
out 0x21, al
out 0xA1, al

mov al, 0x11  ; initialisation de ICW1
out 0x20, al
jmp .1        ; temporisation
.1:
mov al, 0x20  ; initialisation de ICW2
out 0x21, al  ; vecteur de départ = 32
jmp .2        ; temporisation
.2:
mov al, 0x04  ; initialisation de ICW3
out 0x21, al
jmp .3  
.3:
mov al, 0x01  ; initialisation de ICW4
out 0x21, al

VII-B-3-b. Registres OCW▲

|x|x|x|x|x|x|x|x|  
 | | | | | | | |
 +------------------ pour chaque IRQ : masque d'interruption établi (1) ou non (0)

in  al, 0x21  ; lecture de l'Interrupt Mask Register (IMR)
and al, 0xEF  ; 0xEF => 11101111b. débloque l'IRQ 4
out 0x21, al  ; recharge l'IMR

mov al, 0x20
out 0x20, al  ; "End Of Interrupt" (EOI) envoyé au PIC

• Le bit P est utilisé pour déterminer si le segment est présent en mémoire physique. Il est à 1 si c'est le cas.
• Le DPL indique le niveau de privilège du segment. Le niveau 0 correspond au mode super-utilisateur.

Les descripteurs système de l'IDT gérant les interruptions, dont le fonctionnement est expliqué au chapitre précédentProgrammer les interruptions du processeur i386 avec le contrôleur d'interruptions 8259A, ont ce modèle :

La structure ci-dessous, définie dans le fichier idt.h, sert à créer les descripteurs d'interruption. Notez là encore la présence de la directive __attribute__ ((packed)) pour empêcher gcc d'insérer des octets de padding au sein de la structure :

/* descripteur de segment */
struct idtdesc {
    u16 offset0_15;    
    u16 select;
    u16 type;
    u16 offset16_31;    
} __attribute__ ((packed));

La fonction init_idt_desc() sert à initialiser les descripteurs système.

void init_idt_desc(u16 select, u32 offset, u16 type, struct idtdesc* desc) {
    desc->offset0_15 = (offset & 0xffff);
    desc->select = select;
    desc->type = type;
    desc->offset16_31 = (offset & 0xffff0000) >> 16;
    return;
}

Par exemple, pour initialiser le descripteur associé à l'IRQ 1 (interruptions clavier), on utilise le code suivant :

init_idt_desc(0x08, (u32) _asm_irq_1, INTGATE, &kidt[33]); /* clavier */

• le premier argument pointe sur le descripteur de segment de code qui contient la routine de gestion de l'interruption (dans notre cas le descripteur est à l'offset 0x08 dans la GDT) ;
• le deuxième argument est l'offset par rapport au début du segment de code pour trouver le début de la routine. Cet offset correspond au nom de la fonction à exécuter ;
• le troisième argument comprend le type de descripteur dans l'IDT (ici interrupt gate) et le niveau de privilège du segment ;
• le dernier argument correspond au descripteur à initialiser.

Lors d'une interruption, un vecteur est transmis par le PIC au processeur pour exécuter la bonne ISR. Une ISR obéit à deux contraintes particulières :

• une fois l'interruption traitée, il faut avertir le contrôleur de la fin du traitement de l'interruption en lui envoyant un message End of Interrupt (EOI) ;
• une routine d'interruption doit retourner en utilisant la directive assembleur iret (au lieu de ret, utilisé habituellement lors de l'appel à une fonction).

Pour envoyer au contrôleur un message EOI, indiquant que l'interruption en cours a été traitée, on utilise le code assembleur suivant :

; envoyer EOI au PIC
    mov al, 0x20
    out 0x20, al

En revanche, pour retourner de la routine d'interruption, rien en C ne nous permet d'utiliser iret. La routine d'interruption appelée doit donc être écrite en assembleur. Par exemple, pour gérer l'interruption de l'IRQ 1 :

_asm_irq_1:
    call isr_kbd_int
    mov al,0x20  ; EOI
    out 0x20,al
    iret

Ce code appelle la fonction isr_kbd_int() qui effectue réellement la gestion de l'interruption du clavier, puis elle envoie un EOI au contrôleur avant de retourner. La partie de code en assembleur ne fait donc qu'encapsuler le code écrit en C dans le fichier interrupt.c.

#include "types.h"
#include "screen.h"

void isr_default_int(void)
{
        print("interrupt\n");
}

void isr_clock_int(void)
{
        static int tic = 0;
        static int sec = 0;
        tic++;
        if (tic % 100 == 0) {
                sec++;
                tic = 0;
                print("clock\n");
        }
}

void isr_kbd_int(void)
{
        print("keyboard\n");
}

Les routines en assembleur sont dans le fichier int.asm.

extern isr_default_int, isr_clock_int, isr_kbd_int
global _asm_default_int, _asm_irq_0, _asm_irq_1

_asm_default_int:
        call isr_default_int
        mov al,0x20
        out 0x20,al
        iret

_asm_irq_0:
        call isr_clock_int
        mov al,0x20
        out 0x20,al
        iret

_asm_irq_1:
        call isr_kbd_int
        mov al,0x20
        out 0x20,al
        iret

La fonction init_idt() effectue l'initialisation des descripteurs système et le chargement de l'IDT. Étant donné leur similarité, le code nécessaire pour initialiser et charger l'IDT ressemble beaucoup à celui utilisé pour l'initialisation de la GDT. À l'exception des descripteurs associés aux IRQ 0 et 1 (respectivement l'horloge et le clavier), l'ensemble des descripteurs pointent vers un handler d'interruption par défaut :

for (i = 0; i < IDTSIZE; i++)                                   /* defaut */
        init_idt_desc(0x08, (u32) _asm_default_int, INTGATE, &kidt[i]);

init_idt_desc(0x08, (u32) _asm_irq_0, INTGATE, &kidt[32]);      /* horloge */
init_idt_desc(0x08, (u32) _asm_irq_1, INTGATE, &kidt[33]);      /* clavier */

tar xfz kernel_ManageINT.tgz
cd ManageINT
make

À l'exécution du noyau, un tic est affiché toutes les 100 interruptions de l'horloge. En revanche, pour le moment, l'appui d'une touche du clavier ne fonctionne qu'une seule fois. Nous verrons plus tard comment gérer correctement le clavier :

Nous avons vu comment créer un programme qui peut à tout moment accéder à n'importe quel endroit de la mémoire et exécuter n'importe quelle instruction. Cette liberté a un prix : le risque de corrompre des données ou d'exécuter une instruction indésirable. Si ce risque est un mal nécessaire pour le noyau qui doit nécessairement pouvoir tout faire, il n'est pas souhaitable que le code d'un utilisateur bénéficie des mêmes permissions. Ce dernier ne doit pas pouvoir accéder aux données des autres utilisateurs ou corrompre l'ensemble du système (intentionnellement ou non).

On distingue deux types de modes d'exécution d'un programme : le mode noyau (ou privilégié ou encore superviseur) et le mode utilisateur :

• le code en mode noyau a un accès total à la machine (mémoire, instructions, périphériques) ;
• le code en mode utilisateur n'a qu'un accès limité à la mémoire et il ne peut pas exécuter certaines instructions dangereuses.

Par exemple, sur un système de type Unix, un programme utilisateur peut seulement accéder à ses propres données et il ne peut pas, par exemple, rebooter la machine.

La famille de processeur i386 offre plusieurs méthodes pour exécuter du code en mode utilisateur. La méthode décrite ici est celle du software task switching. Pour commuter une tâche par cette méthode, le noyau doit :

1. Définir les segments de mémoire utilisables par la tâche ;
2. Copier la tâche (le code exécutable et les données) en mémoire ;
3. Créer et initialiser la structure TSS ;
4. Empiler certaines valeurs clefs permettant la commutation sur la pile ;
5. Commuter grâce à l'instruction iret.

Cela peut sembler un peu compliqué, mais pourtant il n'en est rien. Ces différents points sont expliqués en détail ci-dessous.

L'initialisation du TSS se fait en plusieurs étapes :

1. Création et initialisation de la structure du TSS

    

   Sélectionnez

   struct tss {
       u16    previous_task, __previous_task_unused;
       u32    esp0;
       u16    ss0, __ss0_unused;
       u32    esp1;
       u16    ss1, __ss1_unused;
       u32    esp2;
       u16    ss2, __ss2_unused;
       u32    cr3;
       u32    eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;
       u16    es, __es_unused;
       u16    cs, __cs_unused;
       u16    ss, __ss_unused;
       u16    ds, __ds_unused;
       u16    fs, __fs_unused;
       u16    gs, __gs_unused;
       u16    ldt_selector, __ldt_sel_unused;
       u16    debug_flag, io_map;
   } __attribute__ ((packed));

    

   Sélectionnez

   struct tss default_tss;
   
       default_tss.debug_flag = 0x00;
       default_tss.io_map = 0x00;
       default_tss.esp0 = 0x20000;
       default_tss.ss0 = 0x18;

2. Création du descripteur de TSS

    

   Sélectionnez

   init_gdt_desc((u32) &default_tss, 0x67, 0xE9, 0x00, &kgdt[7]); /* descripteur de tss */

3. Chargement du registre TR à l'aide de l'instruction ltr

    

   Sélectionnez

   asm("  movw $0x38, %ax \n \
          ltr %ax");

4. La mise à jour du segment et du pointeur de pile noyau du TSS (champs ss0 et esp0 du TSS) avec les valeurs courantes se fait très simplement :

asm("  movw %%ss, %0 \n \
       movl %%esp, %1" : "=m" (default_tss.ss0), "=m" (default_tss.esp0) : );

L'instruction iret sert normalement à retourner d'une interruption. Dans le cas présent, une petite astuce à la base de notre implémentation va se servir de iret pour donner la main à une tâche non privilégiée.

Quand une tâche utilisateur s'exécute et qu'une interruption survient, le processeur va automatiquement sauvegarder sur la pile noyau différents registres lui permettant de retourner dans le contexte utilisateur une fois le traitement de l'interruption terminé :

Une fois l'interruption traitée, l'instruction iret fait les choses suivantes :

1. Le processeur dépile les registres EIP et CS ;
2. Il vérifie s'il y a un changement de privilège ;
3. Il met à jour les registres EIP et CS ;
4. Il dépile et met à jour le registre EFLAGS ;
5. En cas de changement de privilège, il dépile et met à jour les registres SS et ESP.

Pour commuter en mode non privilégié, il suffit donc de :

1. Empiler des registres SS et ESP qui pointent sur la pile utilisateur ;
2. Empiler un registre d'état EFLAGS valide ;
3. Empiler des registres CS et EIP qui pointent vers le code utilisateur ;
4. Exécuter iret.

Le code ci-dessous effectue un saut vers la fonction task1() en mode utilisateur :

asm("   cli \n \
            push $0x33 \n \
            push $0x30000 \n \
            pushfl \n \
            popl %?x \n \
            orl $0x200, %?x \n \
            and $0xffffbfff, %?x \n \
            push %?x \n \
            push $0x23 \n \
            push $0x0 \n \
            movl $0x20000, %0 \n \
            movw $0x2B, %%ax \n \
            movw %%ax, %%ds \n \
            iret" : "=m" (default_tss.esp0) : );

X-E-1-a. Le code vu pas à pas▲

asm("   cli \n \

push $0x33 \n \
push $0x30000 \n \

pushfl            \n \
popl %?x        \n \
orl $0x200, %?x \n \
and $0xffffbfff, %?x \n \
push %?x        \n \

push $0x23 \n \
push $0x0 \n \

movl $0x20000, %0 \n \

movw $0x2B, %%ax \n \
movw %%ax, %%ds \n \

iret" : "=m" (default_tss.esp0) : );

Quand le processeur est en mode utilisateur et qu'une interruption est reçue, il doit passer en mode privilégié pour exécuter l'ISR appropriée. En cas de changement de privilège, le processeur fait automatiquement les choses suivantes :

1. Il récupère dans le TSS les valeurs des champs ss0 et esp0 correspondant aux registres SS et ESP de la pile noyau ;
2. Il bascule sur la pile noyau et il empile dessus les registres SS, ESP, EFLAGS, CS et EIP liés à la tâche utilisateur ;
3. Dans certains cas, il empile un code d'erreur ;
4. Il exécute l'ISR.

Mais cela n'est pas suffisant. Pour sauvegarder entièrement le contexte d'exécution de la tâche utilisateur, il faut stocker quelque part, par exemple en les empilant sur la pile noyau, les autres registres du processeur susceptibles d'êtres modifiés par la routine d'interruption.
Pour illustrer ce point, à l'origine notre handler pour l'interruption IRQ0 était :

_asm_irq_0:
    call isr_clock_int
    mov al,0x20
    out 0x20,al
    iret

Nous devons le modifier afin qu'il sauvegarde les registres (on remarque aussi qu'il initialise le sélecteur de segment de données DS afin que le noyau puisse accéder au segment de données) :

%macro  SAVE_REGS 0
        pushad 
        push ds
        push es
        push fs
        push gs 
        push ebx
        mov bx,0x10
        mov ds,bx
        pop ebx
%endmacro

%macro  RESTORE_REGS 0
        pop gs
        pop fs
        pop es
        pop ds
        popad
%endmacro

_asm_irq_0:
        SAVE_REGS
        call isr_clock_int
        mov al,0x20
        out 0x20,al
        RESTORE_REGS
        iret

Le mécanisme de segmentation empêche le code utilisateur d'accéder librement aux périphériques ou au noyau. Pour accéder à ces ressources, par exemple pour écrire dans la mémoire vidéo ou sur disque, le code utilisateur utilise des services implémentés au niveau du noyau : les appels système. Le noyau illustré ici implémente un appel système permettant d'afficher un message à l'écran.

Nous avons vu aux chapitres précédents que des interruptions peuvent être déclenchées par les périphériques ou directement par le processeur en cas d'exception. Un troisième type d'interruption existe, ce sont les interruptions logicielles, déclenchées volontairement par le code noyau ou utilisateur à l'aide de l'instruction int. Ce sont ces interruptions qui vont nous servir pour implémenter les appels système.

Nous avons déjà détaillé la façon dont fonctionnent les interruptions matérielles. Les interruptions logicielles fonctionnent exactement de la même façon à deux différences près :

• nous allons utiliser un descripteur de Trap Gate au lieu d'un descripteur de type Interrupt Gate. La seule différence entre les deux est qu'un Trap Gate ne désactive pas les interruptions ;
• nous allons initialiser différemment le champ DPL du descripteur.

XI-A-3-a. Descripteur système de type Trap Gate▲

init_idt_desc(0x08, (u32) _asm_syscalls, 0xEF00, &kidt[48]); /* appels systeme - int 0x30 */

Nous avons vu ci-dessus qu'un appel système se fait très simplement grâce aux interruptions logicielles. Le noyau peut ainsi fournir des services aux applications utilisateur, mais comment passer des paramètres à ces services ? Deux solutions sont très courantes :

• passer les paramètres via la pile utilisateur ;
• passer les paramètres en les plaçant dans les registres, la plus simple à implémenter.

Nous allons voir comment implémenter la deuxième solution. Elle a le mérite d'être simple, mais le nombre réduit de registres sur les architectures i386 limite le nombre de paramètres que l'on peut passer par cette méthode (eax, ebx, ecx, edx, edi et esi).

Dans notre implémentation d'un appel système qui affiche une chaîne de caractères à l'écran, les registres utilisés sont :

• eax, qui contient le numéro d'appel système ;
• ebx, qui contient l'adresse de la chaîne de caractères à afficher.

Le code qui réalise l'appel :

asm("mov %0, %?x; mov $0x01, %?x; int $0x30" :: "m" (msg));

La routine de traitement de l'interruption est semblable à celle déjà vue pour les interruptions matérielles. Elle commence par sauvegarder les registres utilisateur et par initialiser le registre DS pour qu'il pointe sur le segment de données du noyau. Ensuite, elle pousse sur la pile le registre eax, qui contient le numéro de l'appel système, pour le transmettre à la fonction do_syscalls() appelée juste après :

_asm_syscalls:
        SAVE_REGS
        push eax                 ; transmission du numéro d'appel
        call do_syscalls
        pop eax
        RESTORE_REGS
        iret

La fonction do_syscalls() effectue le vrai travail de gestion de l'interruption. Le principe de cette fonction est simple :

• déterminer l'appel système grâce au numéro passé en argument à la fonction ;
• récupérer les paramètres de l'appel, placés dans les registres et poussés sur la pile

#include "types.h"
#include "gdt.h"
#include "screen.h"

void do_syscalls(int sys_num)
{
        u16 ds_select;
        u32 ds_base;
        struct gdtdesc *ds;
        uchar *message;

        if (sys_num == 1) {
                asm("   mov 44(%?p), %?x    \n \
                        mov %?x, %0           \n \
                        mov 24(%?p), %%ax     \n \
                        mov %%ax, %1" : "=m"(message), "=m"(ds_select) : );

                ds = (struct gdtdesc *) (GDTBASE + (ds_select & 0xF8));
                ds_base = ds->base0_15 + (ds->base16_23 << 16) + (ds->base24_31 << 24);

                print((char*) (ds_base + message));
        } else {
                print("syscall\n");
        }

        return;
}

XI-A-6-a. Que fait exactement cette fonction ?▲

void do_syscalls(int sys_num)

if (sys_num == 1) {

asm("   mov 44(%?p), %?x    \n \
        mov %?x, %0           \n \
        mov 24(%?p), %%ax     \n \ 
        mov %%ax, %1" : "=m" (message), "=m" (ds_select) : );

ds = (struct gdtdesc*) (GDTBASE + (ds_select & 0xF8));
ds_base = ds->base0_15 + (ds->base16_23 << 16) + (ds->base24_31 << 24);

print(ds_base + message);

} else {
    print("syscall\n");
}
return;

Nous avons déjà vu que dans le système de segmentation, une adresse physique est calculée à partir d'un sélecteur de segment et d'un offset. Avec la pagination activée, l'adresse obtenue par la segmentation est une adresse linéaire qui sera ensuite traduite en une adresse physique :

La pagination est un mécanisme d'adressage de la mémoire qui permet :

• de s'affranchir des limites en mémoire de l'ordinateur en utilisant le disque dur comme extension ;
• d'affecter à chaque tâche son propre espace d'adressage ;
• d'allouer et de désallouer dynamiquement de la mémoire de façon simple.

Quand la pagination est activée, le processeur découpe l'espace d'adressage linéaire (ou virtuel) et la mémoire physique en pages de taille fixe (généralement 4ko ou 4Mo) qui peuvent être associées librement. La traduction des adresses linéaires en adresses physiques est réalisée par le processeur grâce à plusieurs structures :

• le répertoire de pages (Page Directory) est un tableau dont les entrées pointent vers des tables de pages. Son adresse est stockée dans le registre CR3 ;
• les tables de pages (Page Table) sont des tableaux dont les entrées sont des pointeurs vers des pages.

Le schéma ci-dessous illustre l'association entre des pages en mémoire linéaire (ou virtuelle) et en mémoire physique par l'unité de pagination de la MMU (Memory Management Unit) :

La traduction d'une adresse linéaire en une adresse physique se fait en plusieurs étapes :

1. Le processeur utilise le registre CR3 pour connaître l'adresse physique du répertoire de pages ;
2. Les 10 premiers bits de l'adresse linéaire forment un offset, entre 0 et 1023, qui pointe sur une entrée de ce répertoire de pages ;
3. Cette entrée du répertoire contient l'adresse physique d'une table de pages ;
4. Les 10 bits suivants de l'adresse linéaire forment un offset qui pointe sur une entrée de cette table de pages ;
5. L'entrée sélectionnée dans la table de pages pointe sur une page de 4 ko ;
6. Les 12 derniers bits de l'adresse linéaire forment un offset, d'une valeur comprise entre 0 et 4095. Ce déplacement permet de pointer sur une adresse précise en mémoire.

Les entrées de ces deux tableaux se ressemblent beaucoup. Seuls les champs en grisé seront utilisés dans nos premières implémentations :

• le bit P indique si la page ou la table pointée est en mémoire physique ;
• le bit R/W indique si la page ou la table est accessible en écriture (bit à 1) ;
• le bit U/S est à 1 pour permettre l'accès aux tâches non privilégiées ;
• le bit PWT et le bit PCD sont liés à la gestion du cache des pages, que nous ne verrons pas pour le moment ;
• le bit A indique si la page ou la table a été accédée ;
• le bit D (table de pages seulement) indique si la page a été écrite ;
• le bit PS (répertoire de pages seulement) indique la taille des pages (bit à 0 pour 4 ko et à 1 pour 4 Mo) ;
• le bit G est lié à la gestion du cache des pages ;
• le champ Avail. est librement utilisable.

On peut noter que les adresses physiques du répertoire de pages ou de la table des pages sont… sur 20 bits ! En fait, ces adresses doivent être alignées sur 4 ko, ce qui signifie que les 12 bits de poids faible doivent être à 0. Le processeur forme cette adresse à partir des 20 bits de poids fort et la complète avec 12 bits à 0. Nous avions déjà vu ce type de mécanisme avec les sélecteurs de segment de la GDT.

XII-A-3-a. Un peu d'arithmétique▲

Le TLB (Translation Lookaside Buffer) est un cache des répertoires et des tables des pages utilisés afin d'accélérer la traduction d'adresse. Quand un répertoire ou une table des pages sont modifiés, les pages concernées doivent être immédiatement invalidées dans le TLB. Dans un premier temps, nous n'aurons pas besoin de nous préoccuper de ces détails.

Pour activer la pagination, il suffit de passer le bit 31 du registre CR0 à 1 :

asm("  mov %%cr0, %?x; \
       or %1, %?x;     \
       mov %?x, %%cr0" \
       :: "i"(0x80000000));

Bien entendu, pour que cela fonctionne, il faut au préalable avoir initialisé un répertoire et au moins une table des pages !

Dans cette première implémentation, nous allons activer la pagination pour le noyau tel que les quatre premiers Mo de mémoire virtuelle coïncident avec les 4 premiers Mo de mémoire physique :

Ce modèle est simple : la première page en mémoire virtuelle correspond à la première page en mémoire physique, la deuxième page en mémoire virtuelle correspond à la deuxième en mémoire physique et ainsi de suite…

Nous avons vu dans les chapitres précédents que notre noyau est tout petit et qu'il loge dans moins de 64 ko, nous allons adopter l'organisation suivante :

• le code et les données du noyau occupent l'espace entre l'adresse 0x0 et 0x10000 ;
• la pile du noyau utilise l'espace entre l'adresse 0x10000 et 0x20000 ;
• le répertoire de pages sera chargé à l'adresse 0x20000 ;
• pour adresser 4 Mo, une seule table de pages suffit. Elle sera en 0x21000.

Les entrées du répertoire et de la table seront initialisées avec les valeurs suivantes :

• le bit 0 et le bit 1 mis à 1 indiquent que les pages/tables pointées sont présentes en mémoire et qu'elles sont en lecture et en écriture ;
• le bit 2 est à 0 pour indiquer que leur accès est réservé au noyau ;
• le bit 7 du répertoire est à 0 pour indiquer que les pages font 4 ko.

La fonction init_mm() initialise le répertoire et les tables de pages du noyau et active la pagination :

#include "types.h"

#define PAGING_FLAG     0x80000000      /* CR0 - bit 31 */

#define PD0_ADDR 0x20000        /* addr. page directory kernel */
#define PT0_ADDR 0x21000        /* addr. page table[0] kernel */

/* créé un mapping tel que vaddr = paddr sur 4Mo */
void init_mm(void)
{
        u32 *pd0;       /* kernel page directory */
        u32 *pt0;       /* kernel page table */
        u32 page_addr;
        int i;

        /* Création du Page Directory */
        pd0 = (u32 *) PD0_ADDR;
        pd0[0] = PT0_ADDR;
        pd0[0] |= 3;
        for (i = 1; i < 1024; i++)
                pd0[i] = 0;


        /* Création de la Page Table[0] */
        pt0 = (u32 *) PT0_ADDR;
        page_addr = 0;
        for (i = 0; i < 1024; i++) {
                pt0[i] = page_addr;
                pt0[i] |= 3;
                page_addr += 4096;
        }

        asm("   mov %0, %?x    \n \
                mov %?x, %%cr3 \n \
                mov %%cr0, %?x \n \
                or %1, %?x     \n \
                mov %?x, %%cr0" :: "i"(PD0_ADDR), "i"(PAGING_FLAG));
}

XII-B-2-a. Que fait exactement cette fonction ?▲

pd0 = (u32 *) PD0_ADDR;

pd0[0] = PT0_ADDR;
pd0[0] |= 3;

for (i = 1; i < 1024; i++)
        pd0[i] = 0;

/* Création de la Page Table[0] */
pt0 = (u32 *) PT0_ADDR;
page_addr = 0;
for (i = 0; i < 1024; i++) {
        pt0[i] = page_addr;
        pt0[i] |= 3;
        page_addr += 4096;
}

init_idt_desc(0x08, (u32) _asm_exc_PF, INTGATE, &kidt[14]); /* #PF */

Lorsque le processeur tente d'accéder à une page qui n'est pas présente en mémoire physique, il déclenche une exception de type Page Fault. L'adresse qui a provoqué le défaut de page est stockée dans le registre CR2. À partir de cette adresse et selon le contexte d'exécution qui a provoqué l'exception, la routine de traitement devrait au choix :

• terminer le programme en renvoyant une erreur de type segmentation fault ;
• charger en mémoire la page qui était temporairement stockée sur le disque dur dans la zone de swap ;
• allouer une page.

Dans notre cas, le noyau va simplement afficher un message d'erreur et stopper.

La première étape du gestionnaire est d'initialiser le bitmap de façon à marquer les pages déjà occupées/réservées. L'espace physique sera organisé de la façon suivante :

On remarque que la tâche utilisateur sera chargée physiquement à l'adresse 0x100000. C'est un choix arbitraire et très simplifié qui nous servira à mettre au point la pagination dans le contexte d'une tâche utilisateur. Nous verrons dans les chapitres suivants comment mettre au point un vrai gestionnaire de mémoire.

Les pages utilisées par le noyau ainsi que celles utilisées par le hardware doivent être marquées comme étant prises :

/* Initialisation du bitmap de pages physiques */
for (pg = 0; pg < RAM_MAXPAGE / 8; pg++)
        mem_bitmap[pg] = 0;

/* Pages réservées pour le noyau */
for (pg = PAGE(0x0); pg < PAGE(0x20000); pg++)
        set_page_frame_used(pg);

/* Pages réservées pour le hardware */
for (pg = PAGE(0xA0000); pg < PAGE(0x100000); pg++)
        set_page_frame_used(pg);

Ce bout de code fait appel à deux macros :

• PAGE(addr) calcule, pour une adresse donnée, le numéro de page physique à laquelle elle appartient ;
• set_page_frame_used(page) met à jour le bitmap pour indiquer qu'une page est utilisée.

Mais il existe également d'autres macros et fonctions indispensables à la gestion des pages physiques :

• réserver une page libre : get_page_frame() ;
• désallouer une page occupée pour la rendre libre : release_page_frame() ;

Toutes ces fonctions sont dans le fichier mm.c et dans le fichier mm.h

mm.c :

#include "types.h"


#define __MM__
#include "mm.h"


/*
 * Parcourt le bitmap à la recherche d'une page libre et la marque
 * comme utilisée avant de retourner son adresse physique.
 */
char* get_page_frame(void)
{
        int byte, bit;
        int page = -1;

        for (byte = 0; byte < RAM_MAXPAGE / 8; byte++)
                if (mem_bitmap[byte] != 0xFF)
                        for (bit = 0; bit < 8; bit++)
                                if (!(mem_bitmap[byte] & (1 << bit))) {
                                        page = 8 * byte + bit;
                                        set_page_frame_used(page);
                                        return (char *) (page * PAGESIZE);
                                }
        return (char *) -1;
}

/* Créé un mapping tel que vaddr = paddr sur 4Mo */
void init_mm(void)
{
        u32 page_addr;
        int i, pg;

        /* Initialisation du bitmap de pages physiques */
        for (pg = 0; pg < RAM_MAXPAGE / 8; pg++)
                mem_bitmap[pg] = 0;

        /* Pages réservées pour le noyau */
        for (pg = PAGE(0x0); pg < PAGE(0x20000); pg++) 
                set_page_frame_used(pg);

        /* Pages réservées pour le hardware */
        for (pg = PAGE(0xA0000); pg < PAGE(0x100000); pg++) 
                set_page_frame_used(pg);

        /* Prend une page pour le Page Directory et une pour la Page Table[0] */
        pd0 = (u32*) get_page_frame();
        pt0 = (u32*) get_page_frame();

        /* Initialisation du Page Directory */
        pd0[0] = (u32) pt0;
        pd0[0] |= 3;
        for (i = 1; i < 1024; i++)
                pd0[i] = 0;

        /* Initialisation de la Page Table[0] */
        page_addr = 0;
        for (pg = 0; pg < 1024; pg++) {
                pt0[pg] = page_addr;
                pt0[pg] |= 3;
                page_addr += 4096;
        }

        asm("   mov %0, %?x \n \
                mov %?x, %%cr3 \n \
                mov %%cr0, %?x \n \
                or %1, %?x \n \
                mov %?x, %%cr0"::"m"(pd0), "i"(PAGING_FLAG));
}

/* Crée un répertoire de pages pour une tâche */
u32 *pd_create_task1(void)
{
        u32 *pd, *pt;
        u32 i;

        /* Prend et initialise une page pour le Page Directory */
        pd = (u32*) get_page_frame();
        for (i = 0; i < 1024; i++)
                pd[i] = 0;

        /* Prend et initialise une page pour la Page Table[0] */
        pt = (u32*) get_page_frame();
        for (i = 0; i < 1024; i++)
                pt[i] = 0;

        /* Espace kernel */
        pd[0] = pd0[0];
        pd[0] |= 3;

        /* Espace u */
        pd[USER_OFFSET >> 22] = (u32) pt;
        pd[USER_OFFSET >> 22] |= 7;

        pt[0] = 0x100000;
        pt[0] |= 7;

        return pd;
}

mm.h :

#include "types.h"

#define PAGESIZE        4096
#define RAM_MAXPAGE     0x10000

#define VADDR_PD_OFFSET(addr)   ((addr) & 0xFFC00000) >> 22
#define VADDR_PT_OFFSET(addr)   ((addr) & 0x003FF000) >> 12
#define VADDR_PG_OFFSET(addr)   (addr) & 0x00000FFF
#define PAGE(addr)              (addr) >> 12

#define PAGING_FLAG 0x80000000  /* CR0 - bit 31 */
#define USER_OFFSET 0x40000000
#define USER_STACK  0xE0000000

#ifdef __MM__
u32 *pd0;                       /* kernel page directory */
u32 *pt0;                       /* kernel page table */
u8 mem_bitmap[RAM_MAXPAGE / 8]; /* bitmap allocation de pages (1 Go) */
#endif

struct pd_entry {
        u32 present:1;
        u32 writable:1;
        u32 user:1;
        u32 pwt:1;
        u32 pcd:1;
        u32 accessed:1;
        u32 _unused:1;
        u32 page_size:1;
        u32 global:1;
        u32 avail:3;

        u32 page_table_base:20;
} __attribute__ ((packed));

struct pt_entry {
        u32 present:1;
        u32 writable:1;
        u32 user:1;
        u32 pwt:1;
        u32 pcd:1;
        u32 accessed:1;
        u32 dirty:1;
        u32 pat:1;
        u32 global:1;
        u32 avail:3;

        u32 page_base:20;
} __attribute__ ((packed));


/* Marque une page comme utilisée/libre dans le bitmap */
#define set_page_frame_used(page)       mem_bitmap[((u32) page)/8] |= (1 << (((u32) page)%8))
#define release_page_frame(p_addr)      mem_bitmap[((u32) p_addr/PAGESIZE)/8] &= ~(1 << (((u32) p_addr/PAGESIZE)%8))

/* Sélectionne une page libre dans le bitmap */
char *get_page_frame(void);

/* Initialise les structures de données de gestion de la mémoire */
void init_mm(void);

/* Crée un répertoire de pages pour une tâche */
u32 *pd_create_task1(void);

Bien que présent dans son espace d'adressage virtuel, la tâche ne doit pas pouvoir accéder à l'espace du noyau à tout moment : cela constituerait un gros problème de sécurité. Pour empêcher la tâche en mode utilisateur d'accéder à l'espace noyau hors d'un appel système, il suffit de positionner le bit US des entrées du répertoire et des tables de pages à :

• 0 (espace privilégié) pour les pages du noyau ;
• 1 (espace non privilégié) pour les pages de l'espace utilisateur.

Nous voulons que la tâche accède au noyau uniquement via des services précis, en l'occurrence des appels système. Le processeur, jusque là en mode utilisateur (ring 3), passe alors en mode noyau (ring 0). Pour distinguer ces deux états, on dit que la tâche s'exécute en mode utilisateur ou en mode noyau.

Pour servir d'exemple, la tâche à exécuter est une fonction très simple, presque identique à celle utilisée au chapitre traitant des appels systèmeLes appels système : un noyau monotâche qui implémente des appels système. La seule différence concerne l'adressage :

• selon notre organisation de la mémoire, la tâche va s'exécuter à l'adresse virtuelle 0x40000000 ;
• dans notre exemple, la tâche sera chargée physiquement à l'adresse 0x100000 ;
• cela signifie que le bloc de mémoire virtuelle commençant en 0x40000000 sera mappé sur le bloc de mémoire physique en 0x100000 grâce au répertoire et aux tables de pages.

Le code ci-dessus recopie les caractères à cet emplacement puis fait un appel système pour afficher la chaîne :

void task1(void)
{
       char *msg = (char*) 0x40000100; /* le message sera stocké en 0x100100 */
       msg[0] = 't';
       msg[1] = 'a';
       msg[2] = 's';
       msg[3] = 'k';
       msg[4] = '1';
       msg[5] = '\n';
       msg[6] = 0;

       asm("mov %0, %?x; mov $0x01, %?x; int $0x30" :: "m" (msg));
       while(1);
       return; /* never go there */
}

Dans le modèle d'organisation de la mémoire, nous avons décidé que la tâche serait en 0x100000 en mémoire physique. Cette fonction occupe au maximum 100 octets, la fonction ci-dessous effectue la copie du code à la bonne adresse :

memcpy((u32*) 0x100000, &task1, 100); /* copie de 100 instructions */

L'utilisation de la pagination repose sur le mode protégé qui implique l'utilisation de la segmentation. Il faut donc créer des descripteurs de segments pour le code, les données et la pile utilisateur. Pour simplifier le modèle, ces segments parcourent toute la mémoire :

init_gdt_desc(0x0, 0xFFFFF, 0xFF, 0x0D, &kgdt[4]); /* ucode */
init_gdt_desc(0x0, 0xFFFFF, 0xF3, 0x0D, &kgdt[5]); /* udata */
init_gdt_desc(0x0, 0x0,     0xF7, 0x0D, &kgdt[6]); /* ustack */

Il faut également créer et initialiser le répertoire et les tables de pages propres à la tâche utilisateur. C'est le rôle de la fonction pd_create_task1(). Elle utilise les fonctions d'allocation et de désallocation de pages de la mémoire physique pour y stocker les répertoires et les tables de pages :

u32 *pd_create_task1(void)
{
        u32 *pd, *pt;
        u32 i;

        /* Prend et initialise une page pour le Page Directory */
        pd = (u32*) get_page_frame();
        for (i = 0; i < 1024; i++)
                pd[i] = 0;

        /* Prend et initialise une page pour la Page Table[0] */
        pt = (u32*) get_page_frame();
        for (i = 0; i < 1024; i++)
                pt[i] = 0;

        /* Espace kernel */
        pd[0] = pd0[0];
        pd[0] |= 3;

        /* Espace u */
        pd[USER_OFFSET >> 22] = (u32) pt;
        pd[USER_OFFSET >> 22] |= 7;

        pt[0] = 0x100000;
        pt[0] |= 7;

        return pd;
}

Nous allons tout d'abord détailler comment la fonction schedule() sauvegarde les registres de la tâche en cours (celle qui a été interrompue) dans la structure qui lui est dédiée et pointée par current.

Les registres à sauvegarder ont déjà été empilés sur la pile noyau par l'interruption d'horloge (ss, esp, eflags, cs et eip) et par l'appel explicite aux instructions pushad et push.

La sauvegarde des registres se fait dans la structure struct process associée à la tâche encore en cours et pointée par current :

struct process {
        unsigned int pid;

        struct {
                u32 eax, ecx, edx, ebx;
                u32 esp, ebp, esi, edi;
                u32 eip, eflags;
                u32 cs:16, ss:16, ds:16, es:16, fs:16, gs:16;
                u32 cr3;
        } regs __attribute__ ((packed));
} __attribute__ ((packed));

Le procédé pour récupérer ces valeurs sur la pile repose sur l'utilisation du registre ebp (voir pour plus de détails la partie sur les Stack FrameAnnexe D - Gérer les arguments sur la pile avec les Stack Frame). La variable stack_ptr adresse la pile de façon à pouvoir ensuite récupérer facilement le contenu des registres sauvegardés lors de l'interruption :

/* stocke dans stack_ptr le pointeur vers les registres sauvegardes */
asm("mov (%?p), %?x; mov %?x, %0" : "=m" (stack_ptr) : );

/* sauve l'ensemble des registres */
current->regs.ss  = stack_ptr[18];
current->regs.esp = stack_ptr[17];
current->regs.eflags = stack_ptr[16];
/* etc... */

L'ordonnanceur choisit une nouvelle tâche et fait pointer la variable current vers la structure de la nouvelle tâche à activer :

/* Choix du nouveau processus (un simple round robin) */
if (n_proc > current->pid+1)
        current = &p_list[current->pid+1];
else 
        current = &p_list[0];

Une fois que l'ancienne tâche est sauvegardée et que la nouvelle tâche est choisie, le scheduler doit charger les registres du processeur avec les valeurs sauvegardées précédemment avant de commuter.

En premier lieu, le pointeur de pile noyau du TSS est initialisé de façon à ce que :

• la pile noyau, sur laquelle des registres ont été sauvegardés, soit nettoyée une fois la commutation effectuée ;
• la pile noyau soit préparée pour la nouvelle tâche.

default_tss.esp0 = (u32) (stack_ptr + 19);

Ensuite, les valeurs sauvegardées correspondant aux registres ss, esp, eflags, cs et eip sont empilées afin de préparer la commutation. La fonction do_switch() est appelée pour effectuer la commutation proprement dite :

asm("   mov %0, %%esp; \
        push %1; \
        push %2; \
        push %3; \
        push %4; \
        push %5; \
        push %6; \
        ljmp $0x08, $do_switch" \
        :: \
        "m" (esp0), \
        "m" (ss), \
        "m" (current->regs.esp), \
        "m" (eflags), \
        "m" (cs), \
        "m" (current->regs.eip), \
        "m" (current)
);

XIV-B-3-a. La fonction do_switch()▲

global do_switch

do_switch:
        ; recuper l'adresse de *current 
        mov esi, [esp]
        pop eax                 ; depile @current

        ; prépare les registres
        push dword [esi+4]      ; eax
        push dword [esi+8]      ; ecx
        push dword [esi+12]     ; edx
        push dword [esi+16]     ; ebx
        push dword [esi+24]     ; ebp
        push dword [esi+28]     ; esi
        push dword [esi+32]     ; edi
        push dword [esi+48]     ; ds
        push dword [esi+50]     ; es
        push dword [esi+52]     ; fs
        push dword [esi+54]     ; gs

        ; enlève le mask du PIC
        mov al, 0x20
        out 0x20, al

        ; charge table des pages
        mov eax, [esi+56]
        mov cr3, eax

        ; charge les registres
        pop gs
        pop fs
        pop es
        pop ds
        pop edi
        pop esi
        pop ebp
        pop ebx
        pop edx
        pop ecx
        pop eax

        ; retourne 
        iret

Dans cette première implémentation, les tâches ne peuvent êtres préemptées alors qu'elles réalisent un appel système, car le partage de la pile noyau conduirait à des incohérences. Il faut donc désactiver les interruptions lors des appels. Cela se fait par le choix d'un INTGATE à la place d'un TRAPGATE :

init_idt_desc(0x08, (u32) _asm_syscalls, INTGATE|0x6000, &kidt[48]); /* appels systeme - int 0x30 */

Quand une tâche fait un appel système, la pile noyau est automatiquement utilisée par le processeur. Les routines de traitement de cet appel utilisent alors cette pile pour stocker des données, passer des paramètres à des fonctions, etc. Une fois que l'appel système est terminé, les données temporaires sont dépilées et la pile noyau retourne à son état initial, tel qu'elle était avant l'appel.

Si l'on autorise les interruptions et la commutation de tâches pendant un appel système, voilà ce qui risque de se passer :

1. Par exemple, la tâche A fait un appel système et utilise la pile noyau pour traiter cet appel ;
2. L'ordonnanceur est activé alors que l'appel n'est pas terminé et il donne la main à la tâche B ;
3. La tâche B fait elle aussi un appel système, et elle utilise donc elle aussi la pile du noyau qui contenait déjà les données en cours pour le traitement de l'appel de la tâche A. À ce moment, la pile noyau contient des données de A et des données de B ;
4. L'ordonnanceur active de nouveau la tâche A et celle-ci reprend sans se douter que la pile a été modifiée. Comme elle va utiliser la pile en supposant qu'elle est dans l'état où elle l'avait laissé, elle va corrompre les données de la tâche B ;
5. La tâche B reprend, mais la pile est corrompue… et c'est le drame !

Pour éviter ce scénario catastrophe, il existe une solution très simple : il suffit que chaque tâche ait sa propre pile noyau !

La fonction load_task() est modifiée afin d'associer à chaque tâche sa propre pile noyau : process.c.

#include "lib.h"
#include "mm.h"

#define __PLIST__
#include "process.h"


void load_task(u32 * code_phys_addr, u32 * fn, unsigned int code_size)
{
        u32 page_base, pages, kstack_base;
        u32 *pd;
        int i;

        /* Copie du code a l'adresse spécifiée */
        memcpy((char *) code_phys_addr, (char *) fn, code_size);

        /* Mise a jour du bitmap */
        page_base = (u32) PAGE(code_phys_addr);

        if (code_size % PAGESIZE)
                pages = code_size / PAGESIZE + 1;
        else
                pages = code_size / PAGESIZE;

        for (i = 0; i < pages; i++)
                set_page_frame_used(page_base + i);

        /* Création du répertoire et des tables de pages */
        pd = pd_create(code_phys_addr, code_size);

        kstack_base = (u32) get_page_frame();
        if (kstack_base > 0x400000) {
                printk("not enough memory to create a kernel stack\n");
                return;
        }

        /* Initialisation des registres */
        p_list[n_proc].pid = n_proc;
        p_list[n_proc].regs.ss = 0x33;
        p_list[n_proc].regs.esp = 0x40001000;
        p_list[n_proc].regs.eflags = 0x0;
        p_list[n_proc].regs.cs = 0x23;
        p_list[n_proc].regs.eip = 0x40000000;
        p_list[n_proc].regs.ds = 0x2B;
        p_list[n_proc].regs.es = 0x2B;
        p_list[n_proc].regs.fs = 0x2B;
        p_list[n_proc].regs.gs = 0x2B;
        p_list[n_proc].regs.cr3 = (u32) pd;

        p_list[n_proc].kstack.ss0 = 0x18;
        p_list[n_proc].kstack.esp0 = kstack_base + PAGESIZE;

        p_list[n_proc].regs.eax = 0;
        p_list[n_proc].regs.ecx = 0;
        p_list[n_proc].regs.edx = 0;
        p_list[n_proc].regs.ebx = 0;

        p_list[n_proc].regs.ebp = 0;
        p_list[n_proc].regs.esi = 0;
        p_list[n_proc].regs.edi = 0;

        n_proc++;
}

Le code ci-dessous alloue à une tâche sa propre pile noyau. Par simplicité, une pile occupe une page :

kstack_base = (u32) get_page_frame();

/* ... */

p_list[n_proc].kstack.ss0 = 0x18;
p_list[n_proc].kstack.esp0 = kstack_base + PAGESIZE;

Suite à une interruption, le processeur empile automatiquement des données sur la pile noyau de la tâche interrompue, sans compter celles ajoutées par les différentes routines du noyau. Il est crucial qu'à l'issue d'une interruption, la pile noyau utilisée soit remise dans le même état qu'avant l'interruption.

La complexité de l'ordonnanceur provient essentiellement des difficultés induites par la gestion des différentes piles noyau et utilisateur.

Le code de l'ordonnanceur est réparti dans deux fichiers :

• schedule.c contient la partie préparatoire au changement de contexte

#include "types.h"
#include "gdt.h"
#include "process.h"


void switch_to_task(int n, int mode)
{
        u32 kesp, eflags;
        u16 kss, ss, cs;

        current = &p_list[n];

        /* charger tss */
        default_tss.ss0 = current->kstack.ss0;
        default_tss.esp0 = current->kstack.esp0;

        /* 
         * Empile les registres ss, esp, eflags, cs et eip nécessaires a la
         * commutation. Ensuite, la fonction do_switch() restaure les
         * registres, la table de pages du nouveau processus courant et commute
         * avec l'instruction iret.
         */
        ss = current->regs.ss;
        cs = current->regs.cs;
        eflags = (current->regs.eflags | 0x200) & 0xFFFFBFFF;

        if (mode == USERMODE) {
                kss = current->kstack.ss0;
                kesp = current->kstack.esp0;
        } else {                /*KERNELMODE */
                kss = current->regs.ss;
                kesp = current->regs.esp;
        }

        asm("   mov %0, %%ss; \
                mov %1, %%esp; \
                cmp %[KMODE], %[mode]; \
                je next; \
                push %2; \
                push %3; \
                next: \
                push %4; \
                push %5; \
                push %6; \
                push %7; \
                ljmp $0x08, $do_switch"
                :: \
                "m"(kss), \
                "m"(kesp), \
                "m"(ss), \
                "m"(current->regs.esp), \
                "m"(eflags), \
                "m"(cs), \
                "m"(current->regs.eip), \
                "m"(current), \
                [KMODE] "i"(KERNELMODE), \
                [mode] "g"(mode)
            );
}

void schedule(void)
{
        struct process *p;
        u32 *stack_ptr;

        /* Stocke dans stack_ptr le pointeur vers les registres sauvegardes */
        asm("mov (%?p), %?x; mov %?x, %0": "=m"(stack_ptr) : );

        /* S'il n'y a pas de processus charge et qu'au moins un est prêt, on le charge */
        if (current == 0 && n_proc) {
                switch_to_task(0, USERMODE);
        }
        /* 
         * S'il y a un seul processus (qu'on laisse tourner) ou aucun
         * processus, on retourne directement.
         */
        else if (n_proc <= 1) {
                return;
        }
        /* S'il y a au moins deux processus, on commute vers le suivant */
        else if (n_proc > 1) {
                /* Sauver les registres du processus courant */
                current->regs.eflags = stack_ptr[16];
                current->regs.cs = stack_ptr[15];
                current->regs.eip = stack_ptr[14];
                current->regs.eax = stack_ptr[13];
                current->regs.ecx = stack_ptr[12];
                current->regs.edx = stack_ptr[11];
                current->regs.ebx = stack_ptr[10];
                current->regs.ebp = stack_ptr[8];
                current->regs.esi = stack_ptr[7];
                current->regs.edi = stack_ptr[6];
                current->regs.ds = stack_ptr[5];
                current->regs.es = stack_ptr[4];
                current->regs.fs = stack_ptr[3];
                current->regs.gs = stack_ptr[2];

                if (current->regs.cs != 0x08) {
                        current->regs.esp = stack_ptr[17];
                        current->regs.ss = stack_ptr[18];
                } else {        /* Interruption pendant un appel systeme */
                        current->regs.esp = stack_ptr[9] + 12;
                        current->regs.ss = default_tss.ss0;
                }

                /* Sauver le tss */
                current->kstack.ss0 = default_tss.ss0;
                current->kstack.esp0 = default_tss.esp0;

                /* Choix du nouveau processus (un simple roundrobin) */
                if (n_proc > current->pid + 1)
                        p = &p_list[current->pid + 1];
                else
                        p = &p_list[0];

                /* Commutation */
                if (p->regs.cs != 0x08)
                        switch_to_task(p->pid, USERMODE);
                else
                        switch_to_task(p->pid, KERNELMODE);
        }
}

• sched.asm contient le code qui effectue effectivement le changement de contexte

global do_switch

do_switch:
        ; récupérer l'adresse de *current 
        mov esi, [esp]
        pop eax                 ; depile @current

        ; prépare les registres
        push dword [esi+4]      ; eax
        push dword [esi+8]      ; ecx
        push dword [esi+12]     ; edx
        push dword [esi+16]     ; ebx
        push dword [esi+24]     ; ebp
        push dword [esi+28]     ; esi
        push dword [esi+32]     ; edi
        push dword [esi+48]     ; ds
        push dword [esi+50]     ; es
        push dword [esi+52]     ; fs
        push dword [esi+54]     ; gs

        ; enlève le mask du PIC
        mov al, 0x20
        out 0x20, al

        ; charge table des pages
        mov eax, [esi+56]
        mov cr3, eax

        ; charge les registres
        pop gs
        pop fs
        pop es
        pop ds
        pop edi
        pop esi
        pop ebp
        pop ebx
        pop edx
        pop ecx
        pop eax

        ; retourne 
        iret

Le design de l'ordonnanceur est plus compliqué, car :

• il doit prendre en compte le contexte de la tâche lors de son interruption ;
• chaque tâche a sa propre pile noyau ;
• l'ordonnanceur change de pile noyau pendant la commutation ;
• la pile noyau ne contient pas le même nombre de registres empilés selon que la tâche interrompue était en mode utilisateur ou en mode noyau. L'interruption d'une tâche en mode utilisateur provoque automatiquement l'empilement des registres ss, esp, eflags, cs et eip. Quand l'interruption survient alors que la tâche est en mode noyau, les seuls registres empilés sont : eflags, cs et eip.

Schémas de la pile noyau après l'interruption d'une tâche en mode utilisateur :

Schémas de la pile noyau après l'interruption d'une tâche en mode noyau :

Toutes les contraintes supportées par l'ordonnanceur peuvent se résumer à :

• sauvegarder les registres de la tâche interrompue ;
• remettre la pile noyau dans l'état précédent l'interruption avant de quitter celle-ci.

Le schéma suivant représente la pile noyau lors de l'appel à la fonction schedule() dans le cas où le processeur était en mode utilisateur lors de l'interruption :

Dans le cas où le processeur était en mode noyau au moment de l'interruption, le schéma est très sensiblement différent, car les registres ss et esp n'ont pas été empilés.

Notre but est de sauvegarder l'état de l'ensemble des registres de la tâche interrompue, ce qui ne pose aucun problème pour l'ensemble d'entre eux (eax, ebx, etc.). La seule difficulté est de retrouver les valeurs de ss et de esp juste avant l'interruption d'horloge, car si l'interruption est survenue pendant un appel système, on ne peut procéder de la même façon pour retrouver ces valeurs, car elles n'ont pas été empilées :

if (current->regs.cs != 0x08) {
    current->regs.esp = stack_ptr[17];
    current->regs.ss = stack_ptr[18];
}
else { /* interruption pendant un appel systeme */
    current->regs.esp = stack_ptr[9] + 12; /* equivalent a : &stack_ptr[17] */
    current->regs.ss = default_tss.ss0;
}

• Le premier cas est celui de l'interruption d'une tâche en mode utilisateur. L'appel système a sauvegardé tous les registres, dont ss et esp, sur la pile noyau de la tâche. C'est un cas assez simple déjà vu au chapitre précédent.

• Le deuxième cas concerne l'interruption d'une tâche en mode noyau. Le processeur utilisait la même pile avant l'interruption et esp pointait juste au sommet des registres empilés par l'interruption. Pour retrouver cette valeur, plusieurs calculs sont possibles :

  • stack_ptr[9] contient la valeur du pointeur de pile juste après l'interruption (et avant l'appel à push et à pushad). Avant l'interruption, esp pointait sur la même pile, mais juste avant les trois registres eflags, cs et eip empilés par l'interruption. Nous avons donc : 3 registres * 4 octets par registre = 12. stack_ptr[9] + 12 pointe donc au sommet de la pile,
  • le sommet de la pile est situé 17 registres au-dessus du pointeur stack_ptr, on pourrait donc utiliser l'un des deux calculs suivants : stack_ptr + 17 * 4 ou &stack_ptr[17].

Après avoir sélectionné une nouvelle tâche, pointée par *p, l'ordonnanceur teste si cette nouvelle tâche à activer avait été interrompue en mode utilisateur ou en mode noyau. La fonction switch_to_task() est appelée avec le pid de la tâche à activer et le mode dans lequel il faut l'activer :

/* commutation */
if (p->regs.cs != 0x08)
    switch_to_task(p->pid, USERMODE);
else
    switch_to_task(p->pid, KERNELMODE);

XV-A-3-a. La fonction switch_to_task()▲

ss = current->regs.ss;
cs = current->regs.cs;
eflags = (current->regs.eflags | 0x200) & 0xFFFFBFFF;

if (mode == USERMODE) {
    kss = current->kstack.ss0;
    kesp = current->kstack.esp0;
}
else { /*KERNELMODE */
    kss = current->regs.ss;
    kesp = current->regs.esp;
}

asm("   mov %0, %%ss; \
        mov %1, %%esp; \
        cmp %[KMODE], %[mode]; \
        je next; \
        push %2; \
        push %3; \
        next: \
        push %4; \
        push %5; \
        push %6; \
        push %7; \
        ljmp $0x08, $do_switch" \
        :: \
        "m" (kss), \
        "m" (kesp), \
        "m" (ss), \
        "m" (current->regs.esp), \
        "m" (eflags), \
        "m" (cs), \
        "m" (current->regs.eip), \
        "m" (current), \
        [KMODE] "i" (KERNELMODE), \
        [mode] "g" (mode)
);

global _start, start
extern kmain
    
?fine MULTIBOOT_HEADER_MAGIC  0x1BADB002
?fine MULTIBOOT_HEADER_FLAGS  0x00000003
?fine CHECKSUM -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS)


_start:
        jmp start

; The Multiboot header
align 4
multiboot_header:
dd MULTIBOOT_HEADER_MAGIC
dd MULTIBOOT_HEADER_FLAGS
dd CHECKSUM     
; ----- Multiboot Header Ends Here -----

start:
        push ebx
        call kmain

        cli ; stop interrupts
        hlt ; halt the CPU

XVI-B-1-a. Le programme principal ▲

void printk(char*, ...);

struct mb_partial_info {
        unsigned long flags;
        unsigned long low_mem;
        unsigned long high_mem;
        unsigned long boot_device;
        unsigned long cmdline;
};
        
void kmain(struct mb_partial_info *mbi)
{
        printk("Grub example kernel is loaded...\n");
        printk("RAM detected : %uk (lower), %uk (upper)\n", mbi->low_mem, mbi->high_mem);
        printk("Done.\n");
}