Fiche de révision : Synchronisation et système de fichiers xv6

Plan du Cours

  1. Rôle du système, appels, processus et mémoire
  2. Descripteurs de fichiers et communication par tubes
  3. Système de fichiers et interface Unix
  4. Partage des ressources, modes et noyau monolithique
  5. Isolation des processus, piles et états
  6. Démarrage de xv6, premier processus et appel exec
  7. Organisation des noyaux réels
  8. Traduction des adresses et espace mémoire des processus
  9. Allocation physique et espace mémoire utilisateur
  10. Chargement ELF et choix de pagination
  11. Transferts vers le noyau, protection et vecteurs de trap
  12. Traitement des appels système et interruptions matérielles
  13. Pilote IDE, tampons et requêtes disque
  14. Principes des pilotes de périphériques
  15. Conditions de course, atomicité et choix des verrous
  16. Granularité des verrous et prévention des interblocages
  17. Verrous, interruptions et ordre mémoire
  18. Verrous dormants et limites des verrous
  19. Ordonnancement des processus et accès au processeur courant
  20. Sommeil, réveils et synchronisation des processus
  21. Synchronisation des tubes et terminaison des processus
  22. Ordonnancement et synchronisation réelle
  23. Objectifs et couches du système de fichiers xv6
  24. Cache de tampons disque
  25. Journalisation, reprise et allocation des blocs disque
  26. Inodes, références et verrous
  27. Blocs et contenu des fichiers
  28. Répertoires, chemins, fichiers ouverts et descripteurs
  29. Liens, création de fichiers et ouverture
  30. Limites et évolutions des systèmes de fichiers
  31. Mode protégé et chargement du noyau ELF
  32. Limites et évolutions du démarrage

1. Rôle du système, appels, processus et mémoire

Notions clés & Définitions

  • Processus xv6 : une mémoire en espace utilisateur contenant instructions, données et pile, ainsi qu’un état propre au processus conservé par le noyau.

★ À maîtriser

  • Un système d’exploitation partage l’ordinateur entre plusieurs programmes, abstrait le matériel de bas niveau et fournit des moyens contrôlés pour que les programmes interagissent.

📌 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.

  • sbrk(n) augmente de n octets la mémoire de données du processus et renvoie l’adresse de la nouvelle mémoire.

Astuce mémo

fork crée le processus, exec charge le programme, exit termine son exécution.

2. Descripteurs de fichiers et communication par tubes

Notions clés & Définitions

  • Descripteur de fichier : un petit entier représentant un objet géré par le noyau, qu’un processus peut lire ou écrire.
  • Tube : un petit tampon du noyau exposé aux processus par une paire de descripteurs, l’un pour lire et l’autre pour écrire; les données écrites à une extrémité deviennent disponibles à la lecture à l’autre extrémité.

★ À 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.

  • 🔄 La connexion de wc au tube suit ces étapes :
    1. L’enfant duplique p[0] sur le descripteur 0.
    2. L’enfant ferme les descripteurs du tube devenus inutiles.
    3. L’enfant exécute wc.
    4. Le parent ferme p[0], écrit « hello world\n » dans p[1], puis ferme p[1].

📌 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.

  • Le processus qui lit un tube doit fermer ses descripteurs d’écriture, faute de quoi il peut ne jamais détecter la fin de 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.

3. Système de fichiers et interface Unix

Notions clés & Définitions

  • Répertoire : Conteneur de références nommées vers des fichiers de données et d’autres répertoires ; les répertoires forment un arbre dont la racine est le répertoire spécial /.
  • Inode : Fichier sous-jacent, distinct de son nom ; plusieurs noms, appelés liens, peuvent désigner le même inode.

★ À 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.

  • Les commandes d’opérations sur le système de fichiers, telles que mkdir, ln et rm, sont des programmes utilisateur ; cd est intégré au shell parce qu’il doit modifier le répertoire courant du shell lui-même.

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 :

    • le type de l’objet
    • le périphérique disque du système de fichiers
    • le numéro d’inode
    • le nombre de liens
    • la taille en octets

📌 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.

4. Partage des ressources, modes et noyau monolithique

Notions clés & Définitions

  • Multiplexage : Partage des ressources de l’ordinateur entre plusieurs processus afin qu’ils puissent tous progresser, même s’ils sont plus nombreux que les processeurs matériels.
  • Isolation : Principe visant à empêcher qu’une défaillance d’un processus affecte les processus qui n’en dépendent pas, tout en permettant les interactions nécessaires entre processus.
  • Noyau monolithique : Organisation où l’ensemble du système d’exploitation s’exécute en mode noyau, ce qui facilite la coopération entre ses composants mais rend fatale une erreur en mode noyau.
  • Micro-noyau : Organisation qui réduit le code exécuté en mode noyau et place la majeure partie des services du système d’exploitation en processus serveur en espace utilisateur, qui communiquent par échange de messages.

★ À maîtriser

  • Un système d’exploitation doit assurer :
    • le multiplexage
    • l’isolation
    • l’interaction entre processus

📌 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.

Astuce mémo

Interdire l’accès matériel direct → renforcer l’isolation et permettre au système de gérer les ressources.

5. Isolation des processus, piles et états

Notions clés & Définitions

  • Processus : L’unité d’isolation de xv6 qui empêche un programme d’accéder à la mémoire, au processeur et aux descripteurs de fichiers d’un autre processus, ou de compromettre le noyau.

★ À maîtriser

  • Le noyau met en œuvre l’isolation des processus au moyen de :

    • du mode utilisateur/noyau
    • des espaces d’adressage
    • du partage du temps entre les threads
  • 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 :

    • alloué
    • prêt à s’exécuter
    • en cours d’exécution
    • en attente d’entrée-sortie
    • en train de se terminer

Astuce mémo

Chaque processus possède une mémoire virtuelle privée, avec le noyau placé tout en haut de l’espace d’adressage.

6. Démarrage de xv6, premier processus et appel exec

★ À 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 :

    1. choisit un processus RUNNABLE
    2. active sa table de pages avec switchuvm
    3. le marque RUNNING
    4. appelle swtch pour passer à son thread noyau
  • 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.

Astuce mémo

userinit prépare initcode, scheduler choisit le processus, puis forkret et trapret le conduisent en espace utilisateur.

7. Organisation des noyaux réels

★ À 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

  • La plupart des systèmes d’exploitation adoptent le concept de processus, et la plupart des processus ressemblent à ceux de xv6.

📌 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.

Astuce mémo

Noyau monolithique intégré, microkernel organisé autour de serveurs

8. Traduction des adresses et espace mémoire des processus

Notions clés & Définitions

  • Table de pages : Mécanisme qui contrôle la signification des adresses mémoire en traduisant les adresses virtuelles en adresses physiques et en protégeant la mémoire des processus.

★ À 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 :

    1. Les bits 47 à 39 sélectionnent l’entrée PML4.
    2. Les bits 38 à 30 sélectionnent l’entrée PDPT.
    3. Les bits 29 à 21 sélectionnent l’entrée du répertoire de pages.
    4. Les bits 20 à 12 sélectionnent l’entrée de la table de pages.
    5. Le numéro de page physique est combiné aux 12 bits de décalage.
  • 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

  • Si une entrée de l’un des quatre niveaux n’est pas présente, le matériel de pagination déclenche une faute ; les tables ou branches inutilisées peuvent ainsi être omises.
  • 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.

Astuce mémo

PML4 → PDPT → répertoire → table de pages

9. Allocation physique et espace mémoire utilisateur

★ À maîtriser

  • xv6 alloue et libère des pages physiques entières de 4096 octets en utilisant la mémoire comprise entre la fin du noyau et PHYSTOP.

📌 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 :

    1. Alloue une page pour la PML4.
    2. Appelle mappages pour installer les traductions décrites dans kmap.
    3. Inclut les instructions et les données du noyau, la mémoire jusqu’à PHYSTOP et les plages d’E/S.
  • 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.

Astuce mémo

Allouer une page, créer les niveaux de tables requis, installer le PTE

10. Chargement ELF et choix de pagination

★ À 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 :

    • le paging à la demande depuis le disque
    • le fork copy-on-write
    • la mémoire partagée
    • l’allocation paresseuse des pages
    • l’extension automatique des piles

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.

Astuce mémo

Vérifier l’ELF, allouer et charger ses segments, puis préparer la pile.

11. Transferts vers le noyau, protection et vecteurs de trap

★ À 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.

  • 🔄 Lors d’un trap utilisateur, le matériel : charge %rsp depuis le segment de tâche, place l’ancien %ss et %rsp sur la nouvelle pile, empile %rflags, %cs et %rip, ajoute éventuellement un code d’erreur, charge %cs et %rip depuis l’entrée IDT

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.

Astuce mémo

IDT, privilèges, sauvegarde de l’état, puis transfert vers le gestionnaire.

12. Traitement des appels système et interruptions matérielles

Notions clés & Définitions

  • Interruption matérielle : Signal produit par un périphérique pour avertir le noyau d’un événement, par exemple la fin d’une opération d’entrée-sortie.

★ À 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 %rsp+8+8(n−6)\%rsp + 8 + 8(n-6), 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 :

    • argint pour un entier
    • argint64 pour un entier 64 bits
    • argptr pour un pointeur
    • argstr pour une chaîne
    • argfd pour un descripteur de fichier

📌 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.

Astuce mémo

Un événement matériel → une interruption → le traitement par le noyau.

13. Pilote IDE, tampons et requêtes disque

Notions clés & Définitions

  • Pilote : Code du système d’exploitation qui commande un périphérique, le configure pour générer des interruptions et traite ces interruptions.
  • Tampon de disque : Structure struct buf contenant une copie en mémoire d’un secteur d’un périphérique donné, avec son numéro de secteur et des indicateurs d’état.

★ À 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. :

    1. Iderw ajoute le tampon à la fin de la file.
    2. Si le tampon est en tête, iderw appelle idestart.
    3. Sinon, le tampon attend que les requêtes précédentes soient terminées.

📌 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.

Astuce mémo

File d’attente → démarrage → interruption → réveil

14. Principes des pilotes de périphériques

★ À 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 :

    • des paquets réseau
    • des échantillons sonores
    • des données vidéo
    • des séquences de commandes
  • 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.

Astuce mémo

DMA transfère les données directement en mémoire ; les E/S programmées les déplacent par instructions CPU.

15. Conditions de course, atomicité et choix des verrous

Notions clés & Définitions

  • Condition de course : Situation où un emplacement mémoire est accédé simultanément et où au moins un des accès est une écriture.
  • Invariant : Propriété d’une structure de données qui doit être maintenue au cours des opérations ; une opération peut la violer temporairement, mais doit la rétablir avant de se terminer.

★ À maîtriser

  • Si deux processeurs insèrent simultanément un nœud en tête d’une liste chaînée et écrivent ensuite chacun dans list, la seconde affectation peut écraser la première et perdre un nœud.

📌 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é.

Astuce mémo

Deux processeurs insèrent chacun un nœud en tête : l’affectation finale peut faire disparaître l’un des deux.

16. Granularité des verrous et prévention des interblocages

★ À 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.

  • Un verrou global du noyau, acquis à l’entrée et libéré à la sortie, permet à un noyau simple de fonctionner sur un multiprocesseur, mais un seul CPU peut alors exécuter du code noyau à la fois.

📌 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.

  • Si un chemin acquiert A puis B et un autre acquiert B puis A, deux threads peuvent chacun détenir un verrou et attendre indéfiniment celui détenu par l’autre.

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 :

    • répertoire
    • inode du nouveau fichier
    • tampon de bloc disque
    • idelock
    • ptable.lock

Astuce mémo

Un verrou global bloque le noyau entier ; des verrous fins laissent travailler plusieurs CPU.

17. Verrous, interruptions et ordre mémoire

★ À 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.

Astuce mémo

Interruption avec verrou détenu → attente impossible → interblocage.

18. Verrous dormants et limites des verrous

Notions clés & Définitions

  • Sleep-lock : un verrou qui permet au thread de céder le processeur pendant sa section critique

★ À 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.

  • Xv6 utilise surtout des spin-locks pour leur faible coût et réserve les sleep-locks au système de fichiers, où ils facilitent le maintien d’un verrou pendant les longues opérations disque.

📌 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.

Astuce mémo

Spin-lock : attente active et interruptions désactivées ; sleep-lock : le thread cède le processeur.

19. Ordonnancement des processus et accès au processeur courant

Notions clés & Définitions

  • mycpu : mycpu renvoie la structure struct cpu du processeur courant en lisant son identifiant matériel APIC local et en recherchant l’entrée correspondante dans le tableau des processeurs.
  • myproc : myproc désactive les interruptions, appelle mycpu, récupère le processus courant dans c->proc, puis réactive les interruptions ; il renvoie zéro lorsque le code s’exécute dans le planificateur sans processus courant.

★ À 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.

  • Le planificateur libère ptable.lock et active explicitement les interruptions une fois par itération, afin qu’un processeur inactif ne bloque pas les autres processeurs et puisse recevoir les interruptions d’E/S.

Astuce mémo

ptable.lock protège la transition RUNNING ↔ RUNNABLE jusqu’au rétablissement des invariants.

20. Sommeil, réveils et synchronisation des processus

Notions clés & Définitions

  • Sleep et wakeup : sleep(chan) endort le processus appelant sur un canal d’attente arbitraire chan en libérant le processeur, tandis que wakeup(chan) réveille tous les processus endormis sur ce canal et ne fait rien si aucun processus n’y attend.

★ À 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 :

    1. wakeup acquiert ptable.lock.
    2. wakeup1 parcourt la table des processus.
    3. Chaque processus SLEEPING associé à chan est marqué RUNNABLE.

📌 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 appel à wakeup peut réveiller tous les processus endormis sur le même canal, même si un seul pourra d’abord traiter la condition.

📌 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.

Astuce mémo

Le verrou maintenu jusqu’au sommeil empêche wakeup de passer avant que le processus dorme.

21. Synchronisation des tubes et terminaison des processus

Notions clés & Définitions

  • Tampon circulaire : Le tampon d’un pipe est circulaire : après buf[PIPESIZE-1], l’écriture reprend à buf[0].

★ À 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.

Astuce mémo

ZOMBIE → wait récupère le PID → le parent libère les ressources

22. Ordonnancement et synchronisation réelle

Notions clés & Définitions

  • Round robin : Le planificateur xv6 applique une politique round robin qui exécute les processus à tour de rôle.
  • Sémaphore : Un sémaphore est une valeur entière manipulée par incrémentation et décrémentation, dont la valeur ne peut pas descendre sous zéro ; décrémenter un sémaphore nul endort le processus jusqu’à une incrémentation.
  • Inversion de priorité : Une inversion de priorité se produit lorsqu’un processus de faible priorité détient un verrou partagé qui empêche un processus de priorité élevée d’avancer.
  • Convoi : Un convoi peut se former lorsque plusieurs processus de priorité élevée attendent un processus de faible priorité qui détient un verrou partagé, et persister longtemps.

★ À 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.

Astuce mémo

signal réveille un seul processus ; broadcast les réveille tous

23. Objectifs et couches du système de fichiers xv6

Notions clés & Définitions

  • Système de fichiers : Un système de fichiers organise et stocke les données, permet généralement leur partage entre utilisateurs et applications et assure leur persistance après un redémarrage.

★ À maîtriser

  • Un système de fichiers doit représenter sur disque l’arbre des fichiers et répertoires, les blocs contenant le contenu des fichiers et les zones de disque libres.

📌 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 :

    • la taille du système de fichiers en blocs
    • le nombre de blocs de données
    • le nombre d’inodes
    • le nombre de blocs du journal

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.

24. Cache de tampons disque

★ À 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

  • Après avoir modifié un tampon, l’appelant doit utiliser bwrite pour écrire les changements sur disque, puis brelse pour libérer le tampon lorsqu’il a terminé.

📌 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.

  • Lorsqu’il faut réutiliser un tampon, le cache choisit le moins récemment utilisé parmi ceux qui ne sont ni verrouillés ni marqués comme modifiés.

25. Journalisation, reprise et allocation des blocs disque

Notions clés & Définitions

  • Bitmap des blocs : Le bitmap des blocs associe un bit à chaque bloc disque : un bit nul indique un bloc libre et un bit égal à un indique un bloc utilisé.
  • Group commit : Le group commit regroupe les écritures de plusieurs appels système complets dans une seule transaction, réduisant le nombre d’opérations disque en répartissant le coût fixe d’une validation.

★ À maîtriser

  • Pour rendre une opération résistante aux pannes, xv6 inscrit les écritures dans le journal, écrit un enregistrement de validation, applique les écritures aux structures du système de fichiers, puis efface le journal.

📌 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 à :

    • le secteur d’amorçage
    • le superbloc
    • le journal
    • les blocs d’inodes
    • les blocs bitmap

📌 balloc et bfree doivent être appelées à l’intérieur d’une transaction.

Astuce mémo

Préparer le journal, valider, installer les blocs, puis effacer l’en-tête.

26. Inodes, références et verrous

★ À 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.

  • Le noyau conserve en mémoire les inodes actifs lorsqu’au moins un pointeur C les référence ; le champ ref compte ces pointeurs et l’inode est retiré de la mémoire lorsque ce compte tombe à zéro.

📌 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.

  • Quand iput() libère la dernière référence d’un inode sans lien vers un répertoire, xv6 tronque le fichier avec itrunc, libère ses blocs, marque l’inode comme libre en mettant son type à 0 et écrit l’inode sur le disque.

📌 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.

Astuce mémo

dinode sur disque, inode actif en mémoire.

27. Blocs et contenu des fichiers

★ À 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.

  • bmap renvoie le numéro du bloc de données demandé et, si ce bloc n’est pas encore alloué, alloue un nouveau bloc et inscrit son numéro dans l’inode ou dans le 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.

28. Répertoires, chemins, fichiers ouverts et descripteurs

Notions clés & Définitions

  • Répertoire : Inode de type T_DIR dont les données sont une séquence d’entrées contenant chacune un nom et un numéro d’inode.
  • struct file : Représentation d’un fichier ouvert qui enveloppe un inode ou un pipe ainsi qu’un décalage d’entrée-sortie.

★ À 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.

  • namex commence la résolution à la racine pour un chemin absolu ou dans le répertoire courant pour un chemin relatif, puis parcourt les composantes en verrouillant chaque répertoire, en recherchant la composante et en libérant le verrou avant de verrouiller l’inode suivant.

📌 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

  • Dans une entrée de répertoire xv6, le nom peut contenir au plus DIRSIZ (14) caractères, les noms plus courts sont terminés par un octet NUL et un numéro d’inode égal à zéro indique une entrée libre.

📌 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.

  • La table globale ftable gère les fichiers ouverts avec filealloc pour allouer une référence, filedup pour la dupliquer et fileclose pour la libérer.

📌 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.

Astuce mémo

Chemin → composantes → répertoire parent ou inode final

29. Liens, création de fichiers et ouverture

★ À maîtriser

  • sys_link vérifie que l’inode source existe et n’est pas un répertoire, incrémente son nombre de liens, recherche le répertoire parent du nouveau chemin avec nameiparent, puis crée une nouvelle entrée pointant vers l’inode source.

📌 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.

  • Les transactions garantissent que les mises à jour de blocs nécessaires à sys_link réussissent toutes ou qu’aucune n’est appliquée, évitant qu’un crash laisse le système de fichiers dans un état incohérent.

📌 sys_link crée un nouveau nom pour un inode existant, tandis que create crée un nouveau nom associé à un nouvel inode.

  • Avec O_CREATE, sys_open appelle create ; sinon, elle appelle namei, puis verrouille elle-même l’inode puisque namei ne le retourne pas verrouillé.

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.

  • sys_pipe reçoit un pointeur vers deux entiers, alloue un tube et installe les deux descripteurs de fichiers en les inscrivant dans l’espace indiqué.

30. Limites et évolutions des systèmes de fichiers

Notions clés & Définitions

  • Mode réel : Le mode dans lequel le processeur simule un Intel 8088, avec huit registres généraux de 16 bits et des adresses mémoire de 20 bits.

★ À 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.

  • La première instruction du boot loader, cli, désactive les interruptions matérielles jusqu’à ce que xv6 soit prêt à les réactiver.

Astuce mémo

Le répertoire xv6 balaie linéairement ; les arbres équilibrés garantissent une recherche logarithmique.

31. Mode protégé et chargement du noyau ELF

Notions clés & Définitions

  • Mode protégé : Utilise des descripteurs de segment définissant une adresse de base, une limite d’adresse et des bits de permission.

★ À 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

  • Le boot loader met à zéro %ds, %es et %ss, puis active par les ports 0x64 et 0x60 le 21e bit d’adresse nécessaire à la compatibilité PC.

📌 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.

  • Le boot loader choisit 0x7c00 comme sommet de pile, qui croît vers les adresses basses, loin du boot loader chargé entre 0x7c00 et 0x7e00.

📌 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 point d’entrée ELF du noyau xv6 est 0x10000c, et le symbole _start le définit dans le fichier entry.S.

📌 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.

Astuce mémo

Lire l’ELF, charger ses segments, puis appeler son point d’entrée

32. Limites et évolutions du démarrage

★ À 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.

  • UEFI permet à un PC de lire sur le disque un chargeur plus volumineux et de le démarrer en mode 64 bits.

Astuce mémo

Le chargeur xv6 tient en 512 octets ; un chargeur complet dispose de plus d’espace

Tableaux de synthèse

Noyau monolithique et micro-noyau

OrganisationServicesCaractéristique
Noyau monolithiqueSystème d’exploitation en mode noyauCoopération facilitée ; une erreur noyau peut faire échouer le système
Micro-noyauServices principalement en serveurs utilisateurNoyau réduit ; communication par messages

Indicateurs des entrées de page

IndicateurRôle
PTE_PIndique que l’entrée est présente.
PTE_WAutorise l’écriture dans la page.
PTE_UAutorise l’accès depuis un programme utilisateur.

Teste tes connaissances

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 :

Faire le QCM →

Révisez avec les flashcards

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.

Voir les flashcards →

Cours similaires

Crée tes propres fiches de révision

Importe ton cours et l'IA génère fiches, QCM et flashcards en 30 secondes.

Générateur de fiches