QCM : Synchronisation et système de fichiers xv6 (99 questions)

Questions et réponses du QCM

1. Concernant le rôle du système d’exploitation :

Il partage l’ordinateur entre plusieurs programmes et abstrait le matériel de bas niveau.
Un appel système fait entrer le processus dans le noyau pour obtenir un service.
Le système d’exploitation abstrait les services logiciels, mais laisse le matériel de bas niveau directement gérer les programmes.
Un appel système exécute le service demandé dans le processus utilisateur, sans passage par le noyau.
xv6 réimplémente Unix Version 6 en C ANSI pour une architecture multiprocesseur x86-64.

Il partage l’ordinateur entre plusieurs programmes et abstrait le matériel de bas niveau. · Un appel système fait entrer le processus dans le noyau pour obtenir un service. · xv6 réimplémente Unix Version 6 en C ANSI pour une architecture multiprocesseur x86-64.

Explication

Le système d’exploitation partage l’ordinateur et abstrait le matériel. Un appel système passe par le noyau, puis rend le contrôle au processus. xv6 est bien une réimplémentation de Unix Version 6 écrite en C ANSI pour x86-64 multiprocesseur ; l’abstraction concerne le matériel de bas niveau, et l’appel système entre dans le noyau.

2. Un processus xv6 comprend :

La sauvegarde des registres lors de l’arrêt du processus permet leur restauration à sa reprise.
La fonction sleep(n) termine le processus appelant après n cycles d’horloge.
L’interface xv6 associe à read(fd, buf, n) l’ouverture d’un fichier en lecture seule.
Une mémoire utilisateur contenant instructions et données, avec un état noyau partagé entre tous les processus.
Une mémoire utilisateur contenant des instructions, des données et une pile, ainsi qu’un état noyau propre.

La sauvegarde des registres lors de l’arrêt du processus permet leur restauration à sa reprise. · Une mémoire utilisateur contenant des instructions, des données et une pile, ainsi qu’un état noyau propre.

Explication

La mémoire utilisateur d’un processus contient instructions, données et pile, et le noyau conserve son état propre. Lorsqu’un processus cesse de s’exécuter, xv6 sauvegarde ses registres puis les restaure à la reprise. L’état noyau n’est pas partagé entre processus ; read lit des octets dans un descripteur ouvert, tandis que sleep suspend le processus pendant n tops d’horloge.

3. Un programme appelle fork, puis le parent modifie une variable et l’enfant appelle exec avec succès. Quelles propositions sont exactes ?

Après exec, l’enfant exécute l’image chargée depuis le fichier au point d’entrée ELF indiqué.
Après fork, les registres du parent et de l’enfant restent communs, comme leurs valeurs de variables.
La modification ultérieure de la variable par le parent ne modifie pas sa copie chez l’enfant.
L’enfant reçoit initialement une mémoire identique à celle du parent au moment de fork.
fork renvoie zéro au parent et le pid de l’enfant au processus enfant.

Après exec, l’enfant exécute l’image chargée depuis le fichier au point d’entrée ELF indiqué. · La modification ultérieure de la variable par le parent ne modifie pas sa copie chez l’enfant. · L’enfant reçoit initialement une mémoire identique à celle du parent au moment de fork.

Explication

fork crée un enfant dont la mémoire initiale est identique à celle du parent ; les deux mémoires deviennent distinctes, de sorte que la modification du parent n’affecte pas l’enfant. exec remplace la mémoire par l’image du fichier et démarre au point d’entrée ELF. Les valeurs de retour de fork sont inversées dans la proposition correspondante, et les registres ne sont pas communs.

4. Un shell prépare une redirection dans un enfant avant de lancer un programme, puis ce programme termine après une augmentation de mémoire par sbrk. Quelles propositions sont exactes ?

sbrk(24) augmente de 24 octets la mémoire de données du processus et renvoie l’adresse obtenue.
wait peut renvoyer le pid d’un enfant terminé ou attendre la fin d’un enfant.
sbrk(24) renvoie le nombre d’octets ajoutés et laisse inchangée la mémoire de données.
La séparation de fork et exec permet au shell de préparer les descripteurs avant le chargement du programme.
exit termine le processus appelant et libère notamment sa mémoire et ses fichiers ouverts.

sbrk(24) augmente de 24 octets la mémoire de données du processus et renvoie l’adresse obtenue. · wait peut renvoyer le pid d’un enfant terminé ou attendre la fin d’un enfant. · La séparation de fork et exec permet au shell de préparer les descripteurs avant le chargement du programme. · exit termine le processus appelant et libère notamment sa mémoire et ses fichiers ouverts.

Explication

exit termine le processus et libère ses ressources, notamment mémoire et fichiers ouverts ; wait renvoie le pid d’un enfant terminé ou attend sa terminaison. La séparation de fork et exec permet au shell de régler les descripteurs avant le chargement du programme. sbrk(24) ajoute 24 octets et renvoie l’adresse de la nouvelle mémoire, et non le nombre d’octets ajoutés.

5. À propos des descripteurs de fichiers et de leur lecture :

Les descripteurs 0, 1 et 2 représentent respectivement l’entrée standard, la sortie standard et la sortie d’erreur.
Un descripteur est un petit entier représentant un objet géré par le noyau, accessible en lecture ou écriture.
read(fd, buf, n) lit exactement n octets et renvoie n lorsque le fichier arrive à sa fin.
Un descripteur peut désigner un fichier, un répertoire, un périphérique ou un tube présenté comme flux d’octets.
Le descripteur 1 correspond par convention à l’entrée standard, généralement reliée à la console.

Les descripteurs 0, 1 et 2 représentent respectivement l’entrée standard, la sortie standard et la sortie d’erreur. · Un descripteur est un petit entier représentant un objet géré par le noyau, accessible en lecture ou écriture. · Un descripteur peut désigner un fichier, un répertoire, un périphérique ou un tube présenté comme flux d’octets.

Explication

Un descripteur est un entier représentant un objet géré par le noyau, et les numéros 0, 1 et 2 correspondent à l’entrée standard, la sortie standard et la sortie d’erreur. Les objets référencés peuvent être des fichiers, répertoires, périphériques ou tubes présentés comme des flux d’octets. read lit au plus n octets et renvoie zéro à la fin ; le numéro 1 désigne la sortie standard.

6. Un parent ouvre un fichier, appelle fork, puis enfant et parent écrivent via leurs descripteurs hérités. Quelles propositions sont exactes ?

Après close, le prochain descripteur alloué est le plus grand numéro inutilisé du processus courant.
write écrit à partir de l’offset courant et avance cet offset du nombre d’octets écrits.
Les descripteurs hérités par fork partagent l’offset du fichier sous-jacent entre parent et enfant.
Les descripteurs hérités par fork ont des offsets indépendants, comme après deux appels open distincts.
dup crée un descripteur supplémentaire qui partage l’offset avec le descripteur d’origine.

write écrit à partir de l’offset courant et avance cet offset du nombre d’octets écrits. · Les descripteurs hérités par fork partagent l’offset du fichier sous-jacent entre parent et enfant. · dup crée un descripteur supplémentaire qui partage l’offset avec le descripteur d’origine.

Explication

Les descripteurs copiés par fork partagent l’offset du fichier sous-jacent, et write avance cet offset du nombre d’octets écrits. dup produit un descripteur partageant l’offset avec l’original. Après close, le prochain numéro alloué est le plus petit numéro inutilisé ; deux appels open distincts ne partagent pas l’offset.

7. Un processus lit un tube vide dont le descripteur d’écriture reste ouvert dans un autre processus. Que peut-il se passer ?

L’appel read attend des données ou la fermeture de tous les descripteurs d’écriture du tube.
Dans un pipeline, le shell lance les deux commandes dans un même processus puis les attend.
La fermeture du descripteur de lecture déclenche le retour de read avec la valeur zéro.
Le lecteur doit conserver ouvert son descripteur d’écriture pour recevoir les données du tube.
Le lecteur détecte la fin de fichier dès que le tampon du tube est vide.

L’appel read attend des données ou la fermeture de tous les descripteurs d’écriture du tube.

Explication

Un read sur un tube vide attend l’arrivée de données ou la fermeture de toutes les extrémités d’écriture ; lorsque celles-ci sont fermées, il renvoie zéro. Le lecteur doit fermer ses propres descripteurs d’écriture pour éviter de bloquer la détection de fin de fichier, et le shell exécute les commandes d’un pipeline dans des processus enfants.

8. Un processus dont le répertoire courant est /a résout les chemins /b/c et d/e ; quelles propositions sont exactes ?

Les répertoires forment une liste plate dont la racine est le répertoire courant.
Le chemin relatif d/e est résolu depuis le répertoire courant du processus.
Le chemin /b/c est résolu depuis la racine du système de fichiers.
L’appel mkdir crée un fichier de données nommé selon le chemin fourni.
L’appel open avec O_CREATE crée un répertoire dans le système de fichiers.

Le chemin relatif d/e est résolu depuis le répertoire courant du processus. · Le chemin /b/c est résolu depuis la racine du système de fichiers.

Explication

Un chemin commençant par / est résolu depuis la racine, tandis que d/e est résolu depuis /a, le répertoire courant du processus. mkdir crée un répertoire, open avec O_CREATE crée un fichier de données, et les répertoires constituent un arbre enraciné en /.

9. Après la création d’un lien supplémentaire vers un fichier, son nom initial est supprimé alors qu’un descripteur reste ouvert. Que peut-on en déduire ?

La suppression du nom initial libère l’inode dès que son nombre de liens devient nul, malgré le descripteur ouvert.
L’inode et ses données restent alloués tant qu’un descripteur les référence.
Les deux noms associés au même inode peuvent être reconnus par leur numéro d’inode commun.
La commande cd est un programme utilisateur ordinaire qui modifie le répertoire du shell parent.
La commande ln modifie le répertoire courant du processus comme le ferait cd.

L’inode et ses données restent alloués tant qu’un descripteur les référence. · Les deux noms associés au même inode peuvent être reconnus par leur numéro d’inode commun.

Explication

La suppression d’un nom ne libère l’inode et ses données que si le nombre de liens est nul et qu’aucun descripteur ne le référence ; le descripteur encore ouvert les maintient donc accessibles. Des noms liés désignent le même inode et partagent son numéro. cd est intégré au shell pour modifier son propre répertoire courant, tandis que ln est une commande utilisateur d’opération sur le système de fichiers.

10. Pourquoi cd est-il intégré au shell, et quelles caractéristiques sont associées à l’interface Unix ?

Les tubes et les descripteurs standard ont empêché le développement d’outils logiciels réutilisables.
Xv6 est conforme à POSIX et fournit notamment une implémentation complète de l’appel lseek.
L’association des descripteurs standard, des tubes et de la syntaxe du shell a favorisé des programmes réutilisables.
Le shell doit lancer cd comme une commande enfant pour changer son propre répertoire courant.
Exécuté dans un processus enfant, cd modifierait le répertoire courant de cet enfant, pas celui du shell parent.

L’association des descripteurs standard, des tubes et de la syntaxe du shell a favorisé des programmes réutilisables. · Exécuté dans un processus enfant, cd modifierait le répertoire courant de cet enfant, pas celui du shell parent.

Explication

Un cd exécuté dans un enfant ne modifierait que le répertoire courant de cet enfant ; le shell intègre donc cd pour changer son propre répertoire. Les descripteurs standard, les tubes et la syntaxe du shell ont favorisé les outils réutilisables. L’interface Unix est normalisée par POSIX, mais xv6 n’est pas conforme à cette norme et omet notamment lseek.

11. Un ordinateur exécute davantage de processus que de processeurs matériels ; certains processus peuvent échouer. Quelles propositions décrivent les exigences du système d’exploitation ?

L’isolation vise à empêcher qu’une défaillance affecte les processus qui ne dépendent pas du processus défaillant.
Une bibliothèque donnant un accès direct au matériel renforce l’isolation entre applications défectueuses.
Le multiplexage permet à davantage de processus que de processeurs matériels de progresser.
Le système d’exploitation doit assurer multiplexage, isolation et interaction entre processus.
Le multiplexage vise à empêcher les interactions nécessaires entre les processus indépendants.

L’isolation vise à empêcher qu’une défaillance affecte les processus qui ne dépendent pas du processus défaillant. · Le multiplexage permet à davantage de processus que de processeurs matériels de progresser. · Le système d’exploitation doit assurer multiplexage, isolation et interaction entre processus.

Explication

Le multiplexage partage les ressources afin que les processus puissent progresser même s’ils sont plus nombreux que les processeurs matériels. L’isolation limite les effets d’une défaillance sans supprimer les interactions nécessaires, et le système d’exploitation doit assurer ces trois exigences. Un accès direct au matériel par une bibliothèque offre moins d’isolation lorsque les applications sont défectueuses ou ne cèdent pas le processeur.

12. Une application en mode utilisateur demande la lecture d’un fichier par un appel système ; quelles propositions décrivent le traitement et les privilèges ?

En mode utilisateur, le processeur interdit les instructions privilégiées, contrairement au mode noyau.
L’appel read permet d’accéder au système de fichiers sans manipuler directement les secteurs du disque.
Un appel système fait passer le processeur en mode noyau par une instruction spéciale vers un point d’entrée fixé.
En mode noyau, le processeur interdit les instructions privilégiées qui permettent les opérations d’entrée-sortie.
Pour partager le processeur, Unix sauvegarde et restaure l’état des registres des processus.

En mode utilisateur, le processeur interdit les instructions privilégiées, contrairement au mode noyau. · L’appel read permet d’accéder au système de fichiers sans manipuler directement les secteurs du disque. · Un appel système fait passer le processeur en mode noyau par une instruction spéciale vers un point d’entrée fixé. · Pour partager le processeur, Unix sauvegarde et restaure l’état des registres des processus.

Explication

Le mode utilisateur interdit les instructions privilégiées, alors que le mode noyau les autorise. read abstrait l’accès au système de fichiers, le partage du processeur s’appuie sur la sauvegarde et la restauration des registres, et l’appel système entraîne une transition vers un point d’entrée du noyau. En mode noyau, les instructions privilégiées sont autorisées, notamment celles nécessaires aux opérations d’entrée-sortie.

13. Un système place tous les services du système d’exploitation en mode noyau et contrôle les transitions privilégiées. Concernant ces choix d’organisation :

Dans un noyau monolithique, les services principaux s’exécutent en processus serveur utilisateur.
Un micro-noyau réduit le code en mode noyau et place des services en serveurs utilisateur.
Le noyau fixe le point d’entrée afin de pouvoir valider les arguments des appels système.
Dans un noyau monolithique, une erreur en mode noyau peut entraîner l’arrêt du système.
Un micro-noyau facilite la communication entre services par partage direct de leurs mémoires.

Un micro-noyau réduit le code en mode noyau et place des services en serveurs utilisateur. · Le noyau fixe le point d’entrée afin de pouvoir valider les arguments des appels système. · Dans un noyau monolithique, une erreur en mode noyau peut entraîner l’arrêt du système.

Explication

Une erreur en mode noyau peut faire échouer un noyau monolithique, tandis qu’un micro-noyau place la majeure partie des services dans des serveurs utilisateur communiquant par messages. Le noyau fixe aussi l’entrée des transitions pour empêcher le contournement de la validation des arguments.

14. Parmi les propositions suivantes concernant l’organisation du noyau de xv6, la(les)quelle(s) est(sont) exacte(s) ?

L’interface noyau de xv6 correspond à l’interface offerte par son système d’exploitation.
Le noyau de xv6 reste plus petit que certains micro-noyaux parce qu’il fournit peu de services.
Dans xv6, la plupart des services fonctionnent dans des serveurs en espace utilisateur.
Xv6 adopte un noyau monolithique qui implémente le système d’exploitation complet.
L’interface noyau de xv6 ne représente qu’une partie de l’interface du système d’exploitation.

L’interface noyau de xv6 correspond à l’interface offerte par son système d’exploitation. · Le noyau de xv6 reste plus petit que certains micro-noyaux parce qu’il fournit peu de services. · Xv6 adopte un noyau monolithique qui implémente le système d’exploitation complet.

Explication

Xv6 est monolithique : son noyau implémente le système complet et son interface correspond à celle du système d’exploitation. Sa taille réduite par rapport à certains micro-noyaux s’explique par le petit nombre de services fournis.

15. Un processus tente de lire la mémoire d’un autre processus et d’accéder à ses descripteurs. Concernant l’isolation dans xv6 :

Le noyau combine modes utilisateur et noyau, espaces d’adressage et partage temporel des threads.
L’abstraction de processus vise à empêcher cet accès aux ressources d’un autre processus.
Chaque processus de xv6 utilise une table de pages commune définissant son espace d’adressage.
Le matériel traduit les adresses virtuelles des instructions en adresses physiques de mémoire.
L’isolation des processus protège la mémoire, mais ne concerne pas le noyau lui-même.

Le noyau combine modes utilisateur et noyau, espaces d’adressage et partage temporel des threads. · L’abstraction de processus vise à empêcher cet accès aux ressources d’un autre processus. · Le matériel traduit les adresses virtuelles des instructions en adresses physiques de mémoire.

Explication

Le processus est l’unité d’isolation et protège notamment la mémoire, les descripteurs et le noyau. Cette isolation s’appuie sur les modes, les espaces d’adressage et le partage temporel; les tables matérielles traduisent les adresses virtuelles en adresses physiques. Dans xv6, chaque processus possède sa propre table de pages.

16. Un programme xv6 agrandit son tas et effectue un appel système. Concernant l’organisation de son espace d’adressage :

Dans l’espace utilisateur, les instructions précèdent les variables globales, puis la pile et le tas extensible.
Dans l’espace utilisateur, le tas précède la pile et les variables globales suivent les instructions.
Le champ p->pml4 contient la table de pages et consigne les adresses des pages physiques allouées.
La structure struct proc rassemble notamment l’état, la table de pages et la pile noyau du processus.
L’espace d’adressage mappe aussi le noyau à des adresses hautes à partir de 0x80000100000.

Dans l’espace utilisateur, les instructions précèdent les variables globales, puis la pile et le tas extensible. · Le champ p->pml4 contient la table de pages et consigne les adresses des pages physiques allouées. · La structure struct proc rassemble notamment l’état, la table de pages et la pile noyau du processus. · L’espace d’adressage mappe aussi le noyau à des adresses hautes à partir de 0x80000100000.

Explication

L’espace utilisateur est organisé avec les instructions, les variables globales, la pile puis le tas extensible; le noyau est mappé à des adresses hautes. La structure struct proc rassemble l’état du processus, sa table de pages et sa pile noyau; p->pml4 contient la table et sert aussi de registre des pages physiques allouées.

17. Un processus a endommagé sa pile utilisateur, puis le noyau doit reprendre son exécution. Quelles propositions décrivent correctement les piles et threads de xv6 ?

Le noyau change de processus en détruisant le thread suspendu avant d’en créer un autre.
Le thread d’un processus peut être suspendu puis repris lors d’un changement de processus.
Le code noyau peut s’exécuter sur la pile noyau, séparée et protégée du code utilisateur.
La séparation des piles permet au noyau de fonctionner malgré une pile utilisateur endommagée.
Le code noyau utilise la pile utilisateur après l’entrée dans le noyau pour poursuivre son exécution.

Le thread d’un processus peut être suspendu puis repris lors d’un changement de processus. · Le code noyau peut s’exécuter sur la pile noyau, séparée et protégée du code utilisateur. · La séparation des piles permet au noyau de fonctionner malgré une pile utilisateur endommagée.

Explication

Chaque processus possède une pile utilisateur et une pile noyau; après l’entrée dans le noyau, celui-ci utilise la pile noyau protégée, ce qui permet de fonctionner malgré une pile utilisateur endommagée. Un thread peut être suspendu puis repris; le changement de processus ne suppose pas sa destruction.

18. Un appel système déclenche une entrée dans le noyau tandis qu’un autre thread attend la fin d’une entrée-sortie. Concernant ces transitions et états :

Dans xv6, p->state peut indiquer qu’un processus attend une entrée-sortie.
Après une entrée-sortie terminée, le thread reprend depuis le début de son opération.
Un thread bloqué pour une entrée-sortie peut reprendre là où il s’était arrêté.
Au retour d’un appel système, le processeur conserve le privilège noyau et la pile noyau active.
À l’entrée, le processeur passe à la pile noyau et élève son niveau de privilège.

Dans xv6, p->state peut indiquer qu’un processus attend une entrée-sortie. · Un thread bloqué pour une entrée-sortie peut reprendre là où il s’était arrêté. · À l’entrée, le processeur passe à la pile noyau et élève son niveau de privilège.

Explication

L’entrée dans le noyau active la pile noyau et élève le privilège; à la fin, le retour s’effectue vers la pile utilisateur et reprend après l’instruction d’appel système. Un thread en attente d’entrée-sortie reprend où il s’était arrêté, et p->state peut représenter cet état d’attente.

19. Au démarrage de xv6, le chargeur lance le noyau avant l’activation de la pagination. Concernant cette séquence :

La table de pages de entry mappe les adresses virtuelles 0:0x40000000 vers les mêmes adresses physiques.
Le chargeur place le noyau à l’adresse physique 0x100000 et commence son exécution à entry.
Le mapping haut de KERNBASE sert au chargeur avant le lancement du noyau à basse adresse.
Le noyau est chargé à 0x100000 car la plage 0xa0000:0x100000 contient des périphériques d’entrée-sortie.
Le mapping bas de entry reste nécessaire après son exécution, tandis que le mapping haut est supprimé.

La table de pages de entry mappe les adresses virtuelles 0:0x40000000 vers les mêmes adresses physiques. · Le chargeur place le noyau à l’adresse physique 0x100000 et commence son exécution à entry. · Le noyau est chargé à 0x100000 car la plage 0xa0000:0x100000 contient des périphériques d’entrée-sortie.

Explication

Avant l’activation de la pagination, le chargeur charge le noyau à l’adresse physique 0x100000 et l’exécute à entry; la plage précédente contient des périphériques d’entrée-sortie. entry établit un mapping identique pour la plage basse. Ce mapping bas sera ensuite supprimé, tandis que le mapping haut permettra au noyau d’accéder à ses instructions et données depuis KERNBASE.

20. Lors de la création du premier processus par xv6, quelles propositions décrivent correctement les étapes concernées ?

allocproc marque EMBRYO une entrée UNUSED et lui attribue un identifiant de processus unique.
Le contexte préparé par allocproc fait commencer le thread noyau dans forkret, puis dans trapret.
inituvm place le binaire initcode.S à l’adresse virtuelle 4096 de la première page utilisateur.
inituvm mappe l’adresse virtuelle zéro sur une page physique contenant initcode.S.
En cas d’échec d’allocation de la pile noyau, allocproc conserve l’entrée à l’état EMBRYO.

allocproc marque EMBRYO une entrée UNUSED et lui attribue un identifiant de processus unique. · Le contexte préparé par allocproc fait commencer le thread noyau dans forkret, puis dans trapret. · inituvm mappe l’adresse virtuelle zéro sur une page physique contenant initcode.S.

Explication

allocproc réserve une entrée UNUSED en la passant à EMBRYO et lui attribue un identifiant unique ; son contexte dirige le thread vers forkret puis trapret. inituvm mappe l’adresse zéro et y copie initcode.S ; l’adresse virtuelle 4096 concerne le sommet de pile initial, et un échec d’allocation remet l’entrée à UNUSED.

21. Un processus xv6 est choisi par l’ordonnanceur pour sa première exécution ; quelles propositions sont exactes ?

Le scheduler active la table de pages du processus avec switchuvm avant son changement de contexte.
Pour initproc, trapret restaure un pointeur d’instruction nul et une pile virtuelle valant 4096.
Avec CPL égal à 3, le code utilisateur ne peut accéder qu’aux pages portant le drapeau PTE_U.
Le scheduler marque le processus RUNNING après swtch, une fois son thread noyau exécuté.
Pour initproc, iretq reprend à l’adresse virtuelle 4096 avec un pointeur de pile nul.

Le scheduler active la table de pages du processus avec switchuvm avant son changement de contexte. · Pour initproc, trapret restaure un pointeur d’instruction nul et une pile virtuelle valant 4096. · Avec CPL égal à 3, le code utilisateur ne peut accéder qu’aux pages portant le drapeau PTE_U.

Explication

Le scheduler active la table de pages avec switchuvm, marque le processus RUNNING puis appelle swtch. Pour initproc, trapret conduit à l’adresse d’instruction 0 et à la pile 4096 ; CPL=3 restreint l’accès utilisateur aux pages PTE_U. L’ordre indiqué pour RUNNING et swtch est inversé, et les valeurs d’adresse de reprise et de pile sont interverties dans la dernière proposition.

22. initcode.S lance exec pour démarrer /init ; quelles propositions décrivent correctement cet appel ?

Un échec d’exec entraîne un retour à initcode.S, qui appelle alors exit en boucle.
exec remplace l’identifiant du processus et son processus parent avec ceux du programme chargé.
initcode.S place l’adresse de $init dans %rdi et celle de $argv dans %rsi avant l’appel.
Après un exec réussi, le processus commence à exécuter le programme demandé sans revenir à initcode.S.
initcode.S place SYS_exec dans %rdi et l’adresse de $init dans %rax avant l’interruption.

Un échec d’exec entraîne un retour à initcode.S, qui appelle alors exit en boucle. · initcode.S place l’adresse de $init dans %rdi et celle de $argv dans %rsi avant l’appel. · Après un exec réussi, le processus commence à exécuter le programme demandé sans revenir à initcode.S.

Explication

Un exec réussi remplace l’image mémoire et les registres puis commence le programme demandé sans revenir ; initcode.S transmet $init dans %rdi et $argv dans %rsi. En cas d’échec, l’appel revient et initcode.S boucle sur exit. exec conserve l’identifiant et le parent, et SYS_exec est placé dans %rax, non dans %rdi.

23. À propos de l’organisation des noyaux réels, quelles propositions sont exactes ?

Un noyau monolithique regroupe les fonctions du système dans le noyau, tandis qu’un microkernel recourt à des serveurs.
Dans un noyau monolithique, les fonctions du système sont organisées en serveurs plutôt que regroupées dans le noyau.
L4, Minix et QNX sont cités comme des exemples de noyaux monolithiques déployés dans l’embarqué.
La plupart des systèmes d’exploitation adoptent le concept de processus, et la plupart ressemblent à ceux de xv6.
Linux est présenté comme un microkernel organisé autour de serveurs pour ses fonctions système.

Un noyau monolithique regroupe les fonctions du système dans le noyau, tandis qu’un microkernel recourt à des serveurs. · La plupart des systèmes d’exploitation adoptent le concept de processus, et la plupart ressemblent à ceux de xv6.

Explication

La distinction porte sur le regroupement des fonctions dans le noyau monolithique et leur organisation en serveurs dans un microkernel ; Linux est cité comme monolithique, tandis que L4, Minix et QNX sont des microkernels. La plupart des systèmes adoptent aussi le concept de processus et la plupart des processus ressemblent à ceux de xv6.

24. Pour trouver une structure proc libre, quelle comparaison entre xv6 et un système réel est correcte ?

xv6 parcourt linéairement la table des processus, tandis qu’un système réel peut utiliser une liste libre en temps constant.
Un système réel repère les structures proc libres par un balayage linéaire de toute la table.
Dans xv6, allocproc trouve une structure proc libre en temps constant grâce à un index dédié.
xv6 utilise une liste libre explicite pour repérer les structures proc en temps constant.
La recherche linéaire des structures proc libres est attribuée aux systèmes réels plutôt qu’à xv6.

xv6 parcourt linéairement la table des processus, tandis qu’un système réel peut utiliser une liste libre en temps constant.

Explication

xv6 utilise un balayage linéaire dans allocproc pour repérer une structure proc libre. La comparaison donnée pour un système réel est une liste libre explicite, permettant une recherche en temps constant ; les autres propositions inversent ces méthodes.

25. Une adresse virtuelle x86-64 est traduite par le matériel de pagination ; quelles propositions sont exactes ?

La table de pages traduit les adresses virtuelles en adresses physiques et contribue à protéger la mémoire des processus.
La traduction x86-64 s’appuie sur quatre niveaux, comprenant PML4, PDPT, répertoire et table de pages.
Une adresse virtuelle x86-64 utilise 48 bits, avec extension du bit 47 dans les bits 63 à 48.
Les douze bits de poids faible sont conservés lors de la traduction, ce qui correspond à des pages de 4096 octets.
Chaque niveau de la table de pages x86-64 contient 256 entrées, réparties sur quatre niveaux.

La table de pages traduit les adresses virtuelles en adresses physiques et contribue à protéger la mémoire des processus. · La traduction x86-64 s’appuie sur quatre niveaux, comprenant PML4, PDPT, répertoire et table de pages. · Une adresse virtuelle x86-64 utilise 48 bits, avec extension du bit 47 dans les bits 63 à 48. · Les douze bits de poids faible sont conservés lors de la traduction, ce qui correspond à des pages de 4096 octets.

Explication

La table de pages effectue la traduction et participe à la protection mémoire. Les adresses virtuelles x86-64 sont décrites sur 48 bits avec extension du bit 47 ; la traduction suit quatre niveaux et conserve les douze bits de décalage, soit des pages de 4096 octets. Chaque niveau contient 512 entrées, non 256.

26. Lors d’une traduction d’adresse virtuelle x86-64, quelles propositions décrivent correctement le parcours et les indicateurs ?

Le matériel sélectionne successivement des entrées dans la PML4, la PDPT, le répertoire puis la table de pages.
Une entrée absente à l’un des quatre niveaux déclenche une faute du matériel de pagination.
PTE_P signale la présence, PTE_W autorise l’écriture et PTE_U l’accès depuis un programme utilisateur.
Le parcours utilise des groupes de 12 bits par niveau, puis combine le résultat avec un décalage de 9 bits.
PTE_W indique la présence d’une entrée, tandis que PTE_P autorise l’écriture et PTE_U l’accès utilisateur.

Le matériel sélectionne successivement des entrées dans la PML4, la PDPT, le répertoire puis la table de pages. · Une entrée absente à l’un des quatre niveaux déclenche une faute du matériel de pagination. · PTE_P signale la présence, PTE_W autorise l’écriture et PTE_U l’accès depuis un programme utilisateur.

Explication

Le parcours sélectionne une entrée à chacun des quatre niveaux et combine le numéro de page physique avec le décalage. Une entrée absente déclenche une faute ; PTE_P indique la présence, PTE_W l’autorisation d’écriture et PTE_U l’accès utilisateur. Les indices de niveaux utilisent des groupes de 9 bits, et les rôles de PTE_P et PTE_W ne sont pas ceux intervertis dans la dernière proposition.

27. Parmi les propositions suivantes concernant les mappages du noyau et des espaces utilisateur, lesquelles sont exactes ?

Les entrées PTE_P des zones inutilisées restent à zéro, tandis que les processus traduisent leurs adresses vers des pages distinctes.
Les mappages du noyau au-dessus de KERNBASE portent PTE_U afin que les processus y accèdent directement.
Les tables de pages des processus comprennent les mappages du noyau situés au-dessus de KERNBASE.
L’espace utilisateur virtuel commence à KERNBASE et peut croître jusqu’à PHYSTOP, permettant d’adresser jusqu’à 8 téraoctets.
Les adresses virtuelles de KERNBASE à KERNBASE+PHYSTOP correspondent aux adresses physiques de zéro à PHYSTOP.

Les entrées PTE_P des zones inutilisées restent à zéro, tandis que les processus traduisent leurs adresses vers des pages distinctes. · Les tables de pages des processus comprennent les mappages du noyau situés au-dessus de KERNBASE. · Les adresses virtuelles de KERNBASE à KERNBASE+PHYSTOP correspondent aux adresses physiques de zéro à PHYSTOP.

Explication

Les zones inutilisées ont PTE_P à zéro, et les tables distinctes dirigent les adresses utilisateur vers des pages physiques distinctes. Les mappages du noyau figurent dans chaque table au-dessus de KERNBASE, sans PTE_U; leur correspondance va de KERNBASE:KERNBASE+PHYSTOP vers 0:PHYSTOP. L’espace utilisateur commence à zéro et peut croître jusqu’à KERNBASE, tandis que les mappages du noyau ne portent pas PTE_U.

28. Pour installer des traductions noyau dans xv6, quelles opérations et caractéristiques décrivent l’allocation et la mise en place des pages ?

L’allocateur xv6 prend et libère des pages physiques entières de 4096 octets entre la fin du noyau et PHYSTOP.
setupkvm réserve une page pour la PML4, puis installe les traductions décrites dans kmap.
Les traductions installées comprennent les instructions, les données, la mémoire physique jusqu’à PHYSTOP et des plages d’E/S.
mappages traite les adresses virtuelles par pages et inscrit numéro physique, permissions demandées et PTE_P.
walkpml4 commence la recherche au niveau PML4, et walkpglevel peut créer une table inférieure si alloc est activé.

L’allocateur xv6 prend et libère des pages physiques entières de 4096 octets entre la fin du noyau et PHYSTOP. · setupkvm réserve une page pour la PML4, puis installe les traductions décrites dans kmap. · Les traductions installées comprennent les instructions, les données, la mémoire physique jusqu’à PHYSTOP et des plages d’E/S. · mappages traite les adresses virtuelles par pages et inscrit numéro physique, permissions demandées et PTE_P. · walkpml4 commence la recherche au niveau PML4, et walkpglevel peut créer une table inférieure si alloc est activé.

Explication

L’allocateur utilise des pages de 4096 octets prises dans la mémoire située entre la fin du noyau et PHYSTOP. setupkvm alloue la PML4 et installe les mappages de kmap; mappages remplit les PTE page par page avec l’adresse physique, les permissions et PTE_P. La recherche commence au niveau PML4, peut créer les tables inférieures si alloc est activé, et les traductions noyau incluent aussi des plages d’E/S.

29. Concernant l’initialisation et le fonctionnement de l’allocateur physique xv6, cochez la (les) proposition(s) exacte(s) :

Les pages libres contiennent la liste chaînée; l’allocation en retire une et la libération l’y ajoute.
Pendant entry, l’allocateur temporaire alloue après les données du noyau sans libération pour créer la première table de pages.
kinit1 prépare l’allocation sans verrouillage dans le premier gigaoctet, puis kinit2 active le verrouillage et étend la mémoire disponible.
L’allocateur temporaire utilisé pendant entry peut libérer des pages avant la création de la première table de pages.
PHYSTOP est fixé à 1 gigaoctet, valeur qui détermine la limite physique retenue par xv6.

Les pages libres contiennent la liste chaînée; l’allocation en retire une et la libération l’y ajoute. · Pendant entry, l’allocateur temporaire alloue après les données du noyau sans libération pour créer la première table de pages. · kinit1 prépare l’allocation sans verrouillage dans le premier gigaoctet, puis kinit2 active le verrouillage et étend la mémoire disponible.

Explication

La liste libre est chaînée dans les pages elles-mêmes: kalloc en retire une et kfree l’ajoute. L’allocateur temporaire d’entry ne libère pas de mémoire et sert à créer la première table de pages. kinit1 prépare l’allocation sans verrouillage dans le premier gigaoctet, puis kinit2 active le verrouillage et rend davantage de mémoire disponible; PHYSTOP vaut 224 mégaoctets, et l’allocateur temporaire ne permet pas la libération.

30. Un programme xv6 possède un segment de texte, des données et une pile, puis demande davantage de mémoire avec sbrk. Quelles propositions décrivent correctement son espace utilisateur ?

L’espace utilisateur commence à zéro; le tas se trouve au-dessus de la pile et peut croître avec sbrk.
Le texte, les données et la pile sont contigus virtuellement, même si leurs pages physiques peuvent être discontinues.
La pile initiale occupe une page et contient au sommet les chaînes des arguments ainsi que leurs pointeurs.
La contiguïté virtuelle du texte, des données et de la pile impose des pages physiques contiguës.
Les chaînes d’arguments et leurs pointeurs sont placés sous la pile initiale, avec argc et argv dans les registres.

L’espace utilisateur commence à zéro; le tas se trouve au-dessus de la pile et peut croître avec sbrk. · Le texte, les données et la pile sont contigus virtuellement, même si leurs pages physiques peuvent être discontinues. · La pile initiale occupe une page et contient au sommet les chaînes des arguments ainsi que leurs pointeurs.

Explication

L’espace utilisateur commence à zéro et le tas se situe au-dessus de la pile pour pouvoir croître avec sbrk. Le texte, les données et la pile sont contigus dans l’espace virtuel, sans exiger de contiguïté physique; la pile initiale tient sur une page et ses chaînes d’arguments et pointeurs se trouvent à son sommet. La dernière proposition place mal ces éléments: argc et argv sont dans %rdi et %rsi.

31. Un processus agrandit puis réduit sa mémoire avec sbrk après avoir modifié ses tables de pages. Quelles conséquences sont exactes ?

Une page de garde non mappée sous la pile provoque une exception si un accès déborde de la page.
Pour une croissance, growproc alloue des pages physiques et les mappe au sommet de l’espace d’adresses.
Après une modification des tables, xv6 recharge cr3 pour conserver les anciennes entrées du TLB.
Après une modification des tables, xv6 recharge cr3 pour invalider les entrées obsolètes du TLB.
La page de garde sous la pile est mappée afin que le dépassement soit traduit sans exception.

Une page de garde non mappée sous la pile provoque une exception si un accès déborde de la page. · Pour une croissance, growproc alloue des pages physiques et les mappe au sommet de l’espace d’adresses. · Après une modification des tables, xv6 recharge cr3 pour invalider les entrées obsolètes du TLB.

Explication

Lorsque sbrk augmente la mémoire, growproc alloue et mappe des pages au sommet de l’espace; lorsqu’il la réduit, il démonte des pages et libère leur mémoire physique. La page de garde sous la pile n’est pas mappée, donc un dépassement déclenche une exception. Le rechargement de cr3 invalide les anciennes entrées du TLB, et non l’inverse.

32. Un chargeur xv6 examine un exécutable ELF dont un segment possède une taille mémoire supérieure à sa taille fichier. Quelles propositions sont exactes ?

Si filesz est inférieur à memsz, les octets excédentaires en mémoire sont initialisés à zéro.
La signature ELF_MAGIC est constituée des quatre octets 0x7F, 'E', 'L', 'F'.
exec vérifie la signature ELF, crée une nouvelle table, charge les segments et prépare la pile avec les arguments.
exec ouvre le fichier binaire après avoir préparé la pile utilisateur et les arguments.
exec réutilise la table de pages existante et prépare les arguments avant de charger les segments.

Si filesz est inférieur à memsz, les octets excédentaires en mémoire sont initialisés à zéro. · La signature ELF_MAGIC est constituée des quatre octets 0x7F, 'E', 'L', 'F'. · exec vérifie la signature ELF, crée une nouvelle table, charge les segments et prépare la pile avec les arguments.

Explication

exec vérifie le fichier ELF, crée une nouvelle table de pages, alloue et charge les segments, puis prépare la pile et les arguments. Quand filesz est inférieur à memsz, la différence est remplie de zéros, car filesz mesure les octets lus du fichier tandis que memsz mesure la taille totale en mémoire. ELF_MAGIC correspond bien à 0x7F, 'E', 'L', 'F'; l’ouverture du fichier binaire intervient avant la préparation de la pile et des arguments.

33. Lors du remplacement d’une image par exec, quelle(s) proposition(s) est (sont) exacte(s) ?

Si la création de la nouvelle image échoue, exec la libère et renvoie –1.
Les adresses demandées pour le chargement doivent rester sous KERNBASE.
La somme ph.vaddr + ph.memsz est vérifiée afin de détecter un débordement.
exec conserve l’ancienne image jusqu’à la création complète de la nouvelle.
Après une création réussie, exec installe la nouvelle image puis libère l’ancienne.

Si la création de la nouvelle image échoue, exec la libère et renvoie –1. · Les adresses demandées pour le chargement doivent rester sous KERNBASE. · La somme ph.vaddr + ph.memsz est vérifiée afin de détecter un débordement. · exec conserve l’ancienne image jusqu’à la création complète de la nouvelle. · Après une création réussie, exec installe la nouvelle image puis libère l’ancienne.

Explication

En cas d’échec pendant la création, exec libère la nouvelle image et renvoie –1, tout en préservant l’ancienne. Il contrôle le débordement de l’addition et la limite KERNBASE pour éviter des écritures dans la mémoire du noyau; en cas de succès, il installe la nouvelle image, libère l’ancienne et renvoie 0.

34. Concernant les mécanismes de pagination présents ou absents dans xv6 :

La table de pages initiale de xv6 utilise des superpages d’un gigaoctet.
L’extension automatique des piles est prise en charge par le système xv6.
xv6 implémente le fork copy-on-write pour partager les pages entre processus.
La pagination à la demande depuis le disque ne fait pas partie des mécanismes implémentés par xv6.
L’allocation paresseuse des pages figure parmi les mécanismes de pagination de xv6.

La table de pages initiale de xv6 utilise des superpages d’un gigaoctet. · La pagination à la demande depuis le disque ne fait pas partie des mécanismes implémentés par xv6.

Explication

xv6 ne met pas en œuvre la pagination à la demande depuis le disque, tandis que sa table de pages initiale utilise des superpages de 1 gigaoctet. Le fork copy-on-write, l’extension automatique des piles et l’allocation paresseuse des pages font partie des mécanismes absents de xv6.

35. Une machine dispose de beaucoup de mémoire vive et son système cherche à réduire le coût de gestion des tables de pages. Quelles propositions sont exactes ?

Des superpages de 1 gigaoctet peuvent convenir aux machines dotées de beaucoup de mémoire.
La méthode la plus répandue consiste à sonder directement les adresses physiques disponibles.
La lecture de la quantité de mémoire en mémoire non volatile est la méthode la plus répandue.
Des superpages de 2 mégaoctets peuvent réduire la surcharge de manipulation des tables de pages.
La consultation d’une table mémoire du BIOS est une méthode courante pour connaître la mémoire disponible.

Des superpages de 1 gigaoctet peuvent convenir aux machines dotées de beaucoup de mémoire. · Des superpages de 2 mégaoctets peuvent réduire la surcharge de manipulation des tables de pages. · La consultation d’une table mémoire du BIOS est une méthode courante pour connaître la mémoire disponible.

Explication

Les superpages de 2 mégaoctets ou de 1 gigaoctet peuvent réduire la surcharge des tables de pages sur les machines disposant de beaucoup de mémoire. Les méthodes courantes d’estimation de la mémoire incluent la consultation d’une table du BIOS, méthode la plus répandue; le sondage physique et la lecture de la mémoire non volatile sont d’autres possibilités.

36. Un programme demande un service, puis provoque une division par zéro, tandis qu’un périphérique signale un besoin d’attention. Quelle(s) proposition(s) est (sont) exacte(s) ?

Dans xv6, un trap est causé par un périphérique plutôt que par le processus courant.
La demande de service constitue un appel système, tandis que la division par zéro constitue une exception.
Le signal du périphérique est une exception causée par l’instruction exécutée par le programme.
La division par zéro est une interruption émise par le périphérique qui signale son activité.
Sur x86, le mécanisme matériel de transfert au gestionnaire ne concerne pas les appels système.

La demande de service constitue un appel système, tandis que la division par zéro constitue une exception.

Explication

La demande de service est un appel système et la division par zéro est une exception causée par le programme; le signal du périphérique est une interruption, et non une exception causée par l’instruction du programme. La division par zéro ne provient pas du périphérique. Sur x86, le mécanisme matériel de transfert au gestionnaire sert aussi aux appels système. Dans xv6, un trap est causé par le processus courant, tandis qu’une interruption est causée par un périphérique.

37. Un programme utilisateur exécute une instruction int visant une entrée autorisée de l’IDT. Quelles propositions décrivent correctement les privilèges et le transfert ?

L’instruction int empile d’abord %rip, puis %cs, %rflags, l’ancien %rsp et l’ancien %ss.
Le champ CPL du registre %cs indique le niveau de privilège courant.
Le x86 compte quatre niveaux de privilège, numérotés de 3, le plus privilégié, à 0.
L’IDT contient 256 entrées, chacune indiquant les valeurs de %cs et de %rsp.
Le niveau de privilège 0 est le plus privilégié, tandis que le niveau 3 l’est le moins.

Le champ CPL du registre %cs indique le niveau de privilège courant. · Le niveau de privilège 0 est le plus privilégié, tandis que le niveau 3 l’est le moins.

Explication

Le x86 numérote ses quatre niveaux de privilège de 0, le plus élevé, à 3, le plus faible; le CPL courant se lit dans %cs. L’IDT contient 256 entrées indiquant %cs et %rip, et int empile l’ancien %ss, l’ancien %rsp, %rflags, %cs puis %rip.

38. Un programme utilisateur tente d’exécuter int vers une entrée de l’IDT dont le DPL vaut 0. Quelles propositions sont exactes ?

Le processeur charge %rsp depuis le descripteur de l’IDT visé lors du changement de mode.
L’instruction provoque l’exception de protection générale int 13, car l’entrée n’a pas un DPL égal à 3.
Lors d’un transfert vers le noyau, le matériel utilise la pile utilisateur comme nouvelle pile.
Une entrée dont le DPL vaut 0 permet à un programme utilisateur d’exécuter int sans faute.
La vérification réalisée par int exige que le CPL soit supérieur ou égal au DPL visé.

L’instruction provoque l’exception de protection générale int 13, car l’entrée n’a pas un DPL égal à 3.

Explication

Pour qu’un programme utilisateur exécute int vers une entrée de l’IDT, le DPL doit être égal à 3; sinon, l’instruction déclenche int 13, une exception de protection générale. Le contrôle porte sur CPL inférieur ou égal à DPL, et le matériel prend la pile du descripteur de segment de tâche plutôt que la pile utilisateur.

39. Dans xv6, un appel système déclenche un trap utilisateur et une interruption matérielle arrive pendant son traitement. Quelles propositions sont exactes ?

La porte de trap de T_SYSCALL conserve le drapeau IF et son DPL vaut DPL_USER.
Xv6 réserve les numéros 32 à 63 aux exceptions logicielles et 0 à 31 aux interruptions matérielles.
La porte d’interruption utilisée pour les interruptions matérielles conserve le drapeau IF.
Les interruptions matérielles sont mappées par xv6 vers les numéros 32 à 63.
Lors d’un trap utilisateur, le matériel charge %rsp depuis l’entrée IDT avant d’empiler l’ancien %ss.

La porte de trap de T_SYSCALL conserve le drapeau IF et son DPL vaut DPL_USER. · Les interruptions matérielles sont mappées par xv6 vers les numéros 32 à 63.

Explication

Xv6 mappe les interruptions matérielles aux numéros 32 à 63 et configure T_SYSCALL avec une porte de trap qui ne désactive pas IF et dont le DPL vaut DPL_USER. Lors d’un trap utilisateur, %rsp est chargé depuis le segment de tâche; les interruptions 0 à 31 sont réservées aux exceptions logicielles, et une porte d’interruption efface IF.

40. Un appel système à sept arguments doit localiser son dernier argument dans le trapframe. Concernant argint64 et les contrôles associés, quelle(s) proposition(s) est(sont) exacte(s) ?

Argptr vérifie l’adresse du pointeur fourni, mais ne vérifie pas l’adresse utilisée pour lire l’argument.
Le processeur vérifie lui-même les pointeurs utilisateur lorsque le noyau les déréférence.
Un numéro d’appel système invalide provoque l’affichage d’une erreur et le retour de 1.
Pour l’argument d’indice 6, argint64 lit à l’adresse %rsp+16\%rsp + 16, où %rsp\%rsp pointe sur l’adresse de retour.
Pour l’argument d’indice 6, argint64 lit à l’adresse %rsp+8\%rsp + 8, où %rsp\%rsp pointe sur l’adresse de retour.

Pour l’argument d’indice 6, argint64 lit à l’adresse $$\%rsp + 8$$, où $$\%rsp$$ pointe sur l’adresse de retour.

Explication

Pour n = 6, la formule %rsp+8+8(n−6)\%rsp + 8 + 8(n-6) donne %rsp+8\%rsp + 8. Un numéro invalide entraîne un retour de −1; argptr vérifie aussi l’adresse servant à récupérer l’argument, et le noyau doit contrôler lui-même les adresses utilisateur qu’il déréférence.

41. À propos des interruptions matérielles et des fonctions de récupération d’arguments, quelles propositions sont exactes ?

Argstr récupère un descripteur de fichier et renvoie le struct file correspondant.
Argfd récupère un descripteur de fichier, le vérifie et renvoie le struct file correspondant.
Une interruption matérielle signale au noyau un événement produit par un périphérique, comme une fin d’entrée-sortie.
Une interruption matérielle est un signal produit par le noyau pour avertir un périphérique d’un événement.
Lorsque les événements sont rares, les interruptions peuvent éviter le temps processeur gaspillé par le polling.

Argfd récupère un descripteur de fichier, le vérifie et renvoie le struct file correspondant. · Une interruption matérielle signale au noyau un événement produit par un périphérique, comme une fin d’entrée-sortie. · Lorsque les événements sont rares, les interruptions peuvent éviter le temps processeur gaspillé par le polling.

Explication

Une interruption matérielle avertit le noyau d’un événement du périphérique, et les interruptions sont avantageuses lorsque les événements sont rares. Argfd vérifie un descripteur et renvoie le struct file associé; argstr récupère une chaîne, et non un descripteur.

42. Un processeur xv6 reçoit une interruption de timer pendant l’exécution d’un processus. Concernant le routage et le traitement de cette interruption :

Le vecteur du timer est 64, comme celui utilisé pour les appels système.
Xv6 ignore les interruptions du PIC et configure l’IO APIC et le LAPIC local pour les interruptions.
L’interruption de timer utilise le vecteur 32, et trap incrémente ticks puis appelle wakeup.
La fréquence visée du timer est de 10 interruptions par seconde pour partager le processeur.
L’IO APIC reçoit les interruptions de chaque processeur, tandis que le LAPIC local les achemine entre processeurs.

Xv6 ignore les interruptions du PIC et configure l’IO APIC et le LAPIC local pour les interruptions. · L’interruption de timer utilise le vecteur 32, et trap incrémente ticks puis appelle wakeup.

Explication

Le timer utilise le vecteur 32; trap incrémente ticks et appelle wakeup. Xv6 ignore le PIC et s’appuie sur l’IO APIC pour le routage ainsi que sur un LAPIC local par processeur; la fréquence visée est de 100 fois par seconde, et le vecteur 64 sert aux appels système.

43. Les caractéristiques du pilote et des tampons de disque comprennent :

Dans xv6, un bloc disque correspond à quatre secteurs traditionnels de 512 octets.
Un struct buf conserve une copie mémoire d’un secteur, son numéro et des indicateurs d’état.
Un pilote commande un périphérique, configure son polling et traite les appels système qui le concernent.
Un pilote commande un périphérique, peut le configurer pour générer des interruptions et traite celles-ci.
Dans xv6, un bloc disque a la même taille qu’un secteur, traditionnellement de 512 octets.

Un struct buf conserve une copie mémoire d’un secteur, son numéro et des indicateurs d’état. · Un pilote commande un périphérique, peut le configurer pour générer des interruptions et traite celles-ci. · Dans xv6, un bloc disque a la même taille qu’un secteur, traditionnellement de 512 octets.

Explication

Le pilote gère le périphérique, sa configuration et le traitement de ses interruptions. Un secteur traditionnel fait 512 octets et la taille du bloc xv6 lui est identique; struct buf conserve la copie en mémoire, le numéro de secteur et les indicateurs d’état.

44. Lors de l’initialisation du pilote IDE puis de l’examen d’un tampon, quelles propositions sont exactes ?

Un tampon portant B_DIRTY indique que ses données ont été lues depuis le disque.
Au démarrage, main appelle ideinit, qui active IDE_IRQ sur le premier processeur.
Le pilote IDE suppose le disque 1 présent et vérifie la disponibilité du disque 0.
Le champ data contient le numéro du secteur, tandis que sector contient sa copie mémoire.
Un tampon portant B_VALID indique que ses données ont été lues depuis le disque.

Un tampon portant B_VALID indique que ses données ont été lues depuis le disque.

Explication

B_VALID indique que les données du tampon ont été lues; B_DIRTY signale au contraire des données à écrire sur disque. Main appelle ideinit, qui active IDE_IRQ sur le dernier processeur; le champ data contient la copie et le disque 0 est supposé présent, tandis que le disque 1 est vérifié.

45. Un tampon n’est pas marqué B_DIRTY et n’est pas marqué B_VALID; une autre requête IDE est déjà en cours. Concernant son traitement :

Iderw choisit une écriture du disque, puisque B_DIRTY n’est pas défini.
Le contrôleur IDE exécute simultanément toutes les requêtes présentes dans sa file.
Iderw ajoute le tampon en fin de file et appelle idestart s’il est en tête.
Iderw choisit une lecture du disque, puisque B_VALID n’est pas défini.
Le contrôleur exécute une seule opération à la fois; la requête en tête est envoyée au matériel.

Iderw ajoute le tampon en fin de file et appelle idestart s’il est en tête. · Iderw choisit une lecture du disque, puisque B_VALID n’est pas défini. · Le contrôleur exécute une seule opération à la fois; la requête en tête est envoyée au matériel.

Explication

L’absence de B_VALID entraîne une lecture; B_DIRTY, lorsqu’il est défini, indique une écriture. Le contrôleur IDE simple ne traite qu’une opération à la fois, et iderw ajoute le tampon en fin de file, en démarrant immédiatement l’opération si ce tampon est en tête.

46. Un processus lance une requête IDE et attend son achèvement : quelles actions caractérisent cette prise en charge ?

Pour une écriture, idestart transmet les données au contrôleur avec outsl avant l’interruption.
Après le lancement, iderw dort jusqu’à la mise à jour des indicateurs du tampon par interruption.
ideintr valide le tampon terminé, efface B_DIRTY et réveille le processus qui attend.
Après avoir traité la requête de tête, ideintr laisse la requête suivante en attente.
Pour une lecture, ideintr récupère les données avec insl lorsque le contrôleur les rend disponibles.

Pour une écriture, idestart transmet les données au contrôleur avec outsl avant l’interruption. · Après le lancement, iderw dort jusqu’à la mise à jour des indicateurs du tampon par interruption. · ideintr valide le tampon terminé, efface B_DIRTY et réveille le processus qui attend. · Pour une lecture, ideintr récupère les données avec insl lorsque le contrôleur les rend disponibles.

Explication

Après le lancement, iderw dort en attendant l’interruption ; idestart envoie les données d’écriture avec outsl, tandis qu’ideintr lit les données de lecture avec insl. ideintr valide le tampon, efface B_DIRTY, réveille le processus et démarre la requête suivante : l’affirmation contraire sur cette dernière action est donc fausse.

47. Parmi les propositions suivantes concernant les transferts de données et les tampons de périphériques, lesquelles sont exactes ?

Les E/S programmées déplacent les données avec des instructions CPU telles qu'insl et outsl.
Avec le DMA, le processeur copie les données entre le périphérique et la mémoire physique.
Les tampons graphiques peuvent contenir des données vidéo ou des séquences de commandes.
Le DMA permet au périphérique de transférer directement les données depuis ou vers la mémoire physique.
Les tampons réseau contiennent des paquets, tandis que ceux des périphériques audio contiennent des échantillons sonores.

Les E/S programmées déplacent les données avec des instructions CPU telles qu'insl et outsl. · Les tampons graphiques peuvent contenir des données vidéo ou des séquences de commandes. · Le DMA permet au périphérique de transférer directement les données depuis ou vers la mémoire physique. · Les tampons réseau contiennent des paquets, tandis que ceux des périphériques audio contiennent des échantillons sonores.

Explication

Les E/S programmées mobilisent des instructions CPU, et les tampons réseau, audio et graphiques contiennent respectivement des paquets, des échantillons ou des données vidéo et commandes. Avec le DMA, c’est le périphérique qui transfère directement les données ; le processeur n’effectue donc pas cette copie.

48. Deux processeurs modifient concurremment une structure partagée : quelles propositions décrivent correctement le risque et sa prévention ?

Un verrou empêche plusieurs processeurs d’exécuter simultanément la section critique protégée.
Le résultat d’une course est indépendant du moment et de l’ordre des opérations mémoire.
Dans deux insertions concurrentes, l’affectation écrasée est celle qui intervient en premier.
Il y a condition de course si un emplacement mémoire est accédé simultanément et qu’au moins un accès écrit.
Deux insertions simultanées en tête peuvent faire perdre un nœud si une affectation écrase l’autre.

Un verrou empêche plusieurs processeurs d’exécuter simultanément la section critique protégée. · Il y a condition de course si un emplacement mémoire est accédé simultanément et qu’au moins un accès écrit. · Deux insertions simultanées en tête peuvent faire perdre un nœud si une affectation écrase l’autre.

Explication

Une condition de course implique des accès simultanés à un emplacement, dont au moins un est une écriture ; des insertions concurrentes peuvent ainsi perdre un nœud. Le verrou assure l’exclusion mutuelle. L’issue dépend du moment et de l’ordre des opérations, et c’est la seconde affectation à list qui peut écraser la première.

49. Un développeur conçoit un verrou et protège une structure dont les invariants doivent rester valides : quelles propositions sont exactes ?

Dans un verrou tournant d’xv6, locked vaut zéro lorsqu’il est disponible et non nul lorsqu’il est détenu.
Xv6 dispose de verrous tournants et de verrous dormants pour protéger ses sections critiques.
Un invariant peut être temporairement violé pendant une opération, mais doit être rétabli avant sa fin.
Pour garantir l’exclusion mutuelle, deux processeurs peuvent réussir simultanément la vérification de locked.
Une acquisition vérifiant locked puis le mettant à 1 en deux opérations séparées garantit l’exclusion mutuelle.

Dans un verrou tournant d’xv6, locked vaut zéro lorsqu’il est disponible et non nul lorsqu’il est détenu. · Xv6 dispose de verrous tournants et de verrous dormants pour protéger ses sections critiques. · Un invariant peut être temporairement violé pendant une opération, mais doit être rétabli avant sa fin.

Explication

Un invariant peut être momentanément violé, à condition d’être rétabli avant la fin de l’opération ; xv6 utilise des verrous tournants et dormants, et son champ locked vaut zéro lorsque le verrou est disponible. Une vérification suivie séparément de l’écriture de 1 n’est pas atomique : deux processeurs pourraient réussir la vérification, ce qui invaliderait l’exclusion mutuelle.

50. Lorsqu’xv6 acquiert un verrou tournant et protège la file du pilote IDE, quelles actions et propriétés s’appliquent ?

La boucle d’acquisition répète xchg jusqu’à ce que l’ancienne valeur de locked soit zéro.
Le verrou idelock protège la file des requêtes IDE et les invariants associés.
La libération efface les informations de débogage avant d’effacer le champ locked.
L’instruction xchg affecte locked à 1 sans lire atomiquement sa valeur précédente.
L’implémentation des verrous tournants d’xv6 est directement portable sur tout processeur.

La boucle d’acquisition répète xchg jusqu’à ce que l’ancienne valeur de locked soit zéro. · Le verrou idelock protège la file des requêtes IDE et les invariants associés. · La libération efface les informations de débogage avant d’effacer le champ locked.

Explication

xchg lit atomiquement locked et lui affecte 1 ; acquire recommence jusqu’à obtenir l’ancienne valeur zéro. release efface les informations de débogage puis locked, et idelock protège la file IDE et ses invariants. L’implémentation repose sur des instructions x86 et n’est donc pas directement portable à d’autres processeurs.

51. Un système protège des données partagées par plusieurs processeurs : quelles règles guident le choix de la protection ?

Si un invariant porte sur plusieurs emplacements mémoire, un seul verrou doit généralement les protéger tous.
Une variable partagée n’a pas besoin de verrou si un processeur peut l’écrire pendant qu’un autre la lit.
Un invariant réparti sur plusieurs emplacements est généralement préservé par des verrous distincts pour chacun.
Protéger davantage de code augmente le parallélisme et améliore ainsi l’efficacité.
Une variable doit être protégée lorsqu’un processeur peut l’écrire tandis qu’un autre la lit ou l’écrit.

Si un invariant porte sur plusieurs emplacements mémoire, un seul verrou doit généralement les protéger tous. · Une variable doit être protégée lorsqu’un processeur peut l’écrire tandis qu’un autre la lit ou l’écrit.

Explication

Un verrou protège une variable lorsque des processeurs peuvent y accéder concurremment avec une écriture ; un invariant couvrant plusieurs emplacements est généralement protégé par un même verrou. Verrouiller trop de code réduit le parallélisme, et des verrous distincts pour les emplacements d’un invariant commun risquent de ne pas le préserver.

52. Une équipe remplace un verrou de table des processus par des verrous individuels. Quelles conséquences faut-il prévoir ?

Des opérations touchant plusieurs entrées peuvent compliquer la préservation des invariants communs.
Les chemins qui détiennent plusieurs verrous doivent respecter un ordre d’acquisition commun.
Des verrous par entrée empêchent les threads de travailler en parallèle sur des entrées distinctes.
Des verrous plus fins peuvent permettre à plusieurs CPU d’exécuter simultanément le noyau.
Dans xv6, ptable.lock protège la table entière des processus et ses invariants.

Des opérations touchant plusieurs entrées peuvent compliquer la préservation des invariants communs. · Les chemins qui détiennent plusieurs verrous doivent respecter un ordre d’acquisition commun. · Des verrous plus fins peuvent permettre à plusieurs CPU d’exécuter simultanément le noyau. · Dans xv6, ptable.lock protège la table entière des processus et ses invariants.

Explication

Une granularité plus fine accroît le parallélisme, mais complique les opérations qui relient plusieurs entrées ou structures; les verrous multiples doivent donc suivre un ordre commun. Dans xv6, ptable.lock protège la table entière, tandis que des verrous individuels permettraient le travail simultané sur des entrées distinctes.

53. Concernant certains enchaînements de verrous dans xv6 :

La création d’un fichier acquiert successivement le verrou du répertoire puis celui du nouvel inode.
Lors d’un appel à wakeup, ideintr détient ptable.lock avant d’acquérir le verrou IDE.
Lors d’un appel à wakeup, ideintr libère le verrou IDE avant que wakeup acquière ptable.lock.
La création d’un fichier acquiert ptable.lock avant idelock.
La création d’un fichier acquiert idelock avant le verrou du tampon de bloc disque.

La création d’un fichier acquiert successivement le verrou du répertoire puis celui du nouvel inode.

Explication

La création d’un fichier suit l’ordre répertoire, inode du nouveau fichier, tampon de bloc, idelock, puis ptable.lock. À l’inverse, ideintr détient le verrou IDE lorsqu’elle appelle wakeup, qui acquiert ptable.lock.

54. Sur un processeur unique, un gestionnaire d’interruption tente de prendre un verrou détenu par le code noyau qu’il vient d’interrompre. Quelles propositions sont exactes ?

La situation décrite peut provoquer un interblocage sur le même processeur.
Le gestionnaire attend un verrou que le code interrompu ne peut libérer avant son retour.
tickslock sérialise l’incrémentation de ticks et sa lecture par sys_sleep.
Une interruption peut créer de la concurrence en interrompant du code noyau à tout moment.
Sur un processeur unique, les interruptions ne peuvent pas créer de concurrence dans le noyau.

La situation décrite peut provoquer un interblocage sur le même processeur. · Le gestionnaire attend un verrou que le code interrompu ne peut libérer avant son retour. · tickslock sérialise l’incrémentation de ticks et sa lecture par sys_sleep. · Une interruption peut créer de la concurrence en interrompant du code noyau à tout moment.

Explication

Une interruption peut s’exécuter au milieu du code noyau; si son gestionnaire attend un verrou détenu par ce code, celui-ci ne peut le libérer avant la fin du gestionnaire, ce qui entraîne un interblocage. Dans xv6, tickslock sérialise l’incrémentation de ticks par l’interruption d’horloge et sa lecture dans sys_sleep.

55. Un processeur entre dans des sections critiques imbriquées protégées par des spin-locks utilisés par un gestionnaire d’interruption. Quelles propositions décrivent le comportement de xv6 ?

popcli restaure l’état initial des interruptions à chaque sortie de section imbriquée.
Xv6 réactive les interruptions dès qu’un spin-lock est libéré, même si d’autres restent détenus.
Le processeur ne doit pas conserver un spin-lock de ce type avec les interruptions activées.
acquire appelle pushcli avant xchg, tandis que release appelle popcli après xchg.
Xv6 désactive les interruptions à l’entrée d’une section critique protégée par spin-lock.

Le processeur ne doit pas conserver un spin-lock de ce type avec les interruptions activées. · acquire appelle pushcli avant xchg, tandis que release appelle popcli après xchg. · Xv6 désactive les interruptions à l’entrée d’une section critique protégée par spin-lock.

Explication

Les interruptions sont désactivées pendant la détention d’un spin-lock susceptible d’être utilisé par un gestionnaire d’interruption. Dans xv6, acquire appelle pushcli avant xchg et release appelle popcli après xchg; l’imbrication est suivie et l’état antérieur est restauré à la sortie de la section externe, pas à chaque section imbriquée.

56. Lors d’une insertion dans une liste, les instructions sont réordonnées et un autre cœur consulte la structure. Quelles conséquences sont possibles ?

Un verrou global du noyau permet à plusieurs CPU d’exécuter du code noyau à la fois.
Publier list = l avant d’initialiser l->next peut exposer un lien non initialisé.
Un compilateur ou un processeur peut réordonner des instructions pour améliorer les performances.
L’affectation de list = l avant celle de l->next garantit que le lien est déjà visible.
Un réordonnancement visible par d’autres cœurs peut produire un comportement incorrect.

Publier list = l avant d’initialiser l->next peut exposer un lien non initialisé. · Un compilateur ou un processeur peut réordonner des instructions pour améliorer les performances. · Un réordonnancement visible par d’autres cœurs peut produire un comportement incorrect.

Explication

Les compilateurs et processeurs peuvent réordonner les instructions, et ce réordonnancement peut devenir observable par d’autres cœurs. Si list = l devient visible avant l’initialisation de l->next, un autre processeur peut observer un lien non initialisé ; l’ordre apparent dans le code ne le garantit pas. Un verrou global du noyau permet à un seul CPU à la fois d’exécuter du code noyau.

57. Lors d’un accès concurrent à une liste protégée par un verrou, que garantit la barrière mémoire employée par xv6 dans acquire et release ?

Elle empêche le compilateur et le processeur de réordonner lectures ou écritures de part et d’autre de la barrière.
Les accès concurrents aux structures de données ont lieu principalement avant acquire et après release.
Elle est utilisée dans acquire et release pour limiter le réordonnancement des opérations mémoire.
Les accès concurrents aux données protégées se déroulent entre acquire et release, ce qui motive le contrôle de leur ordre.
Elle autorise le processeur à déplacer des écritures à travers la barrière, mais empêche le compilateur de le faire.

Elle empêche le compilateur et le processeur de réordonner lectures ou écritures de part et d’autre de la barrière. · Elle est utilisée dans acquire et release pour limiter le réordonnancement des opérations mémoire. · Les accès concurrents aux données protégées se déroulent entre acquire et release, ce qui motive le contrôle de leur ordre.

Explication

La barrière mémoire empêche le compilateur et le processeur de déplacer lectures ou écritures à travers elle, et xv6 l’emploie dans acquire comme dans release. Les accès concurrents aux structures autres que le verrou se produisent entre ces deux opérations ; la barrière ne permet donc pas le réordonnancement indiqué et ces accès ne sont pas placés principalement à l’extérieur.

58. Un gestionnaire d’interruption doit protéger une donnée, tandis qu’un autre chemin peut dormir en attendant cette donnée ; quelles limites s’appliquent aux sleep-locks ?

Un sleep-lock ne convient pas au gestionnaire d’interruption, car il laisse les interruptions activées.
Xv6 utilise généralement des sleep-locks dans la plupart des situations, leur coût étant inférieur à celui des spin-locks.
Xv6 réserve principalement les spin-locks au système de fichiers pour les longues opérations disque.
Les spin-locks ne peuvent pas être utilisés dans une section protégée par sleep-lock, car ils désactivent les interruptions.
Un sleep-lock ne peut pas être pris dans une section protégée par spin-lock, car acquiresleep peut céder le processeur.

Un sleep-lock ne convient pas au gestionnaire d’interruption, car il laisse les interruptions activées. · Un sleep-lock ne peut pas être pris dans une section protégée par spin-lock, car acquiresleep peut céder le processeur.

Explication

Les sleep-locks laissent les interruptions activées et acquiresleep peut céder le processeur : ils sont donc inadaptés aux gestionnaires d’interruption et aux sections protégées par spin-lock. Xv6 privilégie les spin-locks pour leur faible coût, réserve les sleep-locks notamment au système de fichiers et permet d’utiliser un spin-lock dans une section protégée par sleep-lock, même si les spin-locks désactivent les interruptions.

59. Dans xv6, un thread attend qu’un autre mette à jour une structure et une fonction est appelée avec des conventions de verrouillage différentes ; quelles propositions sont exactes ?

Pour attendre une mise à jour, xv6 conserve le verrou des données jusqu’à la réception de l’événement.
Une fonction partagée par des appelants avec des besoins différents doit acquérir un verrou dans toutes ses variantes.
Sur un processeur unique, le changement de thread restaure les registres du nouveau thread et change pile et code exécuté.
Une fonction peut offrir une variante qui acquiert le verrou et une autre qui l’attend déjà détenu par son appelant.
Le thread en attente ne conserve pas le verrou des données, afin de permettre leur mise à jour par l’autre thread.

Sur un processeur unique, le changement de thread restaure les registres du nouveau thread et change pile et code exécuté. · Une fonction peut offrir une variante qui acquiert le verrou et une autre qui l’attend déjà détenu par son appelant. · Le thread en attente ne conserve pas le verrou des données, afin de permettre leur mise à jour par l’autre thread.

Explication

Une fonction peut avoir deux variantes selon que l’appelant détient déjà le verrou, ou imposer une convention commune aux appelants. Le thread qui attend une mise à jour ne peut conserver le verrou des données ; sleep et wakeup coordonnent séparément verrou et attente. Lors du changement de thread sur un processeur, les registres sont sauvegardés et restaurés, ce qui change notamment la pile et le code exécuté.

60. Lorsqu’un processus cède le processeur à xv6, quelles opérations décrivent le passage de son contexte à celui du planificateur ?

yield appelle sched, qui fait sauvegarder proc->context et restaurer cpu->scheduler par swtch.
swtch restaure d’abord le contexte du planificateur, puis sauvegarde celui du processus dans cpu->scheduler.
swtch reçoit l’ancien et le nouveau contexte, sauvegarde les registres sur la pile et restaure le contexte choisi.
Sur x86-64, swtch sauvegarde explicitement %rbp, %rbx, %r12, %r13, %r14 et %r15.
Le pointeur de pile courant est enregistré implicitement dans *old, tandis que l’instruction call a déjà empilé %rip.

yield appelle sched, qui fait sauvegarder proc->context et restaurer cpu->scheduler par swtch. · swtch reçoit l’ancien et le nouveau contexte, sauvegarde les registres sur la pile et restaure le contexte choisi. · Sur x86-64, swtch sauvegarde explicitement %rbp, %rbx, %r12, %r13, %r14 et %r15. · Le pointeur de pile courant est enregistré implicitement dans *old, tandis que l’instruction call a déjà empilé %rip.

Explication

swtch échange les contextes en sauvegardant l’ancien sur la pile et en restaurant le nouveau ; lors d’un yield, sched l’utilise pour enregistrer proc->context et reprendre cpu->scheduler. Sur x86-64, les six registres préservés par l’appelé sont poussés explicitement, %rsp est enregistré via *old et %rip a déjà été empilé par call. L’option restante inverse la sauvegarde et les destinations des contextes.

61. Un processus xv6 passe à l’état RUNNABLE avant de céder le processeur ; quelles règles gouvernent l’appel à sched et le verrou ptable.lock ?

Lors de swtch, ptable.lock reste détenu par le processus appelant et n’est pas transmis au code repris.
Avant sched, le processus acquiert ptable.lock, libère ses autres verrous et met à jour son état.
Avant sched, le processus met à jour son état puis libère ptable.lock afin que swtch puisse l’acquérir.
sched vérifie les conditions de cession et appelle swtch en conservant ptable.lock.
ptable.lock protège les invariants de contexte, notamment contre une exécution concurrente avant que l’ancienne pile noyau soit abandonnée.

Avant sched, le processus acquiert ptable.lock, libère ses autres verrous et met à jour son état. · sched vérifie les conditions de cession et appelle swtch en conservant ptable.lock. · ptable.lock protège les invariants de contexte, notamment contre une exécution concurrente avant que l’ancienne pile noyau soit abandonnée.

Explication

Avant l’appel à sched, le processus acquiert ptable.lock, relâche ses autres verrous et met à jour son état. Le verrou protège les invariants d’état et de contexte pendant swtch, notamment contre une exécution prématurée sur un autre processeur. sched conserve ce verrou lors de l’appel à swtch et son contrôle passe au code qui reprend l’exécution.

62. Au cours d’une itération, le planificateur xv6 cherche un processus exécutable et doit permettre l’arrivée d’interruptions d’E/S ; que fait-il ?

Il parcourt la table et cherche un processus dont l’état est RUNNABLE.
Il garde ptable.lock et laisse les interruptions désactivées pendant chaque itération, y compris lorsqu’il attend.
Après la recherche, il marque le processus choisi RUNNABLE puis appelle swtch pour le démarrer.
Après avoir trouvé un processus exécutable, il le définit comme courant et bascule vers sa table de pages avec switchuvm.
Il libère ptable.lock et active explicitement les interruptions une fois par itération de sa boucle externe.

Il parcourt la table et cherche un processus dont l’état est RUNNABLE. · Après avoir trouvé un processus exécutable, il le définit comme courant et bascule vers sa table de pages avec switchuvm. · Il libère ptable.lock et active explicitement les interruptions une fois par itération de sa boucle externe.

Explication

Le planificateur recherche un processus RUNNABLE, le définit comme processus courant, bascule vers sa table de pages, le marque RUNNING puis appelle swtch. Il libère aussi ptable.lock et active explicitement les interruptions une fois par itération, ce qui permet notamment de recevoir les interruptions d’E/S ; il ne garde donc pas le verrou avec les interruptions désactivées pendant toute l’itération, et le processus choisi devient RUNNING, non RUNNABLE.

63. Un thread consulte plusieurs champs de la structure renvoyée par mycpu ; concernant cette utilisation :

La référence renvoyée reste fiable si une interruption déplace le thread vers un autre processeur.
Les interruptions doivent rester désactivées tant que la structure renvoyée est utilisée.
mycpu lit l’identifiant matériel APIC local pour retrouver le processeur correspondant.
mycpu identifie le processeur courant à partir du processus enregistré dans c->proc.
Une interruption peut déplacer le thread sans invalider la référence à struct cpu.

Les interruptions doivent rester désactivées tant que la structure renvoyée est utilisée. · mycpu lit l’identifiant matériel APIC local pour retrouver le processeur correspondant.

Explication

Désactiver les interruptions pendant l’utilisation protège la référence contre un déplacement du thread. mycpu recherche le processeur à partir de son identifiant APIC local ; c->proc n’est pas la méthode d’identification, et un déplacement peut rendre la référence invalide.

64. Dans une file producteur-consommateur, recv attend un pointeur sur le canal associé à la condition ; concernant sleep et wakeup :

sleep(chan) endort le processus appelant et libère le processeur pour une autre tâche.
Le polling répété de q->ptr consomme du processeur pendant l’attente du pointeur.
wakeup(chan) réveille un seul processus endormi lorsque plusieurs attendent sur chan.
Le canal d’attente peut être l’adresse d’une structure noyau liée à la condition.
Dans cette file, recv attend que la file soit vide avant d’en retirer un pointeur.

sleep(chan) endort le processus appelant et libère le processeur pour une autre tâche. · Le polling répété de q->ptr consomme du processeur pendant l’attente du pointeur. · Le canal d’attente peut être l’adresse d’une structure noyau liée à la condition.

Explication

sleep endort le processus et cède le processeur ; le canal est souvent l’adresse d’une structure noyau liée à la condition. recv attend un pointeur non nul, et le polling consomme du processeur ; wakeup réveille tous les processus endormis sur le canal.

65. Dans une file, recv vérifie q->ptr puis peut s’endormir pendant que send dépose un pointeur ; quelles propositions décrivent correctement la synchronisation ?

Après son réveil, sleep reprend avec lk libéré et ptable.lock conservé.
Un réveil perdu est possible si send appelle wakeup avant que recv ne s’endorme.
Garder q->lock pendant tout le sommeil permet à send de déposer le pointeur.
sleep(chan, lk) acquiert ptable.lock avant de libérer le verrou lk.
wakeup1 parcourt les processus et rend RUNNABLE ceux qui dorment sur un canal différent.

Un réveil perdu est possible si send appelle wakeup avant que recv ne s’endorme. · sleep(chan, lk) acquiert ptable.lock avant de libérer le verrou lk.

Explication

Le réveil est perdu si send réveille avant que recv ne soit enregistré comme endormi. sleep acquiert ptable.lock avant de libérer lk ; wakeup1 cible les processus endormis sur le canal correspondant, garder q->lock bloque send, et sleep reprend avec lk réacquis.

66. Un réveilleur modifie une condition protégée par un verrou tandis qu’un processus vérifie cette condition avant de dormir ; concernant la prévention des réveils perdus :

Le processus conserve un verrou pertinent entre la vérification et son passage à l’état endormi.
Les appels xv6 à wakeup se font en tenant le verrou qui protège la condition de sommeil.
Si le réveilleur acquiert le verrou après sa libération dans sleep, il peut réveiller avant l’endormissement.
La prévention repose sur wakeup acquérant le verrou de condition avant le processus qui s’endort.
Si le réveilleur modifie d’abord la condition, le processus endormi ne peut pas observer sa nouvelle valeur.

Le processus conserve un verrou pertinent entre la vérification et son passage à l’état endormi. · Les appels xv6 à wakeup se font en tenant le verrou qui protège la condition de sommeil.

Explication

Le processus conserve le verrou de condition, ptable.lock ou les deux jusqu’à son passage à l’état endormi ; wakeup est appelé en tenant le verrou de la condition. Si le réveilleur agit avant, le processus observe la nouvelle valeur ; s’il agit après, ptable.lock le fait attendre jusqu’à l’endormissement.

67. Deux processus attendent sur un même canal, mais le réveil ne garantit pas que leur condition respective soit satisfaite ; quelles propositions sont exactes ?

Un processus réveillé revérifie sa condition et se rendort si elle reste fausse.
Après un réveil, le processus peut poursuivre sans vérifier si sa condition est devenue vraie.
Un réveil parasite indique que la condition attendue est devenue vraie pour le processus.
wakeup peut réveiller plusieurs processus endormis sur le même canal d’attente.
Deux usages peuvent partager un canal sans nuire à la correction si les conditions sont revérifiées.

Un processus réveillé revérifie sa condition et se rendort si elle reste fausse. · wakeup peut réveiller plusieurs processus endormis sur le même canal d’attente. · Deux usages peuvent partager un canal sans nuire à la correction si les conditions sont revérifiées.

Explication

wakeup peut réveiller tous les processus endormis sur le canal, même si un seul traite d’abord la condition. Chaque processus revérifie sa condition dans une boucle ; cette précaution tolère aussi le partage accidentel d’un canal et les réveils parasites.

68. Un lecteur et un écrivain utilisent un pipe dont le tampon vient d’être rempli ; quelles propositions décrivent correctement ses compteurs et sa synchronisation ?

Un tampon plein correspond à nwrite égal à nread plus PIPESIZE.
Après buf[PIPESIZE-1], l’écriture reprend au début du tampon circulaire.
Après une lecture, piperead réveille les écrivains avant d’avancer nread.
Pour un tampon vide, nwrite vaut nread plus PIPESIZE et les compteurs repartent de zéro.
Quand pipewrite remplit le tampon, il réveille les lecteurs puis dort sur &p->nread.

Un tampon plein correspond à nwrite égal à nread plus PIPESIZE. · Après buf[PIPESIZE-1], l’écriture reprend au début du tampon circulaire.

Explication

Le tampon est plein lorsque nwrite = nread + PIPESIZE, et l’indexation du tampon circulaire revient à buf[0] après buf[PIPESIZE-1]. pipewrite dort sur &p->nwrite après avoir réveillé les lecteurs ; les compteurs ne bouclent pas, et piperead avance nread avant de réveiller les écrivains.

69. Concernant la terminaison d’un processus enfant :

Le parent récupère le PID de l’enfant par l’appel système exit.
Dans le pilote IDE, le processus est réveillé avant la fin de sa requête disque.
Dans un tube, p->nwrite sert de canal d’attente aux lecteurs.
Dans un tube, p->nread sert de canal d’attente aux lecteurs.
Un enfant terminé reste ZOMBIE jusqu’à ce que son parent appelle wait.

Dans un tube, p->nread sert de canal d’attente aux lecteurs. · Un enfant terminé reste ZOMBIE jusqu’à ce que son parent appelle wait.

Explication

L’enfant reste ZOMBIE jusqu’à l’appel de wait, qui permet au parent de récupérer son PID et de libérer ses ressources. Dans les tubes, p->nread est le canal des lecteurs, tandis que p->nwrite est celui des écrivains; le pilote IDE réveille le processus à la fin de la requête, et exit ne remplace pas wait pour récupérer le PID.

70. Après une panne, un système de fichiers doit préserver ses données et rester cohérent au redémarrage. Quelles propositions décrivent ses objectifs et ses couches ?

Un système de fichiers organise et stocke les données, qui peuvent persister après un redémarrage.
xv6 fournit des fichiers, des répertoires et des chemins de type Unix sur un disque IDE.
Sa représentation sur disque comprend l’arbre des fichiers et répertoires, le contenu et les zones libres.
Le système de fichiers xv6 conserve ses données sur un disque mémoire volatile plutôt que sur disque IDE.
Après une panne, un bloc ne doit pas être à la fois utilisé par un fichier et marqué libre.

Un système de fichiers organise et stocke les données, qui peuvent persister après un redémarrage. · xv6 fournit des fichiers, des répertoires et des chemins de type Unix sur un disque IDE. · Sa représentation sur disque comprend l’arbre des fichiers et répertoires, le contenu et les zones libres. · Après une panne, un bloc ne doit pas être à la fois utilisé par un fichier et marqué libre.

Explication

Un système de fichiers organise et stocke les données, généralement partageables, et vise leur persistance après redémarrage. Sa représentation comprend l’arbre des fichiers et répertoires, les blocs de contenu et les zones libres; la cohérence après panne interdit qu’un bloc soit simultanément utilisé et marqué libre. xv6 fournit des fichiers, répertoires et chemins de type Unix, et stocke les données sur un disque IDE.

71. Dans un système xv6 soumis à des accès concurrents, quelles propriétés caractérisent l’organisation et le rôle du cache de blocs ?

L’implémentation du système de fichiers xv6 est organisée en sept couches distinctes.
La couche disque lit et écrit les blocs sur un disque dur IDE.
Le cache autorise plusieurs processus du noyau à modifier simultanément le même bloc.
Le cache évite de relire les blocs populaires depuis un disque plus lent que la mémoire.
Le cache conserve les blocs disque en mémoire et synchronise leur accès concurrent.

L’implémentation du système de fichiers xv6 est organisée en sept couches distinctes. · La couche disque lit et écrit les blocs sur un disque dur IDE. · Le cache évite de relire les blocs populaires depuis un disque plus lent que la mémoire. · Le cache conserve les blocs disque en mémoire et synchronise leur accès concurrent.

Explication

L’architecture xv6 compte sept couches, et le cache garde des blocs en mémoire tout en sérialisant leur modification. Il réduit les lectures du disque, plus lent que la mémoire, tandis que la couche disque assure les lectures et écritures IDE ; plusieurs processus ne modifient pas simultanément le même bloc.

72. Un étudiant examine les premiers blocs d’un système de fichiers xv6 et un chemin tel que /usr/rtm/xv6/fs.c. Quelles propositions sont exactes ?

Le superbloc indique le nombre de répertoires et la taille du secteur d’amorçage.
Le bloc 0 est réservé au secteur d’amorçage, tandis que le bloc 1 contient le superbloc.
Chaque entrée de répertoire associe un nom de fichier à la taille de son inode.
La couche des chemins résout des noms hiérarchiques par une recherche récursive.
Le superbloc indique la taille du système en blocs et le nombre de blocs de données.

Le bloc 0 est réservé au secteur d’amorçage, tandis que le bloc 1 contient le superbloc. · La couche des chemins résout des noms hiérarchiques par une recherche récursive. · Le superbloc indique la taille du système en blocs et le nombre de blocs de données.

Explication

Le bloc 0 est réservé au secteur d’amorçage et le bloc 1 au superbloc ; celui-ci contient notamment la taille du système, les blocs de données, les inodes et les blocs du journal. Chaque entrée de répertoire associe un nom de fichier à un i-number, et non à la taille de l’inode. Les chemins hiérarchiques sont résolus récursivement : le superbloc ne décrit pas le nombre de répertoires, et les deux premiers blocs ne sont pas inversés.

73. Le cache doit choisir un tampon à réutiliser et suivre son état ; quelles propositions décrivent correctement ces mécanismes ?

Un tampon marqué comme modifié reste admissible à la réutilisation selon le critère LRU.
B_DIRTY signale que les données du tampon ont été lues depuis le disque.
B_VALID signale qu’une copie du bloc a été lue dans le tampon.
Le cache choisit le moins récemment utilisé parmi les tampons admissibles à la réutilisation.
Un tampon verrouillé peut être choisi comme victime s’il est le moins récemment utilisé.

B_VALID signale qu’une copie du bloc a été lue dans le tampon. · Le cache choisit le moins récemment utilisé parmi les tampons admissibles à la réutilisation.

Explication

B_VALID indique qu’une copie du bloc est présente, tandis que le choix de réutilisation privilégie le tampon admissible le moins récemment utilisé. B_DIRTY signale des données modifiées qui doivent être écrites sur disque ; les tampons verrouillés ou modifiés sont exclus des candidats.

74. Plusieurs appels système complets modifient des blocs, et un même bloc est modifié plusieurs fois dans une transaction. Concernant la journalisation dans xv6, quelles propositions sont exactes ?

Lorsqu’un bloc est modifié à nouveau dans la transaction, log_write réutilise son emplacement dans le journal.
Le group commit rassemble les écritures de plusieurs appels complets dans une seule transaction.
Les grandes écritures sont découpées en transactions plus petites pour respecter la capacité du journal.
La taille fixe du journal explique qu'unlink ne pose pas de problème pratique avec le bitmap unique de xv6.
Après une modification, log_write marque le tampon B_DIRTY afin d’empêcher son éviction.

Lorsqu’un bloc est modifié à nouveau dans la transaction, log_write réutilise son emplacement dans le journal. · Le group commit rassemble les écritures de plusieurs appels complets dans une seule transaction. · Les grandes écritures sont découpées en transactions plus petites pour respecter la capacité du journal. · La taille fixe du journal explique qu'unlink ne pose pas de problème pratique avec le bitmap unique de xv6. · Après une modification, log_write marque le tampon B_DIRTY afin d’empêcher son éviction.

Explication

Le group commit mutualise le coût d’une validation entre plusieurs appels système complets. Les grandes écritures sont fractionnées pour tenir dans le journal, tandis que log_write protège le tampon et absorbe les modifications répétées d’un même bloc. Le journal a une capacité fixe, mais unlink reste praticable puisque xv6 n’utilise qu’un bloc bitmap.

75. À la fin du dernier appel système en cours, quelle(s) proposition(s) décrit (décrivent) correctement la validation et le bitmap de xv6 ?

end_op journalise les blocs modifiés, valide la transaction, installe les blocs puis remet le compte d’en-tête à zéro.
Dans le bitmap, un bit nul correspond à un bloc libre et un bit égal à un à un bloc utilisé.
Le bitmap de xv6 associe un bit à chaque octet du disque plutôt qu’à chaque bloc.
mkfs marque comme libres les blocs réservés au secteur d’amorçage, au superbloc et au journal.
Après l’installation des blocs, end_op conserve un compte non nul dans l’en-tête pour signaler la fin.

end_op journalise les blocs modifiés, valide la transaction, installe les blocs puis remet le compte d’en-tête à zéro. · Dans le bitmap, un bit nul correspond à un bloc libre et un bit égal à un à un bloc utilisé.

Explication

La validation décrite par end_op suit l’écriture des blocs dans le journal, l’écriture de l’en-tête de validation, l’installation des blocs, puis la remise à zéro du compte. Le bitmap utilise bien un bit par bloc, avec zéro pour libre et un pour utilisé. mkfs marque les blocs réservés comme utilisés, et l’en-tête est remis à zéro après l’installation.

76. Un allocateur xv6 parcourt le bitmap depuis le bloc 0 et rencontre un bit nul. Concernant balloc et bfree, cochez la (les) proposition(s) exacte(s) :

bfree libère un bloc en effaçant le bit correspondant dans le bitmap du disque.
Le parcours effectué par balloc examine les blocs à partir du bloc 0 du système de fichiers.
bfree réserve le bloc libéré en positionnant à un le bit correspondant dans le bitmap des inodes.
balloc repère le bit nul, met à jour le bitmap pour réserver le bloc et renvoie ce bloc.
Les appels à balloc et à bfree doivent être effectués à l’intérieur d’une transaction.

bfree libère un bloc en effaçant le bit correspondant dans le bitmap du disque. · Le parcours effectué par balloc examine les blocs à partir du bloc 0 du système de fichiers. · balloc repère le bit nul, met à jour le bitmap pour réserver le bloc et renvoie ce bloc. · Les appels à balloc et à bfree doivent être effectués à l’intérieur d’une transaction.

Explication

balloc recherche un bloc libre à partir du bloc 0, met à jour le bitmap pour l’allouer et le renvoie. bfree libère le bloc en effaçant son bit dans le bitmap des blocs; le bitmap des inodes suit l’état des inodes, pas celui des blocs. Les deux fonctions doivent s’exécuter dans une transaction.

77. Lorsqu’on distingue les représentations d’un inode et les champs de la dinode sur disque, quelles propositions sont exactes ?

La taille fixe des inodes empêche de localiser l’inode numéro n à partir de son i-number.
Les inodes sur disque sont rangés dans une zone contiguë appelée blocs d’inodes.
Le champ nlink dénombre les blocs de données associés à la dinode pour calculer la taille du fichier.
Le champ type distingue fichiers, répertoires et fichiers spéciaux, tandis que zéro indique un inode libre.
L’inode en mémoire est une copie de la dinode enrichie d’informations utiles au noyau.

Les inodes sur disque sont rangés dans une zone contiguë appelée blocs d’inodes. · Le champ type distingue fichiers, répertoires et fichiers spéciaux, tandis que zéro indique un inode libre. · L’inode en mémoire est une copie de la dinode enrichie d’informations utiles au noyau.

Explication

Le terme inode peut désigner la dinode sur disque ou sa copie en mémoire, enrichie pour les besoins du noyau. Les inodes disque occupent une zone contiguë et leur taille fixe facilite la localisation par i-number. Le champ type décrit la catégorie de l’inode; nlink compte plutôt les entrées de répertoire qui le référencent.

78. Deux processus partagent un inode actif : l’un modifie son contenu tandis que l’autre gère une référence. À propos des références et des verrous d’inode, quelles propositions sont exactes ?

Le sleep-lock propre à chaque inode protège le compteur global de références du cache.
Dans la dinode, size contient les numéros de blocs et addrs indique le nombre d’octets du fichier.
iget et iput modifient le champ nlink pour acquérir ou libérer des pointeurs vers un inode.
Le champ ref compte les pointeurs C vers l’inode en mémoire, qui est retiré quand ce compte atteint zéro.
icache.lock protège l’unicité des inodes du cache et la cohérence de leur compteur de références.

Le champ ref compte les pointeurs C vers l’inode en mémoire, qui est retiré quand ce compte atteint zéro. · icache.lock protège l’unicité des inodes du cache et la cohérence de leur compteur de références.

Explication

Le champ ref dénombre les pointeurs C et l’inode est retiré de la mémoire lorsque ce compte tombe à zéro. icache.lock protège l’unicité des entrées et la cohérence de ref, tandis que le sleep-lock propre à l’inode protège ses champs et ses blocs de contenu. size et addrs sont inversés dans l’énoncé correspondant, et iget/iput modifient ref, non nlink.

79. Un processus obtient un inode par iget, puis doit lire ses métadonnées; un autre inode libre est ensuite recherché pour une création. Concernant ces opérations, quelles propositions sont exactes ?

L’icache synchronise principalement l’accès concurrent aux inodes référencés par le noyau.
iget verrouille l’inode et charge ses données depuis le disque avant de fournir toute référence.
ialloc cherche un inode libre sur disque, inscrit son nouveau type puis appelle iget pour obtenir une entrée du cache.
iget fournit une référence non exclusive qui reste valide jusqu’à ce qu’elle soit libérée par iput.
L’icache sert principalement à conserver en mémoire les inodes fréquemment utilisés, plutôt qu’à synchroniser les accès.

L’icache synchronise principalement l’accès concurrent aux inodes référencés par le noyau. · ialloc cherche un inode libre sur disque, inscrit son nouveau type puis appelle iget pour obtenir une entrée du cache. · iget fournit une référence non exclusive qui reste valide jusqu’à ce qu’elle soit libérée par iput.

Explication

iget acquiert une référence non exclusive; il faut appeler ilock pour verrouiller l’inode et charger ses données si nécessaire, puis iput pour libérer la référence. L’icache sert d’abord à synchroniser l’accès aux inodes référencés, le cache de tampons pouvant conserver les inodes fréquemment utilisés. ialloc écrit le nouveau type de l’inode libre avant d’appeler iget.

80. Un appel système apparemment en lecture seule peut provoquer la libération d’un inode sans lien lors d’un iput. Quelle proposition est exacte ?

Après un redémarrage, xv6 récupère les inodes alloués qui ne sont référencés par aucune entrée de répertoire.
Lors de cette libération, iput conserve les blocs de données et marque l’inode avec un type non nul.
La libération par iput écrit le nouvel état de l’inode en mémoire sans le reporter sur le disque.
L’appel système doit être inclus dans une transaction, car iput peut écrire sur le disque en libérant l’inode.
Un appel système de lecture ne peut provoquer de lecture sur le disque lors du traitement d’un inode.

L’appel système doit être inclus dans une transaction, car iput peut écrire sur le disque en libérant l’inode.

Explication

xv6 ne récupère pas après redémarrage les inodes restés alloués sans entrée de répertoire correspondante. Lorsqu’iput libère un inode sans lien, il tronque le fichier, libère ses blocs, met le type à zéro et écrit l’inode sur le disque; il ne conserve donc ni les blocs ni un type non nul, et l’état est bien reporté sur le disque. Comme iput peut écrire sur le disque, l’appel système doit être inclus dans une transaction, même s’il paraît en lecture seule. Le traitement d’un inode peut également nécessiter une lecture sur le disque.

81. Un fichier xv6 dépasse la zone accessible par ses blocs directs. Concernant son adressage :

Les blocs indirects couvrent les 64 kB initiaux du fichier avant les blocs directs.
Les premiers blocs de données sont référencés directement dans les entrées de l’inode.
Les blocs directs couvrent les premiers 6 kB du fichier selon les constantes décrites.
Les blocs indirects sont référencés chacun directement par une entrée distincte de l’inode.
Les blocs suivants sont référencés par un bloc indirect dont l’adresse figure dans l’inode.

Les premiers blocs de données sont référencés directement dans les entrées de l’inode. · Les blocs directs couvrent les premiers 6 kB du fichier selon les constantes décrites. · Les blocs suivants sont référencés par un bloc indirect dont l’adresse figure dans l’inode.

Explication

L’inode référence directement les premiers blocs, puis contient l’adresse du bloc indirect qui référence les suivants. Les blocs directs couvrent les premiers 6 kB; les 64 kB suivants relèvent de l’adressage indirect, et non de la zone initiale.

82. Lorsqu’un fichier xv6 est étendu et que des blocs doivent être attribués ou libérés, quelles affirmations décrivent bmap et itrunc ?

Pour un bloc absent, bmap renvoie son numéro sans effectuer d’allocation.
Pour un bloc déjà présent, bmap renvoie son numéro de bloc de données.
Lors de la troncature, itrunc libère les blocs directs avant ceux référencés indirectement.
Lors de la troncature, itrunc libère le bloc indirect avant les blocs directs.
Pour un bloc demandé encore absent, bmap en alloue un et en enregistre le numéro.

Pour un bloc déjà présent, bmap renvoie son numéro de bloc de données. · Lors de la troncature, itrunc libère les blocs directs avant ceux référencés indirectement. · Pour un bloc demandé encore absent, bmap en alloue un et en enregistre le numéro.

Explication

Bmap renvoie le numéro du bloc demandé et alloue celui-ci s’il manque, en inscrivant son numéro dans la structure appropriée. Itrunc libère d’abord les blocs directs, puis les blocs indirects et enfin le bloc indirect lui-même.

83. Une lecture commence au-delà de la fin d’un fichier, tandis qu’une autre commence avant la fin et la dépasse. Concernant readi et writei :

Une lecture qui atteint la fin du fichier entraîne nécessairement une erreur.
Readi modifie le contenu du fichier lorsqu’il atteint la fin.
Une écriture qui étend le fichier laisse sa taille inchangée selon writei.
La lecture commencée au-delà de la fin entraîne une erreur selon readi.
Une lecture qui dépasse la fin renvoie exactement le nombre d’octets demandé.

La lecture commencée au-delà de la fin entraîne une erreur selon readi.

Explication

Readi renvoie une erreur si la lecture commence après la fin, mais peut renvoyer moins d’octets lorsqu’elle atteint ou traverse la fin. Writei peut étendre le fichier et met alors sa taille à jour; readi ne modifie pas son contenu.

84. Dans un répertoire xv6, une entrée nommée « rapport » est recherchée puis éventuellement ajoutée. Quelles affirmations sont exactes ?

Dirlookup ajoute une entrée nouvelle et échoue si ce nom existe déjà.
Dirlink recherche l’entrée demandée et renvoie l’inode déverrouillé correspondant.
Une entrée libre du répertoire est signalée par un numéro d’inode égal à zéro.
Un nom d’entrée peut contenir jusqu’à 15 caractères dans la représentation xv6.
Le répertoire est un inode de type T_DIR dont les données contiennent des entrées nom-inode.

Une entrée libre du répertoire est signalée par un numéro d’inode égal à zéro. · Le répertoire est un inode de type T_DIR dont les données contiennent des entrées nom-inode.

Explication

Un répertoire est un inode T_DIR contenant des entrées associant un nom à un numéro d’inode; le numéro zéro indique une entrée libre. Dirlookup recherche et renvoie un inode déverrouillé, tandis que dirlink ajoute une entrée et signale une erreur si le nom existe déjà; DIRSIZ vaut 14 caractères.

85. Un processus résout un chemin absolu, puis demande l’inode parent du chemin pour créer son dernier élément. Quelles affirmations sont exactes ?

Namex parcourt les composantes en recherchant chacune dans le répertoire courant verrouillé.
Nameiparent renvoie l’inode du parent et place le dernier élément dans name.
Namei renvoie l’inode correspondant au chemin complet résolu.
La référence obtenue par iget protège l’inode après la libération du verrou du répertoire.
Pour un chemin absolu, namex commence son parcours à la racine.

Namex parcourt les composantes en recherchant chacune dans le répertoire courant verrouillé. · Nameiparent renvoie l’inode du parent et place le dernier élément dans name. · Namei renvoie l’inode correspondant au chemin complet résolu. · La référence obtenue par iget protège l’inode après la libération du verrou du répertoire. · Pour un chemin absolu, namex commence son parcours à la racine.

Explication

Namei résout le chemin complet; nameiparent s’arrête avant le dernier élément et fournit l’inode parent ainsi que cet élément. Namex part de la racine pour un chemin absolu, parcourt les répertoires en gérant leurs verrous, et la référence iget maintient l’inode référencé après le déverrouillage.

86. Deux processus ouvrent séparément le même fichier, puis l’un partage une ouverture au moyen de dup. Quelles affirmations décrivent les fichiers ouverts ?

Un struct file représente un fichier ouvert et contient un inode ou un pipe ainsi qu’un décalage.
La table globale ftable utilise filealloc pour allouer une référence à un fichier ouvert.
Les deux appels distincts à open créent des struct file ayant des décalages propres.
La fonction filedup décrémente le compteur de références du fichier ouvert.
Les références d’un même struct file peuvent être partagées entre des entrées après dup.

Un struct file représente un fichier ouvert et contient un inode ou un pipe ainsi qu’un décalage. · La table globale ftable utilise filealloc pour allouer une référence à un fichier ouvert. · Les deux appels distincts à open créent des struct file ayant des décalages propres. · Les références d’un même struct file peuvent être partagées entre des entrées après dup.

Explication

Un struct file enveloppe un inode ou un pipe et un décalage d’entrée-sortie. Chaque open crée une instance distincte avec son propre décalage; dup partage une instance existante. Ftable gère les références avec filealloc, filedup et fileclose, et filedup incrémente le compteur de références.

87. Un fichier ouvert correspond à un inode, tandis qu’un autre descripteur correspond à un pipe. Lors des opérations de lecture et d’écriture :

Pour un pipe, fileread applique un décalage d’entrée-sortie qu’il fait ensuite avancer.
Quand les références d’un struct file atteignent zéro, fileclose libère l’objet sous-jacent.
Pour un inode, fileread utilise le décalage du struct file puis le fait avancer.
Pour un inode, filewrite utilise le décalage du struct file puis le fait avancer.
Quand le compteur de références atteint zéro, fileclose conserve l’inode sous-jacent.

Quand les références d’un struct file atteignent zéro, fileclose libère l’objet sous-jacent. · Pour un inode, fileread utilise le décalage du struct file puis le fait avancer. · Pour un inode, filewrite utilise le décalage du struct file puis le fait avancer.

Explication

Pour un inode, fileread et filewrite utilisent le décalage du struct file et le font avancer; les pipes n’ont pas de notion de décalage. Lorsque le compteur de références atteint zéro, fileclose libère le pipe ou l’inode sous-jacent selon le type.

88. Un processus crée un lien vers un fichier existant : concernant sys_link, quelles propositions sont exactes ?

sys_link crée un inode neuf avant d’ajouter une entrée au répertoire parent.
Après avoir trouvé le parent, sys_link remplace l’inode source par un inode nouvellement alloué.
sys_link vérifie que l’inode source existe et qu’il ne désigne pas un répertoire.
Si la création échoue, sys_link augmente ip->nlink pour conserver le lien demandé.
Le répertoire parent du nouveau chemin doit se trouver sur le même périphérique que l’inode source.

sys_link vérifie que l’inode source existe et qu’il ne désigne pas un répertoire. · Le répertoire parent du nouveau chemin doit se trouver sur le même périphérique que l’inode source.

Explication

sys_link vérifie l’existence de l’inode source et refuse une source qui est un répertoire. Le parent doit partager le périphérique de l’inode, car les numéros d’inode ne sont uniques que sur un disque ; sys_link réutilise l’inode existant, et en cas d’échec décrémente ip->nlink.

89. Pour différencier la création d’un lien de celle d’un fichier, cochez la (les) proposition(s) exacte(s) :

Pour créer un répertoire, create ajoute son nom au parent avant d’initialiser ses entrées . et .. .
sys_link ajoute un nom faisant référence à un inode déjà existant dans le système.
Lorsqu’un nom demandé existe, create réutilise un fichier régulier pour un appel à open.
create associe le nouveau nom d’un lien à un inode qui vient d’être alloué.
Si un nom existe déjà, create réutilise le répertoire existant pour un appel à open.

sys_link ajoute un nom faisant référence à un inode déjà existant dans le système. · Lorsqu’un nom demandé existe, create réutilise un fichier régulier pour un appel à open.

Explication

sys_link crée un autre nom pour un inode existant, tandis que create sert à créer un nom associé à un nouvel inode. Si le nom existe déjà, create peut réutiliser un fichier régulier pour open ; elle signale une erreur dans les autres cas et initialise les entrées . et .. avant l’ajout d’un répertoire au parent.

90. Un appel à open reçoit un nom de fichier et des indicateurs : quelles propositions décrivent correctement le chemin suivi ?

create sert à la fois à open avec O_CREATE, à mkdir et à mkdev.
Sans O_CREATE, sys_open appelle namei pour retrouver l’inode correspondant au chemin.
Avec O_CREATE, sys_open appelle create pour obtenir l’inode associé au nom demandé.
Après namei, sys_open verrouille l’inode, car namei ne le retourne pas verrouillé.
Sans O_CREATE, sys_open passe par create, puis déverrouille l’inode retourné par namei.

create sert à la fois à open avec O_CREATE, à mkdir et à mkdev. · Sans O_CREATE, sys_open appelle namei pour retrouver l’inode correspondant au chemin. · Avec O_CREATE, sys_open appelle create pour obtenir l’inode associé au nom demandé. · Après namei, sys_open verrouille l’inode, car namei ne le retourne pas verrouillé.

Explication

Avec O_CREATE, sys_open passe par create ; sinon, elle appelle namei et verrouille elle-même l’inode que namei ne retourne pas verrouillé. create généralise la création utilisée par open avec O_CREATE, mkdir et mkdev.

91. Lors de l’ouverture d’un répertoire et de la création d’un tube, quelles propositions sont exactes ?

sys_open initialise le fichier alloué dans la table du processus qui effectue l’appel.
sys_open vérifie qu’un répertoire est ouvert en lecture avant de poursuivre l’ouverture.
Après cette vérification, sys_open alloue un fichier et un descripteur pour l’ouverture.
sys_pipe reçoit un pointeur vers un espace pouvant contenir deux entiers.
sys_pipe inscrit dans cet espace les deux descripteurs associés au tube créé.

sys_open initialise le fichier alloué dans la table du processus qui effectue l’appel. · sys_open vérifie qu’un répertoire est ouvert en lecture avant de poursuivre l’ouverture. · Après cette vérification, sys_open alloue un fichier et un descripteur pour l’ouverture. · sys_pipe reçoit un pointeur vers un espace pouvant contenir deux entiers. · sys_pipe inscrit dans cet espace les deux descripteurs associés au tube créé.

Explication

sys_open vérifie qu’un répertoire est ouvert en lecture, puis alloue un fichier et un descripteur qu’elle initialise dans la table du processus courant. sys_pipe alloue un tube et inscrit ses deux descripteurs dans l’espace désigné par le pointeur reçu.

92. Un répertoire contient un grand nombre de fichiers : parmi les propositions suivantes concernant les systèmes de fichiers, lesquelles sont exactes ?

Dans xv6, une recherche parcourt linéairement les entrées du répertoire.
En cas d’échec d’une opération disque, xv6 déclenche une panique.
BSD UFS/FFS reprend essentiellement les structures d’inodes et de répertoires de xv6.
NTFS recherche les entrées d’un répertoire par un parcours linéaire des blocs.
Le système de fichiers xv6 est limité à un périphérique disque de taille fixe.

Dans xv6, une recherche parcourt linéairement les entrées du répertoire. · En cas d’échec d’une opération disque, xv6 déclenche une panique. · BSD UFS/FFS reprend essentiellement les structures d’inodes et de répertoires de xv6. · Le système de fichiers xv6 est limité à un périphérique disque de taille fixe.

Explication

Les recherches de répertoire dans xv6 sont linéaires, tandis que NTFS utilise des arbres équilibrés permettant une recherche logarithmique. BSD UFS/FFS reprend essentiellement les structures d’inodes et de répertoires de xv6 ; xv6 panique en cas d’échec disque et son système de fichiers reste limité à un disque de taille fixe.

93. Au démarrage d’un ordinateur x86, quelles propositions décrivent correctement le transfert de contrôle et le rôle du chargeur ?

Le chargeur xv6 charge le noyau depuis le disque en mémoire, puis lui transfère le contrôle.
Le chargeur doit quitter le mode où le processeur simule un Intel 8088.
Le secteur d’amorçage chargé par le BIOS est le premier secteur de 512 octets du disque.
Le BIOS charge le secteur d’amorçage du disque de démarrage à l’adresse mémoire 0x7c00.
Le BIOS charge directement le noyau xv6 en mémoire et lui transfère le contrôle.

Le chargeur xv6 charge le noyau depuis le disque en mémoire, puis lui transfère le contrôle. · Le chargeur doit quitter le mode où le processeur simule un Intel 8088. · Le secteur d’amorçage chargé par le BIOS est le premier secteur de 512 octets du disque. · Le BIOS charge le secteur d’amorçage du disque de démarrage à l’adresse mémoire 0x7c00.

Explication

Le BIOS charge à l’adresse 0x7c00 le premier secteur de 512 octets du disque de démarrage, puis transfère le contrôle à son code. Le chargeur quitte le mode simulant un Intel 8088, charge le noyau xv6 en mémoire et lui passe le contrôle ; c’est le chargeur, et non le BIOS, qui effectue ce chargement du noyau.

94. Lors de l’initialisation du processeur, quelle séquence et quelles caractéristiques concernent le passage du chargeur en mode protégé ?

Les descripteurs de segment définissent une base, une limite d’adresse et des bits de permission.
Les segments de la GDT du chargeur ont une base nulle et une limite maximale de quatre gigaoctets.
Le chargeur charge la GDT avec lgdt, positionne CR0_PE, puis exécute un saut lointain ljmp.
La GDT contient une entrée nulle, une entrée de code et une entrée de données.
Le chargeur met à zéro %ds, %es et %ss avant d’activer le 21e bit d’adresse par les ports 0x64 et 0x60.

Les descripteurs de segment définissent une base, une limite d’adresse et des bits de permission. · Les segments de la GDT du chargeur ont une base nulle et une limite maximale de quatre gigaoctets. · Le chargeur charge la GDT avec lgdt, positionne CR0_PE, puis exécute un saut lointain ljmp. · La GDT contient une entrée nulle, une entrée de code et une entrée de données. · Le chargeur met à zéro %ds, %es et %ss avant d’activer le 21e bit d’adresse par les ports 0x64 et 0x60.

Explication

L’entrée en mode protégé suit bien l’ordre lgdt, activation de CR0_PE, puis saut lointain ljmp ; la GDT comprend une entrée nulle ainsi que des entrées de code et de données. Les descripteurs portent base, limite et permissions, et le chargeur met à zéro les registres indiqués avant d’activer le 21e bit par les ports concernés ; la base nulle et la limite de quatre gigaoctets caractérisent ses segments.

95. Après l’activation du mode protégé, le chargeur doit préparer l’exécution du code C. Quelles propositions sont exactes ?

Le sommet de pile est fixé à 0x7c00, puis la pile croît vers les adresses basses.
La pile démarre à 0x7e00 et croît vers les adresses hautes, en s’éloignant du chargeur.
Le chargeur initialise les registres de segment de données avec SEG_KCODE avant l’appel de bootmain.
En mode 32 bits, le chargeur initialise les registres de segment de données avec SEG_KDATA.
L’activation du mode protégé ne modifie pas immédiatement la traduction des adresses logiques.

Le sommet de pile est fixé à 0x7c00, puis la pile croît vers les adresses basses. · En mode 32 bits, le chargeur initialise les registres de segment de données avec SEG_KDATA. · L’activation du mode protégé ne modifie pas immédiatement la traduction des adresses logiques.

Explication

En mode 32 bits, les segments de données reçoivent SEG_KDATA et le sommet de pile est fixé à 0x7c00 ; la pile croît vers les adresses basses. Le passage en mode protégé ne change la traduction des adresses qu’au chargement d’une nouvelle valeur dans un registre de segment. SEG_KCODE et un sommet à 0x7e00 avec croissance ascendante sont incorrects.

96. Lors du chargement du noyau ELF par bootmain, cochez la (les) proposition(s) exacte(s) :

bootmain recherche le noyau exécutable à partir du deuxième secteur du disque.
Les segments du noyau sont copiés avant la pagination à l’adresse physique 0x80000100000.
Les données d’un segment sont lues vers paddr avec readseg, puis le reste est mis à zéro avec stosb.
Avant l’activation de la pagination, les segments sont copiés à l’adresse physique 0x00000100000.
bootmain charge les 4096 premiers octets du fichier ELF à l’adresse mémoire 0x20000.

bootmain recherche le noyau exécutable à partir du deuxième secteur du disque. · Les données d’un segment sont lues vers paddr avec readseg, puis le reste est mis à zéro avec stosb. · Avant l’activation de la pagination, les segments sont copiés à l’adresse physique 0x00000100000.

Explication

Le noyau est attendu à partir du deuxième secteur, et bootmain charge les segments via readseg vers paddr avant de mettre leur reste à zéro avec stosb. Avant la pagination, les segments sont copiés à l’adresse physique 0x00000100000 ; les 4096 premiers octets de l’ELF sont placés à 0x10000, et l’adresse virtuelle haute n’est pas l’adresse physique de copie.

97. Au démarrage de xv6, avant que le noyau ait achevé sa transition vers le sous-mode 64 bits, quelles propositions sont exactes ?

Le point d’entrée ELF du noyau xv6 est 0x10000c.
Le symbole _start définit le point d’entrée du noyau dans le fichier entry.S.
Le code entry réalise ensuite le passage vers le sous-mode 64 bits de l’IA-32e.
Le chargeur appelle le point d’entrée physique alors que le processeur fonctionne encore en mode protégé 32 bits.
La pagination configure la correspondance des adresses virtuelles à partir de 0x80000100000 vers les adresses physiques à partir de 0x00000100000.

Le point d’entrée ELF du noyau xv6 est 0x10000c. · Le symbole _start définit le point d’entrée du noyau dans le fichier entry.S. · Le code entry réalise ensuite le passage vers le sous-mode 64 bits de l’IA-32e. · Le chargeur appelle le point d’entrée physique alors que le processeur fonctionne encore en mode protégé 32 bits. · La pagination configure la correspondance des adresses virtuelles à partir de 0x80000100000 vers les adresses physiques à partir de 0x00000100000.

Explication

Après son démarrage, le noyau configure la pagination entre les plages virtuelle et physique indiquées. Le point d’entrée ELF est 0x10000c, défini par _start dans entry.S ; le chargeur y transfère le contrôle en mode protégé 32 bits, puis le code entry effectue la transition vers le sous-mode 64 bits.

98. Un système doit pouvoir trouver un noyau dont l’emplacement sur le disque n’est pas supposé contigu. Concernant les limites du chargeur xv6 simplifié et les évolutions nécessaires :

La disposition contiguë supposée par le chargeur xv6 simplifie son fonctionnement, mais limite ses possibilités de localisation du noyau.
Le chargeur xv6 compilé occupe environ 450 octets et suppose le noyau contigu à partir du secteur 1.
Les systèmes PC utilisent souvent deux étapes : un chargeur simple récupère un chargeur complet à un emplacement variable, puis celui-ci localise, charge et exécute le noyau.
Un chargeur destiné à parcourir un système de fichiers peut se contenter de l’hypothèse du noyau contigu au secteur 1.
Un chargement réseau demande un chargeur capable de gérer des protocoles réseau et des contrôleurs.

La disposition contiguë supposée par le chargeur xv6 simplifie son fonctionnement, mais limite ses possibilités de localisation du noyau. · Le chargeur xv6 compilé occupe environ 450 octets et suppose le noyau contigu à partir du secteur 1. · Un chargement réseau demande un chargeur capable de gérer des protocoles réseau et des contrôleurs.

Explication

Le chargeur xv6 occupe environ 450 octets et repose sur un noyau contigu à partir du secteur 1, ce qui simplifie le chargement mais limite la localisation du noyau. Un chargement réseau nécessite la gestion des protocoles et des contrôleurs ; un chargeur de système de fichiers doit gérer ce système plutôt que s’appuyer sur la seule hypothèse de contiguïté. Dans le démarrage en deux étapes, le chargeur simple récupère le chargeur complet à un emplacement connu, et non à un emplacement variable.

99. À propos des méthodes de démarrage employées pour dépasser les limites d’un chargeur initial simplifié :

Un premier chargeur simple peut lancer un chargeur complet situé à un emplacement connu, qui charge ensuite le noyau.
Dans un démarrage à deux étapes, le premier chargeur localise et exécute directement le noyau.
UEFI démarre le chargeur volumineux en mode protégé 32 bits après l’avoir lu sur le disque.
Le chargeur complet récupère le premier chargeur à un emplacement connu, puis celui-ci lance le noyau.
UEFI permet au PC de charger depuis le disque un chargeur plus volumineux en mode réel.

Un premier chargeur simple peut lancer un chargeur complet situé à un emplacement connu, qui charge ensuite le noyau.

Explication

Le démarrage en deux étapes fait d’abord lancer un chargeur complet par un chargeur simple ; le chargeur complet localise, charge et exécute ensuite le noyau. UEFI permet de lire un chargeur plus volumineux sur le disque et de le démarrer en mode 64 bits, non en mode 32 bits ou réel.

Révisez avec les flashcards

Mémorisez les réponses avec 95 flashcards sur Synchronisation et système de fichiers xv6.

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 →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Synchronisation et système de fichiers xv6.

Voir la fiche →

Cours similaires

Crée tes propres QCM

Importe ton cours et l'IA génère des QCM avec corrections en 30 secondes.

Générateur de QCM