Leçon 82 : kill et signaux — Contrôler les processus

Introduction

Sous Linux, les signaux sont le mécanisme fondamental de communication entre processus. Quand vous appuyez sur Ctrl+C pour arrêter un programme ou quand un processus se termine proprement à la réception d'une notification, ce sont des signaux qui agissent en coulisses.

La commande kill envoie un signal à un processus. Contrairement à ce que son nom suggère, kill ne sert pas uniquement à tuer un processus — il peut lui envoyer de nombreux types de signaux pour le redémarrer, le suspendre, ou lui demander de se reconfigurer.

Comprendre les signaux

Un signal est un message asynchrone envoyé à un processus. Chaque signal a un numéro et un nom. Les processus peuvent capturer (handler) la plupart des signaux pour réagir de manière personnalisée, sauf SIGKILL et SIGSTOP qui sont invariants.

Syntaxe de base

kill [OPTIONS] PID

kill envoie par défaut le signal SIGTERM (15) au processus identifié par son PID.

Les signaux les plus courants

Nom	Numéro	Description	Usage typique
`SIGTERM`	15	Demande d'arrêt élégante	Arrêt normal d'un processus
`SIGINT`	2	Interruption (comme Ctrl+C)	Interrompre un processus au premier plan
`SIGHUP`	1	Raccrochage (Hangup)	Demander à un daemon de relire sa config
`SIGKILL`	9	Kill forcé	Tuer un processus bloqué (dernier recours)
`SIGSTOP`	19	Stop (suspension)	Suspendre un processus (Ctrl+Z)
`SIGCONT`	18	Continue	Reprendre un processus suspendu
`SIGUSR1`	10	Signal utilisateur 1	Usage personnalisé par les applications
`SIGUSR2`	12	Signal utilisateur 2	Usage personnalisé par les applications
`SIGWINCH`	28	Fenêtre redimensionnée	Terminaux et émulateurs
`SIGPIPE`	13	Tube cassé	Quand on écrit dans un pipe fermé

Utilisation basique

Arrêter un processus (SIGTERM)

# Arrêter un processus par son PID
kill 1234

# C'est équivalent à :
kill -15 1234
kill -SIGTERM 1234

SIGTERM est le signal par défaut. Le processus reçoit l'ordre de s'arrêter et peut capturer ce signal pour effectuer un nettoyage (fermer des fichiers, vider des buffers, etc.).

Tuer forc\u00e9ment (SIGKILL)

# Tuer un processus qui ne répond plus
kill -9 1234

# Ou avec le nom du signal :
kill -SIGKILL 1234

Attention : SIGKILL ne peut pas être capturé ou ignoré. Le processus est immédiatement terminé sans possibilité de nettoyage. Utilisez-le uniquement en dernier recours.

Interrompre un processus (SIGINT)

# Équivalent à Ctrl+C
kill -2 1234

# Ou :
kill -SIGINT 1234

Même effet que d'appuyer sur Ctrl+C dans le terminal.

Redémarrer avec SIGHUP

# Pour un daemon comme Apache ou Nginx :
kill -HUP 1234

# Nginx relit sa configuration
# Apache重新加载配置
# Les daemons utilisent souvent SIGHUP pour relire leur configuration

Trouver le bon PID

Avec ps

# Trouver le PID d'un processus par son nom
ps aux | grep nginx

# Lister les processus nommés chrome
ps aux | grep -i chrome

Avec pgrep

# Trouver le PID directement par le nom
pgrep firefox
1712
2845

# Avec plus de détails :
pgrep -l firefox
1712 firefox
2845 firefox

Avec pkill

# Tuer tous les processus firefox
pkill firefox

# Arrêter élégamment tous les processus nginx
pkill -TERM nginx

pkill fonctionne comme kill mais accepte un nom de processus au lieu d'un PID.

Avec killall

# Tuer tous les processus d'un même programme
killall firefox

# Tuer par nom de commande :
killall -9 chrome

Suspendre et reprendre

Suspendre (SIGSTOP)

# Suspendre le processus au premier plan
kill -19 $$

# C'est l'équivalent de Ctrl+Z dans le shell
# Le processus est stoppé et mis en arrière-plan

Reprendre (SIGCONT)

# Reprendre un processus suspendu
kill -18 1234

# Si le processus était au premier plan, il y revient
fg

Envoyer des signaux à plusieurs processus

# Tuer tous les processus d'un utilisateur
pkill -u username

# Tuer tous les processus d'un groupe
pkill -G groupname

# Tuer tous les processus enfants d'un parent
pkill -P 1234

Gérer les jobs en arrière-plan

# Lister les jobs en arrière-plan
jobs
[1]  Running    sleep 1000 &
[2]+ Running    python script.py &

# Arrêter le job 1
kill %1

# Suspendre le job au premier plan
Ctrl+Z

# Reprendre en arrière-plan
bg %2

Le %1, %2 notation réfère aux jobs du shell actuel.

Signaux et scripts bash

Capturer un signal

#!/bin/bash
# Script qui capture SIGTERM pour un arrêt propre

cleanup() {
    echo "Arrêt en cours... nettoyage."
    rm -f /tmp/mon_script.lock
    exit 0
}

# Capturer SIGTERM et SIGINT
trap cleanup SIGTERM SIGINT

echo "Script en cours... (PID: $$)"
echo "Appuyez Ctrl+C ou envoyez kill $$ pour arrêter."

while true; do
    sleep 1
done

Quand le script reçoit SIGTERM, il appelle cleanup() avant de se terminer.

Ignorer un signal

#!/bin/bash
# Ignorer SIGINT (Ctrl+C) pendant une opération critique

trap '' SIGINT

echo "Phase critique en cours..."
sleep 60
echo "Phase terminée."

Pendant le sleep de 60 secondes, Ctrl+C n'aura aucun effet sur ce script.

Demander confirmation avant d'arrêter

#!/bin/bash
trap 'echo "Arrêt refusé. Utilisez kill -9 $$."' SIGTERM

while true; do
    sleep 1
done

Signaux standards (POSIX)

Signal	Action par défaut	Description
`SIGABRT`	Terminer + core dump	Arrêt abortif (appel système abort())
`SIGALRM`	Terminer	Alarme timer (alarm())
`SIGFPE`	Terminer + core dump	Erreur mathématique (division par 0)
`SIGILL`	Terminer + core dump	Instruction illégale
`SIGSEGV`	Terminer + core dump	Erreur de segmentation (accès mémoire invalide)
`SIGBUS`	Terminer + core dump	Erreur bus (accès mémoire aligné)
`SIGTRAP`	Terminer	Trap matériel
`SIGURG`	Ignorer	Données urgentes sur socket
`SIGVTALRM`	Terminer	Alarme virtuelle
`SIGPROF`	Terminer	Profilage timer
`SIGSYS`	Terminer + core dump	Mauvais argument système
`SIGSTKFLT`	Terminer	Erreur stack FPU
`SIGIO`	Terminer	EA IO asynchrone
`SIGPWR`	Terminer	Changement de courant
`SIGSYS`	Terminer	Mauvais appel système
`SIGSTKFLT`	Terminer	Stack fault sur coprocesseur

La commande kill en détails

Options utiles

Option	Description
`-l`	Lister tous les signaux disponibles
`-L`	Lister les signaux (sans numéros)
`-s SIGNAL`	Spécifier le signal par son nom
`-n NUM`	Spécifier le signal par son numéro
`--signal=SIGNAL`	Forme longue de l'option

Lister les signaux

$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN   35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGSYS     64) SIGRTMAX

# Trouver le numéro d'un signal
$ kill -l SIGTERM
15

# Trouver le nom d'un signal
$ kill -l 9
KILL

Exemples pratiques

Arrêter un processus qui ne répond plus

# 1. Essayer d'abord avec SIGTERM (arrêt élégant)
kill 1234

# 2. Attendre quelques secondes

# 3. Si ça ne marche pas, essayer SIGINT
kill -2 1234

# 4. En dernier recours, SIGKILL
kill -9 1234

Redémarrer un service

# Relire la configuration d Nginx
nginx_pid=$(pgrep nginx)
kill -HUP $nginx_pid

# Ou avec systemctl (plus propre)
systemctl reload nginx

Recharger un script sans le redémarrer

#!/bin/bash
# Script avec rechargement à chaud

reload() {
    echo "Rechargement de la configuration..."
    source /etc/mon_script.conf
}

trap reload SIGHUP

while true; do
    sleep 10
done

# Pour recharger :
# kill -HUP $(pgrep -f mon_script)

Debug avec les signaux

# Demander à un processus de dumps ses statistiques
kill -USR1 1234

# Certains services (comme Apache) créent un core dump
# quand ils reçoivent SIGUSR1

Signaux et processus zombie

Un processus zombie est un processus terminé dont l'entrée dans la table des processus n'a pas encore été nettoyée par le parent. Vous ne pouvez pas tuer un zombie avec kill -9 — il est déjà mort. La solution est de tuer le processus parent ou d'attendre que le parent récupère le statut du fils.

# Trouver les zombies
ps aux | grep -Z

# Tuer le parent du zombie
kill -9 [PID_PARENT]

Ordre de priorité des signaux

D'abord SIGTERM — laissez une chance au processus de s'arrêter proprement
Ensuite SIGINT — interruption normale
En dernier SIGKILL — seulement si les autres ne fonctionnent pas

Pourquoi ? SIGKILL ne permet pas au processus de nettoyer ses ressources (fermer des fichiers, vider des buffers, supprimer des fichiers temporaires). Un arrêt sale peut laisser deslocks ou des fichiers corrompus.

Récapitulatif

Commande	Usage
`kill PID`	Envoyer SIGTERM à un processus
`kill -9 PID`	Tuer forc\u00e9ment un processus
`kill -HUP PID`	Redémarrer / relire la config
`kill -STOP PID`	Suspendre un processus
`kill -CONT PID`	Reprendre un processus suspendu
`pkill nom`	Envoyer un signal par nom
`killall nom`	Envoyer un signal à tous les processus d'un nom
`kill -l`	Lister les signaux

Exercices pratiques

Lancez sleep 1000 & en arrière-plan, trouvez son PID, puis arrêtez-le avec kill.
Utilisez pkill pour envoyer SIGTERM à tous les processus sleep.
Créez un script qui capture SIGINT et affiche un message avant de se terminer.
Suspendez un processus avec kill -STOP et reprenez-le avec kill -CONT.
Envoyez SIGHUP à un processus ssh-agent pour voir comment il réagit.

Corrections

sleep 1000 & puis pgrep sleep et kill [PID]
pkill sleep (envoie SIGTERM par défaut)
Script avec trap 'echo "Interruption"; exit 1' SIGINT
kill -STOP $(pgrep sleep) puis kill -CONT $(pgrep sleep)
ssh-agent & puis kill -HUP $(pgrep ssh-agent) — ssh-agent ne supporte généralement pas SIGHUP