Travaux Pratiques Guidés :

Création d’un Système d’Exploitation Minimaliste

B. Tanguy KABORE

30 juin 2025

Table des matières

1 Contexte 3
1.1 Introduction aux systèmes d’exploitation . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Intérêt pédagogique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Objectifs pédagogiques 3

3 Architecture de Mini-OS 4
3.1 Composants principaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

4 Prérequis 4
4.1 Connaissances recommandées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.2 Environnement technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.3 Installation des outils nécessaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.3.1 Installation sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.3.2 Installation sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.3.3 Installation sous macOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

5 Vérification de l’environnement 6

6 Structure du TP 6

7 Introduction à la conception d’un OS minimaliste 7

7.1 Révision du processus de démarrage . . . . . . . . . . . . . . . . . . . . . . . . . 7
7.2 Structure d’un secteur de démarrage . . . . . . . . . . . . . . . . . . . . . . . . . 7

8 Développement du bootloader 7
8.1 Approche 1 : Création manuelle du bootloader . . . . . . . . . . . . . . . . . . . . 7
8.1.1 Structure du code en octets . . . . . . . . . . . . . . . . . . . . . . . . . . 8
8.1.2 Utilisation et exécution du bootloader manuel . . . . . . . . . . . . . . . . 8
8.1.3 Implémentation du script PowerShell . . . . . . . . . . . . . . . . . . . . . 10
8.1.4 Explication détaillée du script . . . . . . . . . . . . . . . . . . . . . . . . . 12
8.1.5 Exercice pratique : Modification du bootloader . . . . . . . . . . . . . . . 13
8.2 Approche 2 : Développement en assembleur NASM . . . . . . . . . . . . . . . . . 13
8.2.1 Structure du code assembleur . . . . . . . . . . . . . . . . . . . . . . . . . 14

1
Systèmes d’exploitation avancés TP Mini-OS

8.2.2 Explication du code assembleur . . . . . . . . . . . . . . . . . . . . . . . . 16

8.2.3 Compilation avec NASM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
8.2.4 Script d’automatisation complet . . . . . . . . . . . . . . . . . . . . . . . 16

9 Travaux pratiques et exercices 19

9.1 TP 1 : Création du bootloader basique . . . . . . . . . . . . . . . . . . . . . . . . 19
9.2 TP 2 : Modification du bootloader . . . . . . . . . . . . . . . . . . . . . . . . . . 20

10 Évaluation des connaissances 20

10.1 Questions théoriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
10.2 Mini-projet : Extension du bootloader . . . . . . . . . . . . . . . . . . . . . . . . 21

11 Conclusion et perspectives 21

Année 2025 Page 2

Systèmes d’exploitation avancés TP Mini-OS

1 Contexte
1.1 Introduction aux systèmes d’exploitation
Les systèmes d’exploitation constituent la couche logicielle fondamentale qui permet l’inter-
action entre le matériel informatique et les logiciels applicatifs. Ils jouent un rôle central dans
tout système informatique moderne, assurant :
— La gestion des ressources matérielles (processeur, mémoire, périphériques)
— L’abstraction du matériel via des interfaces standardisées
— Le partage sécurisé des ressources entre applications
— L’exécution des programmes et la coordination des tâches
Comprendre le fonctionnement interne d’un système d’exploitation représente un défi consi-
dérable pour les étudiants en informatique, car il nécessite des connaissances avancées en archi-
tecture des ordinateurs, en programmation bas niveau, et en conception de systèmes complexes.

1.2 Intérêt pédagogique

Ce TP guidé propose une approche progressive pour démystifier les systèmes d’exploitation
en créant un OS minimaliste appelé Mini-OS. Nous nous concentrerons sur les aspects fonda-
mentaux :
— Le processus de démarrage d’un ordinateur (boot sequence)
— La programmation en assembleur x86 et l’interaction avec le BIOS
— La création d’images disque bootables
— Les fondamentaux des modes d’opération du processeur
En développant Mini-OS, vous acquerrez une compréhension pratique et concrète des mé-
canismes sous-jacents qui permettent à un ordinateur de démarrer et d’exécuter un système
d’exploitation, avant même que les fonctionnalités avancées comme la gestion des processus ou
les systèmes de fichiers n’entrent en jeu.

2 Objectifs pédagogiques
À l’issue de ce TP guidé, vous serez capable de :

Objectifs d’apprentissage

— Comprendre le processus de démarrage d’un ordinateur de type PC

— Maîtriser les bases de la programmation en assembleur x86 16-bits
— Développer un bootloader minimal capable d’afficher du texte à l’écran
— Créer une image disque bootable contenant votre système
— Tester votre OS dans un environnement d’émulation
— Appréhender les fondements théoriques des composants d’un OS

Ce TP constitue une base solide pour aborder ultérieurement des concepts plus avancés tels
que le mode protégé, la pagination mémoire, l’ordonnancement des processus, et les systèmes de
fichiers.

Année 2025 Page 3

Systèmes d’exploitation avancés TP Mini-OS

3 Architecture de Mini-OS
Mini-OS v1 est un système d’exploitation minimaliste conçu pour illustrer les principes fon-
damentaux du démarrage d’un système informatique. Sa structure est volontairement simple :

— Démarrage
Bootloader (512 octets) — Initialisation basique
— Affichage texte
— Boucle infinie
BIOS

Matériel (CPU, mémoire, ...)

Figure 1 – Architecture simplifiée de Mini-OS v1

3.1 Composants principaux

— Bootloader (512 octets) - Le composant central et unique de notre système qui :
— Est chargé par le BIOS à l’adresse 0x7C00 en mémoire
— Initialise les segments de base (code, données, pile)
— Utilise les interruptions BIOS pour afficher du texte à l’écran
— Se termine par une boucle infinie pour maintenir le système actif
— Image disque (1.44 Mo) - Contient le bootloader dans son premier secteur (secteur de
démarrage)

4 Prérequis
4.1 Connaissances recommandées
Pour tirer le meilleur parti de ce TP, il est recommandé d’avoir :
— Des notions d’architecture des ordinateurs (CPU, mémoire, bus)
— Une familiarité basique avec au moins un langage de programmation
— Des connaissances élémentaires en représentation binaire et hexadécimale
— Une compréhension générale du rôle d’un système d’exploitation

4.2 Environnement technique

Ce TP nécessite l’installation des outils suivants sur votre machine :

Année 2025 Page 4

 Systèmes d’exploitation avancés TP Mini-OS

Outils requis

— NASM (Netwide Assembler) - Version 2.16.03 ou ultérieure

— QEMU - Version 10.0.0 ou ultérieure, particulièrement qemu-system-i386
— GCC (MinGW sous Windows) - Version 9.2.0 ou ultérieure
— GNU LD (Linker) - Version 2.32 ou ultérieure
— GNU Make - Version 4.4.1 ou ultérieure
— PowerShell - Version 5.0 ou ultérieure (pour les scripts d’automatisation)
— Un éditeur de texte ou IDE de votre choix

4.3 Installation des outils nécessaires

4.3.1 Installation sous Windows
1. Installation de NASM :
— Téléchargez la dernière version de NASM depuis [Link]
— Exécutez l’installateur et ajoutez NASM au PATH système
— Vérifiez l’installation avec la commande : nasm –version
2. Installation de QEMU :
— Téléchargez QEMU pour Windows depuis [Link]
— Installez en suivant les instructions et assurez-vous que qemu-system-i386 est inclus
— Vérifiez l’installation avec : qemu-system-i386 –version
3. Installation de MinGW (GCC, LD) :
— Téléchargez l’installateur MinGW depuis [Link]
— Sélectionnez au minimum les paquets : mingw32-base, mingw32-gcc-g++, mingw32-
binutils
— Ajoutez le dossier bin de MinGW au PATH système
— Vérifiez avec : gcc –version et ld –version
4. Installation de GNU Make :
— Téléchargez Make pour Windows depuis [Link]
[Link]
— Installez et ajoutez au PATH
— Vérifiez avec : make –version

4.3.2 Installation sous Linux

Sous la plupart des distributions Linux, ces outils peuvent être installés via le gestionnaire
de paquets :
1 # Sur Ubuntu / Debian
2 sudo apt - get update
3 sudo apt - get install nasm qemu - system - i386 build - essential make
4
5 # Sur Fedora
6 sudo dnf install nasm qemu - system - x86 gcc binutils make
7
8 # Sur Arch Linux
9 sudo pacman -S nasm qemu gcc binutils make

Année 2025 Page 5

 Systèmes d’exploitation avancés TP Mini-OS

4.3.3 Installation sous macOS

1 # Installez d ' abord Homebrew si n c e s s a i r e

2 / bin / bash -c " $ ( curl - fsSL https :// raw . g ithubuse rcontent . com / Homebrew /
install / HEAD / install . sh ) "
3
4 # Installez les outils n c e s s a i r e s
5 brew install nasm qemu gcc make

5 Vérification de l’environnement
Avant de commencer le développement, vérifiez que tous les outils sont correctement installés
et accessibles :
1 # V r i f i e z les versions des outils
2 nasm -- version
3 qemu - system - i386 -- version
4 gcc -- version
5 ld -- version
6 make -- version
Vous devriez obtenir des résultats similaires à :
1 NASM version 2.16.03 compiled on Apr 17 2024
2 QEMU emulator version 10.0.0 ( v10 .0.0 -12080 - g252feb9469 - dirty )
3 gcc . exe ( MinGW . org GCC Build -2) 9.2.0
4 GNU ld ( GNU Binutils ) 2.32
5 GNU Make 4.4.1
Si tous les outils sont correctement installés, vous êtes prêt à commencer la création de votre
système d’exploitation minimaliste !

6 Structure du TP
Ce TP guidé est organisé en plusieurs parties progressives :
1. Partie 1 : Mini-OS v1 - Création d’un bootloader basique qui affiche un message
— Comprendre le format du secteur de démarrage
— Écrire le code assembleur pour le bootloader
— Assembler et créer une image disque
— Tester dans QEMU
2. Partie 2 : Mini-OS v2 (TP ultérieur)
— Passer en mode protégé 32-bits
— Implémenter un noyau minimaliste en C
— Gérer les interruptions matérielles
— Créer un shell basique
La suite de ce document se concentre sur la partie 1, où nous développerons Mini-OS v1, un
système minimaliste mais fonctionnel.

Année 2025 Page 6

Systèmes d’exploitation avancés TP Mini-OS

7 Introduction à la conception d’un OS minimaliste

7.1 Révision du processus de démarrage
Avant d’entrer dans le développement de notre système d’exploitation, il est essentiel de
comprendre précisément ce qui se passe lorsqu’un ordinateur de type PC démarre :
1. Mise sous tension - Le matériel s’initialise et le CPU commence l’exécution
2. Exécution du firmware - Le BIOS/UEFI démarre et effectue des tests matériels (POST)
3. Recherche d’un périphérique bootable - Le BIOS cherche un périphérique de démar-
rage selon l’ordre configuré
4. Chargement du secteur d’amorçage - Le premier secteur (512 octets) du périphérique
est chargé à l’adresse 0x7C00
5. Vérification de la signature - Le BIOS vérifie les deux derniers octets (0x55, 0xAA)
6. Exécution du bootloader - Si la signature est valide, l’exécution est transférée au code
du bootloader
Notre Mini-OS v1 se concentre uniquement sur l’étape 6 : nous allons créer un bootloader
minimaliste qui s’exécute directement après son chargement par le BIOS.

7.2 Structure d’un secteur de démarrage

Un secteur de démarrage valide doit respecter une structure spécifique :

Structure du secteur de démarrage

— Taille : Exactement 512 octets

— Instructions de démarrage : Code assembleur exécutable
— BPB (BIOS Parameter Block) : Zone de données contenant des paramètres
(généralement pour les systèmes de fichiers)
— Signature de boot : Les octets 0x55, 0xAA aux positions 510-511

Offset Taille Description Contenu Mini-OS

0x000 3 octets Instructions initiales JMP + NOP
0x003 ≈ 59 octets BPB / Zone de données "MINI-OS1" + padding
0x03E ≈ 467 octets Code du bootloader Code pour afficher texte
0x1FE 2 octets Signature (0x55, 0xAA) 0x55, 0xAA

Figure 2 – Structure du secteur de démarrage de Mini-OS v1

8 Développement du bootloader
Dans cette section, nous allons développer pas à pas le bootloader de Mini-OS v1, en utilisant
deux approches :
1. Approche "manuelle" - Création d’un bootloader via un tableau d’octets en PowerShell
2. Approche "assembleur" - Écriture du bootloader en assembleur NASM

8.1 Approche 1 : Création manuelle du bootloader

Cette approche utilise un script PowerShell pour générer directement le bootloader sous forme
d’un tableau d’octets. Elle est particulièrement didactique car elle permet de visualiser chaque
octet du secteur de démarrage.

Année 2025 Page 7

 Systèmes d’exploitation avancés TP Mini-OS

8.1.1 Structure du code en octets

Notre bootloader va afficher "ABC" à l’écran et entrer dans une boucle infinie. Voici la
décomposition du code en octets :
1 # 1. Jump par - dessus la zone BPB (3 octets )
2 0 xEB , 0 x3C , 0 x90 # JMP +60 , NOP
3

4 # 2. Zone BPB (59 octets )

5 0 x4D , 0 x49 , 0 x4E , 0 x49 , 0 x2D , 0 x4F , 0 x53 , 0 x31 # " MINI - OS1 "
6 [51 octets de 0 x00 ] # Padding pour c o m p l t e r la zone
7
8 # 3. Code principal du bootloader ( commence l ' offset 0 x3E )
9 0 x31 , 0 xC0 # XOR AX , AX - Met AX z ro
10 0 x8E , 0 xD8 # MOV DS , AX - Initialisation du segment de d o n n e s
11 0 x8E , 0 xC0 # MOV ES , AX - Initialisation du segment extra
12 0 x8E , 0 xD0 # MOV SS , AX - Initialisation du segment de pile
13 0 xBC , 0 x00 , 0 x7C # MOV SP , 0 x7C00 - Initialisation du pointeur de pile
14
15 # 4. Effacement de l ' cran
16 0 xB8 , 0 x00 , 0 x00 # MOV AX , 0 x0000 - Fonction 0 de l ' INT 10 h
17 0 xCD , 0 x10 # INT 0 x10 - Appel l ' interruption BIOS v i d o
18
19 # 5. Affichage " A "
20 0 xB4 , 0 x0E # MOV AH , 0 x0E - Fonction t l t y p e ( affichage c a r a c t r e )
21 0 xB0 , 0 x41 # MOV AL , 'A ' - C a r a c t r e afficher
22 0 xB7 , 0 x07 # MOV BH , 0 x07 - Page v i d o et attribut
23 0 xCD , 0 x10 # INT 0 x10 - Appel l ' interruption BIOS v i d o
24
25 # 6. Affichage " B " et " C " ( similaire )
26 0 xB0 , 0 x42 # MOV AL , 'B '
27 0 xCD , 0 x10 # INT 0 x10
28 0 xB0 , 0 x43 # MOV AL , 'C '
29 0 xCD , 0 x10 # INT 0 x10
30
31 # 7. Boucle infinie
32 0 xFA # CLI - D s a c t i v e les interruptions
33 0 xEB , 0 xFE # JMP $ - Saute l ' adresse courante ( boucle infinie )
34
35 # 8. Padding et signature
36 [ Octets 0 x00 jusqu ' 510]
37 0 x55 , 0 xAA # Signature du secteur de d m a r r a g e
Listing 1 – Structure du bootloader en octets

8.1.2 Utilisation et exécution du bootloader manuel

Pour tester cette approche manuelle du bootloader, suivez ces étapes détaillées :

Année 2025 Page 8

Systèmes d’exploitation avancés TP Mini-OS

Procédure d’exécution de l’approche manuelle

1. Créez un fichier PowerShell : Créez un nouveau fichier nommé

boot_working.ps1 et copiez-y le code PowerShell complet de la section sui-
vante.
2. Vérifiez les droits d’exécution : Ouvrez PowerShell en tant qu’administrateur
et exécutez la commande suivante pour autoriser l’exécution de scripts :
1 Set - ExecutionPolicy - ExecutionPolicy RemoteSigned - Scope
Process
2

3. Naviguez vers le dossier contenant votre script :

1 cd chemin \ vers \ votre \ dossier
2

4. Exécutez le script :
1 .\ boot_working . ps1
2

5. Résultats attendus :
— Le script crée un fichier boot_exact.bin de 512 octets
— Le script crée une image disquette [Link] de 1.44 Mo
— QEMU démarre automatiquement avec l’image disque
— Vous devriez voir les lettres "ABC" affichées à l’écran
6. Pour quitter QEMU : Fermez la fenêtre QEMU ou utilisez la combinaison de
touches Ctrl+Alt+2 puis tapez "quit" dans la console QEMU.

Dépannage courant :
— QEMU non trouvé : Si le script ne trouve pas QEMU, vérifiez son installation ou modifiez
les chemins dans le script ($qemuPaths).
— Erreur de permissions : Si PowerShell refuse d’exécuter le script, vérifiez la politique
d’exécution.
— Aucun affichage : Si rien ne s’affiche dans QEMU, vérifiez que les octets du bootloader
sont correctement définis.

Options avancées : Vous pouvez modifier le script pour :

— Changer les caractères affichés en modifiant les valeurs des octets (0x41, 0x42, 0x43)
— Modifier les attributs d’affichage (couleurs) en changeant la valeur 0x07 (texte blanc sur
fond noir)
— Ajouter plus de caractères en suivant le même modèle

Année 2025 Page 9

 Systèmes d’exploitation avancés TP Mini-OS

8.1.3 Implémentation du script PowerShell

Voici le script PowerShell complet pour créer notre bootloader manuellement :
1 # Script PowerShell pour c r e r un bootloader exact de 512 octets
2 Write - Host " Mini - OS v1 - Bootloader 512 octets exact " - ForegroundColor
Green
3 Write - Host " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " - ForegroundColor Green
4 Write - Host " "
5
6 # 1. Fermer toute instance QEMU en cours
7 Get - Process - Name " qemu - system - i386 " - ErrorAction SilentlyContinue |
ForEach - Object {
8 Write - Host " A r r t de QEMU ( PID : $ ( $_ . Id ) ) ... " - ForegroundColor
Yellow
9 $_ . Kill ()
10 }
11
12 # 2. C r e r un bootloader exact 512 octets
13 Write - Host " C r a t i o n du bootloader ... " - ForegroundColor Cyan
14
15 # D f i n i r manuellement les octets du bootloader
16 # Ce bootloader minimaliste affiche " ABC " et se met en pause
17 $bootcode = [ byte []] @ (
18 # Jump passant par - dessus le BPB ( BIOS Parameter Block ) - standard
dans les bootloaders
19 0 xEB , 0 x3C , 0 x90 , # JMP opcode , offset , NOP
20
21 # Pseudo - BPB (8 octets de signature + padding = 59 octets )
22 0 x4D , 0 x49 , 0 x4E , 0 x49 , 0 x2D , 0 x4F , 0 x53 , 0 x31 # " MINI - OS1 "
23 )
24

25 # Ajouter des z r o s pour c o m p l t e r la partie BPB ( total 62 octets )

26 for ( $i = 0; $i - lt 51; $i ++) {
27 $bootcode += 0 x00
28 }
29
30 # Code du bootloader r e l
31 $bootcode += [ byte []] @ (
32 # Initialiser les segments
33 0 x31 , 0 xC0 , # XOR AX , AX
34 0 x8E , 0 xD8 , # MOV DS , AX
35 0 x8E , 0 xC0 , # MOV ES , AX
36 0 x8E , 0 xD0 , # MOV SS , AX
37 0 xBC , 0 x00 , 0 x7C , # MOV SP , 0 x7C00
38
39 # Effacer l ' cran
40 0 xB8 , 0 x00 , 0 x00 , # MOV AX , 0 x0000
41 0 xCD , 0 x10 , # INT 0 x10
42

43 # Afficher " A "

44 0 xB4 , 0 x0E , # MOV AH , 0 x0E
45 0 xB0 , 0 x41 , # MOV AL , 'A '
46 0 xB7 , 0 x07 , # MOV BH , 0 x07 ( attribut : blanc sur noir )
47 0 xCD , 0 x10 , # INT 0 x10
48
49 # Afficher " B "
50 0 xB0 , 0 x42 , # MOV AL , 'B '
51 0 xCD , 0 x10 , # INT 0 x10

Année 2025 Page 10

 Systèmes d’exploitation avancés TP Mini-OS

52
53 # Afficher " C "
54 0 xB0 , 0 x43 , # MOV AL , 'C '
55 0 xCD , 0 x10 , # INT 0 x10
56
57 # D s a c t i v e r les interruptions et boucle infinie
58 0 xFA , # CLI
59 0 xEB , 0 xFE # JMP $ ( boucle infinie )
60 )
61
62 # V r i f i e r la taille du code actuel
63 $codesize = $bootcode . Count
64 Write - Host " Taille actuelle du code : $codesize octets " - ForegroundColor
Gray
65
66 # Compl ter 510 octets (512 - 2 pour la signature )
67 while ( $bootcode . Count - lt 510) {
68 $bootcode += 0 x00
69 }
70

71 # Ajouter les octets de signature boot (0 x55 , 0 xAA )

72 $bootcode += 0 x55
73 $bootcode += 0 xAA
74
75 # V r i f i e r la taille finale
76 if ( $bootcode . Count - eq 512) {
77 Write - Host " Taille finale : 512 octets ( correct ) " - ForegroundColor
Green
78 } else {
79 Write - Host " ERREUR : Taille incorrecte : $ ( $bootcode . Count ) octets " -
ForegroundColor Red
80 exit 1
81 }
82
83 # 3. crire dans un fichier
84 $bootloaderPath = Join - Path $PSScriptRoot " boot_exact . bin "
85 [ System . IO . File ]:: WriteAllBytes ( $bootloaderPath , $bootcode )
86
87 Write - Host " Bootloader crit : $bootloaderPath " - ForegroundColor Green
88
89 # V r i f i e r la taille du fichier c r
90 $fileInfo = Get - Item $bootloaderPath
91 Write - Host " Taille du fichier : $ ( $fileInfo . Length ) octets " -
ForegroundColor Gray
92
93 # 4. C r e r une image disque
94 Write - Host " ` n C r a t i o n de l ' image disquette ... " - ForegroundColor Cyan
95
96 $imagePath = Join - Path $PSScriptRoot " bootdisk . img "
97 if ( Test - Path $imagePath ) {
98 Remove - Item - Path $imagePath - Force
99 }
100
101 # C r e r une image vide de 1.44 MB
102 $fs = [ System . IO . File ]:: Create ( $imagePath )
103 $fs . SetLength (1474560) # 1.44 MB
104 $fs . Close ()
105

Année 2025 Page 11

 Systèmes d’exploitation avancés TP Mini-OS

106 # 5. crire le bootloader au d b u t de l ' image

107 $bootloaderBytes = [ System . IO . File ]:: ReadAllBytes ( $bootloaderPath )
108 $imageFile = [ System . IO . File ]:: Open ( $imagePath , [ System . IO . FileMode ]::
Open )
109 $imageFile . Write ( $bootloaderBytes , 0 , $bootloaderBytes . Length )
110 $imageFile . Close ()
111
112 Write - Host " Image disque cr e : $imagePath " - ForegroundColor Green
113
114 # 6. Localiser QEMU
115 $qemuPath = $null
116 $qemuPaths = @ (
117 " C :\ Program Files \ qemu \ qemu - system - i386 . exe " ,
118 " C :\ Program Files ( x86 ) \ qemu \ qemu - system - i386 . exe "
119 )
120
121 foreach ( $path in $qemuPaths ) {
122 if ( Test - Path $path ) {
123 $qemuPath = $path
124 Write - Host " QEMU t r o u v : $qemuPath " - ForegroundColor Green
125 break
126 }
127 }
128
129 if ( - not $qemuPath ) {
130 Write - Host " QEMU non t r o u v ! " - ForegroundColor Red
131 exit 1
132 }
133
134 # 7. Lancer QEMU
135 Write - Host " ` n D m a r r a g e de QEMU ... " - ForegroundColor Cyan
136 Write - Host " Vous devriez voir les lettres ABC l ' cran . " -
ForegroundColor Yellow
137
138 # Options QEMU basiques
139 $qemuArgs = @ (
140 " - fda " , $imagePath ,
141 " - boot " , " a "
142 )
143
144 Write - Host " E x c u t i o n de : $qemuPath $qemuArgs " - ForegroundColor Gray
145
146 # D m a r r e r QEMU
147 Start - Process - FilePath $qemuPath - ArgumentList $qemuArgs
Listing 2 – Script PowerShell pour créer le bootloader (boot_working.ps1)

8.1.4 Explication détaillée du script

Le script précédent peut être décomposé en plusieurs étapes clés :
1. Préparation :
— Arrêt des instances QEMU en cours d’exécution pour éviter les conflits
— Affichage des informations de progression
2. Création du bootloader :
— Définition de l’en-tête avec le saut initial et la signature "MINI-OS1"
— Ajout du padding pour respecter la structure BPB

Année 2025 Page 12

Systèmes d’exploitation avancés TP Mini-OS

— Implémentation du code principal (initialisation, affichage "ABC", boucle infinie)

— Complétion à 510 octets avec des zéros
— Ajout de la signature de boot (0x55, 0xAA)
3. Vérification :
— Contrôle que la taille totale est exactement 512 octets
— Écriture du bootloader dans un fichier binaire
4. Création de l’image disque :
— Création d’une image de disquette vide de 1.44 Mo
— Écriture du bootloader au début de l’image
5. Lancement de l’émulation :
— Détection automatique de QEMU
— Configuration des paramètres d’émulation
— Démarrage de QEMU avec l’image créée

8.1.5 Exercice pratique : Modification du bootloader

Maintenant que nous comprenons comment fonctionne notre bootloader, modifions-le pour
afficher un message différent :

Exercice 1 : Modification du bootloader

1. Copiez le script PowerShell fourni dans un nouveau fichier appelé
mon_bootloader.ps1
2. Modifiez le code pour afficher votre prénom au lieu de "ABC"
3. Pour chaque caractère à afficher, suivez ce modèle :
1 0 xB0 , 0 x # # , # MOV AL , '? ' o 0 x ## est le code ASCII du
caractere
2 0 xCD , 0 x10 , # INT 0 x10

4. Exécutez le script et vérifiez que votre prénom s’affiche dans QEMU

Astuce
Vous pouvez utiliser le code ASCII pour représenter chaque caractère. Par exemple :
— ’A’ = 0x41, ’B’ = 0x42, ..., ’Z’ = 0x5A
— ’a’ = 0x61, ’b’ = 0x62, ..., ’z’ = 0x7A
Pour convertir facilement, utilisez cette commande PowerShell :
1 [ int ][ char ] 'X ' # Remplacez X par le caractere souhaite pour
obtenir le code ASCII
2 ' {0: X2 } ' -f [ int ][ char ] 'X ' # Pour obtenir le code HEX
correspondant

8.2 Approche 2 : Développement en assembleur NASM

L’approche précédente était très didactique mais peu pratique pour des développements plus
complexes. Dans cette section, nous allons réécrire notre bootloader en utilisant le langage as-
sembleur et l’assembleur NASM.

Année 2025 Page 13

 Systèmes d’exploitation avancés TP Mini-OS

8.2.1 Structure du code assembleur

Voici le code assembleur équivalent pour notre bootloader :
1 ; Bootloader Mini - OS v1
2 ; Ce bootloader affiche " Hello World !" et entre dans une boucle infinie
3
4 [ BITS 16] ; Mode 16 bits ( mode reel )
5 [ ORG 0 x7C00 ] ; Point de chargement par le BIOS
6
7 ; Saut par - dessus le BPB
8 jmp start
9 nop
10

11 ; BPB ( BIOS Parameter Block ) - 59 octets

12 OEM_ID db " MINI - OS1 " ; 8 octets : Identifiant OS
13 BytesPerSector dw 512 ; 512 octets par secteur
14 Secto rsPerClu ster db 1 ; 1 secteur par cluster
15 ReservedSectors dw 1 ; 1 secteur reserve
16 NumFATs db 2 ; 2 tables FAT
17 RootEntries dw 224 ; 224 entrees dans le repertoire racine
18 TotalSectors dw 2880 ; 2880 secteurs au total (1 .44MB )
19 MediaType db 0 xF0 ; Type de media ( disquette 1 .44MB )
20 SectorsPerFAT dw 9 ; 9 secteurs par FAT
21 SectorsPerTrack dw 18 ; 18 secteurs par piste
22 NumHeads dw 2 ; 2 tetes
23 HiddenSectors dd 0 ; 0 secteurs caches
24 LargeSectors dd 0 ; Pas utilise pour les petits disques
25 BootDrive db 0 ; Lecteur de demarrage
26 Reserved db 0 ; R serve
27 ExtBootSig db 0 x29 ; Signature etendue
28 VolumeID dd 0 xABCD1234 ; ID de volume
29 VolumeLabel db " MINI - OS - VOL " ; 11 octets : etiquette de volume
30 FileSys db " FAT12 " ; 8 octets : type de systeme de fichiers
31
32 start :
33 ; Initialisation des segments
34 xor ax , ax ; AX = 0
35 mov ds , ax ; DS = 0
36 mov es , ax ; ES = 0
37 mov ss , ax ; SS = 0
38 mov sp , 0 x7C00 ; SP = 0 x7C00 ( pile juste en dessous du bootloader )
39
40 ; Effacer l ' cran ( fonction 0 x00 , INT 0 x10 )
41 mov ah , 0 x00 ; Fonction : definir le mode video
42 mov al , 0 x03 ; Mode texte 80 x25 , 16 couleurs
43 int 0 x10 ; Appel BIOS
44
45 ; Afficher " Hello World !"
46 mov si , msg ; SI pointe vers notre message
47 call print ; Appeler la routine d ' affichage
48
49 ; Boucle infinie
50 cli ; D s a c t i v e r les interruptions
51 hlt ; Mettre le CPU en pause
52 jmp $ ; Boucle infinie ( au cas o le CPU sort de HLT )
53
54 ; Fonction pour afficher une chaine de caracteres
55 ; E n t r e : SI = pointeur vers la c h a n e t e r m i n e par 0

Année 2025 Page 14

 Systèmes d’exploitation avancés TP Mini-OS

56 print :
57 push ax ; Sauvegarder AX
58 push bx ; Sauvegarder BX
59 mov ah , 0 x0E ; Fonction teletype BIOS
60 mov bh , 0 ; Page 0
61 mov bl , 0 x07 ; Attribut : blanc sur noir
62
63 .loop :
64 lodsb ; Charger le caractere pointe par SI dans AL , puis
i n c r m e n t e r SI
65 test al , al ; V r i f i e r si AL est nul ( fin de chaine )
66 jz .done ; Si AL = 0 , terminer
67 int 0 x10 ; Sinon , afficher le caractere
68 jmp .loop ; Continuer avec le prochain caractere
69
70 .done :
71 pop bx ; Restaurer BX
72 pop ax ; Restaurer AX
73 ret ; Retourner
74

75 ; Donn es
76 msg db " Hello World ! " , 0 ; Notre message termine par un octet nul
77
78 ; Padding et signature de boot
79 times 510 -( $ - $$ ) db 0 ; Remplir de zeros jusqu 'a 510 octets
80 dw 0 xAA55 ; Signature de boot (0 x55 , 0 xAA en little - endian )
Listing 3 – Bootloader en assembleur NASM ([Link])

Année 2025 Page 15

 Systèmes d’exploitation avancés TP Mini-OS

8.2.2 Explication du code assembleur

Le code assembleur du bootloader présente plusieurs avantages par rapport à la méthode
manuelle :
— Plus lisible et maintenable
— Utilisation d’étiquettes et de variables symboliques
— Support de macros et structures de programmation
— Facilité de modification et d’extension
Examinons les éléments clés de notre code :
— [BITS 16] - Indique à NASM de générer du code 16 bits (mode réel)
— [ORG 0x7C00] - Indique que le code sera chargé à l’adresse 0x7C00
— jmp start - Saute par-dessus la zone BPB
— nop - Instruction "No Operation" pour compléter le saut
— db, dw, dd - Directives pour définir des données (byte, word, double word)
— times 510-($-$$) db 0 - Remplit le reste du secteur avec des zéros
— dw 0xAA55 - Ajoute la signature de démarrage (en little-endian)
La routine print implémente un affichage efficace utilisant :
— lodsb - Charge un octet depuis DS :SI dans AL et incrémente SI
— int 0x10 - Appel à l’interruption BIOS pour l’affichage
— Boucle jusqu’à rencontrer un octet nul (0) marquant la fin de la chaîne

8.2.3 Compilation avec NASM

Pour compiler notre bootloader en assembleur :
1 # Compiler le bootloader
2 nasm -f bin bootloader . asm -o bootloader . bin
3
4 # V r i f i e r la taille ( doit tre exactement 512 octets )
5 ls -l bootloader . bin
6

7 # C r e r une image disquette vide de 1.44 MB

8 dd if =/ dev / zero of = minios . img bs =1024 count =1440
9
10 # crire le bootloader au d b u t de l ' image
11 dd if = bootloader . bin of = minios . img conv = notrunc
Listing 4 – Compilation avec NASM

8.2.4 Script d’automatisation complet

Pour simplifier le processus de développement, nous pouvons créer un script PowerShell com-
plet :
1 # Mini - OS v1 - Script principal
2 Write - Host " Mini - OS v1 - C r a t i o n et e x c u t i o n " - ForegroundColor Green
3 Write - Host " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " - ForegroundColor Green
4 Write - Host " "
5

6 # 1. Fermer toute instance QEMU en cours

7 Get - Process - Name " qemu - system - i386 " - ErrorAction SilentlyContinue |
ForEach - Object {

Année 2025 Page 16

 Systèmes d’exploitation avancés TP Mini-OS

8 Write - Host " A r r t de QEMU ( PID : $ ( $_ . Id ) ) ... " - ForegroundColor

Yellow
9 $_ . Kill ()
10 }
11
12 # 2. V r i f i e r si NASM est disponible
13 $nasmPath = $null
14 $nasmPaths = @ (
15 " C :\ Program Files \ NASM \ nasm . exe " ,
16 " C :\ Program Files ( x86 ) \ NASM \ nasm . exe " ,
17 " C :\ NASM \ nasm . exe "
18 )
19
20 foreach ( $path in $nasmPaths ) {
21 if ( Test - Path $path ) {
22 $nasmPath = $path
23 Write - Host " NASM t r o u v : $nasmPath " - ForegroundColor Green
24 break
25 }
26 }
27
28 if ( - not $nasmPath ) {
29 # Chercher NASM dans le PATH
30 $nasmPath = ( Get - Command " nasm . exe " - ErrorAction SilentlyContinue ) .
Source
31 if ( $nasmPath ) {
32 Write - Host " NASM t r o u v dans le PATH : $nasmPath " -
ForegroundColor Green
33 } else {
34 Write - Host " ERREUR : NASM non t r o u v ! " - ForegroundColor Red
35 Write - Host " Veuillez installer NASM et l ' ajouter au PATH . " -
ForegroundColor Yellow
36 exit 1
37 }
38 }
39
40 # 3. Chemin du fichier source et destination
41 $sourcePath = Join - Path $PSScriptRoot " bootloader . asm "
42 $binPath = Join - Path $PSScriptRoot " bootloader . bin "
43 $imagePath = Join - Path $PSScriptRoot " minios . img "
44
45 if ( - not ( Test - Path $sourcePath ) ) {
46 Write - Host " ERREUR : Fichier source non t r o u v : $sourcePath " -
ForegroundColor Red
47 exit 1
48 }
49
50 # 4. Compiler le bootloader avec NASM
51 Write - Host " ` nCompilation du bootloader ... " - ForegroundColor Cyan
52 $nasmArgs = @ ( " -f " , " bin " , $sourcePath , " -o " , $binPath )
53 Start - Process - FilePath $nasmPath - ArgumentList $nasmArgs - Wait -
NoNewWindow
54
55 if ( - not ( Test - Path $binPath ) ) {
56 Write - Host " ERREUR : La compilation a chou ! " - ForegroundColor Red
57 exit 1
58 }
59

Année 2025 Page 17

 Systèmes d’exploitation avancés TP Mini-OS

60 # 5. V r i f i e r la taille du fichier binaire

61 $fileInfo = Get - Item $binPath
62 if ( $fileInfo . Length - ne 512) {
63 Write - Host " ERREUR : Taille du bootloader incorrecte : $ ( $fileInfo .
Length ) octets ( devrait tre 512) " - ForegroundColor Red
64 exit 1
65 } else {
66 Write - Host " Bootloader c o m p i l avec s u c c s : $ ( $fileInfo . Length )
octets " - ForegroundColor Green
67 }
68
69 # 6. C r e r une image disque
70 Write - Host " ` n C r a t i o n de l ' image disquette ... " - ForegroundColor Cyan
71

72 if ( Test - Path $imagePath ) {

73 Remove - Item - Path $imagePath - Force
74 }
75
76 # C r e r une image vide de 1.44 MB
77 $fs = [ System . IO . File ]:: Create ( $imagePath )
78 $fs . SetLength (1474560) # 1.44 MB
79 $fs . Close ()
80
81 # crire le bootloader au d b u t de l ' image
82 $bootloaderBytes = [ System . IO . File ]:: ReadAllBytes ( $binPath )
83 $imageFile = [ System . IO . File ]:: Open ( $imagePath , [ System . IO . FileMode ]::
Open )
84 $imageFile . Write ( $bootloaderBytes , 0 , $bootloaderBytes . Length )
85 $imageFile . Close ()
86
87 Write - Host " Image disque cr e : $imagePath " - ForegroundColor Green
88

89 # 7. Localiser QEMU
90 $qemuPath = $null
91 $qemuPaths = @ (
92 " C :\ Program Files \ qemu \ qemu - system - i386 . exe " ,
93 " C :\ Program Files ( x86 ) \ qemu \ qemu - system - i386 . exe "
94 )
95
96 foreach ( $path in $qemuPaths ) {
97 if ( Test - Path $path ) {
98 $qemuPath = $path
99 Write - Host " QEMU t r o u v : $qemuPath " - ForegroundColor Green
100 break
101 }
102 }
103
104 if ( - not $qemuPath ) {
105 Write - Host " QEMU non t r o u v dans les emplacements standards ! " -
ForegroundColor Red
106 Write - Host " Veuillez installer QEMU ou s p c i f i e r le chemin
manuellement . " - ForegroundColor Yellow
107 $qemuPath = Read - Host " Entrez le chemin complet vers qemu - system -
i386 . exe "
108

109 if ( - not ( Test - Path $qemuPath ) ) {

110 Write - Host " Chemin invalide . Impossible de continuer . " -
ForegroundColor Red

Année 2025 Page 18

 Systèmes d’exploitation avancés TP Mini-OS

111 exit 1
112 }
113 }
114
115 # 8. Demander l ' utilisateur s ' il veut lancer QEMU
116 Write - Host " ` n P r t d m a r r e r Mini - OS dans QEMU . " - ForegroundColor
Cyan
117 $response = Read - Host " Appuyez sur ENTER pour lancer QEMU ou 'q ' pour
quitter "
118
119 if ( $response - eq " q " ) {
120 Write - Host " T e r m i n sans lancer QEMU . " - ForegroundColor Yellow
121 exit 0
122 }
123
124 # 9. Lancer QEMU
125 Write - Host " ` n D m a r r a g e de Mini - OS dans QEMU ... " - ForegroundColor Cyan
126 Write - Host " ( CTRL + ALT + G pour l i b r e r la souris , fermez la f e n t r e pour
quitter ) " - ForegroundColor Yellow
127

128 # Options QEMU pour d m a r r e r Mini - OS

129 $qemuArgs = @ (
130 " - fda " , $imagePath , # Utiliser l ' image comme lecteur de disquette A
:
131 " - boot " , " a " , # D m a r r e r depuis le lecteur A :
132 " -m " , " 128 M " # Allouer 128 Mo de RAM
133 )
134
135 Write - Host " E x c u t i o n de : $qemuPath $qemuArgs " - ForegroundColor Gray
136
137 # D m a r r e r QEMU
138 Start - Process - FilePath $qemuPath - ArgumentList $qemuArgs
139
140 Write - Host " Mini - OS a d m a r r . Vous devriez voir ' Hello World ! ' l'
cran . " - ForegroundColor Green
Listing 5 – Script PowerShell d’automatisation (mini-os-final.ps1)

9 Travaux pratiques et exercices

9.1 TP 1 : Création du bootloader basique
TP 1 : Premier bootloader
Dans ce TP, vous allez créer votre premier bootloader en suivant ces étapes :
1. Créez un fichier [Link] avec le code assembleur fourni
2. Compilez-le avec NASM : nasm -f bin [Link] -o [Link]
3. Vérifiez que la taille du fichier est exactement 512 octets
4. Créez une image disquette et placez-y le bootloader (utilisez le script PowerShell
fourni)
5. Lancez l’image dans QEMU et vérifiez que "Hello World !" s’affiche

Année 2025 Page 19

Systèmes d’exploitation avancés TP Mini-OS

9.2 TP 2 : Modification du bootloader

TP 2 : Personnalisation du bootloader
Maintenant, modifiez votre bootloader pour :
1. Changer le message "Hello World !" par un message personnalisé
2. Ajouter le changement de couleur du texte (utilisez BL pour définir l’attribut)
3. Ajouter un autre message sur une nouvelle ligne
Pour afficher une nouvelle ligne, ajoutez cette séquence après votre message :
1 ; Afficher CR + LF ( retour chariot + saut de ligne )
2 mov ah , 0 x0E ; Fonction teletype
3 mov al , 0 x0D ; Retour chariot ( CR )
4 int 0 x10
5 mov al , 0 x0A ; Saut de ligne ( LF )
6 int 0 x10

10 Évaluation des connaissances

10.1 Questions théoriques
1. Quelle est l’adresse mémoire où le BIOS charge le secteur de démarrage ? Pourquoi cette
adresse est-elle importante ?
2. Expliquez pourquoi la signature 0x55, 0xAA est nécessaire à la fin du secteur de démarrage.
3. Quel est le rôle de l’instruction [ORG 0x7C00] dans le code assembleur ?
4. Pourquoi initialise-t-on les segments DS, ES et SS à zéro au début du bootloader ?
5. Quelle est la fonction de l’interruption BIOS 0x10 ? Donnez au moins deux fonctionnalités
qu’elle offre.
6. Expliquez la différence entre le mode réel et le mode protégé du processeur x86.

Année 2025 Page 20

Systèmes d’exploitation avancés TP Mini-OS

10.2 Mini-projet : Extension du bootloader

Mini-projet d’évaluation

À partir du bootloader de base, implémentez au moins deux des fonctionnalités suivantes :

— Affichage avancé : Ajoutez une fonction pour centrer le texte à l’écran
— Entrée utilisateur : Implémentez la lecture du clavier pour interagir avec l’utili-
sateur
— Animation : Créez une animation simple (par exemple, un texte qui se déplace)
— Couleur : Implémentez un affichage multicolore du texte
— Menu : Créez un menu simple avec plusieurs options
— Lecture disque : Lisez un secteur supplémentaire du disque (au-delà du secteur de
démarrage)
Critères d’évaluation :
— Fonctionnalité correcte du code
— Qualité et lisibilité du code assembleur
— Commentaires et documentation
— Respect de la taille limite (512 octets pour le bootloader)
— Originalité et complexité des fonctionnalités ajoutées

11 Conclusion et perspectives
Mini-OS v1 est une excellente introduction aux concepts fondamentaux des systèmes d’ex-
ploitation et du démarrage d’un ordinateur. Pour aller plus loin, vous pourriez :
— Passer en mode protégé 32-bits
— Implémenter un chargeur de noyau pour charger du code au-delà du premier secteur
— Développer un noyau minimaliste en C
— Ajouter la gestion des interruptions matérielles
— Implémenter un système de fichiers simple
— Créer un shell interactif
Ces sujets seront abordés dans la suite du cours avec Mini-OS v2.

Année 2025 Page 21