Anime-Sanctuary

Diagnostiquer un disque saturé

Serveur lent alors que le processeur dort : comment diagnostiquer un disque saturé avec iostat et PSI, trouver le programme coupable, puis le calmer ?

Parcours
Tutoriel 33 sur 35
Durée
35 min de lecture
Vérifié avec
Debian 13.7 (trixie), sysstat 12.7.5, iotop 0.6, util-linux 2.41.5
Ce que vous saurez faire
  • Reconnaître un disque saturé à l'attente d'entrées/sorties que montre top.
  • Lire la sortie de iostat -x et le fichier /proc/pressure/io.
  • Trouver le programme coupable avec pidstat, iotop et lsof.
  • Le calmer avec ionice, puis ranger l'essai.

Avant de commencer : Lire les journaux, Supervision simple.

Sommaire
  1. Le disque, une caisse pour tout le monde
  2. 1. Préparer une saturation sous contrôle
  3. 2. Reconnaître le symptôme : attente et charge
  4. 3. iostat : l'état du disque
  5. 4. PSI : ce que subissent les programmes
  6. 5. Trouver le coupable
  7. 6. Calmer le coupable avec ionice
  8. 7. Quand ionice ne change rien : l'ordonnanceur
  9. 8. Ranger l'essai
  10. Si ça échoue
  11. Pour aller plus loin
  12. La suite

Le disque, une caisse pour tout le monde

Un serveur lent dont le processeur dort a souvent la même cause : le disque est saturé. Un disque ne traite qu'un nombre limité de demandes par seconde. Chaque lecture ou écriture est une entrée/sortie (E/S), et celles qui arrivent trop vite patientent dans une file d'attente, comme devant une caisse de supermarché.

Votre site web qui veut lire une page se retrouve alors derrière un gros transfert de fichiers. Il n'a rien fait de mal : il attend son tour. Nous allons fabriquer cette situation en petit, la mesurer de trois façons, puis la défaire. Tous les chiffres de l'article sont des exemples : les vôtres seront différents, mais de la même forme.

La file d'attente d'un disque calme et d'un disque saturé Deux files de huit places menant à un disque. Disque calme : la file est vide, une lecture passe tout de suite en 5 millisecondes. Disque saturé : sept écritures attendent dans la file, la lecture arrive derrière elles et attend 80 millisecondes. Disque calme disque Une lecture passe tout de suite : 5 ms. Disque saturé disque La lecture attend derrièresept écritures : 80 ms. Gris : écritures. Bleu : lecture.
Texte équivalent : sur un disque calme, une lecture passe seule et prend 5 millisecondes. Sur un disque saturé, sept écritures occupent la file et la même lecture attend derrière elles, 80 millisecondes. Durées données en exemple.

Ce schéma explique pourquoi un disque saturé ne se voit pas au processeur. Celui-ci calcule peu, car il attend. Pour étudier cette attente, il nous faut d'abord un disque qui en souffre.

1Préparer une saturation sous contrôle

Nous allons fabriquer la saturation avec dd, une commande qui copie des données d'un endroit à un autre. Ici, elle écrira des zéros dans un fichier de 256 Mo, en boucle, sans toucher au reste du disque.

Avant la charge, préparons une sonde : un petit fichier de 4 Ko dont nous mesurerons la lecture. Il joue un client seul à la caisse. Son temps de passage dit la longueur de la file. D'abord, on crée ce fichier :

Sur le serveur
dd if=/dev/zero of=/var/tmp/sonde.bin bs=4k count=1 oflag=direct status=none
  • if=/dev/zero (« input file ») est la source : un fichier spécial qui fournit des zéros à volonté.
  • of=/var/tmp/sonde.bin (« output file ») est le fichier à écrire.
  • bs=4k count=1 : un bloc de 4 Ko, copié une seule fois.
  • oflag=direct écrit sans passer par le cache, la mémoire où Linux garde les fichiers récents. Sans cela, le disque ne travaillerait pas vraiment.
  • status=none masque les messages de dd.

Cette commande n'affiche rien. Ensuite, on lit le fichier, et c'est cette seconde commande qui affiche le temps de passage :

Sur le serveur
dd if=/var/tmp/sonde.bin of=/dev/null bs=4k count=1 iflag=direct
Résultat attendu
1+0 records in
1+0 records out
4096 bytes (4.1 kB, 4.0 KiB) copied, 0.000312 s, 13.1 MB/s

Seul le temps compte, le nombre avant « s » (secondes). Ici 0,000312 s, soit 0,3 ms (millisecondes) : un temps minuscule, c'est le disque au repos. Lançons maintenant la charge, qui reprend la même commande en boucle, avec des blocs de 1 Mo copiés 256 fois. Elle a quatre morceaux de plus :

  • while true; do ...; done est une boucle : « tant que vrai » ne devient jamais faux, donc elle répète dd sans fin.
  • sh -c '...' lance un petit interpréteur de commandes (sh) qui exécute le texte entre apostrophes. Il faut ce détour, car timeout ne sait surveiller qu'un seul programme, pas une boucle.
  • timeout 600 coupe le tout au bout de 600 secondes, soit 10 minutes.
  • & lance la commande en arrière-plan et vous rend la main tout de suite.
Sur le serveur
timeout 600 sh -c 'while true; do dd if=/dev/zero of=/var/tmp/charge.bin bs=1M count=256 oflag=direct status=none; done' &

Le terminal, la fenêtre où vous tapez vos commandes, affiche une ligne du genre [1] 4242, puis vous rend la main. Le 4242 est le PID (numéro d'identification) de timeout, le premier programme lancé. Celui de dd sera différent, et l'étape 5 vous le montre. Si, à l'étape suivante, la lecture de la sonde redevient rapide, les 10 minutes sont écoulées : relancez la commande timeout 600 ci-dessus. Le disque travaille, voyons ce que cela change vu de l'extérieur.

2Reconnaître le symptôme : attente et charge

Un disque saturé se reconnaît à un processeur qui attend au lieu de calculer, et top l'affiche dans la ligne %Cpu(s), sous le nom wa. Ce iowait est la part du temps où le processeur n'a rien à faire, parce qu'il attend une réponse du disque. Demandons à top une seule photo, avec -b (sortie simple, sans écran interactif) et -n1 (un seul relevé). Le trait vertical | est un tube, qui passe la sortie de la commande de gauche à celle de droite. Ici, head -3 n'en garde que les trois premières lignes.

Sur le serveur
top -bn1 | head -3
Résultat attendu
top - 14:02:11 up 3 days,  4:17,  1 user,  load average: 5.12, 3.40, 1.85
Tasks: 104 total,   2 running, 102 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.3 us,  1.9 sy,  0.0 ni, 13.6 id, 82.0 wa,  0.0 hi,  0.2 si,  0.0 st

Deux signes comptent ici. Le wa est très haut, 82 %, alors que us (le travail des programmes) reste à 2,3 %. Et la charge moyenne (load average) monte. Ce sont trois nombres, pour 1, 5 et 15 minutes, et ils comptent aussi les programmes bloqués à attendre le disque.

Mesurons maintenant ce que vit un seul client : relisons la sonde, pendant que la charge tourne.

Sur le serveur
dd if=/var/tmp/sonde.bin of=/dev/null bs=4k count=1 iflag=direct
Résultat attendu
1+0 records in
1+0 records out
4096 bytes (4.1 kB, 4.0 KiB) copied, 0.0821 s, 49.9 kB/s

La même lecture, qui prenait 0,000312 s (0,3 ms), en prend ici 0,0821 s (82 ms) : plus de 200 fois plus. L'écart varie selon le disque. Reste un manque : wa prouve que le processeur attend un disque, sans dire lequel ni à quel point il est débordé. C'est le travail de iostat.

3iostat : l'état du disque

La commande iostat -x montre, pour chaque disque, combien de demandes il reçoit, combien de temps elles attendent et à quel point il est occupé. Elle vient du paquet sysstat, que vous savez installer depuis Mises à jour et paquets. Le mot sudo, placé devant une commande, l'exécute avec les droits d'administrateur.

Sur le serveur
sudo apt install sysstat

Lançons-la avec cinq réglages, qui rendent la sortie lisible :

  • -d affiche les disques seulement, sans le processeur.
  • -x ajoute les colonnes détaillées (le « x » de « extended », étendu).
  • -z cache les disques sans activité.
  • -y saute le premier relevé, une moyenne depuis le démarrage qui ne dit rien de l'instant.
  • 2 3 demande un relevé toutes les 2 secondes, trois fois.
Sur le serveur
iostat -dxzy 2 3
Résultat attendu
Device            r/s     rkB/s   rrqm/s  %rrqm r_await rareq-sz     w/s     wkB/s   wrqm/s  %wrqm w_await wareq-sz     d/s     dkB/s   drqm/s  %drqm d_await dareq-sz     f/s f_await  aqu-sz  %util
sda             22.50     90.00     0.00   0.00   78.40     4.00   74.00  75776.00     0.00   0.00   11.90  1024.00    0.00      0.00     0.00   0.00    0.00     0.00    0.00    0.00    2.64   99.80

Vous verrez trois blocs semblables, et le nom de votre disque (souvent sda ou nvme0n1) ; nous n'en montrons qu'un. Sur la vingtaine de colonnes, six suffisent :

  • r/s et w/s : lectures et écritures demandées par seconde.
  • r_await et w_await : le temps moyen, en millisecondes, entre la demande et sa réponse, attente dans la file comprise.
  • aqu-sz : le nombre moyen de demandes en attente, la longueur de la file.
  • %util : la part du temps où le disque a eu du travail.

Lisez await en premier, en le comparant à l'état calme : c'est lui que ressent le programme qui attend. Le tableau met côte à côte un disque calme et le nôtre. Les valeurs du disque calme sont un exemple : aucune commande de cet article ne les produit.

ColonneDisque calmeDisque saturé
r/s422,5
w/s374
r_await1,3 ms78,4 ms
w_await2,0 ms11,9 ms
aqu-sz0,012,64
%util1,2 %99,8 %

iostat raconte le point de vue du disque. Il manque le point de vue des programmes : combien de temps perdent-ils vraiment à attendre ? Le noyau a un second compteur pour cela.

4PSI : ce que subissent les programmes

PSI (Pressure Stall Information) est un compteur du noyau, le cœur de Linux. Il dit quelle part du temps vos programmes passent bloqués à attendre le disque. Il se lit dans un simple fichier, sans rien installer.

Sur le serveur
cat /proc/pressure/io
Résultat attendu
some avg10=61.20 avg60=48.35 avg300=22.10 total=1834567890
full avg10=55.80 avg60=43.02 avg300=19.77 total=1650234567

Le fichier a deux lignes et quatre nombres par ligne :

  • some : la part du temps où au moins un programme attendait le disque.
  • full : la part du temps où tous les programmes actifs attendaient en même temps. Le processeur ne produit alors plus rien d'utile.
  • avg10, avg60, avg300 : cette part en pourcentage, sur les 10, 60 et 300 dernières secondes.
  • total : le temps d'attente cumulé depuis le démarrage, en microsecondes.

Ici, some avg10=61.20 veut dire que pendant 61 % des 10 dernières secondes, au moins un programme attendait. Un disque au repos affiche des valeurs proches de 0. Comparez avg10 à avg300 : s'il est bien plus haut, la pression vient de monter.

iostat ou PSI : lequel regarder

Les deux compteurs se complètent. Le tableau les compare.

CritèreiostatPSI
VueLe disqueLes programmes
Dit sile disque débordeles programmes attendent
DétailPar disqueTotal
PaquetsysstatAucune

Nous savons que le disque est débordé et que les programmes le sentent. Reste la question utile : qui lui fait faire tout ce travail ?

5Trouver le coupable

La commande pidstat -d liste ce que chaque programme lit et écrit sur le disque. Elle est dans le même paquet que iostat, et sudo lui permet de voir les programmes de tous les utilisateurs. Ici, 2 1 veut dire un relevé de 2 secondes.

Sur le serveur
sudo pidstat -d 2 1
Résultat attendu
14:03:20      UID       PID   kB_rd/s   kB_wr/s kB_ccwr/s iodelay  Command
14:03:22        0      4242      0.00  75776.00      0.00       0  dd

Le PID est le numéro qui identifie un programme en cours. La colonne kB_wr/s donne les kilo-octets écrits par seconde : le coupable est la ligne la plus haute, ici dd avec 75 776 ko/s. Les autres colonnes peuvent attendre.

Le coupable est connu : dd. Le tuer n'est pas toujours une bonne idée : ce programme est peut-être votre sauvegarde. Mieux vaut le calmer. Le repli ci-dessous, à ouvrir en cliquant sur son titre, montre comment voir le fichier visé.

Voir en direct avec iotop, et trouver le fichier avec lsof

L'outil iotop fait la même chose que pidstat en direct, à la manière de top, mais il demande les droits d'administrateur. Quatre options le rendent lisible d'un coup d'œil :

  • -b : sortie simple.
  • -o : programmes actifs seulement.
  • -P : un programme par ligne.
  • -n 2 : deux relevés, le premier est à zéro.
Sur le serveur
sudo apt install iotop
sudo iotop -boPn 2

Vous retrouvez dd en tête, avec sa ligne de commande complète dans la dernière colonne. Savoir qui écrit ne dit pas encore quoi : lsof (« list open files », la liste des fichiers ouverts) répond. Avec -p et le PID, il liste les fichiers ouverts par ce programme. pgrep -nx dd retrouve le PID du dd le plus récent ; les $( ) remplacent le texte par le résultat de la commande qu'ils contiennent. Si pgrep répond 4242, la commande devient sudo lsof -p 4242. grep charge ne garde que les lignes qui parlent de notre fichier.

Sur le serveur
sudo lsof -p "$(pgrep -nx dd)" | grep charge
Résultat attendu
dd      4242 root    1w      REG               0,45 134217728   262151 /var/tmp/charge.bin

Le 1w désigne la sortie du programme, ouverte en écriture, et la dernière colonne donne le fichier : /var/tmp/charge.bin. Les numéros seront les vôtres.

6Calmer le coupable avec ionice

La commande ionice donne à un programme une priorité d'E/S basse, pour qu'il laisse passer les autres devant la caisse. Une classe est un niveau de politesse. La classe idle (-c 3, « au repos ») est la plus polie : le programme n'a le disque que si personne d'autre n'en veut.

Il faut d'abord arrêter la charge en cours, puis la relancer avec ionice. pkill arrête les programmes par leur nom, et -f le cherche dans le texte entier de la commande : celle de notre boucle contient charge.bin. Sans cet arrêt, deux charges tourneraient en même temps.

Sur le serveur
pkill -f charge.bin
ionice -c 3 timeout 600 sh -c 'while true; do dd if=/dev/zero of=/var/tmp/charge.bin bs=1M count=256 oflag=direct status=none; done' &

Relisez ensuite la sonde avec la commande de l'étape 2 : dd if=/var/tmp/sonde.bin of=/dev/null bs=4k count=1 iflag=direct. Sa durée devrait baisser, car la charge laisse la place aux autres. Si elle ne baisse pas, la cause probable est l'ordonnanceur du disque, vu juste après.

Les autres classes, nice, et un programme déjà lancé

Ouvrez ce repli pour changer la priorité d'un programme déjà lancé. Deux autres classes existent :

  • Best-effort (-c 2) : la classe par défaut, avec un niveau de 0 (le plus prioritaire) à 7 (le moins).
  • Realtime (-c 1) : passe toujours en premier. Évitez-la : un seul programme ainsi réglé peut priver toute la machine de disque.

La commande nice règle, elle, la priorité d'accès au processeur, de -20 (prioritaire) à 19 (le plus poli). Selon la documentation, elle décale aussi la priorité d'E/S : nice -n 19 donne le niveau 7, le plus bas du best-effort. Pour un programme déjà en marche, inutile de le relancer : sudo ionice -c 3 -p 4242 change sa priorité en place, -p étant suivi de son PID (ici 4242).

7Quand ionice ne change rien : l'ordonnanceur

L'ordonnanceur d'E/S est le logiciel du noyau qui décide dans quel ordre les demandes de la file passent au disque. C'est lui qui décide si ionice est écouté : certains ordonnanceurs l'ignorent, d'autres le respectent. D'après la documentation du noyau, bfq et mq-deadline respectent ionice, et none l'ignore. Nous n'avons pas mesuré cet effet sur votre machine : vérifiez-le avec la sonde. Ouvrez le repli ci-dessous, en cliquant sur son titre, pour lire et changer votre ordonnanceur.

Lire et changer l'ordonnanceur

Trouvons d'abord le nom de votre disque et son type avec lsblk (liste des disques), puis lisons son réglage.

Sur le serveur
lsblk -d -o NAME,ROTA
cat /sys/block/sda/queue/scheduler
Résultat attendu
NAME ROTA
sda     1
[mq-deadline] none bfq

La colonne ROTA vaut 1 pour un disque dur à plateaux, 0 pour un SSD. Remplacez sda par le nom de votre disque. Le nom entre crochets est l'ordonnanceur actif. Les trois noms courants :

  • none : aucun tri, les demandes passent dans l'ordre d'arrivée. Il ignore ionice ; c'est le choix courant des SSD rapides.
  • mq-deadline : donne à chaque demande une date limite et sert plutôt les lectures avant les écritures. Il respecte ionice.
  • bfq : partage le disque équitablement entre les programmes, pour que la machine reste réactive. Il respecte aussi ionice.

Pour changer de réglage, on écrit le nom dans le même fichier. Une redirection est le signe >, qui envoie un texte dans un fichier. Elle est exécutée par votre terminal, avec vos droits, et non par sudo. Voilà pourquoi sudo echo bfq > fichier est refusé. La commande tee règle le problème : elle écrit elle-même dans le fichier ce que le tube lui passe, et sudo s'applique à elle.

Sur le serveur
echo bfq | sudo tee /sys/block/sda/queue/scheduler

Relisez le fichier avec la commande cat ci-dessus : bfq doit être entre crochets. Le changement s'applique tout de suite et disparaît au redémarrage. Pour revenir en arrière avant, répétez la commande tee avec l'ancien nom, ici mq-deadline.

Le diagnostic est fait : disque saturé, coupable trouvé, priorité baissée. Il reste à ranger l'essai.

8Ranger l'essai

Arrêtons la charge, puis effaçons ses deux fichiers de test avec rm (supprimer), dont l'option -f évite tout message si un fichier manque.

Sur le serveur
pkill -f charge.bin
rm -f /var/tmp/charge.bin /var/tmp/sonde.bin

Vérifions que plus rien n'écrit. La première commande cherche un dd encore actif, la seconde liste les fichiers de test restants.

Sur le serveur
pgrep -x dd || echo "plus de dd"
ls /var/tmp/*.bin 2>/dev/null || echo "plus de fichier de test"
Résultat attendu
plus de dd
plus de fichier de test

Si vous avez changé l'ordonnanceur à l'étape 7, remettez l'ancien nom avec tee, sinon il reste jusqu'au redémarrage. Les paquets installés restent aussi, mais rien ne tourne en tâche de fond : ni service, ni tâche planifiée.

Si ça échoue

  • iostat: command not found (ou pidstat) : le paquet sysstat manque. Installez-le comme à l'étape 3 (sudo apt install sysstat).
  • dd: failed to open '/dev/shm/charge.bin': Invalid argument : le dossier /dev/shm est en mémoire vive, et l'option direct n'y fonctionne pas. Écrivez sur le vrai disque, comme avec /var/tmp.
  • Netlink error: Operation not permitted (1) : iotop a été lancé sans droits d'administrateur (Netlink est le canal par lequel il interroge le noyau). Ajoutez sudo devant.
  • La sonde reste rapide : la charge s'est arrêtée après 10 minutes, ou votre disque est très rapide. Relancez la commande timeout 600 de l'étape 1.
  • Pas de fichier /proc/pressure/io : votre noyau n'a pas PSI. iostat et pidstat suffisent alors pour le diagnostic.

Pour aller plus loin

Simuler un site qui lit au hasard

Un site web lit rarement un gros fichier d'un trait : il pioche de petits morceaux un peu partout. L'outil fio imite cela pendant 15 secondes, avec 16 lectures de 4 Ko en parallèle, sur un fichier de 256 Mo. Ses options se lisent par groupes :

  • --name, --filename, --size : le nom du test, le fichier utilisé et sa taille.
  • --rw=randread, --bs=4k : des lectures au hasard (« random read »), par blocs de 4 Ko.
  • --direct=1 : sans passer par le cache, comme direct pour dd.
  • --runtime=15, --time_based : durée de 15 secondes, quoi qu'il arrive.
  • --iodepth=16, --ioengine=libaio : 16 demandes en même temps, avec la méthode libaio de Linux.
Sur le serveur
sudo apt install fio
fio --name=aleatoire --filename=/var/tmp/fio.bin --size=256M --rw=randread --bs=4k --direct=1 --runtime=15 --time_based --iodepth=16 --ioengine=libaio
rm /var/tmp/fio.bin

Ouvrez une seconde fenêtre de terminal pendant ce temps et lancez-y iostat -dxzy 2 3. Vous verrez r/s monter, avec des lectures beaucoup plus petites que celles de dd.

La pression sur le processeur et la mémoire

PSI ne s'arrête pas au disque. Les fichiers /proc/pressure/cpu et /proc/pressure/memory ont le même format : ils disent si les programmes attendent un cœur de processeur ou de la mémoire. La documentation du noyau explique aussi comment recevoir un signal quand la pression dépasse un seuil que vous fixez.

La suite

Vous savez maintenant reconnaître un disque saturé, trouver qui le sature et le calmer à la main. Cette main reste pourtant le maillon faible : un service qui redémarre repart sans vos réglages. L'article suivant, Durcir un service avec systemd, montre comment fixer les règles d'un service dans son propre fichier, une fois pour toutes.