Les processus sur Linux : comment ça marche

Linux comme tout système d’exploitation permet à un utilisateur d’exécuter des applications qui se lancent dans l’OS comme un processus.
Il existe aussi de nombreux processus systèmes.

Mais chaque OS, le fonctionnement interne des processus diffère de Windows ou MacOSX.

Dans cet article, je vous donne les bases du fonctionnement des processus sur Linux comme l’initialisation, les états.
Enfin comment gérer les processus sur Linux en utilisant certaines commandes.

Qu’est-ce qu’un processus

Un processus fait référence à un programme d’exécution.
Il se compose des instructions du programme, des données lues à partir de fichiers, d’autres programmes ou de saisie d’un utilisateur système.

Un utilisateur peut lancer autant de programme qu’il le souhaite (tant que les ressources systèmes le permettent).
Enfin il existe des processus systèmes, internes à l’OS nécessaires au fonctionnement générale de l’OS.

Enfin l’OS doit établir des règles de fonctionnement des processus notamment lorsque ce dernier se doit de réserver des ressources matériels.
Par exemple, allouer de la mémoire et interdire d’autres processus d’y lire les données, écrire sur le disque, envoyer des instructions aux processeurs.

Enfin le système d’exploitation permet à l’utilisation d’interagir avec le processus pour suspendre ou arrêter un processus.

Les types de processus sur Linux

Les processus interactifs et non interactifs

Sur Linux, on peut distinguer deux type de processus

• Processus de premier plan (également appelé processus interactifs) – ceux-ci sont initialisés et contrôlés via une session de terminal (TTY). En d’autres termes, ce sont les processus initialisé par un utilisateur connecté à un terminal
• Processus en fond (également appelé processus non interactifs / automatiques) – sont des processus non connectés à un terminal; Ils ne s’attendent pas à une entrée utilisateur. Il peut s’agit :
  • d’un processus exécuté par le noyau Linux
  • d’un daemon/services

La commande PS permet d’identifier ces processus :

• Les processus en fond :
  • liés au noyau Linux sont entre crochets (car PS ne peut identifier l’argument) et généralement exécuté avec root
  • ou dans le cas d’un daemon executé un binaire dans /sbin/ ou /usr/sbin et s’exécute en par root ou un utilisateur spécifique
  • Mais surtout dans les deux cas la colonne TTY indique ?

• Les Processus de premier plan :
  • s’exécute un utilisateur
  • comporte pts dans la colonne TTY

On peut lister les processus rattachés à un terminal utilisateur avec les options -ft et en spécifiant le numéro du TTY :

ps -ft pts/0
ps -ft pts/1

Les processus parents et enfants et leurs PID

Pour faciliter la gestion, un programme est identifié par son ID de processus (PID) ainsi que par les processus de processus parent (PPID), donc des processus peuvent en outre être classés dans:

• Processus des parents – Ce sont des processus qui créent d’autres processus pendant la période d’exécution
• Processus d’enfants – Ces processus sont créés par d’autres processus pendant la période d’exécution

De ce fait, il existe une arborescence des processus que l’on peut afficher avec la commande pstree.
On voit tout en haut que le premier processus est systemd.

Comment Linux identifient les processus ?

Le processus INIT

Au démarrage du système, init est le premier processus exécuté.
C’est le processus parent qui initialise les autres processus systèmes.
C’est le noyau Linux (kernel) qui exécute le processus init et donc ce dernier n’a pas de processus parent.

Le processus initial a toujours un identifiant de processus de 1. Il fonctionne comme un parent adoptif pour tous les processus orphelins.

Trouver le PID ou PPID d’un processus

La commande PS permet de lister les processus et affiche le PID et PPID.
On retrouve /sbin/init avec le PID 1.

Mais on peut aussi utiliser la commande pidof pour obtenir le PID d’un processus.
Mais aussi pgrep qui se base sur grep. Il retourne alors plusieurs ID car il existe plusieurs processus avec le mot systemd comme le confirme PS.
Enfin on notera que systemd est un processus enfant d’init, car on voit que le PPID est 1.

Exécuter un processus sur Linux

Dans un terminal, dès lors que vous lancez une commande, cela exécute le programme et son processus.
Il se passe la même chose lorsque vous cliquez sur un menu depuis l’environnement de bureau.

Par exemple pour lancer l’éditeur de texte vim depuis un terminal pour éditer le fichier /tmp/toto :

[email protected]:~$ vim /tmp/toto

Tant que la page de vim est ouvert, le processus est considéré comme étant en cours d’exécution avec son propre PID.

Exécuter un processus en fond

Pour démarrer un processus en fond, on utilise le caractère & :

[email protected]:~$ vim /tmp/toto&

Cela retourne [1] suivi du PID.

Vous pouvez également envoyer un processus à l’arrière-plan en le suspendant à l’aide de CTRL+Z, cela enverra le signal SIGSTOP au processus, ce qui empêche ainsi ses opérations; Il devient inactif.

On peut récupérer le programme avec la commande fg suivante ou via CTRL+G ce qui envoie le signal SIGCONT.

Les états des processus

Ainsi, la vie d’un processus est régit par des états qui diffèrent selon son activité ou si le système ou utilisateur tente de l’arrêter.

Un processus peut être suspendu, arrêté, reprendre, résilié et interrompu à l’aide de signaux. Les signaux sont discutés plus en détail plus loin dans ce chapitre.
Les signaux peuvent être utilisés par d’autres processus, par le noyau lui-même ou par des utilisateurs connectés au système.

On distingue quatre états :

• En cours d’exécution (Running) – Le processus est en cours d’exécution ou il est prêt à fonctionner (il attend d’être attribué à l’un des processeurs).
• En attente (Waitting) – Dans cet état, un processus attend qu’un événement se produise ou une ressource système. De plus, le noyau se différencie également entre deux types de processus d’attente (voir tableau plus bas);
  • Les processus d’attente interruptibles – peuvent être interrompus par des signaux et des processus d’attente
  • ininterruptibles – attendent directement dans des conditions matérielles et ne peuvent être interrompus par aucun événement / signal.
• Arrêté (Stopped) – dans cet état, un processus a été arrêté, généralement en recevant un signal. Par exemple, un processus qui est débogué.
• Zombie – Ici, un processus est mort, il a été arrêté, mais il a toujours une entrée dans la table de processus.

En réalité, c’est un peu complexe car les états peuvent avoir des sous-états identifiés par des drapeaux (flags).
Cela est utile à connaître si vous êtes développeur ou administrez un serveur pour résoudre des problèmes tels qu’un load average élevé.

NOM	DRAPEAU	NOM D’ETAT ET DESCRIPTION DEFINIS PAR LE NOYAU
Running	R	TASK_RUNNING: Le processus est soit exécuté sur une CPU ou en attente de courir. Le processus peut exécuter des routines utilisateur ou des routines de noyau (appels système), ou être en file d’attente et prête lors de l’état exécutant (ou exécutable).
Sleeping	S	TASK_INTERRUPTE: Le processus attend une condition: une demande matérielle, un accès des ressources système ou un signal. Lorsqu’un événement ou un signal satisfait à la condition, le processus revient à courir.
Sleeping	D	TASK_UNINTERRUPTE: Ce processus dort également, mais contrairement à S State, ne répond pas aux signaux. Utilisé uniquement lorsque l’interruption de processus peut provoquer un état de périphérique imprévisible.
Sleeping	K	TASK_KILLABLE: identique à l’état D ininterruptible, mais modifié pour permettre une tâche en attente de répondre au signal qu’il doit être tué (sortie complètement). Les utilitaires affichent fréquemment des processus tués tels que l’état D.
Sleeping	I	TASK_REPORT_IDLE: Un sous-ensemble d’état D. Le noyau ne compte pas ces processus lors du calcul de la moyenne de la charge. Utilisé pour les fils du noyau. Les drapeaux Task_uninterruptable et Task_NoLoad sont définis. Semblable à Task_Killable, également un sous-ensemble d’état D. Il accepte des signaux fatals.
Stopped	T	TASK_STOPPED: Le processus a été arrêté (suspendu), généralement en étant signalé par un utilisateur ou un autre processus. Le processus peut être poursuivi (repris) par un autre signal pour revenir à la course à pied.
Stopped	T	TASK_TRACED: Un processus en cours de débogage est également temporairement arrêté et partage le même drapeau de l’état T.
Zombie	Z	EXIT_ZOMBIE: Un processus enfant signale son parent à sa sortie. Toutes les ressources sauf pour l’identité de processus (PID) sont libérées.
Zombie	X	EXIT_DEAD: Lorsque le parent nettoie (récolte) la structure de processus d’enfant restante, le processus est maintenant libéré complètement. Cet état ne sera jamais observé dans les services publics de la liste de processus.

Afficher les états d’un processus

Les commandes TOP ou PS sont capable d’afficher ces états.
Sur Top, c’est dans la colonne S :

Pour PS, c’est dans la colonne STAT en utilisant la commande de cette manière :

[email protected]:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0 170668  7012 ?        Ss   Jul15   1:36 /sbin/init
root         2  0.0  0.0      0     0 ?        S    Jul15   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        I<   Jul15   0:00 [rcu_gp]
root         4  0.0  0.0      0     0 ?        I<   Jul15   0:00 [rcu_par_gp]
root         6  0.0  0.0      0     0 ?        I<   Jul15   0:00 [kworker/0:0H-kblockd]
root         8  0.0  0.0      0     0 ?        I<   Jul15   0:00 [mm_percpu_wq]
root         9  0.0  0.0      0     0 ?        S    Jul15   0:00 [ksoftirqd/0]
root        10  0.0  0.0      0     0 ?        I    Jul15   6:11 [rcu_sched]

Ce qui donne les commandes kill suivant, on voit bien que le processus passe de l’état S (Running) à T (STOP) pour revenir à S (Running) :

Envoyer un signal à un processus

Pour contrôler et interagir avec les processus, Linux permet de leur envoyer un signal.
C’est la commande Kill qui permet d’envoyer un signal à un processus.

Pour lister les signaux :

kill -L

Voici un tableau récapitulatif issu de Wikipedia :

ID	Nom	Description
1	SIGHUP	Rupture détectée sur le terminal contrôleur ou mort du processus parent
2	SIGINT	Interruption du clavier (Ctrl+C dans un terminal)
3	SIGQUIT	Arrêt du processus
4	SIGILL	Instruction illégale
6	SIGABRT	Arrêt anormal du processus
8	SIGFPE	Erreur sur un nombre flottant
9	SIGKILL	Tue immédiatement le processus
11	SIGSEGV	Erreur de segmentation
13	SIGPIPE	Erreur de tube (écriture dans un tube sans lecteur)
14	SIGALRM	Signal du timer définit par alarm(2)
15	SIGTERM	Termine le processus
16, 10, 30	SIGUSR1	Signaux utilisateurs, l’action est spécifique au processus
18, 20, 17	SIGCHLD	Processus enfant terminé ou stoppé
19, 18, 25	SIGSTOP	Interromps immédiatement le processus
20, 18, 24	SIGSTP	Interromps le processus (Ctrl+Z dans un terminal)
21, 26	SIGTTIN	Entrée de terminal pour un processus en arrière plan
22, 27	SIGTTOU	Sortie de terminal pour un processus en arrière plan
	SIGVTALRM	chronomètre virtuel (Virtual Timer) expiré
	SIGXCPU	Le processus a dépassé une certaine limite d’utilisation du processus définit par l’utilisateur. Le processus doit alors sauvegarder les données temporairement obtenues et quitter proprement avant une interception par le signal SIGKILL.
	SIGXFSZ	Le script a fait grossir un fichier au-delà d’une limite définie
	SIGWINCH	la taille du terminal contrôlant le processus a changé

Par exemple arrêter un processus en cours d’exécution, soit donc tuer un processus, on envoie le signal SIGTERM (donc 9) avec la commande kill de cette manière :

kill -s KILL <PID du processus>
kill -9 <PID du processus>

Pour envoyer le signal HUP pour relire un fichier de configuration modifié à uin processus, on peut encore utiliser la commande kill.
Ces utilisations sont équivalentes :

kill -s HUP 632
kill -s 1 632
kill -HUP 632
kill -1 632

Mais d’autres commandes utilisent aussi les signaux, notamment les commandes bg, fg, jobs qui manipulent les processus en arrière plan.
Elles s’appuient sur les signaux SIGSTOP, SIGSTP SIGCONT, SIGTTIN, SIGTTOU, …

Lister, arrêter des processus sur Linux

ps : lister les processus

PS est la commande standard pour lister les processus sur Linux.
La syntaxe la plus commune est :

ps -ef

Mais cette commande possède énormément d’options.
Vous trouverez beaucoup d’exemple d’utilisation dans le tutoriel suivant :

top : lister, tuer les processus

top est un gestionnaire de tâches qui affiche les processus en temps réel avec l’utilisation CPU et mémoire.
Dans l’en-tête, on trouve aussi des informations générales du système comme l’uptime, le load average.
L’utilisation globale de la mémoire et SWAP.

Pour comprendre l’utilisation de top, suivez ce tutoriel :

kill : arrêter un processus

Kill est une commande qui permet d’envoyer un signal à un processus.
Typiquement, on l’utilise pour arrêter un processus ou encore le relancer après une modification d’un fichier de configuration.

Pour arrêter un processus avec kill, suivez ce tutoriel :

renice : changer la priorité d’un processus

La commande renice modifie la priorité de planification d’un ou de plusieurs processus de fonctionnement.
Le premier argument est la valeur de priorité à utiliser. Plus celle-ci est basse et plus la priorité sera donnée au processus.
Les autres arguments sont interprétés comme ID de processus (par défaut), ID de groupe (option -g), ID utilisateur (option -u).

Par exemple pour modifier la priorité des processus avec l’ID 2867, 2103 :

renice +8 -p 2687
renice +8 -p 2103

Récapitulatif des commandes Linux pour gérer les processus

Commandes	Actions
bg	Passer un processus en tache de fond (background)
fg	Pour reprendre un processus arrêté en arrière plan
kill	Envoyer un signal à un processus pour le tuer
nice	Démarrer un processus avec une priorité définis
renice	Changer la priorité d’un processus en cours d’exécution
pidof	Donne le PID d’un processus
ps	Lister les processus
top	Afficher et classe les processus actifs (cpu – mém – temps)