Debian 13 : tutoriel / Diagnostiquer le manque d’espace, les inodes épuisés et les fichiers supprimés ouverts
Lorsque vous ne pouvez pas écrire de fichiers sur Debian 13, vous devez d'abord vérifier séparément la capacité des blocs et les inodes du chemin en question. Si l’espace utilisé ne diminue pas et que l’espace libre n’augmente pas après la suppression de fichiers, vérifiez s'il y a des fichiers supprimés encore ouverts, et si c'est un problème de /tmp, vérifiez la limite du tmpfs, qui est séparée du disque racine. Dans ce tutoriel, nous comparons trois causes dans un petit espace de pratique dédié sans supprimer de fichiers des services en exploitation.
Commencez par le chemin qui a échoué
Un inode est un objet dans le système de fichiers qui gère des informations telles que le type de fichier, les permissions, la propriété et l'emplacement des données. Même les fichiers vides utilisent des inodes, donc vous pourriez ne pas pouvoir créer de nouveaux fichiers même s'il y a beaucoup d'espace au niveau des octets. Inversement, quelques gros fichiers peuvent épuiser les blocs.
Adaptez les chemins des commandes suivantes à l’emplacement où l’écriture a réellement échoué. Il est important de ne pas juger /var/tmp et /tmp ensemble comme un problème du disque root.
findmnt --target /var/tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
df -hT /var/tmp
df -i /var/tmp
sudo du -x -h --max-depth=1 /var | sort -h
findmnt montre le point de montage réel contenant le chemin, et df montre l'espace de ce système de fichiers. df -i vérifie la disponibilité des inodes. du fait la somme des fichiers liés sous l'arborescence de répertoires accessible, et -x empêche de traverser d'autres systèmes de fichiers. Si des erreurs de permission surviennent, le total est incomplet. Ne masquez pas les erreurs pour présenter ensuite ce total incomplet comme une mesure exacte. Exécuter du sur un grand arbre prend du temps et effectue des opérations d'entrée/sortie, donc réduisez la portée au chemin problématique.
| Résultats de l'observation | Causes à vérifier en premier | Détermination de l'action |
|---|---|---|
| Presque plus d'espace de blocs disponible, mais des inodes restent | Fichiers volumineux, journaux, augmentation des données réelles | Vérifiez le service propriétaire et la politique de conservation, et prévoyez de déplacer les données, organiser la rotation des journaux ou étendre le stockage. |
| Des blocs restent, mais pas d'inodes | Un très grand nombre de petits fichiers, augmentation du cache ou de la file d'attente | Identifiez le répertoire problématique et la cause de création, puis utilisez la fonction de nettoyage de l'application. |
| df montre une utilisation élevée, mais le total de du est faible | Fichiers ouverts supprimés, fichiers cachés par des montages, différences de permissions ou de portée d'agrégation | Comparez avec le même système de fichiers et les mêmes permissions, puis examinez le processus et la structure de montage. |
| / a de l'espace disponible, mais l'écriture dans /tmp échoue | Taille et limites d'inodes d'un tmpfs séparé ou état de la mémoire | Vérifiez df et les options de montage de /tmp ainsi que free. |
Les messages Permission denied (permission refusée), Read-only file system (système de fichiers en lecture seule) et Disk quota exceeded (quota dépassé) désignent des causes différentes du manque d’espace. Même s'il y a de l'espace disponible, l'échec peut se produire en raison de la propriété, des listes de contrôle d’accès (ACL, Access Control Lists), des montages en lecture seule ou des quotas. En raison de l'espace réservé et des métadonnées dans ext4, df et la taille du contenu du fichier n'ont pas besoin de correspondre exactement. Les seules différences d'espace ne déterminent pas la corruption.
Comparer l'épuisement des blocs et des inodes sur un tmpfs de 4 MiB
Le laboratoire utilise Python 3, e2fsprogs (mkfs.ext4 et e2fsck), util-linux (mount, findmnt et losetup), et les outils GNU standards pour les fichiers. Vérifiez d'abord command -v python3 mkfs.ext4 e2fsck mount findmnt losetup truncate df du. Si quelque chose manque, examinez les changements du paquet avant d'installer le paquet Debian nécessaire. Exécutez la configuration dans une session Bash dédiée : un échec inattendu sous set -euo pipefail peut terminer ce shell. Reconnectez-vous si nécessaire, inspectez le montage et les fichiers du laboratoire, puis utilisez le nettoyage ciblé plutôt que de recréer les ressources par-dessus.
Une VM de pratique Debian 13 séparée, un utilisateur régulier pouvant utiliser sudo, et Python 3 sont requis. L'exemple ci-dessous crée un tmpfs dédié pouvant atteindre 4 MiB et 32 inodes sans remplir /tmp. tmpfs utilise la mémoire virtuelle et, si le swap est activé, certaines pages peuvent aller dans le swap. Il ne faut pas supposer qu'il est stocké uniquement dans la RAM physique, et le contenu est perdu lors du démontage.
Le bloc suivant doit être exécuté dans le même terminal Bash. Si le chemin existe déjà, arrêtez-vous pour examiner son usage et son contenu ; ne le supprimez pas pour contourner cette vérification. Dans cette VM, l'UID et le GID de l'utilisateur régulier étaient tous deux 1000, mais les commandes utilisent les valeurs du compte actuel.
set -euo pipefail
tm=/mnt/lf-space24-tmpfs
if test -e "$tm"; then
echo "Path already exists: $tm" >&2
exit 1
fi
sudo mkdir "$tm"
sudo mount -t tmpfs -o "size=4M,nr_inodes=32,uid=$(id -u),gid=$(id -g),mode=0700,nosuid,nodev" tmpfs "$tm"
findmnt --mountpoint "$tm"
Après avoir vérifié que le résultat du montage est tmpfs et que la taille correspond à 4 MiB, exécutez l'exemple complet suivant en tant qu'utilisateur régulier. Les tentatives d'écriture sont limitées à un maximum de 8 MiB, et le nombre de fichiers vides est limité à un maximum de 40. Seule l'erreur ENOSPC (No space left on device, plus d’espace disponible sur le périphérique) prévue est gérée, et les autres erreurs arrêteront le processus.
python3 - <<'PY'
import errno, pathlib, subprocess
p=pathlib.Path('/mnt/lf-space24-tmpfs')
try:
with (p/'fill.bin').open('xb') as f:
for i in range(8):
f.write(b'x' * 1048576)
f.flush()
except OSError as e:
if e.errno != errno.ENOSPC: raise
print('BLOCK_LIMIT_ENOSPC', flush=True)
else:
raise RuntimeError('Expected bounded block exhaustion')
subprocess.run(['df','-hT',str(p)],check=True)
subprocess.run(['df','-i',str(p)],check=True)
(p/'fill.bin').unlink()
created=[]
try:
for i in range(40):
f=p/f'empty-{i}'
f.touch(exist_ok=False)
created.append(f)
except OSError as e:
if e.errno != errno.ENOSPC: raise
print('INODE_LIMIT_ENOSPC',len(created),flush=True)
else:
raise RuntimeError('Expected bounded inode exhaustion')
subprocess.run(['df','-hT',str(p)],check=True)
subprocess.run(['df','-i',str(p)],check=True)
for f in created: f.unlink()
PY
Dans l'environnement réel du noyau 6.12.107 et de Python 3.13.5, les résultats suivants, correspondant à deux ressources distinctes épuisées ont été obtenus. Les 32 inodes incluent le répertoire de niveau supérieur du montage, donc l'échec s'est produit après la création de 31 fichiers vides.
| Expérience | Utilisation des blocs | Utilisation des inodes |
|---|---|---|
| Écriture dans fill.bin | 4,0 MiB / 4,0 MiB, libre 0 | 2 / 32, libre 30 |
| Supprimez fill.bin, puis créez des fichiers vides | Utilisé 0, Libre 4,0 MiB | 32 / 32, Libre 0 |
Le fichier créé sera supprimé à la fin de l'exemple. S'il a été interrompu par une autre erreur en cours de processus, vérifiez d'abord le point de montage et les fichiers à l'intérieur. Ce tmpfs est uniquement pour des données de pratique jetables, donc vous pouvez le démonter avec la commande suivante en dehors du répertoire de travail. Si vous recevez une erreur disant qu'il est en cours d'utilisation, déplacez chaque répertoire courant des shells concernés en dehors de ce chemin et fermez tous les fichiers ouverts par les processus du laboratoire avant de réessayer.
cd "$HOME"
sudo umount /mnt/lf-space24-tmpfs
sudo rmdir /mnt/lf-space24-tmpfs
Observez l'espace occupé par un fichier supprimé mais ouvert
Supprimer un nom de fichier avec l'opération unlink et fermer un fichier ouvert sont des choses différentes. Même si le dernier nom dans un répertoire a disparu, si un processus l'a encore ouvert, l'espace du fichier peut être conservé. Si vous supprimez toujours les journaux avec rm, vous pourriez créer cette situation et perdre les noms que vous aviez l'intention d'examiner.
Ce qui suit est une pratique pour créer ext4 à l'intérieur d'un nouveau fichier régulier de 64 MiB. Cela n'initialise pas un périphérique disque réel. D'abord, vérifiez qu'il y a plus de 64 MiB d'espace libre sur le système de fichiers racine et un peu d'espace de travail supplémentaire. Si le même chemin existe déjà, arrêtez-vous et examinez son utilisation. Exécutez tout le bloc de préparation ci-dessous dans le même terminal Bash également.
set -euo pipefail
base=/var/lib/lf-space24
em=/mnt/lf-space24-ext4
df -hT /var/lib /mnt
for p in "$base" "$em"; do
if test -e "$p"; then
echo "Path already exists: $p" >&2
exit 1
fi
done
sudo install -d -m 700 "$base"
sudo mkdir "$em"
sudo truncate -s 64M "$base/space.img"
sudo mkfs.ext4 "$base/space.img"
sudo mount -o loop,nosuid,nodev "$base/space.img" "$em"
findmnt --mountpoint "$em"
sudo install -d -o "$(id -u)" -g "$(id -g)" "$em/work"
Les fichiers créés avec truncate sont initialement des fichiers clairsemés, donc la taille logique de 64 MiB n'est pas immédiatement allouée physiquement dans son intégralité. Les métadonnées du système de fichiers et les écritures ultérieures effectives utilisent l'espace réel. La cible de mkfs doit être le nouveau fichier space.img et ne doit pas être remplacée par un nom de disque comme /dev/sda.
Le dossier lost+found d'ext4 peut ne pas être lisible par les utilisateurs ordinaires, donc sans changer la propriété de manière imprudente, seul le répertoire de travail séparé est mesuré. Le code suivant ouvre et écrit un fichier de 8 MiB, supprime son nom, et compare avant et après la fermeture du fichier dans le même processus.
python3 - <<'PY'
import os,pathlib,subprocess
p=pathlib.Path('/mnt/lf-space24-ext4/work')
def used():
return int(subprocess.check_output(['df','--output=used','-B1',str(p)],text=True).splitlines()[1])
def show(label):
os.sync()
print(label,flush=True)
subprocess.run(['df','-B1',str(p)],check=True)
subprocess.run(['du','-B1','-s',str(p)],check=True)
baseline=used()
f=(p/'held.bin').open('xb')
for i in range(8): f.write(b'x'*1048576)
f.flush();os.fsync(f.fileno())
show('BEFORE_UNLINK');before=used()
(p/'held.bin').unlink()
print('OPEN_FD',os.readlink(f'/proc/self/fd/{f.fileno()}'),flush=True)
show('UNLINKED_OPEN');held=used()
f.close()
show('AFTER_CLOSE');released=used()
if not (before >= baseline+8388608 and held == before and released < held):
raise RuntimeError((baseline,before,held,released))
print('DELETED_OPEN_FILE_RELEASE_PASSED',baseline,before,held,released,flush=True)
PY
| Temps | df octets utilisés | du : octets du répertoire work |
|---|---|---|
| Après avoir écrit un fichier de 8 MiB | 8 436 736 | 8 389 632 |
| Nom supprimé, fichier encore ouvert | 8 436 736 | 1 024 |
| Après avoir fermé le fichier | 48 128 | 1 024 |
Les chiffres ci-dessus sont les mesures réelles de cette image d'exercice et peuvent varier en fonction des options et de la version de création du système de fichiers. Le résultat important est qu'après la suppression du nom, seul le du a diminué tandis que le df est resté le même, et qu'après fermeture, l'utilisation du df a également diminué. La sortie de /proc/self/fd montrait held.bin (deleted). os.sync ne synchronise que les écritures avant l'observation et ne ferme pas de force les fichiers ouverts.
Sur les serveurs de production, vérifiez la fonctionnalité de réouverture des journaux du processus qui a ouvert le fichier et du service. Si lsof est installé, vous pouvez examiner les fichiers ouverts avec un nombre de liens inférieur à 1 en utilisant sudo lsof +L1, mais dans les résultats, les périphériques, fichiers et processus doivent être croisés ensemble. Le redémarrage affecte les connexions et les opérations, donc examinez d'abord la méthode de rotation/réouverture des journaux prise en charge par le service. N'écrivez pas arbitrairement dans le descripteur de fichier /proc d’un autre processus ou ne terminez pas un processus directement.
Vérifiez l'image ext4 uniquement après avoir démonté
La pratique ci-dessus n'a pas causé de corruption du ext4. Il n'est pas nécessaire d'exécuter e2fsck simplement parce que l'espace est plein. Le manuel e2fsck de Debian met en garde contre son exécution sur un système de fichiers monté, et bien que certaines exécutions en lecture seule soient possibles, les résultats de la vérification ne sont pas valides tant que le système de fichiers est monté.
Dans cette pratique, nous vérifions qu'aucun processus ne garde de fichier ouvert dans work, nous libérons l'image, puis nous effectuons un contrôle en lecture seule avec -fn. -f force un contrôle complet et -n est le mode lecture seule qui refuse les modifications. La cible est un seul fichier image de pratique.
cd "$HOME"
sudo umount /mnt/lf-space24-ext4
sudo losetup -j /var/lib/lf-space24/space.img
sudo e2fsck -fn /var/lib/lf-space24/space.img
Le résultat de losetup -j doit être vide. Si des connexions restent, ne supprimez pas l'image et vérifiez quel montage ou processus l'utilise. Dans la pratique normale, la vérification étape par étape avec e2fsck se termine et sort avec le code 0. Si ce n'est pas 0, conservez la sortie et le code de sortie sans supprimer immédiatement le fichier. Vérifier le système de fichiers racine en exploitation est une tâche de récupération distincte qui nécessite de préparer une console, une sauvegarde ou un environnement de démarrage de secours et de revérifier l'UUID cible pendant que la racine est démontée.
Après que la vérification se termine normalement, seule l'image de pratique est supprimée. Les disques de données existants, le LVM des cours précédents et /etc/fstab ne sont pas modifiés.
sudo rm -- /var/lib/lf-space24/space.img
sudo rmdir /var/lib/lf-space24 /mnt/lf-space24-ext4
findmnt --target /tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
df -hT / /tmp /var/tmp
Vérifiez le stockage et la rétention des fichiers temporaires de Debian 13
Selon l'avis de changement de /tmp de Debian 13, le /tmp par défaut est tmpfs et la limite de taille par défaut est la moitié de la mémoire. Ce maximum ne correspond pas à une quantité de mémoire réservée dès le démarrage : l’utilisation dépend des fichiers réellement créés. Des paramètres /tmp séparés dans le fstab existant peuvent changer le résultat, donc vérifiez d'abord le montage réel.
findmnt --target /tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
findmnt --target /var/tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
systemctl cat tmp.mount
systemd-tmpfiles --cat-config | less
systemctl cat systemd-tmpfiles-clean.timer
systemctl list-timers systemd-tmpfiles-clean.timer --no-pager
free -h
Dans less, vous pouvez rechercher avec /tmp.conf et quitter avec q. Étant donné que cat-config montre plusieurs paramètres, vérifiez non seulement les valeurs par défaut dans /usr/lib/tmpfiles.d mais aussi toutes les entrées remplacées par des fichiers portant le même nom dans /etc/tmpfiles.d. N'exécutez pas systemd-tmpfiles --clean à des fins de vérification. Cette commande peut en fait effectuer des suppressions.
Sur la nouvelle VM d'installation pour ce cours, /tmp était un tmpfs avec un maximum d'environ 2 Gio, et /var/tmp était inclus dans l'ext4 racine. Les règles par défaut appliquées étaient /tmp 10 jours, /var/tmp 30 jours, et le minuteur de nettoyage était réglé pour 15 minutes après le démarrage et ensuite à intervalle d’un jour à partir de la précédente activation de la tâche de nettoyage. Il n'y a aucune garantie que les fichiers seront supprimés immédiatement juste parce que la date est atteinte ; les horodatages des fichiers, les règles d'exclusion et le moment d'exécution du minuteur entrent tous en jeu.
Guide sur les modifications du nettoyage des fichiers temporaires dans Debian explique également les différences entre les nouvelles installations et les mises à niveau. Sur les systèmes mis à niveau de Debian 12 vers Debian 13, /etc/tmpfiles.d/tmp.conf peut être créé pour maintenir le comportement de rétention précédent, donc vous ne devez pas supposer le même calendrier de suppression que pour une nouvelle installation. /var/tmp reste généralement après un redémarrage mais n'est pas un emplacement de stockage permanent.
Pour les fichiers temporaires petits et de courte durée, utilisez /tmp, et pour les travaux temporaires plus volumineux, choisissez un chemin séparé avec suffisamment d'espace. Après avoir vérifié que le service respecte le paramètre TMPDIR, modifiez-le en conséquence, et placez les données persistantes et les sauvegardes dans des chemins dédiés pour l'état/les sauvegardes. Selon les directives de systemd sur l'utilisation du répertoire temporaire, utilisez des méthodes de création sécurisées comme mktemp dans les répertoires temporaires partagés. Les limites de tmpfs et le comportement de swap peuvent être consultés dans la documentation du noyau Linux sur tmpfs, et la priorité des règles de nettoyage ainsi que la détermination du temps peuvent être trouvées dans la documentation Debian tmpfiles.d.




