Principes fondamentaux de la gestion des processus sous Linux
Objectif
Apprendre les bases de la gestion des processus sous Linux
Système d’exploitation et versions logicielles
- Système d’exploitation : – Toutes les distributions Linux
Exigences
- Certains programmes mentionnés dans ce tutoriel nécessitent un accès root
Difficulté
FACILE
Conventions
- # – nécessite que les commandes Linux données soient exécutées avec les privilèges root, soit
directement en tant qu’utilisateur root, soit en utilisant la commandesudo - $ – nécessite que des commandes Linux données soient exécutées en tant qu’utilisateur régulier non privilégié
Introduction
L’une des activités principales d’un administrateur système est celle de surveiller et d’interagir avec les processus exécutés sur une machine. Dans ce tutoriel, vous serez initié à l’utilisation de certains outils fondamentaux qui vous aideront à accomplir cette tâche vitale.
La commande ps
Ps est l’un des programmes fondamentaux utilisés dans la surveillance des processus : il vous donne essentiellement un instantané des processus en cours d’exécution sur une machine au moment où vous appelez la commande. Voyons-le en action : nous allons d’abord essayer de l’exécuter sans aucune option :
ps
PID TTY TIME CMD
24424 pts/0 00:00:00 bash
24468 pts/0 00:00:00 ps
Comme vous pouvez le voir sur la sortie ci-dessus, seuls deux processus sont représentés : bash avec un PID (ID de processus) 24424 et ps lui-même avec le pid 24468. En effet, lorsqu’elle est appelée sans aucune option, la commande ps affiche les processus associés à l’UID de l’utilisateur qui a lancé la commande et du terminal à partir duquel elle est appelée.
Comment surmonter cette limitation ? En utilisant l’option -a, nous pouvons faire ps pour nous montrer tous les processus, à l’exception des leaders de session et des processus non associés à un terminal.
Un animateur de session est un processus qui a un PID identique à celui du SID (Session Id) de la session dont il est (le premier) membre. Lorsqu’un processus est créé, il fait partie de la même session que son processus parent : puisque par convention l’identifiant de session est le même que le PID de son premier membre, nous appelons ce processus un leader de session. Essayons d’exécuter ps avec l’option -a et de vérifier sa sortie :
ps -a
PID TTY TIME CMD
12466 tty1 00:00:00 gnome-session-b
12480 tty1 00:00:17 gnome-shell
12879 tty1 00:00:00 Xwayland
12954 tty1 00:00:00 gsd-sound
12955 tty1 00:00:00 gsd-wacom
12957 tty1 00:00:00 gsd-xsettings
12961 tty1 00:00:00 gsd-a11y-keyboa
12962 tty1 00:00:00 gsd-a11y-settin
12965 tty1 00:00:00 gsd-clipboard
12966 tty1 00:00:03 gsd-color
12967 tty1 00:00:00 gsd-datetime
12970 tty1 00:00:00 gsd-housekeepin
12971 tty1 00:00:00 gsd-keyboard
12972 tty1 00:00:00 gsd-media-keys
12973 tty1 00:00:00 gsd-mouse
12976 tty1 00:00:00 gsd-orientation
[...]
La sortie du programme a été tronquée, mais vous pouvez facilement voir qu’il inclut maintenant des processus qui appartiennent à différents terminaux et utilisateurs. La sortie nous montre des informations sur PID dans la première colonne, TTY dans la seconde, TIME qui est le temps cumulé que le processeur a passé sur le processus, et CMD qui est la commande qui a démarré le processus.
Pour avoir une sortie encore plus riche, nous pouvons ajouter les options -u et -x : la première indique à ps de faire une sélection par l’identifiant de l’utilisateur, tandis que la seconde indique au programme d’inclure également des processus non associés à un terminal, tels que les démons :
ps -aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.2 223932 8708 ? Ss Jul20 0:04 /usr/lib/systemd/systemd --switched-root --system --deserialize 25
root 2 0.0 0.0 0 0 ? S Jul20 0:00 [kthreadd]
root 4 0.0 0.0 0 0 ? S< Jul20 0:00 [kworker/0:0H]
root 6 0.0 0.0 0 0 ? S< Jul20 0:00 [mm_percpu_wq]
root 7 0.0 0.0 0 0 ? S Jul20 0:00 [ksoftirqd/0]
root 8 0.0 0.0 0 0 ? S Jul20 0:07 [rcu_sched]
root 9 0.0 0.0 0 0 ? S Jul20 0:00 [rcu_bh]
root 10 0.0 0.0 0 0 ? S Jul20 0:04 [rcuos/0]
root 11 0.0 0.0 0 0 ? S Jul20 0:00 [rcuob/0]
root 12 0.0 0.0 0 0 ? S Jul20 0:00 [migration/0]
root 13 0.0 0.0 0 0 ? S Jul20 0:00 [watchdog/0]
root 14 0.0 0.0 0 0 ? S Jul20 0:00 [cpuhp/0]
root 15 0.0 0.0 0 0 ? S Jul20 0:00 [cpuhp/1]
root 16 0.0 0.0 0 0 ? S Jul20 0:00 [watchdog/1]
root 17 0.0 0.0 0 0 ? S Jul20 0:00 [migration/1]
root 18 0.0 0.0 0 0 ? S Jul20 0:00 [ksoftirqd/1]
root 20 0.0 0.0 0 0 ? S< Jul20 0:00 [kworker/1:0H]
root 21 0.0 0.0 0 0 ? S Jul20 0:02 [rcuos/1]
root 22 0.0 0.0 0 0 ? S Jul20 0:00 [rcuob/1]
root 23 0.0 0.0 0 0 ? S Jul20 0:00 [cpuhp/2]
root 24 0.0 0.0 0 0 ? S Jul20 0:00 [watchdog/2]
root 25 0.0 0.0 0 0 ? S Jul20 0:00 [migration/2]
root 26 0.0 0.0 0 0 ? S Jul20 0:00 [ksoftirqd/2]
root 28 0.0 0.0 0 0 ? S< Jul20 0:00 [kworker/2:0H]
[...]
egdoc 13128 0.0 0.1 74736 5388 ? Ss Jul20 0:00 /usr/lib/systemd/systemd --user
egdoc 13133 0.0 0.0 106184 420 ? S Jul20 0:00 (sd-pam)
egdoc 13143 0.0 0.1 218328 3612 ? Sl Jul20 0:00 /usr/bin/gnome-keyring-daemon --daemonize --login
[...]
Vous pouvez voir que beaucoup de nouvelles informations ont été ajoutées. La première nouvelle colonne de la sortie est %CPU : elle indique l’utilisation du processeur du processus, exprimée en pourcentage. Un pourcentage est également utilisé pour la colonne suivante, %MEM, qui indique la mémoire physique de la machine utilisée par le processus. VSZ est la taille de la mémoire virtuelle du processus exprimée en Kio.
La colonne STAT utilise un code pour exprimer l’état du processus. Nous n’allons pas décrire tous les états possibles ici, mais simplement expliquer ceux qui apparaissent dans la sortie ci-dessus (vous pouvez avoir une vue d’ensemble complète en consultant la page de manuel ps).
Examinons le premier processus de la sortie : il a le PID 1, c’est donc le premier processus lancé par le noyau. C’est logique, on peut voir qu’il s’agit de systemd, le système d’initialisation Linux relativement nouveau, maintenant adopté par presque toutes les distributions. Tout d’abord, nous avons un S qui indique que le processus est en état de veille interruptible, ce qui signifie qu’il est inactif et qu’il se réveillera dès qu’il recevra une entrée. Le s, au contraire, nous dit que le processus est un chef de session.
Un autre symbole, qui n’apparaît pas dans le premier brut, mais dans certaines des descriptions des autres processus, est < qui indique que le processus a une priorité élevée, et donc une faible valeur de politesse (nous verrons ce qu’est une valeur de politesse dans la section correspondante de ce tutoriel). Un l dans la colonne STAT indique que le processus est multithread et un signe + qu’il se trouve dans le groupe de processus de premier plan.
Enfin, dans la dernière colonne, nous avons la colonne START, indiquant l’heure à laquelle la commande a commencé.
Une autre option intéressante que nous pouvons passer à la commande ps, est -o, qui est la version courte de --format. Cette option vous permet de modifier la sortie à l’aide d’espaces réservés, en spécifiant les colonnes à afficher. Par exemple, la course à pied :
ps -ax -o %U%p%n%cOn nous donnera d’abord la colonne USER ( %U), suivie du PID du processus ( %p), de la colonne NI ( %n), qui indique le niveau de politesse, et enfin de la colonne COMMAND ( %c) :
USER PID NI COMMAND
root 1 0 systemd
root 2 0 kthreadd
root 4 -20 kworker/0:0H
root 6 -20 mm_percpu_wq
root 7 0 ksoftirqd/0
root 8 0 rcu_sched
root 9 0 rcu_bh
root 10 0 rcuos/0
root 11 0 rcuob/0
root 12 - migration/0
root 13 - watchdog/0
root 14 0 cpuhp/0
root 15 0 cpuhp/1
root 16 - watchdog/1
root 17 - migration/1
root 18 0 ksoftirqd/1
root 20 -20 kworker/1:0H
root 21 0 rcuos/1
root 22 0 rcuob/1
root 23 0 cpuhp/2
root 24 - watchdog/2
root 25 - migration/2
root 26 0 ksoftirqd/2
Utilisation de 'top' pour interagir dynamiquement avec les processus
Alors que ps nous donne un instantané statique des processus et de leurs informations au moment où vous l’exécutez, top nous donne une vue dynamique des processus, mise à jour à un intervalle de temps spécifié que nous pouvons spécifier à la fois lors du lancement du programme et de manière interactive (la valeur par défaut est de 3 secondes).
Top ne se contente pas de nous montrer une représentation dynamique des processus en cours d’exécution : nous pouvons interagir avec eux et avec le programme lui-même, en utilisant quelques touches. Par exemple, appuyer sur B nous permet de basculer l’utilisation des caractères gras, d nous permet d’entrer une valeur pour modifier le temps de retard, k nous permet d’envoyer un signal à un processus en l’invitant à saisir son PID et le code du signal, SIGTERM étant la valeur par défaut.
Changez la priorité des processus avec nice and renice
Comme nous l’avons vu précédemment, chaque processus a une priorité qui lui est attribuée, ce qui indique combien de temps le processus doit attendre que d’autres processus libèrent des ressources avant de pouvoir y accéder. Cette priorité peut être spécifiée avec une valeur qui se trouve dans une plage allant de -20 à 19. Moins la valeur est élevée, plus la priorité du processus est élevée. Cela peut sembler contre-intuitif au début, mais voyez-le de cette façon : plus le processus est agréable pour les autres processus, plus ils le surpasseront dans l’accès aux ressources.
Mais comment fixer la priorité d’un processus ? Nous pouvons utiliser le bon programme pour accomplir la tâche. Supposons que vous vouliez exécuter un script avec la valeur de priorité la plus basse possible : vous le préfaceriez de cette façon :
nice -n 19 ./script.shVous pouvez également modifier la priorité d’un programme qui est déjà en cours d’exécution en utilisant renice en connaissant son PID :
renice -n 15 PIDOù PID est l’ID de processus du programme. N’oubliez pas que la commande renice doit être exécutée avec les autorisations root.
Envoyer des signaux aux processus avec les commandes kill et killall
Nous pouvons utiliser la commande kill pour envoyer un signal à un processus qui nous appartient, ou à chaque processus si nous avons les permissions root. Les différents signaux que l’on peut envoyer sont identifiés par un numéro : on peut facilement voir ces correspondances en exécutant la commande kill avec l’option -l :
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) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
Si aucune option n’est passée à la commande kill, par défaut, elle enverra un signal SIGTERM au processus spécifié, auquel ce dernier pourrait réagir de différentes manières : il peut s’arrêter immédiatement, essayer de faire un peu de nettoyage avant de s’arrêter, ou simplement ignorer le signal.
Pour spécifier le signal à envoyer à l’aide de kill, nous exécutons la commande suivie d’un tiret et du numéro du signal à envoyer. Par exemple, pour exécuter un signal SIGKILL, nous devons exécuter :
kill -9 PIDLe signal SIGKILL, contrairement à SIGTERM, ne peut pas être capté par le processus, qui ne peut pas réagir : il sera simplement arrêté immédiatement.
Un autre signal que vous verrez souvent est SIGINT qui est le signal envoyé lors de l’interruption du clavier (CTRL-c). Il essaie également de mettre fin au processus de manière élégante et peut être ignoré par le processus. SIGSTOP et SIGCONT vont respectivement suspendre et reprendre l’exécution d’un processus : le premier, comme SIGKILL, ne peut pas être intercepté ou ignoré. Pour une liste complète et une description des signaux, vous pouvez consulter le manuel pour signal(7) en fonctionnement :
man 7 signalLe programme killall a le même but de kill, et comme kill, envoie un signal SIGTERM quand aucun autre n’est spécifié, (cette fois avec l’option --signal), mais au lieu de référencer un processus par son PID, il le fera par le nom de la commande, tuant effectivement tous les processus fonctionnant sous le même.