Un fichier n'est pas ce que tu crois : c'est un nom, un numéro et des blocs de données.
⏱️ Durée : environ 75 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Archiviste
🎬 L'histoire
Kodi supprime un fichier de 5 Go : le disque ne se vide pas. Il supprime un autre fichier : l'espace est libéré. Il crée un « raccourci » et s'étonne qu'il ne fonctionne plus quand le fichier d'origine est déplacé, alors qu'une autre copie, elle, résiste.
« Les fichiers, les noms et les raccourcis sont trois choses différentes, dit Sam. Regardons ce qu'il y a derrière. »
Tu comprends comment le noyau organise et retrouve tes données sur le disque.
🎯 Ta mission
À la fin, je serai capable de :
- décrire inode, bloc de données, répertoire et nom de fichier
- distinguer lien physique (hard link) et lien symbolique
- expliquer pourquoi supprimer un fichier ne libère pas toujours l'espace
- expliquer la journalisation (journaling)
- lire les métadonnées d'un fichier avec
os.stat
🧩 Défi d'échauffement (5 XP)
Une bibliothèque a un catalogue (titre → numéro de rayonnage) et des rayonnages (livres). Deux fiches du catalogue peuvent pointer vers le même livre. Si tu retires une fiche, le livre disparaît-il ? Quand le livre peut-il être jeté ? Et si une fiche indique « voir le titre X » au lieu d'un rayonnage, que se passe-t-il quand le titre X est renommé ?
💡 Le concept
Les couches d'un fichier
| Élément | Rôle |
|---|---|
| Bloc de données | contient le contenu (par morceaux de 4 Ko, par exemple) |
| Inode | la « fiche d'identité » : taille, propriétaire, droits, dates, emplacement des blocs. Pas le nom ! |
| Répertoire | un fichier spécial qui associe des noms à des numéros d'inode |
Répertoire /notes Inode 4821 Blocs de données
───────────────────── ──────────────────── ──────────────────
rapport.txt → 4821 → taille : 2 150 octets → bloc 912, bloc 913
copie.txt → 4821 droits : rw-r--r--
nombre de liens : 2
Le nom appartient au répertoire, pas au fichier.
Lien physique et lien symbolique
| Lien physique (hard link) | Lien symbolique (symlink) | |
|---|---|---|
| Nature | un deuxième nom pour le même inode | un fichier spécial qui contient un chemin |
| Si l'original est supprimé | le fichier existe toujours | le lien est cassé |
| Entre systèmes de fichiers | impossible | possible |
| Sur un dossier | généralement interdit | possible |
Pourquoi l'espace n'est pas libéré ?
Le contenu est supprimé quand le nombre de liens tombe à 0 ET qu'aucun processus ne garde le fichier ouvert. Un fichier de log supprimé alors qu'un serveur l'écrit encore continue d'occuper le disque.
Les métadonnées avec Python
import os, stat, tempfile
with tempfile.TemporaryDirectory() as d:
chemin = os.path.join(d, "note.txt")
with open(chemin, "w") as f:
f.write("bonjour")
s = os.stat(chemin)
print("inode :", s.st_ino)
print("taille :", s.st_size, "octets")
print("droits :", stat.filemode(s.st_mode))
print("liens :", s.st_nlink)
Journalisation
Une écriture touche plusieurs structures (données, inode, répertoire). Une coupure de courant au milieu laisse un système incohérent. Un système de fichiers journalisé (ext4, NTFS, APFS…) note d'abord l'opération dans un journal : au redémarrage, il la rejoue ou l'annule. Cela évite de longues vérifications.
L'arborescence et les points de montage
L'ensemble des fichiers forme un arbre unique partant de /. Chaque disque ou partition est monté à un endroit de l'arbre (par exemple /mnt/donnees).
🧠 Astuce : un « fichier » est un nom (dans un répertoire) vers un inode vers des blocs.
🔍 Exemple pas à pas
Problème : observer la différence entre lien physique et lien symbolique, avec un fichier supprimé.
import os, tempfile
with tempfile.TemporaryDirectory() as d:
original = os.path.join(d, "original.txt")
dur = os.path.join(d, "lien_dur.txt")
symbolique = os.path.join(d, "lien_sym.txt")
with open(original, "w") as f:
f.write("contenu important")
os.link(original, dur) # lien physique
os.symlink(original, symbolique) # lien symbolique
print("même inode (original / lien dur) :", os.stat(original).st_ino == os.stat(dur).st_ino)
print("nombre de liens :", os.stat(original).st_nlink)
os.remove(original) # on supprime le nom d'origine
print("lien dur lisible :", open(dur).read())
print("lien symbolique cassé :", not os.path.exists(symbolique))
Lecture :
original.txtetlien_dur.txtsont deux noms pour le même inode : le nombre de liens vaut 2.- Après
os.remove(original), le contenu existe toujours, car il reste un nom. - Le lien symbolique stocke seulement le chemin
original.txt: une fois supprimé, il pointe dans le vide.
Fichier supprimé mais ouvert :
import os, tempfile
with tempfile.TemporaryDirectory() as d:
chemin = os.path.join(d, "log.txt")
f = open(chemin, "w")
f.write("x" * 1000)
f.flush()
os.remove(chemin) # le nom disparaît
print(os.path.exists(chemin)) # False
f.write("encore") # mais le processus peut continuer à écrire
f.close() # le contenu est libéré ici
✍️ À toi, avec aide (10 XP)
Crée dans un dossier temporaire un fichier a.txt, un lien physique b.txt et un lien symbolique c.txt. Pour chacun, affiche l'inode et le nombre de liens. Puis modifie le contenu via b.txt et vérifie que a.txt et c.txt montrent le nouveau contenu.
💡 Indice 1
os.link(src, dst) et os.symlink(src, dst).
💡 Indice 2
os.stat(chemin).st_ino pour l'inode ; os.lstat ne suit pas les liens symboliques.
💡 Indice 3
Écrire dans b.txt modifie les blocs de données partagés par a.txt.
✅ Réponse
import os, tempfile
with tempfile.TemporaryDirectory() as d:
a, b, c = (os.path.join(d, n) for n in ("a.txt", "b.txt", "c.txt"))
open(a, "w").write("v1")
os.link(a, b)
os.symlink(a, c)
for nom, p in (("a", a), ("b", b), ("c (suit le lien)", c)):
s = os.stat(p)
print(nom, "inode", s.st_ino, "liens", s.st_nlink)
print("c lui-même (lstat) :", os.lstat(c).st_ino)
with open(b, "w") as f:
f.write("v2")
print(open(a).read(), open(c).read()) # v2 v2
a et b ont le même inode et 2 liens. c est un autre inode (le lien lui-même) mais os.stat(c) suit le lien et montre l'inode de a.
🚀 À toi, en solo (20 XP)
Détective de doublons. Écris trouver_doublons(dossier) qui parcourt un dossier (récursivement) et renvoie des groupes de chemins qui correspondent au même contenu. Pour être efficace : regroupe d'abord par taille, puis calcule une empreinte (hashlib.sha256) seulement pour les fichiers de même taille. Distingue deux cas : (a) copies indépendantes (inodes différents) ; (b) liens physiques (même inode).
✅ Pistes de correction
import hashlib, os, tempfile
from collections import defaultdict
def empreinte(chemin):
h = hashlib.sha256()
with open(chemin, "rb") as f:
for bloc in iter(lambda: f.read(65536), b""):
h.update(bloc)
return h.hexdigest()
def trouver_doublons(dossier):
par_taille = defaultdict(list)
for racine, _, fichiers in os.walk(dossier):
for nom in fichiers:
p = os.path.join(racine, nom)
if not os.path.islink(p):
par_taille[os.path.getsize(p)].append(p)
groupes = []
for taille, chemins in par_taille.items():
if len(chemins) < 2:
continue
par_hash = defaultdict(list)
for p in chemins:
par_hash[empreinte(p)].append(p)
for liste in par_hash.values():
if len(liste) > 1:
inodes = {os.stat(p).st_ino p liste}
groupes.append((liste, (inodes) == ))
groupes
tempfile.TemporaryDirectory() d:
nom, contenu ((, ), (, ), (, )):
(os.path.join(d, nom), ).write(contenu)
os.link(os.path.join(d, ), os.path.join(d, ))
g trouver_doublons(d):
([os.path.basename(p) p g[]], g[])
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Croire que le nom est dans le fichier | Confusion entre lien dur et copie | Nom = répertoire ; données = inode |
| Supprimer un log encore ouvert | L'espace n'est pas libéré | Redémarrer ou tronquer le fichier |
| Lien symbolique relatif cassé | Le lien ne résout plus après déplacement | Utiliser des chemins absolus ou vérifier |
| Débrancher pendant une écriture | Système incohérent sans journal | Systèmes journalisés, arrêt propre |
🐉 Mini-boss (40 XP)
Mini système de fichiers en mémoire. Implémente MiniFS avec :
- des inodes (dictionnaire numéro → {contenu, nlink}) ;
- des répertoires (dictionnaire nom → numéro d'inode) ;
creer(chemin, contenu),lire(chemin),lier(source, destination)(lien physique),supprimer(chemin);- le contenu n'est effacé que lorsque
nlinktombe à 0.
Teste : créer un fichier, lui faire un lien, supprimer l'original, relire via le lien, supprimer le lien et vérifier que l'inode a disparu.
✅ Pistes de correction
class MiniFS:
def __init__(self):
self.inodes = {} # numéro -> {"contenu": str, "nlink": int}
self.repertoire = {} # chemin -> numéro d'inode
self._suivant = 1
def creer(self, chemin, contenu):
if chemin in self.repertoire:
raise FileExistsError(chemin)
n = self._suivant; self._suivant += 1
self.inodes[n] = {"contenu": contenu, "nlink": 1}
self.repertoire[chemin] = n
def lire(self, chemin):
return self.inodes[self.repertoire[chemin]]["contenu"]
def lier(self, source, destination):
n = self.repertoire[source]
self.repertoire[destination] = n
self.inodes[n]["nlink"] += 1
():
n = .repertoire.pop(chemin)
.inodes[n][] -=
.inodes[n][] == :
.inodes[n]
fs = MiniFS()
fs.creer(, )
fs.lier(, )
fs.supprimer()
fs.lire() == (fs.inodes) ==
fs.supprimer()
(fs.inodes) ==
()
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un inode contient :
- A. le nom du fichier
- B. les métadonnées du fichier (taille, droits, emplacement)
- C. le contenu en clair
2. Un lien physique :
- A. contient un chemin
- B. ne peut exister qu'une fois
- C. est un deuxième nom pour le même inode
3. Un lien symbolique devient cassé quand :
- A. le fichier cible est supprimé ou déplacé
- B. on le lit
- C. on le copie
4. 🔁 Révision mission 05 : La table des pages sert à :
- A. stocker les fichiers
- B. traduire les adresses virtuelles en adresses physiques
- C. chiffrer la mémoire
5. 🔁 Révision mission 05 : Le thrashing est :
- A. un virus
- B. un type de cache
- C. un système qui passe son temps à échanger des pages
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel équivalent des « liens physiques » et « symboliques » trouves-tu dans ta vie (deux adresses pour un même lieu, un panneau « voir ailleurs ») ?
- Pourquoi la journalisation est-elle précieuse en cas de coupure de courant ?
🎒 À retenir
- Fichier = nom (répertoire) → inode → blocs.
- Lien physique : même inode ; lien symbolique : chemin.
- Le contenu disparaît quand liens = 0 et plus aucun processus ne l'ouvre.
- Journalisation : cohérence après une panne.
- Tout se rattache à un arbre unique via les points de montage.
flowchart LR
T(["Les systèmes de fichiers"])
T --> R1["1. Fichier = nom répertoire → inode → blocs."]
T --> R2["2. Lien physique : même inode ; lien symbolique : chemin."]
T --> R3["3. Le contenu disparaît quand liens = 0 et plus aucun processus ne…"]
T --> R4["4. Journalisation : cohérence après une panne."]
T --> R5["5. Tout se rattache à un arbre unique via les points de montage."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Archiviste
← Mission 05 — La mémoire virtuelle · Mission 07 — Permissions et identité →
HEF-050 — Systèmes d'exploitation

