Plusieurs applications se trouvent sur un système. L'utilisateur démarre la bonne application pour un besoin qu'il a. Par exemple, lancez un navigateur Web pour accéder à Wikipédia ou lancez l'application Spotify pour écouter de la musique.

L'utilisateur peut démarrer des applications à l'aide de l'interface utilisateur graphique (GUI) ou de l'interface de ligne de commande (CLI). Dans le cas de l'interface graphique, le démarrage se fait à l'aide des éléments graphiques (souris, menus, icônes du bureau). Dans le cas de l'interface de ligne de commande, le démarrage s'effectue en entrant et en exécutant des commandes.

Les applications CLI, également appelées utilitaires, sont conçues pour être démarrées et utilisées à partir de la ligne de commande. Nous appelons le plus souvent les applications en ligne de commande utilitaires ou simplement commandes. Nous écrivons le nom de l'utilitaire / de la commande dans un terminal et l'utilitaire sera démarré (contrairement au scénario d'utilisation de Alt+F2, lorsque nous utilisons des applications CLI dans la ligne de commande, les messages seront Cela se produit parce que la ligne de commande signifie l'existence d'un terminal où nous pouvons afficher les messages. )). Par exemple, si nous voulons afficher les utilisateurs présents dans le système, nous lançons une application de terminal et utilisons l'utilitaire who :

student@uso:~$ whox
student  :0           2020-09-04 17:42 (:0)
student  pts/0        2020-09-19 15:57 (192.168.56.1)

Ou, si nous voulons voir combien de mémoire nous avons (disponible) dans le système, nous utilisons l'utilitaire free :

student@uso:~$ free
              total        used        free      shared  buff/cache   available
Mem:        2040972     1025716       83824       32916      931432      794692
Swap:        777300       37056      740244

1. Démarrez l'utilitaire ls (liste de répertoires en ligne de commande (CLI)) à l'aide de la ligne de commande.
2. Lancer l'utilitaire df (afficher l'espace disque) à l'aide de la ligne de commande

Pour lancer des applications/utilitaires en ligne de commande, on utilise des commandes qui contiennent le nom de l'utilitaire, éventuellement suivi d'arguments. Ainsi, pour lancer les utilitaires ”ls” ou ”ps”, on utilise des commandes comme celles ci-dessous, simples ou avec arguments :

student@uso:~$ ls
Desktop  Documents  Downloads  examples.desktop  Music  Pictures  Public  snap  Templates  uso.git  Videos  vm-actions-log.txt
student@uso:~$ ls -l
total 60
drwxr-xr-x  2 student student 4096 Aug  6  2018 Desktop
drwxr-xr-x  3 student student 4096 Aug 20  2018 Documents
drwxr-xr-x  2 student student 4096 Aug  6  2018 Downloads
-rw-r--r--  1 student student 8980 Aug  6  2018 examples.desktop
drwxr-xr-x  2 student student 4096 Aug  6  2018 Music
drwxr-xr-x  2 student student 4096 Aug  8 11:52 Pictures
drwxr-xr-x  2 student student 4096 Aug  6  2018 Public
drwxr-xr-x  3 student student 4096 Aug  8 09:02 snap
drwxr-xr-x  2 student student 4096 Aug  6  2018 Templates
drwxr-xr-x 14 student student 4096 Aug 20  2018 uso.git
drwxr-xr-x  2 student student 4096 Aug  6  2018 Videos
-rw-r--r--  1 student student 4827 Aug 21  2018 vm-actions-log.txt
student@uso:~$ ps
  PID TTY          TIME CMD
 3370 pts/4    00:00:00 bash
 7979 pts/4    00:00:00 ps
student@uso:~$ ps -f
UID        PID  PPID  C STIME TTY          TIME CMD
student   3370  3369  0 08:55 pts/4    00:00:00 -bash
student   7982  3370  0 13:17 pts/4    00:00:00 ps -f

Une application dans la ligne de commande peut s'exécuter trop longtemps ou se bloquer. Auquel cas nous voulons l'arrêter. La solution de contournement consiste à fermer la fenêtre du terminal, ce qui ferme généralement également l'application. La meilleure solution consiste simplement à fermer l'application. Pour ce faire, nous utilisons la combinaison de touches Ctrl+c qui arrête l'exécution de l'application dans le terminal ¹⁾. Cela peut également être fait pour les applications graphiques, comme nous l'avons vu plus haut.

Par exemple, si nous utilisons la commande sleep 100 qui se figera pendant 100 secondes, nous l'arrêterons en utilisant Ctrl+c comme ci-dessous :

student@uso:~$ sleep 100
^C
student@uso:~$

Exercice : utilisez la commande suivante qui démarre une application de longue durée et l'arrête de force :

• watch ps : pour surveiller les processus dans le terminal actuel

Démarrer une application signifie allouer des ressources système (processeur, mémoire, périphériques d'entrée/sortie) pour exécuter l'application. Une application en cours d'exécution, c'est-à-dire utilisant des ressources système pour exécuter du code et traiter des données, est appelée un processus. Lorsque nous démarrons une application, un processus est créé ; quand on arrête l'application, ou quand elle termine son exécution, on entend la fin de l'exécution du processus.

Le processus est démarré à partir d'un fichier exécutable qui contient le code de l'application (instructions) et des données. Le fichier exécutable est également appelé image de processus. Le fichier exécutable est un programme. Nous disons que le processus est un programme en cours d'exécution ²⁾.

Le fichier exécutable d'une application est chargé dans la mémoire système et le code est exécuté. à partir de ce moment, nous disons que l'application est en cours d'exécution.

Par exemple, l'application Firefox (navigateur web) a associé le fichier exécutable /usr/bin/firefox ; l'application Vim (éditeur) a un fichier exécutable associé /usr/bin/vim ; l'application LibreOffice (suite bureautique) a un fichier exécutable associé /usr/bin/libreoffice. On peut identifier le fichier exécutable d'une application à l'aide de la commande which suivi de la commande de lancement de l'application comme ci-dessous :

student@uso:~$ which firefox
/usr/bin/firefox
student@uso:~$ which vim
/usr/bin/vim
student@uso:~$ which libreoffice
/usr/bin/libreoffice

Exercice : Identifiez le fichier exécutable des applications/utilitaires python, vim, ls, df.

Un système d'exploitation a généralement plusieurs applications en cours d'exécution, donc plusieurs processus. Trop de processus peuvent surcharger le système, le ralentir ou l'empêcher de fonctionner. Certains processus peuvent consommer des ressources excessives affectant d'autres processus. C'est pourquoi il est utile d'étudier les processus d'un système et leur consommation de ressources.

Un processus est créé par un autre processus. Par exemple, ci-dessus, le processus which a été créé à partir d'un processus shell (bash). Le processus shell a été à son tour créé par un autre processus. Un processus a un processus parent ; un processus peut avoir plusieurs processus enfants. Les processus font donc partie d'une hiérarchie.

Au sommet de la hiérarchie des processus se trouve le processus nommé classiquement init. Dans la liste ci-dessus, nous voyons que le processus au sommet de la hiérarchie est systemd. systemd³⁾ est l'implémentation de init présent dans la plupart des distributions Linux actuelles ⁴⁾.

Sur un plan plus didactique, nous pouvons visualiser la liste des processus d'un système. L'utilitaire ps affiche les processus actuels du système (un instantané des processus système). Lors d'une simple exécution, l'utilitaire ps affiche les processus dans le terminal actuel :

student@uso:~$ ps
  PID TTY          TIME CMD
14897 pts/4    00:00:00 bash
14910 pts/4    00:00:00 ps

Dans le terminal courant (indiqué par la colonne TTY à l'écran, c'est-à-dire le terminal pts/4) il y a deux processus :

1. le processus shell (bash) dans lequel nous exécutons des commandes qui créent de nouveaux processus ;
2. le processus de listing (ps) que nous venons de lancer avec la commande ps ; il s'affiche essentiellement

Pour afficher tous les processus système, nous utilisons l'option -e (pour everything) de l'utilitaire ps comme dans la commande ci-dessous :

student@uso:~$ ps -e
  PID TTY          TIME CMD
    1 ?        00:00:19 systemd
    2 ?        00:00:00 kthreadd
    4 ?        00:00:00 kworker/0:0H
    6 ?        00:00:00 mm_percpu_wq
    7 ?        00:00:09 ksoftirqd/0
    8 ?        00:00:06 rcu_sched
    9 ?        00:00:00 rcu_bh
   10 ?        00:00:00 migration/0
   11 ?        00:00:00 watchdog/0
[...]

L'utilitaire ps a un affichage tabulaire des processus, chaque colonne correspondant à un attribut des processus. Dans un run simple, comme nous l'avons vu plus haut, quatre colonnes sont affichées :

• PID : représentant l'identifiant du processus
• TTY : le terminal dans lequel le processus s'exécute (apparaît ? pour un processus qui n'a pas de terminal - généralement des processus de type service, également appelés processus démons , n'ont pas de terminal)
• TIME : temps d'exécution sur le CPU (en heures, minutes, secondes)
• CMD : le nom de l'image du processus (c'est-à-dire le nom de l'exécutable/programme à partir duquel le processus a été créé)

PID (Process Id) est l'attribut essentiel du processus, un index qui identifie le processus au niveau du système. Un processus est identifié par son PID, et non par son nom d'exécutable (CMD). Nous pouvons avoir plusieurs processus créés à partir du même exécutable, chaque processus ayant son propre PID ⁵⁾.

Pour vérifier plusieurs processus, nous allons créer plusieurs processus shell. Pour commencer, nous ouvrons plusieurs sessions de terminal, en utilisant, par exemple, Alt+F2 dans l'environnement graphique et en entrant la commande gnome-terminal dans l'invite créée. Ensuite, nous ne visualisons que les processus créés à partir de l'exécutable bash en exécutant la commande :

student@uso:~$ ps -e | grep bash
 2181 pts/1    00:00:00 bash
 2194 pts/2    00:00:00 bash
 2205 pts/3    00:00:00 bash
14750 pts/0    00:00:00 bash
14897 pts/4    00:00:00 bash

On obtient un résultat comme ci-dessus. Il y a cinq processus, tous créés à partir de l'exécutable bash, avec cinq PID différents : 2181, 2194, 2205 '' , 14705, 14879.

Un processus a plus que les quatre attributs affichés dans une simple exécution de l'utilitaire ps. Pour afficher plus d'attributs, nous utilisons l'option -f (du format complet) ou l'option -F (du format extra complet ), comme ci-dessous :

student@uso:~$ ps -f
UID        PID  PPID  C STIME TTY          TIME CMD
student  14897 14896  0 17:12 pts/4    00:00:00 -bash
student  15026 14897  0 17:46 pts/4    00:00:00 ps -f
 
student@uso:~$ ps -F
UID        PID  PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
student  14897 14896  0  6056  5136   0 17:12 pts/4    00:00:00 -bash
student  15027 14897  0  9728  3340   0 17:46 pts/4    00:00:00 ps -F

Bien sûr, nous pouvons combiner ces options avec l'option -e pour afficher tous les processus :

student@uso:~$ ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 Aug18 ?        00:00:19 /lib/systemd/systemd --system --deserialize 39
root         2     0  0 Aug18 ?        00:00:00 [kthreadd]
root         4     2  0 Aug18 ?        00:00:00 [kworker/0:0H]
root         6     2  0 Aug18 ?        00:00:00 [mm_percpu_wq]
root         7     2  0 Aug18 ?        00:00:09 [ksoftirqd/0]
root         8     2  0 Aug18 ?        00:00:06 [rcu_sched]
root         9     2  0 Aug18 ?        00:00:00 [rcu_bh]
root        10     2  0 Aug18 ?        00:00:00 [migration/0]
root        11     2  0 Aug18 ?        00:00:00 [watchdog/0]
[...]

Les options -f et -F affichent également d'autres attributs du processus, tels que :

• UID : le nom de l'utilisateur propriétaire du processus
• PPID : identifiant du processus parent
• C : pourcentage d'occupation du processeur
• STIME : heure de début (heure de début)
• RSS : mémoire RAM occupée (taille de l'ensemble résident)

De tels attributs sont utiles pour voir quels processus consomment le plus de ressources (par exemple CPU ou mémoire).

L'utilitaire ps affiche les processus et leurs attributs à un instant donné, un instantané des processus système. Souvent on s'intéresse aussi à l'évolution des processus dans le temps : évolution de la consommation des ressources, émergence de nouveaux processus. Autrement dit, pour surveiller les processus. La surveillance des processus consiste à obtenir périodiquement des informations sur les processus.

Évidemment, un moyen simple de surveiller est d'exécuter périodiquement l'utilitaire ps. Il existe cependant des utilitaires dédiés à la surveillance.

L'utilitaire top est l'utilitaire de surveillance de processus de base dans le monde Linux. C'est l'équivalent du Gestionnaire des tâches de Windows. L'exécution de top conduit à afficher, dans le terminal, les processus du système et à rafraîchir périodiquement les informations (par défaut 2 secondes). L'image ci-dessous est une fenêtre de terminal exécutant top :

top affiche des informations périodiques sur les processus et sur l'état du système : CPU, consommation de mémoire. A chaque période (par défaut 2 secondes) les informations affichées sont rafraîchies.

Pour terminer de force (tuer) un processus, nous utilisons des signaux. Un signal est une notification envoyée par l'utilisateur ou le système d'exploitation à un processus. Un signal n'est pas nécessaire pour tuer le processus de réception, mais c'est le comportement le plus courant et la principale utilisation des signaux.

Pour envoyer un signal à un processus nous avons besoin de connaître son PID et nous utilisons l'utilitaire kill suivi du PID du processus. Autrement dit, si nous démarrons un processus sleep dans un terminal en utilisant la commande ci-dessous :

student@uso:~$ sleep 60

dans un autre terminal, nous trouverons son PID (en utilisant pidof):

student@uso:~$ pidof sleep
9486

puis nous le tuerons (en utilisant kill):

student@uso:~$ kill -SIGKILL 9486

La commande kill reçoit en argument le PID du processus à tuer, soit 9486.

Nous vérifions à nouveau s'il existe un processus sleep utilisant pidof :

student@uso:~$ pidof sleep
student@uso:~$

Nous voyons d'après la sortie que le processus ”sleep” n'existe plus, il a donc été tué.

Dans le terminal initial, où j'ai exécuté la commande sleep, un message apparaît indiquant que le processus a été tué :

student@uso:~$ sleep 60
Killed

• Démarrez trois processus sleep dans trois terminaux différents. Tuez-les tous avec une seule commande. Le PID du shell actuel peut être trouvé à l'aide de la commande :

student@uso:~$ echo $$
9477

• Tuez le shell actuel.
• Démarrez une application python. Démarrez une application vim. Tuez ces processus en utilisant l'utilitaire kill.

Notes de bas de page