★ À maîtriser
📌 Un appel système est une procédure de l’interface du système d’exploitation qui fait entrer le processus dans le noyau pour obtenir un service, puis lui rend le contrôle.
fork crée un processus enfant dont la mémoire initiale est identique à celle du processus parent, et retourne le pid de l’enfant au parent ainsi que zéro à l’enfant.
exec remplace la mémoire du processus appelant par une image de programme chargée depuis un fichier au format ELF et commence l’exécution au point d’entrée indiqué dans l’en-tête ELF; en cas de succès, exec ne revient pas au programme appelant.
exit arrête le processus appelant et libère ses ressources, notamment sa mémoire et ses fichiers ouverts, tandis que wait renvoie le pid d’un enfant terminé ou attend qu’un enfant termine.
Compléments
xv6 est une réimplémentation de Unix Version 6, écrite en C ANSI pour un système multiprocesseur x86-64 et adaptée à cette architecture par Léon Gall.
L’interface d’appels système de xv6 comprend fork(), exit(), wait(), kill(pid), getpid(), sleep(n), exec(filename, *argv), sbrk(n), open(filename, flags), read(fd, buf, n), write(fd, buf, n), close(fd), dup(fd), pipe(p), chdir(dirname), mkdir(dirname), mknod(name, major, minor), fstat(fd), link(f1, f2) et unlink(filename).
Pour partager le temps processeur entre les processus, xv6 sauvegarde les registres du processus lorsqu’il cesse de s’exécuter et les restaure lorsqu’il reprend.
📌 Après fork, le parent et l’enfant ont des mémoires et des registres distincts : modifier une variable dans l’un ne modifie pas la variable correspondante dans l’autre.
📌 La séparation de fork et exec permet au shell de créer un enfant puis de préparer ses descripteurs avant de charger le programme, sans que ce programme ait à gérer lui-même la redirection des entrées-sorties.
fork crée le processus, exec charge le programme, exit termine son exécution.
★ À maîtriser
Les descripteurs 0, 1 et 2 désignent par convention l’entrée standard, la sortie standard et la sortie d’erreur; dans xv6, le shell les garde ouverts, par défaut sur la console.
read(fd, buf, n) lit au plus n octets dans buf depuis fd, avance l’offset du nombre d’octets lus et renvoie zéro lorsqu’il n’y a plus rien à lire.
📌 fork copie la table des descripteurs du parent, mais les offsets des fichiers sous-jacents restent partagés entre parent et enfant; des descripteurs issus du même descripteur par fork ou dup partagent aussi leur offset.
📌 Si aucune donnée n’est disponible dans un tube, read attend l’arrivée de données ou la fermeture de tous les descripteurs de son extrémité écriture ; dans ce dernier cas, read renvoie 0, comme à la fin d’un fichier.
Compléments
Un descripteur peut désigner un fichier, un répertoire, un périphérique ou un tube, et l’interface les présente comme des flux d’octets.
write(fd, buf, n) écrit les octets de buf dans fd à partir de l’offset courant, avance cet offset du nombre d’octets écrits et ne peut en écrire moins que n qu’en cas d’erreur.
close libère un descripteur, et le prochain descripteur alloué est toujours le plus petit numéro inutilisé du processus courant.
dup(fd) crée un nouveau descripteur qui désigne le même objet d’entrée-sortie et partage son offset avec le descripteur d’origine.
Pour rediriger l’entrée d’un programme, le shell peut fermer le descripteur 0 dans l’enfant, ouvrir le fichier voulu afin qu’il réutilise le numéro 0, puis appeler exec.
Pour exécuter un pipeline, le shell xv6 crée un tube, puis lance les commandes des deux côtés dans des processus enfants et attend leur terminaison ; les pipelines imbriqués peuvent former un arbre de processus dont les feuilles sont des commandes et les nœuds intérieurs attendent leurs enfants.
📌 Par rapport aux fichiers temporaires, les tubes se nettoient automatiquement, transmettent des flux de longueur arbitraire sans espace disque préalable, permettent l’exécution parallèle des étapes et rendent les lectures et écritures bloquantes plus efficaces pour la communication entre processus.
★ À maîtriser
📌 Un chemin commençant par / est résolu depuis la racine, tandis qu’un chemin relatif est résolu depuis le répertoire courant du processus, que chdir peut modifier.
📌 unlink supprime un nom du système de fichiers, mais l’inode et ses données ne sont libérés que lorsque son nombre de liens est nul et qu’aucun descripteur de fichier ne le référence.
Compléments
Dans xv6, mkdir crée un répertoire, open avec O_CREATE crée un fichier de données et mknod crée un fichier de périphérique.
Un fichier de périphérique créé par mknod n’a pas de contenu ; ses métadonnées enregistrent son type et ses numéros majeur et mineur, qui identifient un périphérique du noyau.
La structure stat contient :
📌 link crée un nouveau nom désignant le même inode qu’un fichier existant ; fstat permet de reconnaître ces noms communs grâce au même numéro d’inode et à un nombre de liens égal à 2 dans l’exemple où a et b sont liés.
📌 Si cd était exécuté comme une commande ordinaire dans un processus enfant, il modifierait le répertoire courant de cet enfant et non celui du shell parent.
L’association des descripteurs de fichiers standard, des tubes et de la syntaxe du shell a favorisé les programmes réutilisables et une culture d’outils logiciels ; le shell a été le premier langage dit de script.
L’interface d’appels système Unix est normalisée par POSIX, mais xv6 n’est pas conforme à POSIX et omet ou implémente partiellement certains appels système, dont lseek.
★ À maîtriser
📌 En mode utilisateur, le processeur interdit les instructions privilégiées, tandis qu’en mode noyau il les autorise ; le noyau s’exécute en mode noyau et les applications en mode utilisateur.
📌 Xv6 utilise un noyau monolithique : son interface noyau correspond à l’interface du système d’exploitation et le noyau implémente le système complet.
Compléments
📌 Une bibliothèque qui laisse chaque application accéder directement au matériel peut convenir à des applications coopératives, mais elle offre moins d’isolation lorsqu’une application est défectueuse ou ne cède pas le processeur.
Les appels système comme open, read, write et close donnent accès au système de fichiers sans que les applications manipulent directement les secteurs du disque.
Unix partage les processeurs entre les processus en sauvegardant et en restaurant leur état de registres, et exec construit l’image mémoire d’un processus sans accès direct de l’application à la mémoire physique.
Pour traiter un appel système, le processeur passe du mode utilisateur au mode noyau par une instruction spéciale et entre à un point d’entrée fixé par le noyau, qui valide ensuite les arguments et autorise ou exécute l’opération.
📌 Le noyau doit fixer le point d’entrée des transitions vers le mode noyau, car laisser l’application le choisir permettrait de contourner la validation des arguments.
xv6 est implémenté comme un noyau monolithique ; son interface noyau correspond donc à l’interface du système d’exploitation et le noyau implémente le système d’exploitation complet.
Le noyau de xv6 est plus petit que certains microkernels parce que xv6 fournit peu de services.
Interdire l’accès matériel direct → renforcer l’isolation et permettre au système de gérer les ressources.
★ À maîtriser
Le noyau met en œuvre l’isolation des processus au moyen de :
Les tables de pages matérielles traduisent les adresses virtuelles manipulées par les instructions x86 en adresses physiques envoyées à la mémoire principale.
Chaque processus possède un thread d’exécution, qui peut être suspendu puis repris lorsque le noyau passe d’un processus à un autre.
Chaque processus possède une pile utilisateur et une pile noyau ; la pile utilisateur sert en espace utilisateur, tandis que le code noyau s’exécute sur la pile noyau après une entrée dans le noyau.
🔄 Lors d’un appel système, le contrôle : passe à la pile noyau, élève le niveau de privilège et exécute le code noyau, réduit le privilège, revient à la pile utilisateur et reprend après l’instruction d’appel système
Compléments
Xv6 maintient une table de pages distincte pour chaque processus afin de définir son espace d’adressage.
Dans l’espace utilisateur d’un processus, les instructions précèdent les variables globales, puis viennent la pile et le tas, que le processus peut agrandir selon ses besoins.
Chaque espace d’adressage de xv6 mappe aussi les instructions et les données du noyau, à des adresses hautes à partir de 0x80000100000, ainsi que la mémoire du programme utilisateur.
La structure struct proc rassemble l’état du processus, notamment sa table de pages, sa pile noyau et son état d’exécution.
Dans xv6, p->pml4 contient la table de pages du processus et sert aussi à consigner les adresses des pages physiques allouées à sa mémoire.
La pile noyau est séparée et protégée du code utilisateur, ce qui permet au noyau de s’exécuter même si le processus a endommagé sa pile utilisateur.
Un thread de processus peut se bloquer dans le noyau en attendant une entrée-sortie, puis reprendre là où il s’était arrêté lorsque l’opération est terminée.
p->state indique si le processus est :
Chaque processus possède une mémoire virtuelle privée, avec le noyau placé tout en haut de l’espace d’adressage.
★ À maîtriser
Au démarrage, le chargeur d’amorçage charge le noyau xv6 depuis le disque à l’adresse physique 0x100000 et l’exécute à partir de entry, alors que la pagination n’est pas encore activée.
entry configure une table de pages qui mappe les adresses virtuelles de 0 à 0x40000000 vers les mêmes adresses physiques et les adresses virtuelles KERNBASE à KERNBASE+0x40000000 vers les adresses physiques de 0 à 0x40000000.
🔄 Pour créer un processus, allocproc : cherche une entrée UNUSED dans la table des processus, la marque EMBRYO et attribue un identifiant pid unique, alloue une pile noyau, en cas d’échec d’allocation, remet l’entrée à UNUSED et signale l’échec
allocproc prépare la pile noyau et le contexte du nouveau processus de façon que son thread commence dans forkret, puis poursuive dans trapret.
userinit crée une table de pages avec setupkvm, puis inituvm alloue une page physique, mappe l’adresse virtuelle zéro sur cette page et y copie le binaire initcode.S.
🔄 Pour lancer un processus, scheduler :
trapret restaure les registres depuis trapframe et iretq reprend l’exécution à l’adresse d’instruction et avec la pile spécifiées, qui valent respectivement 0 et 4096 pour initproc.
La page utilisateur de initproc est accessible au code utilisateur parce que sa table de pages porte le drapeau PTE_U ; le niveau CPL=3 empêche ce code d’accéder aux pages sans ce drapeau et de modifier des registres matériels sensibles comme %cr3.
L’appel exec remplace la mémoire et les registres du processus courant par un nouveau programme, tout en conservant ses descripteurs de fichiers, son identifiant de processus et son processus parent.
initcode.S prépare l’appel exec en plaçant $init dans %rdi, $argv dans %rsi et SYS_exec dans %rax, puis déclenche l’interruption T_SYSCALL.
📌 Si exec réussit, il ne revient pas et commence à exécuter le programme demandé ; s’il échoue et revient, initcode appelle exit en boucle.
Compléments
Le noyau est chargé à 0x100000 plutôt qu’à 0x0 parce que la plage 0xa0000:0x100000 contient des périphériques d’entrée-sortie.
Le mapping bas de entry est nécessaire tant que le processeur exécute entry à basse adresse et sera ensuite supprimé ; le mapping haut permet au noyau de retrouver ses instructions et données à partir de KERNBASE.
🔄 Pour passer au sous-mode 64 bits, xv6 : active PAE, charge l’adresse physique de la table PML4 dans %cr3, active LME dans IA32_EFER et CR0_PG dans %cr0, charge une table globale de descripteurs avec le drapeau 64 bits, effectue un saut lointain
Après la transition, entry configure la pile noyau puis saute vers main, qui s’exécute en haute mémoire.
trapret restaure les registres utilisateur depuis la structure trapframe placée en haut de la pile noyau, puis transfère le contrôle au programme utilisateur.
userinit prépare initcode, scheduler choisit le processus, puis forkret et trapret le conduisent en espace utilisateur.
★ À maîtriser
📌 Un noyau monolithique regroupe les fonctions du système dans le noyau, tandis qu’un microkernel organise des fonctions en serveurs ; Linux est cité comme noyau monolithique, et L4, Minix et QNX comme microkernels déployés notamment dans les systèmes embarqués.
Compléments
📌 xv6 recherche les structures proc libres par un balayage linéaire dans allocproc, tandis qu’un système réel utiliserait une liste libre explicite pour les trouver en temps constant.
Noyau monolithique intégré, microkernel organisé autour de serveurs
★ À maîtriser
Une adresse virtuelle x86-64 fait 48 bits et est signée par extension du bit 47 dans les bits 63 à 48 ; les 12 bits de poids faible sont conservés lors de la traduction, ce qui correspond à des pages de 4096 octets.
La table de pages x86-64 est une arborescence à quatre niveaux : PML4, PDPT, répertoire de pages et table de pages, chaque niveau contenant 512 entrées.
🔄 Le matériel parcourt les niveaux de la table :
Chaque processus possède une table de pages distincte, et xv6 change de table de pages lorsqu’il passe d’un processus à un autre.
Dans xv6, la mémoire utilisateur virtuelle commence à l’adresse zéro et peut croître jusqu’à KERNBASE, ce qui permet à un processus d’adresser jusqu’à 8 téraoctets de mémoire.
Lorsqu’un processus demande davantage de mémoire, xv6 trouve des pages physiques libres puis ajoute à sa table des entrées PTE_U, PTE_W et PTE_P pointant vers ces pages.
Compléments
PTE_P indique la présence d’une entrée, PTE_W autorise l’écriture et PTE_U autorise l’accès depuis un programme utilisateur.
Les entrées PTE_P des zones inutilisées restent à zéro, et les tables de pages distinctes traduisent les adresses utilisateur des processus vers des pages physiques différentes afin de préserver leur mémoire privée.
La table de chaque processus contient aussi les mappages du noyau au-dessus de KERNBASE, mais xv6 n’y définit pas PTE_U, de sorte que seul le noyau peut accéder à ces pages.
xv6 mappe les adresses virtuelles KERNBASE:KERNBASE+PHYSTOP vers les adresses physiques 0:PHYSTOP afin que le noyau accède à ses instructions, à ses données et aux pages physiques.
PML4 → PDPT → répertoire → table de pages
★ À maîtriser
📌 La liste libre de l’allocateur est chaînée dans les pages libres elles-mêmes : l’allocation retire une page de la liste et la libération l’y ajoute.
Dans xv6, l’espace utilisateur commence à l’adresse 0 et contient le texte, les données et la pile, puis le tas au-dessus de la pile afin qu’il puisse croître avec sbrk.
Le texte, les données et la pile sont contigus dans l’espace d’adresses virtuelles, mais peuvent être associés à des pages physiques non contiguës.
Quand sbrk augmente la mémoire, growproc alloue et mappe des pages physiques au sommet de l’espace d’adresses ; quand sbrk la réduit, growproc démonte des pages et libère les pages physiques correspondantes.
Compléments
🔄 setupkvm construit la table du noyau :
mappages installe les traductions page par page en appelant walkpml4 pour trouver l’adresse du PTE, puis en y inscrivant le numéro de page physique, les permissions demandées et PTE_P.
walkpml4 lance la recherche récursive au niveau PML4 ; walkpglevel utilise à chaque niveau les bits correspondants de l’adresse virtuelle et peut allouer la table du niveau inférieur si l’option alloc est activée.
Pour résoudre le problème d’amorçage, un allocateur temporaire utilisé pendant entry alloue après le segment de données du noyau, sans permettre la libération, afin de créer la première table de pages du noyau.
kinit1 prépare l’allocation sans verrouillage dans le premier gigaoctet et kinit2 active le verrouillage et rend davantage de mémoire allouable ; dans xv6, PHYSTOP est fixé à 224 mégaoctets.
kfree remplit d’abord les octets libérés avec la valeur 1, puis insère la page en tête de la liste libre ; kalloc retire et renvoie le premier élément de cette liste.
La pile initiale occupe une page et contient au sommet les chaînes des arguments et leurs pointeurs ; les valeurs de argc et argv sont placées dans %rdi et %rsi.
xv6 place une page de garde non mappée sous la pile afin qu’un dépassement de la page déclenche une exception.
Après une modification des tables de pages, xv6 recharge cr3 pour invalider les entrées obsolètes du TLB et éviter qu’une ancienne correspondance permette d’accéder à une page réattribuée à un autre processus.
Allouer une page, créer les niveaux de tables requis, installer le PTE
★ À maîtriser
exec ouvre le fichier binaire, vérifie la signature ELF, crée une nouvelle table de pages, alloue la mémoire de chaque segment, charge les données du fichier, puis prépare la pile utilisateur et les arguments.
Dans un segment ELF, filesz peut être inférieur à memsz ; les octets entre les deux tailles sont initialisés à zéro plutôt que lus dans le fichier.
exec conserve l’ancienne image jusqu’à ce que la nouvelle soit entièrement créée ; en cas d’erreur pendant la création, il libère la nouvelle image et renvoie –1, sinon il installe la nouvelle image, libère l’ancienne et renvoie 0.
exec vérifie que l’addition ph.vaddr + ph.memsz ne déborde pas et que les adresses demandées restent sous KERNBASE, car des valeurs malveillantes pourraient sinon faire écrire le chargement dans la mémoire du noyau.
xv6 ne fournit pas les mécanismes suivants :
Compléments
Un fichier ELF commence par la signature de quatre octets 0x7F, 'E', 'L', 'F', appelée ELF_MAGIC.
exec réserve une page pour la pile et place une page inaccessible en dessous ; si les arguments ne tiennent pas dans la page, copyout échoue et renvoie –1.
xv6 utilise des superpages de 1 gigaoctet dans sa table de pages initiale.
Pour déterminer la mémoire disponible, les méthodes courantes consistent à sonder les adresses physiques, à lire la quantité de mémoire dans la mémoire non volatile du PC ou à consulter une table de configuration mémoire du BIOS ; cette dernière méthode est la plus répandue, mais sa mise en œuvre est complexe.
Sur les machines disposant de beaucoup de mémoire, les superpages de 2 mégaoctets ou de 1 gigaoctet peuvent réduire la surcharge de manipulation des tables de pages.
Vérifier l’ELF, allouer et charger ses segments, puis préparer la pile.
★ À maîtriser
📌 Un appel système demande un service du système d’exploitation, une exception résulte d’une action illégale du programme, et une interruption est un signal émis par un périphérique qui requiert l’attention du système.
La gestion des transferts vers le noyau doit sauvegarder les registres, préparer l’exécution en mode noyau, choisir le point de départ du noyau, rendre accessibles les informations sur l’événement et préserver l’isolation.
Le x86 possède quatre niveaux de privilège, numérotés de 0, le plus privilégié, à 3, le moins privilégié ; la plupart des systèmes d’exploitation n’utilisent que les niveaux 0 et 3, correspondant au mode noyau et au mode utilisateur.
🔄 L’instruction int n effectue les opérations suivantes : lit le descripteur n de l’IDT, vérifie que CPL est inférieur ou égal à DPL, sauvegarde %rsp et %ss dans des registres internes au processeur, charge %ss et %rsp depuis un descripteur de segment de tâche, empile l’ancien %ss, empile l’ancien %rsp, empile %rflags, empile %cs, empile %rip
L’instruction x86 int vérifie que le niveau de privilège courant CPL dans %cs est inférieur ou égal au niveau DPL du descripteur IDT visé.
📌 Pour qu’un programme utilisateur exécute int vers une entrée de l’IDT, le DPL de cette entrée doit être 3; sinon, l’instruction provoque l’exception de protection générale int 13.
Lors d’un changement du mode utilisateur vers le mode noyau, le matériel utilise la pile définie dans le descripteur de segment de tâche plutôt que la pile utilisateur, qui peut être invalide.
Xv6 réserve les interruptions 0 à 31 aux exceptions logicielles, mappe les 32 interruptions matérielles vers les numéros 32 à 63 et utilise l’interruption 64 pour les appels système.
📌 Pour T_SYSCALL, xv6 configure une porte de trap qui ne désactive pas IF et dont le DPL vaut DPL_USER, alors que les interruptions matérielles passent par une porte d’interruption qui efface IF.
Compléments
Les systèmes d’exploitation utilisent un mécanisme matériel pour transférer le contrôle au gestionnaire d’interruption ; sur x86, les appels système et les exceptions utilisent aussi ce mécanisme d’interruption.
xv6 emploie le terme trap pour désigner une exception et utilise parfois les termes trap et interruption de manière interchangeable, bien qu’un trap soit causé par le processus courant et qu’une interruption soit causée par un périphérique.
Sur x86, le niveau de privilège courant est indiqué par le champ CPL du registre %cs.
La table des descripteurs d’interruption (IDT) contient 256 entrées, chacune indiquant les valeurs de %cs et %rip à utiliser pour l’interruption correspondante.
Pendant un int, le processeur efface le bit IF de %rflags uniquement si l’entrée correspond à une interruption, et charge ensuite %cs et %rip à partir du descripteur IDT.
Tvinit configure les 256 entrées de l’IDT; chaque entrée pointe vers un code distinct de vectors[i], car le processeur ne fournit pas le numéro du trap au gestionnaire.
IDT, privilèges, sauvegarde de l’état, puis transfert vers le gestionnaire.
★ À maîtriser
Selon la cause du trap, trap : appelle syscall pour T_SYSCALL, traite les interruptions matérielles, ignore les interruptions parasites, marque le processus utilisateur fautif pour être tué, appelle panic si le noyau provoque un trap inattendu
Syscall lit dans le trapframe le numéro d’appel système sauvegardé dans %rax, l’utilise pour indexer la table des appels et place la valeur de retour de la fonction appelée dans %rax.
Pour un argument d’indice n ≥ 6, argint64 le localise à l’adresse , car %rsp pointe sur l’adresse de retour et les arguments suivants se trouvent au-dessus.
Xv6 ignore les interruptions du PIC et configure l’IO APIC pour acheminer les interruptions vers les processeurs et le LAPIC local de chaque processeur pour recevoir ses interruptions.
Le timer déclenche le vecteur 32, configuré comme porte d’interruption; dans trap, une interruption de timer incrémente ticks et appelle wakeup.
Compléments
🔄 Le retour du gestionnaire suit ces étapes : alltraps transmet l’adresse du trapframe à trap, trap retourne, trapret dépile le trapframe et restaure les registres, iretq reprend l’exécution sauvegardée
Pour le premier appel système présenté, %rax contient SYS_exec et l’entrée correspondante de la table appelle sys_exec.
📌 Les appels système renvoient conventionnellement une valeur négative en cas d’erreur et une valeur positive en cas de succès; un numéro d’appel invalide provoque l’affichage d’une erreur et le retour de −1.
Argptr vérifie à la fois que l’adresse utilisateur utilisée pour lire l’argument est valide et que l’adresse passée comme argument se situe dans l’espace utilisateur; argstr vérifie aussi que la chaîne est terminée par NUL et entièrement située dans cet espace.
Le noyau doit vérifier explicitement que les adresses fournies par l’utilisateur sont inférieures à p->sz, car le noyau peut déréférencer une adresse utilisateur que le processeur empêcherait l’utilisateur d’accéder hors de sa mémoire.
Les fonctions d’extraction des arguments sont :
📌 Les interruptions sont préférables au polling lorsque les événements sont rares, car le polling gaspillerait du temps processeur.
Xv6 vise une interruption de timer 100 fois par seconde afin de suivre le temps et de partager le processeur entre les processus sans surcharger le processeur de traitement des interruptions.
Xv6 achemine les interruptions du clavier vers le processeur 0 et les interruptions du disque vers le processeur de numéro le plus élevé.
L’instruction cli efface IF pour désactiver les interruptions du processeur, tandis que sti active les interruptions; le planificateur les active sur chaque processeur.
Un événement matériel → une interruption → le traitement par le noyau.
★ À maîtriser
Un disque présente traditionnellement ses données sous forme de secteurs numérotés de 512 octets; dans xv6, la taille d’un bloc est identique à celle d’un secteur.
Dans struct buf, les champs dev et sector indiquent le périphérique et le numéro de secteur, data contient la copie en mémoire, B_VALID indique que les données ont été lues et B_DIRTY qu’elles doivent être écrites sur le disque.
📌 Dans iderw, si B_DIRTY est défini, le tampon est écrit sur le disque ; si B_VALID ne l’est pas, le tampon est lu depuis le disque.
Le pilote IDE maintient les requêtes dans une file, mais le contrôleur IDE simple ne peut exécuter qu’une seule opération à la fois ; la requête en tête est envoyée au matériel et les autres attendent.
Après le démarrage de l’opération, iderw dort en attendant que le gestionnaire d’interruption mette à jour les indicateurs du tampon ; ideintr traite la requête en tête, valide le tampon, efface B_DIRTY, réveille le processus en attente et démarre la requête suivante.
Compléments
Xv6 initialise le pilote IDE au démarrage en appelant ideinit depuis main; ideinit active IDE_IRQ sur le dernier processeur, puis sonde le matériel du disque.
Le pilote IDE attend que le disque ne soit plus occupé et soit prêt, puis sélectionne le disque 1 et vérifie sa disponibilité ; le disque 0 est supposé présent car il a servi au chargement du système.
🔄 Le traitement d’une requête suit ces étapes. :
📌 Pour une écriture, idestart envoie les données au contrôleur avec outsl avant l’interruption ; pour une lecture, le gestionnaire d’interruption récupère les données avec insl lorsque le contrôleur les rend disponibles.
File d’attente → démarrage → interruption → réveil
★ À maîtriser
📌 Les E/S programmées déplacent les données avec des instructions CPU comme insl et outsl, tandis que le DMA permet au périphérique de copier directement les données depuis ou vers la mémoire physique et d’interrompre le processeur à la fin.
Compléments
Les tampons de périphériques peuvent contenir :
Les contrôleurs de disque modernes peuvent accepter un lot de requêtes et les réordonner afin d’utiliser plus efficacement le bras du disque.
📌 Certains pilotes passent des interruptions au polling pendant un afflux d’événements, puis reviennent aux interruptions lorsque l’afflux est traité ; le polling évite le coût des interruptions mais peut retarder le traitement d’un événement.
DMA transfère les données directement en mémoire ; les E/S programmées les déplacent par instructions CPU.
★ À maîtriser
📌 Un verrou empêche plusieurs processeurs d’exécuter simultanément une section critique protégée, ce qui évite les interférences entre les opérations sur la structure de données.
Une acquisition naïve qui vérifie locked puis le met à 1 en deux opérations séparées ne garantit pas l’exclusion mutuelle, car deux processeurs peuvent réussir la vérification simultanément.
Xv6 utilise l’instruction xchg pour lire locked et lui affecter 1 de façon atomique ; acquire répète cette opération jusqu’à obtenir l’ancienne valeur 0, qui signale l’acquisition du verrou.
📌 Un verrou doit protéger une variable lorsqu’un processeur peut l’écrire pendant qu’un autre processeur la lit ou l’écrit.
📌 Lorsqu’un invariant concerne plusieurs emplacements mémoire, un seul verrou doit généralement les protéger tous afin de préserver cet invariant.
Compléments
Le résultat d’une condition de course dépend du moment exact des opérations et de leur ordre dans le système mémoire, ce qui rend les erreurs difficiles à reproduire et à déboguer.
Xv6 utilise deux types de verrous : les verrous tournants et les verrous dormants.
Dans un verrou tournant d’xv6, le champ locked vaut zéro lorsque le verrou est disponible et une valeur non nulle lorsqu’il est détenu.
Xv6 libère le verrou en effaçant ses informations de débogage puis son champ locked ; l’implémentation repose sur des instructions x86 et n’est donc pas directement portable vers d’autres processeurs.
Dans le pilote IDE, iderw protège avec idelock la file des requêtes de disque et les invariants associés, car plusieurs processeurs peuvent ajouter des requêtes simultanément.
Verrouiller trop de code réduit le parallélisme ; il faut donc éviter les verrous inutiles pour préserver l’efficacité.
Deux processeurs insèrent chacun un nœud en tête : l’affectation finale peut faire disparaître l’un des deux.
★ À maîtriser
📌 Lorsqu’un invariant porte sur plusieurs emplacements mémoire, un seul verrou doit généralement protéger l’ensemble de ces emplacements.
📌 Des verrous plus fins permettent à plusieurs CPU d’exécuter simultanément le noyau, mais compliquent les opérations qui maintiennent des invariants communs à plusieurs structures ou entrées.
📌 Lorsque plusieurs verrous doivent être détenus simultanément, tous les chemins de code doivent les acquérir dans le même ordre afin d’éviter les interblocages.
Compléments
📌 Il faut éviter de verrouiller excessivement, car les verrous réduisent le parallélisme.
Xv6 utilise notamment ptable.lock pour protéger la table entière des processus et ses invariants, tandis qu’un verrou par entrée permettrait aux threads travaillant sur des entrées différentes d’avancer en parallèle.
Les exigences d’ordre des verrous font partie des spécifications des fonctions, car leurs appelants doivent provoquer leur acquisition dans l’ordre convenu.
Dans xv6, ideintr détient le verrou IDE lorsqu’elle appelle wakeup, qui acquiert ptable.lock.
La création d’un fichier acquiert les verrous dans l’ordre suivant :
Un verrou global bloque le noyau entier ; des verrous fins laissent travailler plusieurs CPU.
★ À maîtriser
Les interruptions peuvent créer de la concurrence sur un processeur unique, car elles peuvent interrompre à tout moment le code noyau pour exécuter un gestionnaire d’interruption.
Si un gestionnaire d’interruption tente d’acquérir un verrou détenu par le code qu’il a interrompu sur le même processeur, il attend un verrou que le code interrompu ne peut libérer avant le retour du gestionnaire, ce qui provoque un interblocage.
📌 Un processeur ne doit jamais détenir avec les interruptions activées un spin-lock utilisé par un gestionnaire d’interruption.
Les compilateurs et processeurs peuvent réordonner les instructions pour améliorer les performances, mais ce réordonnancement peut rendre visibles aux autres cœurs des effets dans un ordre incorrect.
Xv6 utilise __sync_synchronize() dans acquire et release comme barrière mémoire qui empêche le compilateur et le processeur de réordonner des lectures ou écritures à travers la barrière.
Compléments
Le verrou tickslock sérialise l’incrémentation de ticks par une interruption d’horloge et sa lecture par un thread noyau dans sys_sleep.
Xv6 désactive les interruptions du processeur lorsqu’il entre dans une section critique protégée par un spin-lock et les réactive lorsqu’il ne détient plus aucun spin-lock.
Dans xv6, acquire appelle pushcli avant xchg et release appelle popcli après xchg, tandis que pushcli et popcli suivent l’imbrication des sections critiques et restaurent à la fin l’état d’activation des interruptions antérieur à la section externe.
Dans l’insertion d’un élément dans une liste, rendre visible list = l avant l’affectation de l->next peut conduire un autre processeur à observer une liste dont le lien suivant n’est pas initialisé.
Xv6 se préoccupe du réordonnancement dans acquire et release parce que les accès concurrents aux structures de données, autres que ceux portant sur le verrou lui-même, ont lieu entre ces deux opérations.
Interruption avec verrou détenu → attente impossible → interblocage.
★ À maîtriser
📌 Contrairement à acquire d’un spin-lock, acquiresleep cède le processeur pendant l’attente et ne désactive pas les interruptions, afin que le thread détenteur du verrou puisse s’exécuter et le libérer.
La fonction swtch échange des contextes sans connaître les threads : elle reçoit un pointeur vers l’ancien contexte et un nouveau contexte, sauvegarde les registres sur la pile, place l’ancien pointeur de pile dans *old, puis restaure le nouveau contexte.
🔄 Le passage du processus au planificateur suit ces étapes : yield appelle sched., sched appelle swtch et sauvegarde le contexte dans proc->context., swtch restaure cpu->scheduler et reprend sur la pile du planificateur.
Compléments
Xv6 utilise des sleep-locks dans le système de fichiers pour pouvoir conserver un verrou pendant des opérations disque qui peuvent durer des dizaines de millisecondes.
Un sleep-lock possède un champ locked protégé par un spin-lock, et acquiresleep appelle sleep pour céder atomiquement le processeur et libérer le spin-lock.
📌 Les sleep-locks ne peuvent pas être utilisés dans les gestionnaires d’interruption, car ils laissent les interruptions activées.
📌 Les sleep-locks ne peuvent pas être utilisés dans une section critique protégée par un spin-lock, car acquiresleep peut céder le processeur, tandis que des spin-locks peuvent être utilisés dans une section protégée par un sleep-lock.
📌 Une fonction appelée par du code qui détient déjà un verrou et par du code qui n’en détient pas peut avoir deux variantes, exiger le verrou de tous ses appelants, ou s’appuyer sur des conventions telles que celles de wakeup1 et sched.
Lorsqu’un thread doit attendre la mise à jour d’une structure par un autre thread, il ne peut pas conserver le verrou de cette donnée, car cela empêcherait la mise à jour ; xv6 utilise alors un mécanisme distinct qui coordonne le verrou et l’attente d’événement, sleep et wakeup.
Dans xv6 avec un seul processeur, un changement de thread sauvegarde les registres de l’ancien thread et restaure ceux du nouveau ; %rsp et %rip changent respectivement la pile et le code exécuté.
Sur x86-64, swtch sauvegarde les registres préservés par l’appelé %rbp, %rbx, %r12, %r13, %r14 et %r15 ; %rsp est sauvegardé implicitement dans *old et %rip a déjà été empilé par l’instruction call.
Spin-lock : attente active et interruptions désactivées ; sleep-lock : le thread cède le processeur.
★ À maîtriser
📌 Avant d’appeler sched, un processus qui cède le processeur doit acquérir ptable.lock, libérer les autres verrous détenus et mettre à jour son état ; yield, sleep et exit suivent cette convention.
ptable.lock protège les invariants d’état et de contexte pendant swtch : sans lui, un autre processeur pourrait exécuter un processus devenu RUNNABLE avant que le premier ait cessé d’utiliser sa pile noyau.
Le planificateur parcourt la table des processus à la recherche d’un processus RUNNABLE, définit le processus courant, bascule vers sa table de pages avec switchuvm, le marque RUNNING et appelle swtch.
📌 Les appels à mycpu doivent désactiver les interruptions jusqu’à la fin de l’utilisation de la structure renvoyée, car une interruption pourrait déplacer le thread vers un autre processeur et rendre cette référence incorrecte.
📌 La référence renvoyée par myproc reste sûre lorsque les interruptions sont activées, car le pointeur struct proc reste le même si le processus est déplacé vers un autre processeur ; la référence renvoyée par mycpu, elle, peut devenir incorrecte après un tel déplacement.
Compléments
📌 sched vérifie les conditions de cession et appelle swtch en conservant ptable.lock ; ce verrou passe ainsi au code qui reprend l’exécution.
ptable.lock protège la transition RUNNING ↔ RUNNABLE jusqu’au rétablissement des invariants.
★ À maîtriser
Un réveil perdu survient si recv constate que q->ptr vaut zéro, puis send dépose un pointeur et appelle wakeup avant que recv appelle sleep ; recv s’endort alors malgré l’arrivée du pointeur.
sleep(chan, lk) acquiert ptable.lock avant de libérer lk, marque le processus SLEEPING sur chan et appelle sched ; après son réveil, sleep reprend avec lk réacquis.
🔄 Le réveil des processus suit ces étapes :
📌 Un processus endormi ne manque pas le réveil nécessaire : il conserve le verrou de la condition, ptable.lock, ou les deux entre la vérification de la condition et son passage à l’état endormi.
📌 Un processus réveillé qui constate que la condition attendue est toujours fausse doit se rendormir ; sleep est donc appelé dans une boucle qui revérifie la condition.
Compléments
Le canal d’attente est souvent l’adresse d’une structure noyau liée à la condition attendue.
Dans une file producteur-consommateur, recv attend que q->ptr soit non nul puis retire le pointeur, tandis que send attend que la file soit vide puis y dépose un pointeur.
Le polling répété de q->ptr par recv consomme du processeur pendant l’attente ; sleep permet au processus de céder le processeur jusqu’à son réveil.
Protéger la condition avec q->lock sans le libérer pendant sleep évite le réveil perdu, mais bloque send indéfiniment, car recv s’endort en gardant le verrou dont send a besoin.
Les appels xv6 à wakeup sont effectués en tenant le verrou qui protège la condition de sommeil ; il suffit en pratique que wakeup suive l’acquisition de ce verrou.
Si le réveilleur modifie la condition avant que le processus endormi n’acquière son verrou, celui-ci observe la nouvelle valeur avant de décider de dormir ; si le réveilleur acquiert le verrou après la libération de celui-ci dans sleep, il doit attendre que sleep ait endormi le processus avant de pouvoir le réveiller.
Deux usages de sleep/wakeup peuvent choisir accidentellement le même canal sans compromettre la correction, car les réveils parasites sont tolérés par les boucles qui revérifient la condition.
📌 Sleep/wakeup est léger parce qu’il ne nécessite pas de structure de données spéciale pour les canaux, et fournit une indirection qui évite aux appelants de connaître le processus précis avec lequel ils interagissent.
Le verrou maintenu jusqu’au sommeil empêche wakeup de passer avant que le processus dorme.
★ À maîtriser
📌 Dans un pipe, nwrite == nread+PIPESIZE indique un tampon plein, tandis que nwrite == nread indique un tampon vide ; les compteurs ne bouclent pas, mais les indices du tampon utilisent le modulo PIPESIZE.
Quand pipewrite remplit le tampon, il réveille les lecteurs puis dort sur &p->nwrite ; après avoir lu des données et avancé nread, piperead réveille les écrivains en attente.
Lorsqu’un enfant termine, il passe à l’état ZOMBIE jusqu’à ce que son parent appelle wait, récupère son PID et libère les ressources du processus.
wait acquiert ptable.lock, cherche les enfants et, s’ils n’ont pas terminé, dort en libérant ce verrou ; après son réveil, il rescane la table et nettoie l’enfant devenu ZOMBIE.
📌 Le parent doit libérer p->kstack et p->pml4, car ces ressources ne peuvent être libérées qu’après que l’enfant a cessé de s’exécuter pour la dernière fois en passant par swtch via sched.
📌 kill ne détruit pas directement le processus visé : il positionne p->killed et le réveille s’il dort ; lorsque le processus entre ou sort du noyau, trap appelle exit si ce drapeau est activé.
Compléments
Le code des pipes utilise p->nread comme canal d’attente des lecteurs et p->nwrite comme canal d’attente des écrivains.
Le pilote IDE utilise sleep/wakeup pour qu’un processus endormi après avoir placé une requête disque dans une file soit réveillé par le gestionnaire d’interruptions lorsque la requête est terminée.
Si un parent se termine avant son enfant, init adopte cet enfant et attend sa terminaison afin qu’un parent puisse effectuer son nettoyage.
exit réveille le parent qui attend sur son canal avant de marquer le processus ZOMBIE, mais ptable.lock empêche wait d’inspecter ce processus avant que exit ait établi cet état.
Les boucles d’attente peuvent abandonner une opération après détection de p->killed seulement lorsque cet abandon est correct ; le pilote IDE ne vérifie pas ce drapeau au milieu d’opérations disque qui doivent rester cohérentes.
ZOMBIE → wait récupère le PID → le parent libère les ressources
★ À maîtriser
📌 Dans les variables de condition, signal réveille un processus en attente, tandis que broadcast réveille tous les processus en attente ; le réveil collectif peut provoquer une ruée où tous les processus se disputent la vérification de la condition.
Compléments
La recherche, par wakeup, de processus ayant un canal correspondant dans toute la table des processus est inefficace ; une structure associant chaque canal à une liste de processus en attente est une solution possible.
Le compte explicite d’un sémaphore évite les réveils perdus et parasites ainsi que le phénomène de ruée, car il conserve le nombre de réveils survenus.
📌 Contrairement à xv6, qui ne prend pas en charge les signaux Unix, un processus Unix réveillé par un signal peut revenir d’un appel système interrompu avec la valeur -1 et l’erreur EINTR.
signal réveille un seul processus ; broadcast les réveille tous
★ À maîtriser
📌 Après une panne, le système de fichiers doit rester correct au redémarrage, notamment en évitant qu’une interruption de mises à jour laisse un bloc à la fois utilisé par un fichier et marqué libre.
L’implémentation du système de fichiers xv6 est organisée en sept couches.
Le cache de blocs conserve des blocs disque en mémoire et synchronise leur accès afin qu’un seul processus du noyau à la fois puisse modifier les données d’un bloc donné.
La couche de journalisation permet aux couches supérieures de regrouper les mises à jour de plusieurs blocs dans une transaction et garantit leur mise à jour atomique en cas de panne.
La couche répertoire représente chaque répertoire par un inode spécial dont le contenu est une suite d’entrées associant un nom de fichier à un i-number.
Le bloc 0 du disque est réservé au secteur d’amorçage et le bloc 1 contient le superbloc.
Le superbloc contient les informations suivantes :
Compléments
Le système de fichiers xv6 fournit des fichiers, des répertoires et des noms de chemin de type Unix, et stocke les données sur un disque IDE pour les conserver.
Le système de fichiers doit coordonner les accès concurrents de processus différents et maintenir un cache mémoire des blocs populaires, car le disque est beaucoup plus lent que la mémoire.
La couche disque lit et écrit les blocs sur un disque dur IDE.
La couche inode fournit des fichiers individuels représentés par un inode doté d’un numéro i-number unique et de blocs contenant ses données.
La couche des chemins fournit des noms hiérarchiques, comme /usr/rtm/xv6/fs.c, et les résout par recherche récursive.
La couche des descripteurs de fichiers présente diverses ressources Unix, notamment les pipes, les périphériques et les fichiers, au moyen d’une interface commune.
Sur le disque xv6, les blocs du journal commencent au bloc 2, puis viennent les inodes, les blocs bitmap et enfin les blocs de données.
★ À maîtriser
Le cache de tampons synchronise l’accès aux blocs disque afin qu’un seul exemplaire de chaque bloc soit en mémoire et qu’un seul thread du noyau utilise cet exemplaire à la fois.
Le cache de tampons conserve les blocs fréquemment utilisés afin d’éviter de les relire sur le disque, dont l’accès est plus lent que celui de la mémoire.
bread fournit un tampon verrouillé contenant une copie du bloc demandé, et lit le disque si le tampon doit être chargé.
Compléments
📌 B_VALID indique qu’un tampon contient une copie du bloc, tandis que B_DIRTY indique que son contenu a été modifié et doit être écrit sur disque.
★ À maîtriser
📌 Au redémarrage, si l’en-tête indique une opération validée, la reprise rejoue ses écritures ; sinon, elle ignore le journal, puis l’efface.
📌 Une panne avant la validation conduit à ignorer le journal, tandis qu’une panne après la validation conduit à rejouer toutes les écritures de l’opération.
balloc parcourt les blocs du système de fichiers à partir du bloc 0, repère un bit nul, met à jour le bitmap et renvoie le bloc correspondant.
bfree libère un bloc en effaçant le bit correspondant dans le bitmap.
Compléments
L’en-tête du journal contient le nombre de blocs journalisés et leurs numéros de secteur ; son compte vaut zéro sans transaction et est non nul pour une transaction complète validée.
Le journal occupe un espace disque fixe ; xv6 découpe les grandes écritures en transactions plus petites pour respecter sa capacité, tandis que unlink ne pose pas de problème en pratique car le système de fichiers xv6 n’utilise qu’un seul bloc bitmap.
log_write enregistre le numéro de secteur d’un bloc modifié, le marque B_DIRTY pour empêcher son éviction et réutilise le même emplacement du journal si ce bloc est modifié plusieurs fois dans une transaction, une optimisation appelée absorption.
Quand le dernier appel système en cours se termine, end_op écrit les blocs modifiés dans le journal, écrit l’en-tête de validation, installe les blocs dans le système de fichiers, puis écrit un en-tête dont le compte est nul.
mkfs marque comme utilisés les blocs correspondant à :
📌 balloc et bfree doivent être appelées à l’intérieur d’une transaction.
Préparer le journal, valider, installer les blocs, puis effacer l’en-tête.
★ À maîtriser
📌 Le terme inode désigne soit la structure dinode sur disque, qui contient la taille du fichier et les numéros de ses blocs de données, soit l’inode en mémoire, copie de la dinode augmentée d’informations utiles au noyau.
📌 Dans xv6, icache.lock protège l’unicité des inodes dans le cache et la cohérence de leur compteur de références, tandis que le sleep-lock propre à chaque inode protège exclusivement ses champs et ses blocs de contenu.
📌 iget() fournit une référence non exclusive qui reste valide jusqu’à iput(), tandis que ilock() verrouille l’inode et charge ses données depuis le disque si nécessaire.
📌 Comme iput() peut écrire sur le disque lorsqu’il libère un inode, tout appel système utilisant le système de fichiers doit être inclus dans une transaction, même si l’appel paraît en lecture seule.
Compléments
Les inodes sur disque sont rangées dans une zone contiguë appelée blocs d’inodes, et leur taille fixe permet de localiser l’inode numéro n à partir de son i-number.
Dans une dinode, le champ type distingue les fichiers, les répertoires et les fichiers spéciaux comme les périphériques, et une valeur nulle indique que l’inode sur disque est libre.
Dans une dinode, nlink compte les entrées de répertoire qui pointent vers l’inode afin de déterminer quand l’inode et ses blocs de données doivent être libérés.
Dans une dinode, size indique le nombre d’octets du contenu du fichier et addrs contient les numéros des blocs disque qui stockent ce contenu.
iget et iput acquièrent et libèrent des pointeurs vers un inode en modifiant son compteur de références.
L’icache sert principalement à synchroniser l’accès concurrent aux inodes référencés par le noyau ; le cache de tampons peut conserver en mémoire les inodes fréquemment utilisés.
🔄 L’allocation d’un inode suit ces étapes : ialloc parcourt les inodes du disque à la recherche d’un inode libre., ialloc écrit le nouveau type de l’inode trouvé., ialloc appelle iget pour obtenir une entrée du cache.
xv6 ne récupère pas après redémarrage les inodes restés alloués sur le disque sans entrée de répertoire correspondante, ce qui peut entraîner une perte d’espace disque au fil du temps.
dinode sur disque, inode actif en mémoire.
★ À maîtriser
📌 Dans la représentation xv6, les premiers NDIRECT blocs de données sont référencés directement par l’inode, tandis que les NINDIRECT blocs suivants sont référencés par un bloc indirect.
📌 writei peut agrandir le fichier jusqu’à sa taille maximale et met à jour sa taille si l’écriture l’a étendu, tandis que readi ne modifie pas le contenu du fichier.
Compléments
Avec les constantes décrites, les blocs directs couvrent les premiers 6 kB d’un fichier et les blocs indirects les 64 kB suivants.
itrunc libère d’abord les blocs directs, puis les blocs référencés dans le bloc indirect, et enfin le bloc indirect lui-même.
📌 readi renvoie une erreur si la lecture commence après la fin du fichier, mais renvoie moins d’octets que demandé si elle commence à la fin ou la traverse.
★ À maîtriser
📌 dirlookup recherche une entrée de répertoire et renvoie un inode déverrouillé obtenu par iget, tandis que dirlink ajoute une entrée et renvoie une erreur si le nom existe déjà.
📌 namei renvoie l’inode correspondant au chemin complet, tandis que nameiparent s’arrête avant le dernier élément et renvoie l’inode du répertoire parent avec le dernier élément dans name.
📌 Chaque appel à open crée un nouveau struct file avec son propre décalage, tandis que dup ou fork peut partager une même instance de struct file entre plusieurs entrées de tables de fichiers.
📌 Pour un fichier inode, fileread et filewrite utilisent le décalage d’entrée-sortie du struct file puis le font avancer, tandis que les pipes ne possèdent pas de décalage.
Compléments
📌 Pendant une recherche de chemin, la référence obtenue par iget empêche la suppression de l’inode après la libération du verrou du répertoire, car son compteur de références reste supérieur à zéro.
📌 Quand le compteur de références d’un struct file atteint zéro, fileclose libère le pipe ou l’inode sous-jacent selon le type de fichier.
Chemin → composantes → répertoire parent ou inode final
★ À maîtriser
📌 Pour créer un lien, sys_link exige que le répertoire parent existe et se trouve sur le même périphérique que l’inode existant, car les numéros d’inode ne sont uniques que sur un disque ; en cas d’échec, sys_link décrémente ip->nlink.
📌 sys_link crée un nouveau nom pour un inode existant, tandis que create crée un nouveau nom associé à un nouvel inode.
Compléments
create cherche le répertoire parent avec nameiparent, vérifie l’existence du nom avec dirlookup, réutilise un fichier régulier existant pour open ou signale une erreur dans les autres cas, puis alloue un inode avec ialloc ; si celui-ci est un répertoire, elle initialise les entrées . et .. avant de l’ajouter au répertoire parent.
create généralise la création réalisée par open avec O_CREATE, mkdir et mkdev ; ces appels créent respectivement un fichier ordinaire, un répertoire et un fichier de périphérique.
📌 sys_open vérifie qu’un répertoire n’est ouvert qu’en lecture, puis alloue un fichier et un descripteur et initialise le fichier dans la table du processus courant.
★ À maîtriser
📌 La récupération par journal rend les appels système atomiques face aux pannes et est plus rapide que le nettoyage au redémarrage, qui examine fichiers, répertoires et listes de blocs et d’inodes libres.
📌 Les répertoires de xv6 sont parcourus linéairement lors d’une recherche, tandis que NTFS, HFS et ZFS utilisent des arbres équilibrés de blocs qui garantissent une recherche logarithmique.
Le BIOS transfère le contrôle au code du secteur d’amorçage, le premier secteur de 512 octets du disque de démarrage, qu’il charge à l’adresse mémoire 0x7c00.
🔄 Le boot loader doit : quitter le mode simulant un Intel 8088, charger le noyau xv6 depuis le disque en mémoire, transférer le contrôle au noyau
En mode réel, le processeur ajoute à l’offset 16 fois la valeur d’un registre de segment pour former l’adresse mémoire de 20 bits ; les accès aux instructions utilisent généralement %cs, les données %ds et la pile %ss.
Compléments
📌 La cache de xv6 utilise une éviction LRU simple, tandis que des caches plus efficaces peuvent employer une table de hachage pour les recherches et un tas pour les évictions LRU.
Les caches de blocs modernes sont souvent intégrées au système de mémoire virtuelle afin de prendre en charge les fichiers mappés en mémoire.
Le journal de xv6 ne permet pas de validation concurrente avec les appels du système de fichiers, journalise des blocs entiers même lorsque quelques octets changent et écrit les blocs du journal de façon synchrone.
BSD UFS/FFS et Linux ext2/ext3 reprennent essentiellement les structures de données d’inodes et de répertoires de xv6, héritées des premiers systèmes UNIX.
En cas d’échec d’une opération disque, xv6 déclenche une panique au lieu de gérer l’erreur plus graduellement.
Le système de fichiers xv6 est limité à un périphérique disque de taille fixe ; les solutions RAID et les dispositifs logiques extensibles permettent de réunir plusieurs disques et de faire évoluer la capacité.
Les systèmes modernes peuvent associer à chaque fichier ouvert une table de pointeurs de fonctions afin de déléguer ses opérations, notamment vers des appels RPC pour les systèmes de fichiers réseau.
Le boot loader xv6 comprend bootasm.S, écrit en assembleur x86 16 et 32 bits, et bootmain.c, écrit en C.
📌 Le code assembleur du boot loader n’emploie pas d’instructions x86-64, car la transition vers le mode 64 bits au démarrage dépasserait la limite de 512 octets du secteur d’amorçage.
Le répertoire xv6 balaie linéairement ; les arbres équilibrés garantissent une recherche logarithmique.
★ À maîtriser
La table GDT du boot loader comporte une entrée nulle, une entrée de code et une entrée de données ; les segments ont une base de zéro et une limite maximale de quatre gigaoctets.
🔄 L’activation du mode protégé se fait ainsi : charger la GDT avec lgdt, mettre à 1 le bit CR0_PE de %cr0, effectuer un saut lointain ljmp pour charger le sélecteur de code et passer en mode 32 bits
Après être passé en mode 32 bits, le boot loader initialise les registres de segment de données avec SEG_KDATA, place le sommet de la pile à 0x7c00 et appelle bootmain.
bootmain attend le noyau exécutable à partir du deuxième secteur du disque et charge les 4096 premiers octets du fichier ELF à l’adresse mémoire 0x10000.
Pour charger les segments du noyau, bootmain lit les données du disque vers l’adresse physique paddr avec readseg, puis met à zéro le reste du segment avec stosb.
Le noyau xv6 est lié pour s’attendre à des adresses virtuelles commençant à 0x80000100000, tandis que ses segments sont copiés avant l’activation de la pagination à partir de l’adresse physique 0x00000100000.
Compléments
📌 L’activation du mode protégé ne change pas immédiatement la traduction des adresses : celle-ci change quand une nouvelle valeur est chargée dans un registre de segment.
📌 Après le démarrage, le noyau configure la pagination pour faire correspondre les adresses virtuelles à partir de 0x80000100000 aux adresses physiques à partir de 0x00000100000.
📌 Le boot loader appelle le point d’entrée physique du noyau alors que le processeur est encore en mode protégé 32 bits ; le code entry doit ensuite passer au sous-mode 64 bits de l’IA-32e.
Lire l’ELF, charger ses segments, puis appeler son point d’entrée
★ À maîtriser
Le boot loader xv6 compilé occupe environ 450 octets et suppose que le noyau est stocké de manière contiguë sur le disque à partir du secteur 1.
Les systèmes PC utilisent souvent deux étapes de démarrage : un chargeur simple récupère un chargeur complet à un emplacement connu, puis celui-ci localise, charge et exécute le noyau.
Compléments
📌 Un système de fichiers ordinaire ou un chargement réseau nécessite un chargeur capable de gérer les systèmes de fichiers, les protocoles réseau et les contrôleurs, contrairement au chargeur xv6 simplifié qui suppose un noyau contigu.
Le chargeur xv6 tient en 512 octets ; un chargeur complet dispose de plus d’espace
| Organisation | Services | Caractéristique |
|---|---|---|
| Noyau monolithique | Système d’exploitation en mode noyau | Coopération facilitée ; une erreur noyau peut faire échouer le système |
| Micro-noyau | Services principalement en serveurs utilisateur | Noyau réduit ; communication par messages |
| Indicateur | Rôle |
|---|---|
| PTE_P | Indique que l’entrée est présente. |
| PTE_W | Autorise l’écriture dans la page. |
| PTE_U | Autorise l’accès depuis un programme utilisateur. |
Teste tes connaissances sur Synchronisation et système de fichiers xv6 avec 99 questions à choix multiples et corrections détaillées.
1. Concernant le rôle du système d’exploitation :
2. Un processus xv6 comprend :
Mémorisez les concepts clés de Synchronisation et système de fichiers xv6 avec 95 flashcards interactives.
Comment un système d’exploitation partage-t-il l’ordinateur entre les programmes ?
Il répartit l’ordinateur entre plusieurs programmes.
Qu’est-ce qu’un appel système dans xv6 ?
Une procédure qui fait entrer le processus dans le noyau pour obtenir un service, puis lui rend le contrôle.
Qu’est-ce qu’un descripteur de fichier ?
Un petit entier représentant un objet géré par le noyau, qu’un processus peut lire ou écrire.
Importe ton cours et l'IA génère fiches, QCM et flashcards en 30 secondes.
Générateur de fiches