Linux avancé : processus et ressources

Prérequis : les bases de la rubrique Linux (terminal, fichiers, droits, paquets, services). Cette rubrique approfondit les commandes de base (Ubuntu Server : commandes utiles) pour comprendre ce que fait une machine Linux et diagnostiquer ses problèmes. Elle vise Ubuntu 24.04 et 26.04 ; les exemples utilisent des noms génériques.

Anatomie d’un processus

Un processus est un programme en cours d’exécution : identifiant (PID), parent (PPID), utilisateur, état, mémoire, fichiers ouverts, variables d’environnement. Tout processus descend de systemd (PID 1).

ps -eo pid,ppid,user,stat,%cpu,%mem,etime,cmd --sort=-%mem | head -15
ps -ef --forest                           # arborescence
pstree -ap                                # arbre avec arguments
pgrep -a nginx                            # PID par nom

États (colonne `STAT`)

Lettre	État	Signification
`R`	Running	Exécution ou prêt à s’exécuter
`S`	Sleeping	Attend un événement (état normal)
`D`	Disk sleep	Attente non interruptible d’une entrée-sortie (disque, réseau monté)
`T`	Stopped	Suspendu (`SIGSTOP`, `Ctrl+Z`)
`Z`	Zombie	Terminé, mais son parent n’a pas lu son code de sortie

Un zombie ne consomme rien (hors une entrée de table) : il disparaît quand le parent le « récolte » ou meurt ; inutile (et impossible) de le tuer, agir sur le parent.
Des processus en D durablement signalent un problème d’entrée-sortie (disque lent ou défaillant, montage réseau bloqué) : voir Disques et systèmes de fichiers.

Signaux

kill -l                                   # liste des signaux
kill 1234                                 # SIGTERM (15) : demande d'arrêt propre
kill -HUP 1234                            # SIGHUP (1) : recharger la configuration (selon le programme)
kill -KILL 1234                           # SIGKILL (9) : arrêt immédiat, non interceptable
kill -STOP 1234; kill -CONT 1234          # suspendre, reprendre
pkill -f "node serveur.js"                # par motif de ligne de commande
killall -TERM nginx                       # par nom

Signal	Numéro	Usage
`SIGTERM`	15	Arrêt propre (à utiliser en premier)
`SIGINT`	2	Interruption (`Ctrl+C`)
`SIGHUP`	1	Rechargement, ou déconnexion du terminal
`SIGKILL`	9	Arrêt brutal : aucune chance de nettoyer (données non écrites perdues)
`SIGSTOP`/`SIGCONT`	19/18	Suspendre / reprendre
`SIGUSR1`/`SIGUSR2`	10/12	Définis par le programme

Ordre de bon sens : SIGTERM, attendre quelques secondes, puis SIGKILL en dernier recours. Un processus en état D ne réagit même pas à SIGKILL tant que l’entrée-sortie n’est pas terminée.

Priorités

nice -n 10 ./traitement-long.sh           # démarrer avec une priorité réduite (−20 haute à 19 basse)
renice -n 5 -p 1234                       # modifier un processus en cours
sudo renice -n -5 -p 1234                 # augmenter la priorité (réservé à root)
ionice -c2 -n7 ./sauvegarde.sh            # priorité d'entrée-sortie réduite (classe 2, niveau 7)
ionice -c3 ./sauvegarde.sh                # classe « idle » : seulement si le disque est libre
chrt -f 50 ./temps-reel                   # ordonnancement temps réel (à manier avec grande prudence)

nice et ionice pour les tâches de fond (sauvegardes, compilations) qui ne doivent pas gêner les services.

`/proc` : l’état du noyau en fichiers

cat /proc/1234/status                     # état, mémoire, UID, signaux
cat /proc/1234/limits                     # limites appliquées au processus
ls -l /proc/1234/fd | head                # descripteurs de fichiers ouverts
cat /proc/1234/cmdline | tr '\0' ' '      # ligne de commande
readlink /proc/1234/exe                   # exécutable
cat /proc/1234/environ | tr '\0' '\n'     # variables d'environnement (même utilisateur ou root)
cat /proc/meminfo | head
cat /proc/loadavg
cat /proc/cpuinfo | grep -m1 "model name"

/proc/<PID>/ est la source d’information de ps, top et lsof. Les fichiers /proc/pressure/{cpu,memory,io} (PSI) indiquent le temps perdu à attendre une ressource, un excellent indicateur de saturation :

cat /proc/pressure/memory
# some avg10=0.00 avg60=0.12 avg300=0.05 total=123456

`lsof`, `fuser`, `strace`

sudo lsof -i :3000                        # qui écoute ou utilise le port 3000
sudo lsof -p 1234                         # fichiers ouverts par un processus
sudo lsof +D /var/log                     # processus qui utilisent ce dossier
sudo lsof | grep "(deleted)"              # fichiers supprimés mais encore ouverts (espace non libéré)
sudo fuser -v /var/www                    # processus utilisant un chemin
sudo fuser -vn tcp 80

sudo strace -p 1234                       # appels système d'un processus en cours
sudo strace -f -e trace=openat,connect -p 1234
strace -c ./commande                      # statistiques des appels système
strace -f -o /tmp/trace.txt ./commande    # trace complète dans un fichier

Besoin	Outil
« Qui utilise ce port ? »	`ss -tlnp`, `lsof -i :PORT`
« Pourquoi le disque ne se libère pas après suppression ? »	`lsof \| grep deleted` : redémarrer le processus qui tient le fichier
« Que fait ce programme bloqué ? »	`strace -p PID` (attente sur un fichier, un réseau, un verrou)
« Quels fichiers ce programme lit-il ? »	`strace -e trace=openat`
« Quel fichier de configuration est lu ? »	`strace -e trace=openat ./commande 2>&1 \| grep conf`

strace ralentit fortement le programme observé : l’utiliser pour un diagnostic ponctuel, pas en production continue.

Mémoire

free -h

Colonne	Sens
`used`	Mémoire utilisée par les programmes
`buff/cache`	Cache disque : récupérable, ne pas s’en inquiéter
`available`	Mémoire réellement disponible pour de nouveaux programmes : le chiffre à regarder
`Swap`	Espace d’échange utilisé

ps -eo pid,user,%mem,rss,cmd --sort=-rss | head -10         # plus gros consommateurs (RSS en Ko)
sudo smem -tk 2>/dev/null | tail                             # (paquet smem) mémoire proportionnelle
vmstat 1 5                                                    # si, so : activité de swap
cat /proc/pressure/memory

Un système sans mémoire disponible commence à échanger (swap) puis, en dernier recours, le noyau tue un processus : l’OOM killer.

OOM killer

sudo journalctl -k | grep -i -E "out of memory|oom-kill|killed process"
sudo dmesg -T | grep -i oom
cat /proc/1234/oom_score                  # « note » de risque (plus élevée = tué en premier)
echo -500 | sudo tee /proc/1234/oom_score_adj    # protéger un processus (−1000 : jamais tué)

Pour un service systemd : OOMScoreAdjust=-500 dans l’unité (voir systemd : durcissement d’un service). Plutôt que de protéger un processus, limiter ceux qui consomment trop (cgroups) et dimensionner la machine.

Limites par processus : `ulimit`

ulimit -a                                 # limites de la session
ulimit -n                                 # nombre maximal de descripteurs de fichiers ouverts
ulimit -n 65536                           # relever pour la session (jusqu'à la limite « dure »)

Limites permanentes pour un utilisateur : /etc/security/limits.d/90-monapp.conf :

monapp  soft  nofile  65536
monapp  hard  nofile  65536

Pour un service systemd, les fichiers de limits.conf ne s’appliquent pas : utiliser LimitNOFILE=65536 dans l’unité (systemd : écrire un service). Un « Too many open files » en production vient presque toujours de cette limite (voir aussi cat /proc/<PID>/limits).

cgroups v2 : borner les ressources

Les cgroups regroupent des processus et limitent leur CPU, mémoire, entrées-sorties. Ubuntu 24.04 et 26.04 utilisent cgroups v2 (hiérarchie unique, gérée par systemd).

systemd-cgls                              # arbre des cgroups
systemd-cgtop                             # consommation par cgroup
systemctl status monapp                   # mentionne le cgroup du service
cat /sys/fs/cgroup/system.slice/monapp.service/memory.current

Borner un service existant

sudo systemctl set-property monapp.service MemoryMax=512M CPUQuota=50% TasksMax=200
sudo systemctl show monapp.service -p MemoryMax -p CPUQuota

Dans l’unité (permanent) :

[Service]
MemoryMax=512M
MemoryHigh=400M
CPUQuota=50%
IOWeight=100
TasksMax=200

Borner une commande ponctuelle

systemd-run --scope -p MemoryMax=500M -p CPUQuota=25% ./compilation.sh
systemd-run --user --scope -p MemoryMax=1G npm run build
systemd-run --unit=exportation --property=Nice=10 ./exportation.sh        # service transitoire

Propriété	Effet
`MemoryMax`	Plafond dur : au-delà, le processus est tué (OOM dans le cgroup)
`MemoryHigh`	Plafond mou : ralentit le cgroup avant d’atteindre le maximum
`CPUQuota`	Pourcentage d’un cœur (`200%` = deux cœurs)
`IOWeight`, `IOReadBandwidthMax`	Part ou plafond d’entrées-sorties
`TasksMax`	Nombre maximal de processus et de fils

Un service qui plante (OOM) dans son propre cgroup n’affecte plus le reste du système.

Dépannage

Symptôme	Piste
Charge (load average) élevée avec un processeur au repos	Processus en `D` : entrées-sorties (`iostat -xz 1`, voir Journaux et diagnostic de performance)
Espace disque non libéré après suppression d’un gros fichier	Fichier encore ouvert : `lsof \| grep deleted`, redémarrer le processus
`Too many open files`	`LimitNOFILE` du service, `/proc/<PID>/limits`
Processus tué sans message	OOM killer : `journalctl -k \| grep -i oom`
`kill` sans effet	Processus en `D`, ou `SIGTERM` ignoré : `SIGKILL` (en dernier recours)
Zombies qui s’accumulent	Le parent ne récolte pas ses fils : le corriger ou le redémarrer
Machine qui « ramolli »	`cat /proc/pressure/*`, `vmstat 1`, swap actif
`Cannot allocate memory`	Mémoire ou `TasksMax`/`ulimit -u` atteints

Ubuntu 24.04 et 26.04 : différences à connaître

Les deux versions utilisent cgroups v2 et systemd (255 sur 24.04, 259 sur 26.04). Sur 26.04, /tmp est un système de fichiers en mémoire ; sudo est fourni par sudo-rs. Les commandes de cette page sont identiques.

Pour aller plus loin

Manuels : man proc, man 7 signal, man systemd.resource-control
Suite : Disques et systèmes de fichiers