104.2 Leçon 1

Certification :

LPIC-1

Version :

5.0

Thème :

104 Disques, systèmes de fichiers Linux, arborescence de fichiers standard (FHS)

Objectif :

104.2 Maintenir l’intégrité des systèmes de fichiers

Leçon :

1 of 1

Introduction

Les systèmes de fichiers Linux modernes sont journalisés. Cela veut dire que chaque opération est enregistrée dans un journal interne avant d’être exécutée. Si l’opération est interrompue en raison d’une erreur du système (comme une panique du noyau -kernel panic-, une panne de courant, etc.), elle peut être reconstruite en inspectant le journal, ce qui permet d’éviter la dégradation du système de fichiers et la perte de données.

Cela réduit considérablement la nécessité d’effectuer des vérifications manuelles du système de fichiers, mais ces dernières peuvent toujours s’avérer nécessaires. La maîtrise des outils utilisés à cet effet (avec les paramètres correspondants) peut faire la différence entre un dîner en famille à la maison et une nuit blanche au travail dans la salle des serveurs.

Dans cette leçon, nous allons voir de plus près les outils disponibles pour surveiller l’utilisation du système de fichiers, optimiser le fonctionnement de ce dernier et voir comment détecter et réparer les éventuelles dégradations.

Vérifier l’utilisation du disque

Il existe deux commandes qui peuvent être utilisées pour vérifier l’espace utilisé et l’espace restant sur un système de fichiers. La première est du, qui signifie "disk usage" (utilisation du disque).

La commande du est récursive en soi. Dans sa forme la plus basique, la commande montre simplement combien de blocs d’un kilo-octet sont utilisés par le répertoire en cours et tous ses sous-répertoires :

$ du
4816	.

Cela ne nous aide pas beaucoup, et nous pouvons demander une sortie plus "humainement lisible" (human readable) en ajoutant le paramètre -h :

$ du -h
4.8M	.

Par défaut, du n’affiche que le décompte de l’utilisation des répertoires (en prenant en compte tous les fichiers et sous-répertoires qu’ils contiennent). Pour afficher un décompte individuel pour tous les fichiers du répertoire, vous pouvez utiliser le paramètre -a :

$ du -ah
432K	./geminoid.jpg
508K	./Linear_B_Hero.jpg
468K	./LG-G8S-ThinQ-Mirror-White.jpg
656K	./LG-G8S-ThinQ-Range.jpg
60K	./Stranger3_Titulo.png
108K	./Baidu_Banho.jpg
324K	./Xiaomi_Mimoji.png
284K	./Mi_CC_9e.jpg
96K	./Mimoji_Comparativo.jpg
32K	./Xiaomi FCC.jpg
484K	./geminoid2.jpg
108K	./Mimoji_Abre.jpg
88K	./Mi8_Hero.jpg
832K	./Tablet_Linear_B.jpg
332K	./Mimoji_Comparativo.png
4.8M	.

Le comportement par défaut consiste à afficher l’utilisation de chaque sous-répertoire, puis l’utilisation totale du répertoire actuel, y compris les sous-répertoires :

$ du -h
4.8M	./Temp
6.0M	.

Dans l’exemple ci-dessus, nous constatons que le sous-répertoire Temp occupe 4,8 Mo et que le répertoire courant, y compris Temp, occupe 6,0 Mo. Mais combien d’espace occupent les fichiers du répertoire courant, sans compter les sous-répertoires ? Pour cela, nous disposons du paramètre -S :

$ du -Sh
4.8M	./Temp
1.3M	.

Tip	Gardez à l’esprit que les paramètres en ligne de commande sont sensibles à la casse : `-s` n’est pas la même chose que `-S`.

Si vous voulez conserver cette distinction entre l’espace utilisé par les fichiers du répertoire courant et l’espace utilisé par les sous-répertoires, tout en gardant un total général à la fin, vous pouvez ajouter le paramètre -c :

$ du -Shc
4.8M	./Temp
1.3M	.
6.0M	total

Vous pouvez régler la "profondeur" des résultats de du avec le paramètre -d N, où N indique les niveaux. Par exemple, si vous utilisez le paramètre -d 1, il affichera le répertoire courant et ses sous-répertoires, mais pas les sous-répertoires de ces derniers.

Voyez la différence ci-dessous. Sans -d :

$ du -h
216K	./somedir/anotherdir
224K	./somedir
232K	.

Et en limitant la profondeur à un seul niveau avec -d 1 :

$ du -h -d1
224K	./somedir
232K	.

Notez que même si anotherdir n’est pas affiché, sa taille sera toujours prise en compte.

Il peut être souhaitable d’exclure certains types de fichiers du décompte, ce que vous pouvez effectuer avec --exclude="PATTERN", où PATTERN correspond au motif que vous voulez faire correspondre. Prenons l’exemple de ce répertoire :

$ du -ah
124K	./ASM68K.EXE
2.0M	./Contra.bin
36K	./fixheadr.exe
4.0K	./README.txt
2.1M	./Contra_NEW.bin
4.0K	./Built.bat
8.0K	./Contra_Main.asm
4.2M	.

Maintenant, nous allons utiliser --exclude pour éliminer tous les fichiers avec l’extension .bin :

$ du -ah --exclude="*.bin"
124K	./ASM68K.EXE
36K	./fixheadr.exe
4.0K	./README.txt
4.0K	./Built.bat
8.0K	./Contra_Main.asm
180K	.

Notez que le total ne prend plus en compte la taille des fichiers exclus.

Vérifier l’espace disponible

du fonctionne au niveau des fichiers. Il existe une autre commande qui peut vous renseigner sur l’utilisation du disque et sur l’espace disponible au niveau du système de fichiers. C’est la commande df.

La commande df fournit une liste de tous les systèmes de fichiers disponibles (déjà montés) sur votre système, avec leur taille totale, l’espace utilisé, l’espace disponible, le pourcentage d’utilisation et le point de montage :

$ df
Filesystem     1K-blocks      Used Available Use% Mounted on
udev             2943068         0   2943068   0% /dev
tmpfs             595892      2496    593396   1% /run
/dev/sda1      110722904  25600600  79454800  25% /
tmpfs            2979440    951208   2028232  32% /dev/shm
tmpfs               5120         0      5120   0% /run/lock
tmpfs            2979440         0   2979440   0% /sys/fs/cgroup
tmpfs             595888        24    595864   1% /run/user/119
tmpfs             595888       116    595772   1% /run/user/1000
/dev/sdb1          89111      1550     80824   2% /media/carol/part1
/dev/sdb3          83187      1550     75330   3% /media/carol/part3
/dev/sdb2          90827      1921     82045   3% /media/carol/part2
/dev/sdc1      312570036 233740356  78829680  75% /media/carol/Samsung Externo

En revanche, l’affichage de la taille par blocs de 1 ko n’est pas très convivial. Tout comme pour du, vous pouvez ajouter le paramètre -h pour obtenir une sortie plus "humainement lisible" :

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
udev            2.9G     0  2.9G   0% /dev
tmpfs           582M  2.5M  580M   1% /run
/dev/sda1       106G   25G   76G  25% /
tmpfs           2.9G  930M  2.0G  32% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           2.9G     0  2.9G   0% /sys/fs/cgroup
tmpfs           582M   24K  582M   1% /run/user/119
tmpfs           582M  116K  582M   1% /run/user/1000
/dev/sdb1        88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3        82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2        89M  1.9M   81M   3% /media/carol/part2
/dev/sdc1       299G  223G   76G  75% /media/carol/Samsung Externo

Vous pouvez également utiliser le paramètre -i pour afficher les inodes utilisés/disponibles plutôt que les blocs :

$ df -i
Filesystem      Inodes  IUsed   IFree IUse% Mounted on
udev            737142    547  736595    1% /dev
tmpfs           745218    908  744310    1% /run
/dev/sda6      6766592 307153 6459439    5% /
tmpfs           745218    215  745003    1% /dev/shm
tmpfs           745218      4  745214    1% /run/lock
tmpfs           745218     18  745200    1% /sys/fs/cgroup
/dev/sda1        62464    355   62109    1% /boot
tmpfs           745218     43  745175    1% /run/user/1000

Un paramètre intéressant est -T, qui affichera en outre le type de chacun des systèmes de fichiers :

$ df -hT
Filesystem     Type      Size  Used Avail Use% Mounted on
udev           devtmpfs  2.9G     0  2.9G   0% /dev
tmpfs          tmpfs     582M  2.5M  580M   1% /run
/dev/sda1      ext4      106G   25G   76G  25% /
tmpfs          tmpfs     2.9G  930M  2.0G  32% /dev/shm
tmpfs          tmpfs     5.0M     0  5.0M   0% /run/lock
tmpfs          tmpfs     2.9G     0  2.9G   0% /sys/fs/cgroup
tmpfs          tmpfs     582M   24K  582M   1% /run/user/119
tmpfs          tmpfs     582M  116K  582M   1% /run/user/1000
/dev/sdb1      ext4       88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3      ext4       82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2      ext4       89M  1.9M   81M   3% /media/carol/part2
/dev/sdc1      fuseblk   299G  223G   76G  75% /media/carol/Samsung Externo

À partir du moment où vous connaissez le type du système de fichiers, vous pouvez filtrer les résultats. Vous pouvez afficher uniquement les systèmes de fichiers d’un type donné avec -t TYPE ou exclure les systèmes de fichiers d’un type donné avec -x TYPE, comme dans les exemples ci-dessous.

Exclure les systèmes de fichiers tmpfs :

$ df -hx tmpfs
Filesystem      Size  Used Avail Use% Mounted on
udev            2.9G     0  2.9G   0% /dev
/dev/sda1       106G   25G   76G  25% /
/dev/sdb1        88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3        82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2        89M  1.9M   81M   3% /media/carol/part2
/dev/sdc1       299G  223G   76G  75% /media/carol/Samsung Externo

Afficher uniquement les systèmes de fichiers ext4 :

$ df -ht ext4
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       106G   25G   76G  25% /
/dev/sdb1        88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3        82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2        89M  1.9M   81M   3% /media/carol/part2

Vous pouvez également personnaliser l’affichage de df en sélectionnant les éléments à afficher et dans quel ordre, grâce au paramètre --output= suivi d’une liste de champs à afficher, séparés par des virgules. Voici quelques champs disponibles :

source: Le périphérique qui correspond au système de fichiers.
fstype: Le type de système de fichiers.
size: La taille totale du système de fichiers.
used: L’espace utilisé.
avail: L’espace disponible.
pcent: Le pourcentage d’utilisation.
target: L’endroit où le système de fichiers est monté (point de montage).

Si vous souhaitez obtenir un résultat avec la cible, la source, le type et l’utilisation, vous pouvez utiliser :

$ df -h --output=target,source,fstype,pcent
Mounted on                    Filesystem     Type     Use%
/dev                          udev           devtmpfs   0%
/run                          tmpfs          tmpfs      1%
/                             /dev/sda1      ext4      25%
/dev/shm                      tmpfs          tmpfs     32%
/run/lock                     tmpfs          tmpfs      0%
/sys/fs/cgroup                tmpfs          tmpfs      0%
/run/user/119                 tmpfs          tmpfs      1%
/run/user/1000                tmpfs          tmpfs      1%
/media/carol/part1            /dev/sdb1      ext4       2%
/media/carol/part3            /dev/sdb3      ext4       3%
/media/carol/part2            /dev/sdb2      ext4       3%
/media/carol/Samsung Externo  /dev/sdc1      fuseblk   75%

df peut également être utilisé pour vérifier les informations sur les inodes, en passant les champs suivants à --output= :

itotal: Nombre total d’inodes du système de fichiers.
iused: Nombre d’inodes utilisés dans le système de fichiers.
iavail: Nombre d’inodes disponibles dans le système de fichiers.
ipcent: Pourcentage d’inodes utilisés dans le système de fichiers.

Par exemple :

$ df --output=source,fstype,itotal,iused,ipcent
Filesystem     Type      Inodes  IUsed IUse%
udev           devtmpfs  735764    593    1%
tmpfs          tmpfs     744858   1048    1%
/dev/sda1      ext4     7069696 318651    5%
tmpfs          tmpfs     744858    222    1%
tmpfs          tmpfs     744858      3    1%
tmpfs          tmpfs     744858     18    1%
tmpfs          tmpfs     744858     22    1%
tmpfs          tmpfs     744858     40    1%

Maintenir les systèmes de fichiers ext2, ext3 et ext4

Pour analyser l’intégrité d’un système de fichiers (et corriger les erreurs éventuelles si tout se passe bien), Linux fournit l’utilitaire fsck (pensez à "filesystem check", ce qui vous aidera à retenir le nom). Dans sa forme la plus sommaire, vous pouvez l’invoquer avec fsck suivi de l’emplacement du système de fichiers que vous voulez vérifier :

# fsck /dev/sdb1
fsck from util-linux 2.33.1
e2fsck 1.44.6 (5-Mar-2019)
DT_2GB: clean, 20/121920 files, 369880/487680 blocks

Warning

Ne lancez JAMAIS fsck (ou les outils équivalents) sur un système de fichiers monté. Si vous le faites quand même, vous risquez de perdre vos données.

Ce n’est pas fsck en soi qui va vérifier l’intégrité du système de fichiers. Il va plutôt faire appel à l’outil approprié en fonction du type de système de fichiers pour le faire. Dans l’exemple ci-dessus, aucun type de système de fichiers n’a été spécifié. fsck a donc présumé un système de fichiers ext2/3/4 par défaut et a fait appel à e2fsck.

Pour spécifier un système de fichiers, utilisez l’option -t suivie du nom du système de fichiers, comme dans fsck -t vfat /dev/sdc. Alternativement, vous pouvez invoquer directement l’outil spécifique au système de fichiers, comme fsck.msdos pour les systèmes de fichiers FAT.

Tip	Tapez `fsck` et deux fois la touche `Tab` pour afficher la liste de toutes les commandes associées sur votre système.

fsck accepte une série d’arguments en ligne de commande. Voici les plus courants :

-A: Vérifie l’intégrité de tous les systèmes de fichiers répertoriés dans /etc/fstab.
-C: Affiche une barre de progression lors de la vérification d’un système de fichiers. Fonctionne uniquement sur les systèmes de fichiers ext2/3/4 pour l’instant.
-N: Affiche ce qui serait fait et quitte le programme sans réellement vérifier le système de fichiers.
-R: Utilisé conjointement avec -A, ce paramètre fait l’impasse sur la vérification du système de fichiers racine.
-V: Mode verbeux : affiche plus d’informations que d’habitude pendant l’opération. Ce mode est utile pour le débogage.

L’outil spécifique pour les systèmes de fichiers ext2, ext3 et ext4 est e2fsck, également appelé fsck.ext2, fsck.ext3 et fsck.ext4 (ces trois derniers ne sont que des liens vers e2fsck). Par défaut, il fonctionne en mode interactif : dès qu’une erreur est détectée dans le système de fichiers, le programme s’arrête et demande à l’utilisateur ce qu’il doit faire. L’utilisateur doit taper y pour corriger le problème, n pour ne pas le corriger ou a pour corriger le problème actuel et tous les problèmes subséquents.

Évidemment, rester devant un terminal en attendant que e2fsck vous demande ce qu’il faut faire n’est pas vraiment une utilisation productive de votre temps, surtout si vous avez affaire à un système de fichiers conséquent. Il existe donc une série d’options qui permettent à e2fsck de s’exécuter en mode non-interactif :

-p: Cette option va tenter de corriger automatiquement toutes les erreurs trouvées. Si une erreur nécessitant l’intervention de l’administrateur système est détectée, e2fsck va fournir un rapport d’analyse du problème et terminer l’exécution.
-y: Ceci va répondre y (oui) à toutes les questions.
-n: Le contraire de -y. En dehors de la réponse n (non) à toutes les questions, ceci aura pour effet de monter le système de fichiers en lecture seule, de manière à ce qu’il ne puisse pas être modifié.
-f: Force e2fsck à vérifier un système de fichiers même s’il est identifié comme "propre", c’est-à-dire s’il a été correctement démonté.

Peaufinage d’un système de fichiers ext

Les systèmes de fichiers ext2, ext3 et ext4 ont un certain nombre de paramètres qui peuvent être peaufinés - ou faire l’objet d’un "tuning" - par l’administrateur du système pour mieux répondre aux besoins du système. L’outil qui sert à afficher ou modifier ces paramètres s’appelle tune2fs.

Pour afficher les paramètres en cours pour un système de fichiers donné, utilisez le paramètre -l suivi du périphérique correspondant à la partition. L’exemple ci-dessous montre la sortie de cette commande sur la première partition du premier disque (/dev/sda1) d’une machine :

# tune2fs -l /dev/sda1
tune2fs 1.44.6 (5-Mar-2019)
Filesystem volume name:   <none>
Last mounted on:          /
Filesystem UUID:          6e2c12e3-472d-4bac-a257-c49ac07f3761
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index filetype needs_recovery extent 64bit flex_bg sparse_super large_file huge_file dir_nlink extra_isize metadata_csum
Filesystem flags:         signed_directory_hash
Default mount options:    user_xattr acl
Filesystem state:         clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              7069696
Block count:              28255605
Reserved block count:     1412780
Free blocks:              23007462
Free inodes:              6801648
First block:              0
Block size:               4096
Fragment size:            4096
Group descriptor size:    64
Reserved GDT blocks:      1024
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         8192
Inode blocks per group:   512
Flex block group size:    16
Filesystem created:       Mon Jun 17 13:49:59 2019
Last mount time:          Fri Jun 28 21:14:38 2019
Last write time:          Mon Jun 17 13:53:39 2019
Mount count:              8
Maximum mount count:      -1
Last checked:             Mon Jun 17 13:49:59 2019
Check interval:           0 (<none>)
Lifetime writes:          20 GB
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:	          256
Required extra isize:     32
Desired extra isize:      32
Journal inode:            8
First orphan inode:       5117383
Default directory hash:   half_md4
Directory Hash Seed:      fa95a22a-a119-4667-a73e-78f77af6172f
Journal backup:           inode blocks
Checksum type:            crc32c
Checksum:                 0xe084fe23

Les systèmes de fichiers ext disposent d’un compteur de montages (mount counts). Ce compteur est incrémenté à chaque montage du système de fichiers. Lorsqu’une valeur seuil (le maximum mount count) est atteinte, l’intégrité du système sera automatiquement vérifiée avec e2fsck au prochain démarrage.

Le maximum de montages peut être défini avec le paramètre -c N, où N correspond au nombre de fois que le système de fichiers peut être monté sans être inspecté. Le paramètre -C N fixe le nombre de fois où le système a été monté à la valeur de N. Notez bien que les paramètres en ligne de commande sont sensibles à la casse et que -c n’est pas la même chose que -C.

Vous pouvez également définir un laps de temps entre les vérifications avec le paramètre -i suivi d’un nombre et les lettres d (days) pour les jours, m (months) pour les mois et y (years) pour les années. Par exemple, -i 10d vérifierait l’intégrité du système de fichiers au prochain redémarrage tous les dix jours. La valeur zéro permet de désactiver cette fonctionnalité.

-L peut être utilisé pour étiqueter le système de fichiers. Cette étiquette peut comporter jusqu’à seize caractères. Le paramètre -U définit l’UUID du système de fichiers, un nombre hexadécimal de 128 bits. Dans l’exemple ci-dessus, l’UUID est 6e2c12e3-472d-4bac-a257-c49ac07f3761. L’étiquette et l’UUID peuvent être utilisés à la place du nom du périphérique (comme /dev/sda1) pour monter le système de fichiers.

L’option -e BEHAVIOUR définit le comportement (behaviour) du noyau lorsqu’une erreur est détectée dans le système de fichiers. On distingue trois comportements possibles :

continue: Continue l’exécution normalement.
remount-ro: Remonte le système de fichiers en lecture seule.
panic: Déclenche une panique du noyau (kernel panic).

Le comportement par défaut est continue. remount-ro (remontage en lecture seule) peut s’avérer utile pour les applications critiques, étant donné que les écritures sur le disque sont immédiatement interrompues, ce qui permet d’éviter d’autres erreurs par la suite.

Les systèmes de fichiers ext3 sont essentiellement des systèmes de fichiers ext2 dotés d’un journal. En utilisant tune2fs vous pouvez ajouter un journal à un système de fichiers ext2 et le convertir ainsi en ext3. La procédure est simple, il suffit de passer le paramètre -j à tune2fs, suivi du périphérique qui contient le système de fichiers :

# tune2fs -j /dev/sda1

Par la suite, lorsque vous montez le système de fichiers converti, n’oubliez pas de spécifier le type ext3 pour utiliser le journal.

Lorsque vous avez affaire à des systèmes de fichiers journalisés, le paramètre -J vous permet d’utiliser des paramètres supplémentaires pour définir une série d’options, comme -J size= pour fixer la taille du journal (en mégaoctets), -J location= pour spécifier l’endroit où le journal doit être stocké (soit un bloc spécifique, soit une position spécifique sur le disque avec des suffixes comme M ou G) et même installer le journal sur un périphérique externe avec -J device=.

Vous pouvez spécifier plusieurs paramètres à la fois en les séparant par une virgule. Par exemple : -J size=10,location=100M,device=/dev/sdb1 va créer un journal de 10 Mo à la position 100 Mo sur le périphérique /dev/sdb1.

Warning

tune2fs dispose d’une option "force brute", -f, qui le forcera à exécuter une opération même en cas d’erreur. Il va sans dire que cette option ne doit être utilisée qu’avec une précaution extrême.

Maintenir les systèmes de fichiers XFS

L’équivalent de fsck pour les systèmes de fichiers XFS est xfs_repair. Si vous soupçonnez que quelque chose ne tourne pas rond avec le système de fichiers, la première chose à faire est de vérifier s’il n’est pas dégradé.

Pour ce faire, passez le paramètre -n à xfs_repair, suivi du périphérique qui contient le système de fichiers. Ce paramètre -n signifie “pas de modification” (no modify) : le système de fichiers sera analysé, les erreurs seront signalées mais aucune correction ne sera effectuée :

# xfs_repair -n /dev/sdb1
Phase 1 - find and verify superblock...
Phase 2 - using internal log
        - zero log...
        - scan filesystem freespace and inode maps...
        - found root inode chunk
Phase 3 - for each AG...
        - scan (but do not clear) agi unlinked lists...
        - process known inodes and perform inode discovery...
        - agno = 0
        - agno = 1
        - agno = 2
        - agno = 3
        - process newly discovered inodes...
Phase 4 - check for duplicate blocks...
        - setting up duplicate extent list...
        - check for inodes claiming duplicate blocks...
        - agno = 1
        - agno = 3
        - agno = 0
        - agno = 2
No modify flag set, skipping phase 5
Phase 6 - check inode connectivity...
        - traversing filesystem ...
        - traversal finished ...
        - moving disconnected inodes to lost+found ...
Phase 7 - verify link counts...
No modify flag set, skipping filesystem flush and exiting.

En cas d’erreur, vous pouvez procéder à la réparation en omettant le paramètre -n, comme ceci : xfs_repair /dev/sdb1.

xfs_repair accepte un certain nombre d’options en ligne de commande. En voici quelques-unes :

-l LOGDEV et -r RTDEV: Nécessaires si le système de fichiers est doté de sections log (journalisation) et realtime (temps réel) externes. Dans ce cas, remplacez LOGDEV et RTDEV par les périphériques correspondants.
-m N: Sert à limiter l’utilisation de la mémoire de xfs_repair à N mégaoctets, ce qui peut être utile sur les serveurs. Selon la page de manuel, par défaut, xfs_repair adaptera son utilisation de la mémoire en fonction des besoins, jusqu’à 75% de la RAM physique du système.
-d: Le mode "dangereux" (dangerous) permet de réparer les systèmes de fichiers montés en lecture seule.
-v: Vous l’aurez probablement deviné : il s’agit du mode verbeux (verbose). La "verbosité" est augmentée à chaque utilisation. (Par exemple, -v -v va afficher plus d’informations qu’un simple -v).

Notez que xfs_repair est incapable de réparer les systèmes de fichiers avec un journal "corrompu". Vous pouvez "éliminer" un journal dégradé avec le paramètre -L, mais gardez à l’esprit qu’il s’agit d’un dernier recours dans la mesure où cette opération peut entraîner la dégradation du système de fichiers et la perte des données.

Pour déboguer un système de fichiers XFS, vous pouvez utiliser l’outil xfs_db, comme dans xfs_db /dev/sdb1. Il est utilisé principalement pour analyser les différents éléments et paramètres du système de fichiers.

L’outil dispose d’une invite interactive, un peu comme parted, avec toute une série de commandes internes. Un système d’aide est également disponible : tapez help pour afficher la liste de toutes les commandes, et help suivi du nom de la commande pour obtenir plus d’informations sur la commande en question.

Un autre outil utile est xfs_fsr, qui peut être utilisé pour réorganiser (ou "défragmenter") un système de fichiers XFS. Lorsqu’il est exécuté sans arguments supplémentaires, il va tourner pendant deux heures et tenter de défragmenter tous les systèmes de fichiers XFS montés et accessibles en écriture qui sont listés dans le fichier /etc/mtab/. Vous devrez éventuellement installer cet outil à l’aide du gestionnaire de paquets de votre distribution Linux, étant donné qu’il ne fait peut-être pas partie de l’installation par défaut. Pour plus d’informations, consultez la page de manuel correspondante.

Exercices guidés

En utilisant du, comment pouvons-nous vérifier l’espace utilisé par les fichiers du répertoire courant ?
En utilisant df, affichez les informations pour chaque système de fichiers ext4, avec les résultats qui incluent les informations suivantes, dans l’ordre : périphérique, point de montage, nombre total d’inodes, nombre d’inodes disponibles, pourcentage d’espace libre.
Quelle est la commande pour exécuter e2fsck sur /dev/sdc1 en mode non-interactif, tout en essayant de corriger automatiquement la plupart des erreurs ?
Admettons que /dev/sdb1 est un système de fichiers ext2. Comment pouvez-vous le convertir en ext3 et en même temps réinitialiser son décompte de montage et modifier son étiquette en UserData ?
Comment pouvez-vous vérifier l’intégrité d’un système de fichiers XFS sans pour autant réparer les éventuelles erreurs qu’il contient ?

Exercices d’approfondissement

Prenons l’exemple d’un système de fichiers ext4 sur /dev/sda1 avec les paramètres suivants, obtenus à l’aide de tune2fs :
```
Mount count:              8
Maximum mount count:      -1
```
Que se passera-t-il au prochain démarrage si la commande tune2fs -c 9 /dev/sda1 est invoquée ?
Considérez le résultat suivant de du -h:
```
$ du -h
216K	./somedir/anotherdir
224K	./somedir
232K	.
```
Quel est l’espace occupé par les seuls fichiers du répertoire courant ? Comment pourrions-nous reformuler la commande pour faire apparaître cette information plus clairement ?
Que se passera-t-il avec le système de fichiers ext2 /dev/sdb1 si la commande ci-dessous est invoquée ?
```
# tune2fs -j /dev/sdb1 -J device=/dev/sdc1 -i 30d
```
Comment pouvons-nous vérifier les erreurs sur un système de fichiers XFS sur /dev/sda1 doté d’une section de journalisation sur /dev/sdc1, mais sans effectuer de réparations ?
Quelle est la différence entre les paramètres -T et -t pour df ?

Résumé

Dans cette leçon, vous avez appris à :

Vérifier l’espace utilisé et l’espace disponible dans un système de fichiers.
Adapter l’affichage de df à vos besoins.
Vérifier l’intégrité d’un système de fichiers et réparer les erreurs avec fsck et e2fsck.
Peaufiner un système de fichiers avec tune2fs.
Vérifier l’intégrité d’un système de fichiers XFS et réparer les erreurs avec xfs_repair.

Les commandes suivantes ont été abordées dans cette leçon :

du: Afficher la quantité d’espace disque utilisée dans un système de fichiers.
df: Afficher la quantité d’espace disque disponible (free) dans un système de fichiers.
fsck: L’outil d’analyse et de réparation des systèmes de fichiers.
e2fsck: L’outil d’analyse et de réparation spécifique aux systèmes de fichiers ext2/3/4.
tune2fs: Modifie les paramètres des systèmes de fichiers ext2/3/4.
xfs_repair: L’équivalent de fsck pour les systèmes de fichiers XFS.
xfs_db: Cet outil sert à afficher les paramètres divers et variés d’un système de fichiers XFS.

Réponses aux exercices guidés

En utilisant du, comment pouvons-nous vérifier l’espace utilisé par les fichiers du répertoire courant ?

Dans un premier temps, utilisez le paramètre -S pour séparer l’affichage du répertoire courant des sous-répertoires. Ensuite, utilisez -d 0 pour limiter la profondeur de l’affichage à zéro, ce qui signifie "pas de sous-répertoires". N’oubliez pas -h pour obtenir une sortie dans un format "humainement lisible" :
```
$ du -S -h -d 0
```
ou
```
$ du -Shd 0
```
En utilisant df, affichez les informations pour chaque système de fichiers ext4, avec les résultats qui incluent les informations suivantes, dans l’ordre : périphérique, point de montage, nombre total d’inodes, nombre d’inodes disponibles, pourcentage d’espace libre.

Vous pouvez filtrer les systèmes de fichiers avec l’option -t suivie du nom du système de fichiers. Pour obtenir les infos demandées, utilisez --output=source,target,itotal,iavail,pcent. La réponse est donc :
```
$ df -t ext4 --output=source,target,itotal,iavail,pcent
```
Quelle est la commande pour exécuter e2fsck sur /dev/sdc1 en mode non-interactif, tout en essayant de corriger automatiquement la plupart des erreurs ?

Le paramètre qui permet d’essayer de corriger automatiquement la plupart des erreurs est -p. La réponse est donc :
```
# e2fsck -p /dev/sdc1
```
Admettons que /dev/sdb1 est un système de fichiers ext2. Comment pouvez-vous le convertir en ext3 et en même temps réinitialiser son décompte de montage et modifier son étiquette en UserData ?

Rappelez-vous que la conversion d’un système de fichiers ext2 en ext3 revient à ajouter un journal, ce qui peut être fait avec le paramètre -j. Pour réinitialiser le décompte de montages, utilisez -C 0. Pour changer l’étiquette, utilisez -L UserData. La bonne réponse est donc :
```
# tune2fs -j -C 0 -L UserData /dev/sdb1
```
Comment pouvez-vous vérifier l’intégrité d’un système de fichiers XFS sans pour autant réparer les éventuelles erreurs qu’il contient ?

Utilisez le paramètre -n, comme dans xfs -n, suivi du périphérique correspondant.

Réponses aux exercices d’approfondissement

Prenons l’exemple d’un système de fichiers ext4 sur /dev/sda1 avec les paramètres suivants, obtenus à l’aide de tune2fs :
```
Mount count:              8
Maximum mount count:      -1
```
Que se passera-t-il au prochain démarrage si la commande tune2fs -c 9 /dev/sda1 est invoquée ?

La commande va fixer le nombre maximum de montages pour le système de fichiers à 9. Puisque ce nombre est actuellement égal à 8, le prochain démarrage du système va entraîner une vérification de l’intégrité du système de fichiers.
Considérez le résultat suivant de du -h:
```
$ du -h
216K	./somedir/anotherdir
224K	./somedir
232K	.
```
Quel est l’espace occupé par les seuls fichiers du répertoire courant ? Comment pourrions-nous reformuler la commande pour faire apparaître cette information plus clairement ?

Sur un total de 232 Ko utilisés, 224 Ko sont utilisés par le sous-répertoire somedir et ses sous-répertoires. Donc, en excluant ces derniers, nous avons 8 Ko occupés par les fichiers du répertoire courant. Cette information peut être affichée plus clairement en utilisant le paramètre -S, qui va dissocier les répertoires dans le décompte.
Que se passera-t-il avec le système de fichiers ext2 /dev/sdb1 si la commande ci-dessous est invoquée ?
```
# tune2fs -j /dev/sdb1 -J device=/dev/sdc1 -i 30d
```
Un journal sera ajouté à /dev/sdb1, ce qui le convertira en ext3. Le journal sera stocké sur le périphérique /dev/sdc1 et le système de fichiers sera vérifié tous les 30 jours.
Comment pouvons-nous vérifier les erreurs sur un système de fichiers XFS sur /dev/sda1 doté d’une section de journalisation sur /dev/sdc1, mais sans effectuer de réparations ?

Utilisez xfs_repair suivi de -l /dev/sdc1 pour indiquer le périphérique contenant la section de journalisation et -n pour éviter les modifications.
```
# xfs_repair -l /dev/sdc1 -n
```
Quelle est la différence entre les paramètres -T et -t pour df ?

Le paramètre -T va inclure le type de chaque système de fichiers dans l’affichage de df. -t est un filtre, et ne montrera que les systèmes de fichiers du type donné dans l’affichage, en excluant tous les autres.