Travail Pratique 5 - Processus 2

Pour ouvrir un nouveau terminal:

Vous pouvez utiliser les raccourcis suivants dans le terminal:

Pour naviguer dans un terminal, surtout quand la sortie d'une commande a un grand contenu, vous pouvez utiliser les reccourcis suivants:

D'autres raccourcis utiles:

Les pages de manuel sont souvent volumineuses et nous devons les parcourir rapidement. Pour pouvoir faire ceka, après avoir ouvert la page de manuel d'une commande, nous pouvons utiliser les combinaisons de touches ci-dessous pour naviguer dans la page:

• Comprendre les concepts de processus
• Acquérir des compétences de surveillance et d'interaction avec les processus
• Acquérir des compétences de travail avec les utilitaires et les commandes Linux
• Connaître les bases de la communication inter-processus: tuyaux et signaux

Pendant les laboratoires, pour télécharger les fichiers nécessaires au laboratoire, nous utiliserons Git. Git est un système de contrôle de version et est utilisé pour le contrôle de version de code dans les grands projets logiciels. Ceux qui souhaitent approfondir les concepts derrière la commande git , ainsi que les utilisations avancées, nous recommandons le cours pratique en ligne sur gitimmersion.

Des informations sur le TP d'USO sont sur ce repository Git.

student@uso:~$ cd ~
student@uso:~$ git clone https://github.com/systems-cs-pub-ro/uso-lab.git
student@uso:~$ cd uso-lab/02-process/support/

Voilà pour la préparation en laboratoire. Commençons maintenant!

La hiérarchie des processus sous Linux est en forme d'arbre; on peut voir en utilisant pstree (similaire avec tree du système de fichiers)

En utilisantpssans aucun paramètre, nous voyons les processus dans le shell actuel associés à l'utilisateur actuel.

student@uso:~$ ps
  PID TTY          TIME CMD
22101 pts/0    00:00:00 bash
22209 pts/0    00:00:00 ps

Aussi a l'aide de ps on peut visualiser un snapshot avex tous les processus. Ceci peut être réalisé en utilisant deux variantes de la commande:

student@uso:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.3 160140  7044 ?        Ss   10:39   0:02 /sbin/init spla
root         2  0.0  0.0      0     0 ?        S    10:39   0:00 [kthreadd]
[...]
student  22101  0.0  0.2  31236  5192 pts/0    Ss   19:38   0:00 bash
student  22114  0.0  0.2  31236  5008 pts/1    Ss+  19:38   0:00 bash
root     22151  0.0  0.3  25656  6260 ?        S    19:40   0:00 /sbin/dhclient 
student  22191  0.0  0.1  46012  3656 pts/0    R+   19:48   0:00 ps aux

Un utilitaire équivalent à Windows Task Manager pour l'affichage en temps réel des processus en cours d'exécution, en ligne de commande, est htop.

student@uso:~$ htop

Le processus est identifié dans le système à l'aide d'un numéro appelé PID (process ID). Il est unique dans le système. Lorsqu'un processus est créé, un nouveau PID est attribué, le prochain libre, en ordre ascendante.

Un autre attribut important est PID-ul du processus parent, PPID. Ayant une structure hiérarchique, tous les processus ont un parent, le parent de tout le monde étant init ou systemd (selon le système) et il a le PID 1.

L'attribut COMMAND nous indique le nom du processus ou de la commande avec laquelle il a été créé:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
student  23176  0.0  0.1  46012  3644 pts/0    R+   22:06   0:00 ps aux

Pour une liste complète des attributs, consultez le manuel .

Il existe plusieurs états dans lesquels un processus peut être:

1. État de fonctionnement
2. L'état dans lequel il est arrêté: on utilise Ctrl+Z
3. L'état dans lequel il est terminé (le processus n'existe plus): on utilise Ctrl+C

En appuyant sur une combinaison des touches ci-dessous, nous envoyons un signal au processus:

Dans la section Demo nous montrons comment traverser ces états.

Un utilisateur peut envoyer un signal à un processus en utilisant la commande kill! Il est très important de comprendre que l'objectif principal de l'utilitaire n'est pas de tuer les processus, bien qu'il puisse le faire. Une liste de tous les signaux qui peuvent être envoyés est affichée par la commande:

student@uso:~$ kill -l   

Les utilitaires pkill et killall terminent les processus en utilisant le nom du processus et pas le PID (identique a kill).

Redirection stdout (standard output, généralement des messages affichés par des commandes similaires à printf en C). Pour rediriger la liste des processus vers un fichier, nous utilisons la commande suivante:

student@uso:~$ ps aux > procese.txt

Ainsi, nous avons spécifié au processus de ne plus afficher le résultat à l'écran, mais dans un fichier. La différence entre > et » est que le premier remplace le contenu du fichier process.txt , tandis que le second ajoute la fin du fichier.

L'operateur < utilise de la facon suivantecommande < fisier.txt définit l'entrée de commande fisier.txt.

student@uso:~$ grep "Disable" < vm-actions-log.txt 
* Disable terminal bell and scrolling in terminal:
* Disable cursor blinking in terminal:
* Disable DNS usage in SSH server:
* Disable automated screen locking:

L'operateur | est très important et généralement utilisé. Il prend le résultat de la première commande et le propose en entrée de la deuxième commande. Quelques exemples:

student@uso:~$ ps aux | grep sleep
student  22406  0.0  0.0  16116   828 pts/0    S    20:28   0:00 sleep 1000
student  22408  0.0  0.0  23076  1084 pts/0    S+   20:28   0:00 grep --color=auto sleep

student@uso:~$ tree | grep Documents
├── Documents

Nous pouvons enchaîner 2 commandes ou plusieurs.

Les processus démon sont des processus qui s'exécutent en arrière-plan. Ce sont généralement des services qui remplissent certaines fonctions spécifiques. Ceux-ci peuvent être reconnus comme ayant le processus parent avec PID 1 (processus init ou systemd).

En utilisant ps sans aucun paramètre, nous visualisons les processus dans le shell actuel associés à l'utilisateur actuel.

student@uso:~$ ps
  PID TTY          TIME CMD
22101 pts/0    00:00:00 bash
22209 pts/0    00:00:00 ps

Aussi avec ps on peut visualiser un snapshot de tous les processus. On a 2 possibilites de l'utiliser:

student@uso:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.3 160140  7044 ?        Ss   10:39   0:02 /sbin/init spla
root         2  0.0  0.0      0     0 ?        S    10:39   0:00 [kthreadd]
[...]
student  22101  0.0  0.2  31236  5192 pts/0    Ss   19:38   0:00 bash
student  22114  0.0  0.2  31236  5008 pts/1    Ss+  19:38   0:00 bash
root     22151  0.0  0.3  25656  6260 ?        S    19:40   0:00 /sbin/dhclient 
student  22191  0.0  0.1  46012  3656 pts/0    R+   19:48   0:00 ps aux

Un utilitaire équivalent à Windows Task Manager pour l'affichage en temps réel des processus en cours d'exécution, en ligne de commande, est htop .

student@uso:~$ htop

Par défaut, lors de l'affichage des processus, les attributs suivants sont inclus:

student@uso:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
[...]

Nous pouvons spécifier quels attributs afficher et dans quel ordre nous voulons:

student@uso:~$ ps -ax -o ppid,pid,cmd
 PPID   PID CMD
    0     1 /sbin/init splash
    0     2 [kthreadd]
[...]

Pour sélectionner uniquement les processus démarrés par l'utilisateur student:

student@uso:~$ ps -f -u student
UID        PID  PPID  C STIME TTY          TIME CMD
student    900     1  0 11:10 ?        00:00:00 /lib/systemd/systemd --user
student    901   900  0 11:10 ?        00:00:00 (sd-pam)
[...]

Nous utiliserons l'utilitaire sleep comme exemple. Nous devons savoir si notre processus est en cours d'exécution ou non. Pour le vérifier, depuis un autre terminal, nous utilisons l'utilitaire ps :

Terminal 1:

student@uso:~$ sleep 100

Terminal 2:

student@uso:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.3 160140  7044 ?        Ss   10:39   0:02 /sbin/init spla
root         2  0.0  0.0      0     0 ?        S    10:39   0:00 [kthreadd]
[...]
student  22268  0.0  0.0  16116   884 pts/0    S    19:54   0:00 sleep 100
student  22281  0.0  0.1  46012  3744 pts/0    R+   19:54   0:00 ps aux

Nous avons trouvé le processus “sleep” dans le système. Nous pouvons utiliser l'utilitaire “pgrep” pour trouver le PID du processus.

student@uso:~$ pgrep sleep
22268

Pour terminer le processus, on va utiliser la combinaison de touches Ctrl+Z:

student@uso:~$ sleep 100
student@uso:~$ ^Z
[1]+  Stopped                 sleep 100
student@uso:~$ jobs
[1]+  Stopped                 sleep 100

J'ai utilisé l'utilitaire jobs pour voir quels processus sont actifs dans le terminal actuel. À partir d'ici, nous pouvons utiliser bg (arrière-plan) pour démarrer le processus de manière interactive ou fg (premier plan) pour démarrer le processus de manière non interactive. Plus simplement, dans bg nous pouvons émettre d'autres commandes pendant que notre programme est en cours d'exécution, et dans fg nous ne pouvons pas émettre d'autres commandes.

En ce qui suit, on va utiliser la commande kill pour envoyer des signaux aux processus. Cette commande ne tue pas nécessairement le processus, malgré son nom.

student@uso:~$ kill --help
kill: kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]
    Send a signal to a job.

À partir d'un autre terminal, nous trouvons le PID du processus sleep à l'aide de l'utilitaire pgrep . Pour terminer le processus, nous envoyons le signal 9 (SIGKILL):

student@uso:~$ jobs
[1]+  Stopped                 sleep 100
student@uso:~$ pgrep sleep
22286
student@uso:~$ kill -9 22286
student@uso:~$ jobs
[1]+  Killed                  sleep 100

On a transmis le signal 9 (SIGKILL) au processus 22286, et il s'est terminé instantanément.

Pour rediriger la liste des processus vers un fichier, nous utilisons la commande suivante:

student@uso:~$ ps aux > procese.txt

Ainsi, nous avons spécifié au processus de ne plus afficher le résultat à l'écran, mais dans un fichier. La différence entre > et » est que le premier remplace le contenu du fichier process.txt , tandis que le second ajoute la fin du fichier. Ainsi, en exécutant la commande pour la deuxième fois:

student@uso:~$ ps aux >> procese.txt

Nous aurons dans le fichier procese.txt affiché 2 fois la sortie de la commande.

L'operateur | est très important et généralement utilisé. Il prend le résultat de la première commande et le propose comme entrée dans la deuxième commande. Quelques exemples:

student@uso:~$ ps aux | grep sleep
student  22406  0.0  0.0  16116   828 pts/0    S    20:28   0:00 sleep 1000
student  22408  0.0  0.0  23076  1084 pts/0    S+   20:28   0:00 grep --color=auto sleep

student@uso:~$ tree | grep Documents
├── Documents

En utilisant ps sans aucun paramètre, nous visualisons les processus dans le shell actuel associés à l'utilisateur actuel.

student@uso:~$ ps
  PID TTY          TIME CMD
22101 pts/0    00:00:00 bash
22209 pts/0    00:00:00 ps

Parametrul aux asociat lui ps ne arată toate procesele din sistem:

student@uso:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.3 160140  7044 ?        Ss   10:39   0:02 /sbin/init spla
root         2  0.0  0.0      0     0 ?        S    10:39   0:00 [kthreadd]
[...]
student  22101  0.0  0.2  31236  5192 pts/0    Ss   19:38   0:00 bash
student  22114  0.0  0.2  31236  5008 pts/1    Ss+  19:38   0:00 bash
root     22151  0.0  0.3  25656  6260 ?        S    19:40   0:00 /sbin/dhclient 
student  22191  0.0  0.1  46012  3656 pts/0    R+   19:48   0:00 ps aux

Pour sélectionner uniquement les processus lancés par l'utilisateur étudiant, nous utilisons - u :

student@uso:~$ ps -f -u student
UID        PID  PPID  C STIME TTY          TIME CMD
student    900     1  0 11:10 ?        00:00:00 /lib/systemd/systemd --user
student    901   900  0 11:10 ?        00:00:00 (sd-pam)
[...]

Nous pouvons spécifier quels attributs afficher et dans quel ordre nous voulons:

student@uso:~$ ps -ax -o ppid,pid,cmd
 PPID   PID CMD
    0     1 /sbin/init splash
    0     2 [kthreadd]
[...]

Avant de poursuivre, vous devez vous assurer de comprendre comment naviguer dans une hiérarchie de processus. Pour ce faire, effectuez les exercices suivants, puis vérifiez avec l'assistant que tout va bien.

1. Afficher tous les processus du système qui contiennent des données liées au PID, le PID parent, l'utilisateur propriétaire du processus et la commande qui a démarré le processus
2. Filtrer les processus par l'utilisateur actuel (student)
3. Afficher les processus de manière interactive (folosind top/htop)

Nous utiliserons le programme bg-proc.sh comme exemple. Il affiche un message “Tick” ou “Tock” chaque seconde. Nous executons le programme:

student@uso:~/.../02-process/support$ ./bg-proc.sh 
Tick!
Tock!
Tick!
^C

On l'a arrete Ctrl+C:

On recommence et cette fois on arrête avec Ctrl+Z. Que remarquons-nous?

student@uso:~/.../02-process/support$ ./bg-proc.sh 
Tick!
Tock!
Tick!
^Z
[1]+  Stopped                 ./bg-proc.sh

Nous vérifions si le processus existe toujours dans le système:

student@uso~/.../02-process/support$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.3 160140  7152 ?        Ss   oct08   0:03 /sbin/init splash
root         2  0.0  0.0      0     0 ?        S    oct08   0:00 [kthreadd]
[...]
**student  23597  0.0  0.1  21532  3532 pts/0    T    09:53   0:00 /bin/bash ./bg-proc.sh**
student  23600  0.0  0.0  16116   780 pts/0    T    09:53   0:00 sleep 1
student  23601  0.0  0.1  46012  3784 pts/0    R+   09:53   0:00 ps aux

Pour redémarrer le processus, nous avons 2 options:

1. Nous démarrons le processus de manière interactive en utilisant la commande bg . Cela signifie que nous pouvons donner des commandes, même si en arrière-plan est un processus qui affiche du texte
2. Nous démarrons le processus en mode non interactif à l'aide de la commande fg . Cela signifie que le processus précédemment arrêté est revenu au premier plan dans le terminal. Nous ne pourrons pas donner d'autres commandes.

student@uso:~/.../02-process/support$ ./bg-proc.sh
Tick!
Tock!
 
[1]+  Stopped                 ./bg-proc.sh
student@uso:~/.../02-process/support$ bg
[1]+ ./bg-proc.sh &
student@uso:~/.../02-process/support$ Tick!
Tock!
lsTick!
 
batman.sh  bg-proc.sh  it-s-a-trap.sh
student@uso:~/.../02-process/support$ Tock!
Tick!
Tock!
^C
student@uso:~/.../02-process/support$ Tick!
Tock!

Vous remarquerez peut-être que nous avons essayé de terminer le programme en utilisant Ctrl + C . Cela n'a pas été possible car il s'exécutait en arrière-plan. Pour cela, nous devons mettre le processus au premier plan et le terminer ou trouver le PID et le terminer à l'aide de l'utilitaire kill .

Exerciții

1. Démarrez le programme bg-proc.sh.
2. Passez-le au premier plan puis à l'arrière-plan.
3. Terminez le processus avec Ctrl + C et l'utilitaire kill
4. Faites de même avec le programme it-s-a-trap.sh

Pour rediriger la liste des processus vers un fichier, nous utilisons la commande suivante:

student@uso:~$ ps aux > procese.txt

Un autre example:

student@uso:~/.../02-process/support$ echo "prima linie din fisier" > fis.txt
student@uso:~/.../02-process/support$ cat fis.txt 
prima linie din fisier
student@uso:~/.../02-process/support$ echo "a2a linie din fisier" >> fis.txt 
student@uso:~/.../02-process/support$ cat fis.txt 
prima linie din fisier
a2a linie din fisier
student@uso:~/.../02-process/support$ echo "a3a linie din fisier" > fis.txt 
student@uso:~/.../02-process/support$ cat fis.txt 
a3a linie din fisier

Nous pouvons voir que dans la troisième ligne, nous avons utilisé > au lieu de » et nous avons supprimé le contenu précédent du fichier.

Nous pouvons rechercher un certain processus dans le système comme suit:

student@uso:~$ ps aux | grep sleep
student  22406  0.0  0.0  16116   828 pts/0    S    20:28   0:00 sleep 1000
student  22408  0.0  0.0  23076  1084 pts/0    S+   20:28   0:00 grep --color=auto sleep

Quelle est la logique derrière la commande? Au lieu de nous montrer à l'écran le résultat de la commande ps aux , il a été envoyé à la prochaine commande grep . Cette dernière commande a recherché le mot sleep dans le résultat des commandes ps aux .

Exercices

1. Affichez récursivement tous les fichiers et dossiers dans uso-lab , en redirigeant tout vers un fichier. Inspectez le fichier pour vérification.
2. Chaînez la commande précédente avec grep pour rechercher dans les fichiers use-lab contenant le mot lab .

Pour cette section, vous devez vous assurer que vous êtes dans le bon répertoire. Exécutez la commande

cd ~/uso-lab/02-process/support/

Nous pouvons vérifier que la commande précédemment exécutée a été exécutée avec succès en utilisant $? :

student@uso:~/.../02-process/support$ cat README.md 
uso
===
 
   * Directorul ''lab02'' conține toate fișierele și structura de directoare necesare rezolvării laboratorului 2 de către studenți
student@uso:~/.../02-process/support$ echo $?
0
student@uso:~/.../02-process/support$ cat fisier-care-nu-exista.txt
cat: fisier-care-nu-exista.txt: No such file or directory
student@uso:~/.../02-process/support$ echo $?
1

Lorsque la valeur est 0 , le processus a été exécuté avec succès. Toute autre valeur differente de 0 est une erreur.

Exercices

1. Essayez d'afficher un fichier qui n'existe pas. Quel code d'erreur recevez-vous?
2. Essayez d'exécuter une commande avec des paramètres aléatoires (ex: ps -ewqgew). Quel code d'erreur recevez-vous?

Nous affichons tous les processus du système avec les attributs PID, PPID, CMD:

student@uso:~/.../02-process/support$ ps ax -o pid,ppid,cmd
  PID  PPID CMD
    1     0 /sbin/init splash
[...]
19540     2 [jfsSync]
22046     2 [kworker/0:1]
22090   900 /usr/lib/gnome-terminal/gnome-terminal-server
22101 22090 bash
22114 22090 bash
22234     1 /usr/bin/python3 /usr/bin/update-manager --no-update --no-focus-on-map
22559     1 /usr/sbin/cupsd -l
22560     1 /usr/sbin/cups-browsed
22742     2 [loop10]
22785     1 /usr/lib/snapd/snapd
22913     2 [loop12]
23200     2 [kworker/u2:0]
23394   530 /sbin/dhclient -d -q -sf /usr/lib/NetworkManager/nm-dhcp-helper -pf /run/dhclient-enp0s8.pid -lf /var/lib/NetworkManager/dhclient-fda81623-2338-36f
23519     2 [kworker/u2:1]
23974     2 [kworker/u2:2]
24107 22101 ps ax -o pid,ppid,cmd

Nous pouvons voir que le parent de la commande exécutée par nous est bash ; il a le PID 22101.

Exercices

1. Affichez l'arborescence des processus. Utilisez l'utilitaire pstree mentionné ci-dessus.
2. Essayez d'obtenir le même effet en utilisant l'utilitaire ps (indice: recherchez dans l'homme le mot tree ).
3. Quelle est la différence entre les deux modes d'affichage? Offre-t-il les mêmes informations?

Pour cet exercice, vous devez vous assurer que vous êtes dans le bon répertoire. Exécutez la commande

cd ~/uso-lab/02-process/support/

Dans ce répertoire se trouve le script batman.sh :

student@uso:~/.../02-process/support$ ls
batman.sh  bg-proc.sh  it-s-a-trap.sh

Exécutez le script batman.sh . Le processus intercepte tous les signaux avec des index de 1 à 13, moins 9 (pour des raisons évidentes). Chaque fois qu'il reçoit un signal dont l'indice est compris entre 1 et 13, il affiche un caractère à l'écran. Ci-dessous, vous avez le mappage entre les index de signal et le caractère affiché:

2.1 Dans un autre terminal, recherchez le PID du processus et envoyez des signaux pour que le processus affiche la chaîne de caractères rullz à l'écran.

Téléchargez un fichier vidéo sur Internet. Vous pouvez installer et utiliseryoutube-dl pour télécharger un film depuis YouTube.

Lancez le film avec un lecteur de film. Pendant l'exécution, supprimez le fichier. Jusqu'à la fin du film, récupérez le fichier à l'aide de procfs (din /proc), du directeur du processus du lecteur de film.

À l'aide de l'utilitaire strace , inspectez les fichiers dans les procfs (dans / proc ) qui sont ouverts par l'utilitaire lsof pour afficher les descripteurs ouverts d'un processus existant, l'utilitaire pmap pour afficher une mémoire et l'utilitaire gratuit pour afficher la mémoire disponible dans le système.