diff --git a/9.filesystems/05_Systemes_fichiers_implementation.md b/9.filesystems/05_Systemes_fichiers_implementation.md
index 981a1faded7bbeefaa93a80efb5c6babe94f31b5..cae85888308a9710d246a73cc59367ae253574f0 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 4f65bbf88068e4ba9de586ac2073c7440212c1e4..96eebc90b850f7fbdc652d911eaa9d7384353ab9 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