Skip to content
Snippets Groups Projects
Commit 09bddee5 authored by Guillaume Chanel's avatar Guillaume Chanel
Browse files

Add section 5 of filesystems: implementation

parent fc4dd1bf
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
9.filesystems/05_Systemes_fichiers_implementation.md
+ 115
− 126
View file @ 09bddee5
---
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}
![](images/blocks_simple_addr.png) <!-- .element width="60%" -->
\centering
![](images/blocks_simple_addr.png){ width=60% }
--
[//]: # ----------------------------------------------------------------
## Adressage : problème 1
Les blocs de données d'un fichier ne sont pas toujours contigus sur le disque
\centering
![](images/blocks_addr_problem.png){ width=100% }
![](images/blocks_addr_problem.png) <!-- .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
![](images/bmap.png){ width=50% }
![](images/bmap.png)<!-- .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}
![](images/blocks_addr_problem2.png) <!-- .element width="80%" -->
\centering
![](images/blocks_addr_problem2.png){ 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
![](images/blocks_indirections.png){ width=90% }
![](images/blocks_indirections.png)<!-- .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
![](images/bmap_example.png){ width=90% }
![](images/bmap_example.png)<!-- .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}
![](images/namei_example.png)<!-- .element width="80%" -->
\centering
![](images/namei_example.png){ 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)
```
......
9.filesystems/Ressources.md
+ 5
− 1
View file @ 09bddee5
# 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
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment