Dans le chapitre précédent, vous avez lancé la commande w qui vous permet d'obtenir un relevé en temps réel des comptes connectés et leurs activités associées. Cette commande effectue en fait un condensé d'autres commandes qui permettent d'auditer l'activité du processus et la charge mémoire.

Je vous propose dans ce chapitre de passer en revue les outils pour effectuer un audit de ce qui se passe en temps réel sur le système. Nous verrons :

• Les commandes ps, pstree, et top et sa dérivée htop ;
• La commande kill qui permet de terminer un processus lorsque nécessaire.

La commande principale pour relever l'activité des processus sur Linux est ps.

Cette commande externe est fournie par les distributions via le package procps. Ce package est très important, il fournit beaucoup de commandes intéressantes pour auditer l'activité du système, nous en verrons plusieurs dans ce chapitre (ps, kill, top, etc.).

ps est une commande très complète, je vous invite à consulter sa documentation, elle vous occupera un bon moment de lecture. Cependant, pour synthétiser, je vais vous présenter les combinaisons d'options que je lance régulièrement avec cette commande. Chacune de ses combinaisons ayant un objectif particulier.

# Lister tous les processus
ps -edf

Les principaux champs affichés par ps :

• UID : utilisateur à qui appartient le processus ;
• PPID : Identifiant du parent du processus ;
• C : pourcentage CPU d'utilisé par le processus ;
• STIME : date de lancement du processus ;
• TTY : terminal auquel le processus est lié ;
• TIME : temps cumulé d'utilisation du processeur par le processus ;
• CMD : commande lancée pour créer le processus.

Quelques options intéressantes :

# Afficher les 5 processus occupant le plus de mémoire
ps -edf --sort=+pmem | tail -5
 
# Afficher les processus occupant le CPU
ps -edf --sort=+pcpu | tail -5

Lorsque la machine démarre, Linux lance un premier processus qui aura un PID=1 (init ou systemd en fonction du type et de l'âge de la distribution). Tous les autres processus seront des fils et petits-fils de ce processus.

Vous avez plusieurs méthodes pour afficher l'arborescence des processus, c'est-à-dire quel processus est le père de quel autre processus.

Voyons maintenant comment :

• Afficher la hiérarchie des processus en utilisant les options de la commande ps ;
• Ou encore en utilisant une nouvelle commande qui est bien pratique pour ça : pstree.

Sous Windows, pour analyser l'activité, il y a le traditionnel “Gestionnaire de tâches”. Son équivalent existe également sous Linux, en mode terminal : c'est la commande top.

Plutôt que de vous expliquer cette commande, qui a l’avantage d’être très graphique (dans le cadre du terminal quand même hein…), je vous propose de la lancer tout simplement et d’analyser ensemble ce qu’elle affiche.

Mais juste avant, je voulais aussi vous parler de la commande htop. C’est la petite cousine de top, mais elle n’est pas forcément installée par défaut sur toutes les distributions.

L'objectif de cette commande est aussi d'afficher un gestionnaire de tâches courantes, mais de manière un peu plus graphique et ergonomique encore.

Les fonctions de tri et de filtre sont plus facilement accessibles via les touches F1 à F10, et il est possible de personnaliser l'affichage avec F2.

htop vous propose par défaut une vue de la charge des CPUs de manière individualisée, ce qu'il est possible de faire également avec top en pressant la touche 1.

Allez, assez de blabla, on y va ! Et au passage je vous présente le concept de “load average”, qui permet d’établir une tendance à l’instant T de la charge du serveur :

Si vous reprenez les exemples d'affichage précédents des commandes top ou htop, il est un champ que nous n'avons pas évoqué : il s'agit de NI(pour NICE).

En effet, le noyau gère l'allocation du temps CPU pour chaque processus en fonction d'un facteur de priorité.

Le champ NI correspond à l'affichage de la valeur numérique de ce facteur de priorité et sous Linux :

• L'intervalle numérique de priorité va de -20 à 20 ;
• Plus la valeur de la priorité est élevée, moins le processus est prioritaire. Un moyen mnémonique très simple de se souvenir de ce fait est de traduire NICE par gentil en français, et de considérer que plus un processus est gentil, plus il laisse les autres occuper du temps CPU avant lui ;
• Un processus plus prioritaire occupera plus de temps CPU et de ressources du système qu'un processus moins prioritaire.

Sans indication contraire, les processus se lancent naturellement avec une priorité intermédiaire valant 0.

Tous les utilisateurs peuvent modifier uniquement à la baisse (c'est-à-dire en augmentant la valeur) la priorité de leur processus. Seul root peut modifier à la hausse la priorité d'un processus (c'est-à-dire en diminuant la valeur).

Dans la plupart des cas, vous aurez besoin de modifier la priorité d'un processus qui est déjà lancé :

• Soit pour l'augmenter afin de terminer ses tâches plus rapidement ;
• Soit pour la diminuer car il bloque l'exécution normale de ses petits copains sur le système.

Allez, je vous montre tout ça en vidéo, et notamment comment utiliser les commandes ps,renice et top :

Dans certains cas, il vous faudra terminer un processus qui ne remplit plus ses tâches pour x raisons :

• bug ;
• boucle infinie ;
• surcharge mémoire ou cpu ;
• etc.

Sans rentrer trop dans le détail de la conception des processus sous Linux (qui reste par ailleurs un excellent sujet), sachez qu'il est possible d'envoyer une information à un processus en cours d'exécution. Cette information est nommée un signal.

• Le noyau Linux peut envoyer des signaux à ces processus ;
• Un processus peut envoyer un signal à un autre processus ;
• Et un processus peut même s’envoyer à lui-même un signal.

Sous Linux, il existe 30 signaux principaux normalisés, numérotés de 1 à 30. Ainsi lorsqu'un processus reçoit un signal, en fonction de sa nature, il peut l’“écouter” et appliquer son message ou bien l’ignorer.

Il faut bien comprendre que l'interprétation d'un signal est de la responsabilité du processus qui le reçoit. Ce dernier peut tout à fait être codé en ignorant un ou plusieurs signaux (sauf 1 signal particulier), mais c'est très rarement le cas.

Il n'est pas nécessaire de connaître tous ces signaux, seuls ceux permettant d'interrompre le fonctionnement d'un processus nous intéressent ici. Ils sont au nombre de 3 :

1. SIGINT (signal numéro 2)
2. SIGTERM (signal numéro 15)
3. SIGKILL (signal numéro 9)

Ces deux signaux indiquent au processus sa terminaison de façon propre. Autrement dit : il y a ici une volonté à ce que ce soit le processus lui-même qui se termine, en libérant correctement toutes les ressources qu'il occupe à cet instant.

SIGINT est assez connu, puisque généralement il correspond à l'interruption clavier CTRL+C.

Notez que ces deux signaux peuvent être ignorés par le processus cible (je pense notamment au processus parent de tous les autres, init ou systemd ou encore à tous les processus gérés directement par le noyau Linux).

C’est le signal destructeur par définition. Souvent, il est envoyé lorsque les deux précédents n'ont pas fonctionné. Le processus ciblé est terminé brutalement :

• Pas forcément aussi proprement qu'avec SIGINT ou SIGTERM ;
• Et les ressources associées ne sont pas libérées proprement.

Les processus ne peuvent pas ignorer ce signal. Tout simplement parce qu'il ne leur est pas adressé directement. SIGKILL est envoyé au processus principal de Linux (init ou systemd) qui se charge, lui, de tuer le processus cible.

Quoi ? Dit comme ça, c’est pas très clair…

Pas d’inquiétude : je vous montre tout ça en vidéo. Et au passage, nous verrons la commande kill qui permet d’envoyer un signal à un processus. (Oui, le nom de cette commande est un peu orienté sur les 3 signaux décrits ci-dessus justement, mais elle peut envoyer des signaux plus gentils que les tueurs… 🤣).

• Les commandes ps et top permettent de visualiser l'activité du système ;
• Les processus sont hiérarchisés et le parent d'origine est init(SystemV) ou systemd ;
• La commande nice permet de modifier la priorité d'exécution d'un processus ;
• La commande kill permet d'envoyer un signal à un processus.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷