From 09bddee59c2ec3ed86684db5568d7beb1f822072 Mon Sep 17 00:00:00 2001 From: Guillaume Chanel <Guillaume.Chanel@unige.ch> Date: Mon, 26 Aug 2024 16:19:31 +0200 Subject: [PATCH] Add section 5 of filesystems: implementation --- .../05_Systemes_fichiers_implementation.md | 241 +++++++++--------- 9.filesystems/Ressources.md | 6 +- 2 files changed, 120 insertions(+), 127 deletions(-) diff --git a/9.filesystems/05_Systemes_fichiers_implementation.md b/9.filesystems/05_Systemes_fichiers_implementation.md index 981a1fa..cae8588 100644 --- a/9.filesystems/05_Systemes_fichiers_implementation.md +++ b/9.filesystems/05_Systemes_fichiers_implementation.md @@ -1,22 +1,6 @@ ---- -author: Florent Gluck - Florent.Gluck@hesge.ch +# Implémentation -title: Systèmes de fichiers - Implémentation - -date: \vspace{.5cm} \footnotesize \today - -institute: \vspace{0.5cm} \tiny \textsuperscript{*}Remerciements à Mickaël Hoerdt - -pandoc-latex-fontsize: - - classes: [tiny] - size: tiny - - classes: [verysmall] - size: scriptsize - - classes: [small] - size: footnotesize - - classes: [huge, important] - size: huge ---- +<!-- ## TODO @@ -24,79 +8,78 @@ pandoc-latex-fontsize: - méthode rapide : seul le bitmap des inode et des blocs est modifié - méthode sécurisée : les blocs de données et le contenus des inodes sont également effacés -[//]: # ---------------------------------------------------------------- +--> + +-- + # Adressage des blocs de données -[//]: # ---------------------------------------------------------------- +-- + ## Facilité d'adressage On désire obtenir un accès ordonné aux blocs qui composent le contenu d'un fichier : début du fichier en bloc 0, suite en bloc 1, etc. -\vspace{.5cm} + <!-- .element width="60%" --> -\centering -{ width=60% } +-- -[//]: # ---------------------------------------------------------------- ## Adressage : problème 1 Les blocs de données d'un fichier ne sont pas toujours contigus sur le disque -\centering -{ width=100% } + <!-- .element width="80%" --> + +-- -[//]: # ---------------------------------------------------------------- ## Adressage souhaité On désire une fonction `bmap` qui mappe un numéro de bloc du fichier (0, 1, 2, ...) vers un numéro de bloc du disque : -\vspace{.2cm} - -```{.c .small} +```c // i : numero du bloc (logique) du fichier // renvoie le numero du bloc physique sur disque -int bmap(inode, i); +int bmap(inode, i); ``` -\centering -{ width=50% } +<!-- .element width="50%" --> + -\footnotesize +<small> -- `bmap(inode, 0)` $\rightarrow$ 18 -- `bmap(inode, 1)` $\rightarrow$ 20 -- `bmap(inode, 2)` $\rightarrow$ 25 -- `bmap(inode, 3)` $\rightarrow$ 11 +- `bmap(inode, 0) $\rightarrow$ 18` +- `bmap(inode, 1) $\rightarrow$ 20` +- `bmap(inode, 2) $\rightarrow$ 25` +- `bmap(inode, 3) $\rightarrow$ 11` + +</small> + +-- -[//]: # ---------------------------------------------------------------- ## Adressage : problème 2 Certains blocs peuvent être des blocs indirects, c'est à dire contenir les adresses d'autres blocs -\vspace{.2cm} + <!-- .element width="80%" --> -\centering -{ width=100% } +-- -[//]: # ---------------------------------------------------------------- ## Problème des indirections -\footnotesize - - Selon le même principe, on peut ajouter des blocs doublement, triplement, etc. indirects - La distinction entre bloc simple, bloc indirect et bloc double indirect se fait sur sa position dans le tableau des adresses de l'inode -\centering -{ width=90% } +<!-- .element width="70%" --> + +-- -[//]: # ---------------------------------------------------------------- ## Repenser la structure de données Ainsi la structure des inodes de MINIX : -```{.c .verysmall} +```c struct minix_inode { ... @@ -108,7 +91,7 @@ struct minix_inode { peut s'écrire : -```{.c .verysmall} +```c struct minix_inode { ... @@ -117,19 +100,19 @@ struct minix_inode { }; ``` -[//]: # ---------------------------------------------------------------- +-- + ## Fonction bmap : algorithme (1/2) -```{.c .tiny} +```c // i : numero du bloc (logique) du fichier // renvoie le numero du bloc physique sur disque int bmap(inode, i); ``` -\small Pseudo-code avec 2 niveaux d'indirections : -```{.c .tiny} +```c if (i < nb_blocs_adressables_directement) { // cas 1 return inode.i_zone[i] } @@ -150,34 +133,35 @@ if (i < nb_blocs_adressables_avec_une_double_indir) { // cas 3 return indir2_bloc[i % nb_blocs_adressables_avec_une_seule_indir] } ``` +<!-- .element style="font-size:0.45em" --> + +-- -[//]: # ---------------------------------------------------------------- ## Fonction bmap : algorithme (2/2) -- Pourquoi la soustraction entre chaque cas ? - - pour réajuster l'indice dans le bloc lors d'une indirection : on passe d'un indice absolu à un indice relatif au bloc indirect +- Pourquoi la soustraction entre chaque cas ? \ +pour réajuster l'indice dans le bloc lors d'une indirection : on passe d'un indice absolu à un indice relatif au bloc indirect -\vspace{.2cm} +<br></br> - Exemple : si 7 blocs sont adressables directement, mais qu'on veut le 8ème, on veut le premier indice du bloc indirect, pas l'indice 8 -[//]: # ---------------------------------------------------------------- -## Fonction bmap : exemple (1/4) +-- -\footnotesize +## Fonction bmap : exemple (1/4) - Nombre de blocs adressables directement : 2 - Nombre de blocs adressables avec une seule indirection : 4 - Nombre de blocs adressables avec une double indirection : 4*4 -\centering -{ width=90% } +<!-- .element width="70%" --> + +-- -[//]: # ---------------------------------------------------------------- ## Fonction bmap : exemple (2/4) -```{.c .tiny} +```c if (i < 2) { // cas 1 return inode.i_zone[i] } @@ -197,78 +181,88 @@ if (i < 16) { // cas 3 return indir2_bloc[i % 4] } ``` +<!-- .element style="font-size:0.45em" --> + +-- -[//]: # ---------------------------------------------------------------- ## Fonction bmap : exemple (3/4) -\scriptsize +<div class="text-block" style="font-size: 0.7em"> **i = 4** : -- pas à inférieur à **2** $\rightarrow$ on rejette le cas 1 -- 4-**2** = **\textcolor{mygreen}{2}** -- **\textcolor{mygreen}{2}** inférieur à **4** $\rightarrow$ on entre dans le cas 2 +- pas à inférieur à *2* $\rightarrow$ on rejette le cas 1 +- 4-*2* = **2** +- **2** inférieur à *4* $\rightarrow$ on entre dans le cas 2 - lecture du bloc d'indirection simple -- indice **\textcolor{mygreen}{2}** dans bloc d'indirection simple pointe bien vers bloc 4 +- indice **2** dans bloc d'indirection simple pointe bien vers bloc 4 **i = 6** : -- pas inférieur à **2** $\rightarrow$ on rejette le cas 1 -- 6-**2** = **\textcolor{mygreen}{4}** -- **\textcolor{mygreen}{4}** pas inférieur à **4** $\rightarrow$ on rejette le cas 2 -- **\textcolor{mygreen}{4}**-**4** = **\textcolor{myred}{0}** -- **\textcolor{myred}{0}** inférieur à **16** $\rightarrow$ on entre dans le cas 3 -- lecture du bloc d'indirection simple d'indice **\textcolor{myred}{0}**/**4** = 0 - - \scriptsize indice **\textcolor{myred}{0}** % **4** (0) dans bloc d'indirection simple pointe bien vers bloc 6 +- pas inférieur à *2* $\rightarrow$ on rejette le cas 1 +- 6-*2* = **4** +- **4** pas inférieur à **4** $\rightarrow$ on rejette le cas 2 +- **4**-**4** = <text style="color:red">**0**</text> +- **<text style="color:red">0</text>** inférieur à *16* $\rightarrow$ on entre dans le cas 3 +- lecture du bloc d'indirection simple d'indice **<text style="color:red">0</text>**/*4* = 0 + - **<text style="color:red">0</text>** % *4* (0) dans bloc d'indirection simple pointe bien vers bloc 6 + +</div> + +-- -[//]: # ---------------------------------------------------------------- ## Fonction bmap : exemple (4/4) -\scriptsize +<div class="text-block" style="font-size: 0.7em"> **i = 9** : -- pas inférieur à **2** $\rightarrow$ on rejette le cas 1 -- 9-**2** = **\textcolor{mygreen}{7}** -- **\textcolor{mygreen}{7}** pas inférieur à **4** $\rightarrow$ on rejette le cas 2 -- **\textcolor{mygreen}{7}**-4 = **\textcolor{myred}{3}** -- **\textcolor{myred}{3}** inférieur à **16** $\rightarrow$ on entre dans le cas 3 -- lecture du bloc d'indirection simple d'indice **\textcolor{myred}{3}**/**4** = 0 - - \scriptsize indice **\textcolor{myred}{3}** % **4** (3) dans bloc d'indirection simple pointe bien vers bloc 9 +- pas inférieur à *2* $\rightarrow$ on rejette le cas 1 +- 9-*2* = **7** +- **7** pas inférieur à *4* $\rightarrow$ on rejette le cas 2 +- **7**-4 = **<text style="color:red">3</text>** +- **<text style="color:red">3</text>** inférieur à *16* $\rightarrow$ on entre dans le cas 3 +- lecture du bloc d'indirection simple d'indice **<text style="color:red">3</text>**/*4* = 0 + - \scriptsize indice **<text style="color:red">3</text>** % *4* (3) dans bloc d'indirection simple pointe bien vers bloc 9 **i = 10** : -- pas inférieur à **2** $\rightarrow$ on rejette le cas 1 -- 10-**2** = **\textcolor{myred}{8}** -- **\textcolor{myred}{8}** pas inférieur à **4** $\rightarrow$ on rejette le cas 2 -- **\textcolor{myred}{8}**-**4** = **\textcolor{myred}{4}** -- **\textcolor{myred}{4}** inférieur à **16** $\rightarrow$ on entre dans le cas 3 -- lecture du bloc d'indirection simple d'indice **\textcolor{myred}{4}**/**4** = 1 - - \scriptsize indice **\textcolor{myred}{4}** % **4** (0) dans bloc d'indirection simple pointe bien vers bloc 10 +- pas inférieur à *2* $\rightarrow$ on rejette le cas 1 +- 10-*2* = **<text style="color:red">8</text>** +- **<text style="color:red">8</text>** pas inférieur à *4* $\rightarrow$ on rejette le cas 2 +- **<text style="color:red">8</text>**-*4* = **<text style="color:red">4</text>** +- **<text style="color:red">4</text>** inférieur à *16* $\rightarrow$ on entre dans le cas 3 +- lecture du bloc d'indirection simple d'indice **<text style="color:red">4</text>**/*4* = 1 + - \scriptsize indice **<text style="color:red">4</text>** % *4* (0) dans bloc d'indirection simple pointe bien vers bloc 10 + +</div> + +-- -[//]: # ---------------------------------------------------------------- # Résolution du chemin d'accès -[//]: # ---------------------------------------------------------------- +-- + ## Problème du chemin d'accès +<br></br> + - Les inodes n'ont pas de noms, juste un numéro... -\vspace{.5cm} +<br></br> - Comment retrouver le numéro d'un inode à partir de son chemin d'accès dans la chaîne des répertoires du système de fichiers ? -[//]: # ---------------------------------------------------------------- +-- + ## Fonction namei On désire une fonction `namei` qui retourne le numéro d'un inode à partir de son chemin d'accès dans le système de fichiers : -\vspace{.2cm} - -```{.c .small} +```c // renvoie le numero d'inode du fichier dont le // chemin d'acces est path -int namei(path); +int namei(path); ``` - La recherche débute depuis : @@ -276,24 +270,21 @@ int namei(path); - le répertoire courant du processus si le chemin d'accès est relatif - `namei` est typiquement utilisée par tous les appels systèmes qui prennent un chemin d'accès en argument -[//]: # ---------------------------------------------------------------- +-- + ## Fonction namei : example P.ex. appeler `namei` sur le chemin `"/usr/bin/bash"` parcourt le contenu des inodes suivants et renvoie 21 : -\vspace{.3cm} +<!-- .element width="80%" --> -\centering -{ width=100% } +-- -[//]: # ---------------------------------------------------------------- ## Fonction namei : algorithme Pseudo-code pour un chemin absolu : -\vspace{.2cm} - -```{.c .small} +```c int namei(path) { inode = ROOT_INODE pour chaque composant du path p { @@ -303,13 +294,11 @@ int namei(path) { } ``` -[//]: # ---------------------------------------------------------------- -## Fonction lookup_entry +-- -\small -\vspace{.2cm} +## Fonction lookup_entry -```{.c .small} +```c // renvoie le numero d'inode correspondant a name int lookup_entry(dir_inode, name); ``` @@ -317,19 +306,20 @@ int lookup_entry(dir_inode, name); - La fonction `lookup_entry` recherche un fichier dans un répertoire et renvoie son inode - `lookup_entry` réalise une recherche linéaire de la chaîne de caractères `name` dans les entrées de répertoire (`dir_entry`) du répertoire dont l'inode est `dir_inode` : -**Attention** : +<fieldset class="warning"> +<legend>Attention:</legend> -- Le contenu du répertoire peut-être réparti sur plusieurs blocs $\rightarrow$ utiliser `bmap` +- Le contenu du répertoire peut-être réparti sur plusieurs blocs `$\rightarrow$` utiliser `bmap` - Aucune garantie que la taille du répertoire soit un multiple de la taille des blocs : utiliser le champs taille de l'inode pour limiter la recherche -[//]: # ---------------------------------------------------------------- -## Fonction lookup_entry : algorithme +</fieldset> -Pseudo-code : +-- + +## Fonction lookup_entry : algorithme -\vspace{.2cm} -```{.c .small} +```c int lookup_entry(dir_inode, name) { pour chaque bloc de dir_node et dans la limite de dir_inode.size { @@ -341,12 +331,11 @@ int lookup_entry(dir_inode, name) { } ``` -[//]: # ---------------------------------------------------------------- -## Fonction del_entry +-- -\small +## Fonction del_entry -```{.c} +```c del_entry(dir_inode, name) ``` diff --git a/9.filesystems/Ressources.md b/9.filesystems/Ressources.md index 4f65bbf..96eebc9 100644 --- a/9.filesystems/Ressources.md +++ b/9.filesystems/Ressources.md @@ -1,5 +1,7 @@ # Ressources +<div class="text-block"> + - [Operating Systems: Three Easy Pieces](http://pages.cs.wisc.edu/~remzi/OSTEP/), Remzi H. and Andrea C. Arpaci-Dusseau. Arpaci-Dusseau Books livre disponible à la bibliothèque @@ -10,4 +12,6 @@ livre disponible à la bibliothèque - `mkfs.minix` [source code](https://github.com/util-linux/util-linux/blob/master/disk-utils/mkfs.minix.c) -- `minix-fs` [on-disk structures](https://github.com/util-linux/util-linux/blob/master/include/minix.h) \ No newline at end of file +- `minix-fs` [on-disk structures](https://github.com/util-linux/util-linux/blob/master/include/minix.h) + +</div> \ No newline at end of file -- GitLab