🐧 Correction TP BASH

Avec la commande top, les processus sont triés par défaut par utilisation CPU décroissante.

Exemple de réponse :

• Processus : python3 ou python
• PID : 1234 (variable selon le système)
• %CPU : 25.3% (variable selon la charge)

Commande principale :

$ ps aux --sort=-%mem

Pour afficher seulement les 10 premiers :

$ ps aux --sort=-%mem | head -11

Explications :

• aux : affiche tous les processus avec détails
• --sort=-%mem : trie par mémoire décroissante (le - indique l'ordre décroissant)
• On peut aussi utiliser --sort=%mem pour un tri croissant

Alternative avec sélection des colonnes :

$ ps -eo pid,user,%mem,%cpu,cmd --sort=-%mem | head -10

Commande pour compter :

$ pgrep python | wc -l

Pour voir les détails :

$ pgrep -a python

Exemple de réponse : 5 processus Python (si on a lancé 5 instances d'infini.py)

Pour tuer tous les processus Python d'un coup :

$ pkill python

Il existe 64 signaux sous Linux (numérotés de 1 à 64).

Commande pour voir tous les signaux :

$ kill -l

Principaux signaux :

Autres signaux importants :

• Signal 1 (SIGHUP) : Rechargement de la configuration (pour les démons)
• Signal 2 (SIGINT) : Interruption (équivalent à Ctrl+C)
• Signal 18 (SIGCONT) : Reprend un processus suspendu
• Signal 20 (SIGTSTP) : Suspend (équivalent à Ctrl+Z)

Commandes à exécuter :

# Lancer infini.py
$ python infini.py &
[1] 5432

# Suspendre le processus
$ kill -STOP 5432

# Vérifier l'état
$ ps -o pid,stat,cmd -p 5432

Résultat attendu :

PID  STAT  CMD
5432 T     python infini.py

Pour reprendre le processus :

$ kill -CONT 5432
# L'état redevient S (Sleeping) ou R (Running)

États possibles (rappel) :

• R : Running (en cours d'exécution)
• S : Sleeping (en attente)
• T : sTopped (suspendu)
• Z : Zombie (terminé mais non récupéré par le parent)
• D : Uninterruptible sleep (attente I/O)

Bonne pratique :

# 1. Essayer d'abord SIGTERM
$ kill 1234

# 2. Attendre quelques secondes (ex: 5-10s)
$ sleep 5

# 3. Si le processus ne s'est pas terminé, utiliser SIGKILL
$ kill -9 1234

import os
import time

def main():
    pid = os.fork()
    
    if pid > 0:
        # Processus parent
        print(f"Parent (PID: {os.getpid()}) a créé l'enfant (PID: {pid})")
        time.sleep(60)  # Le parent attend sans récupérer l'enfant
    else:
        # Processus enfant
        print(f"Enfant (PID: {os.getpid()}) se termine")
        exit(0)

main()

Exécution et détection :

# Lancer le programme
$ python zombie.py

# Dans un autre terminal, détecter les zombies
$ ps aux | grep defunct
# ou
$ ps aux | grep Z
# ou plus précis
$ ps -eo pid,stat,cmd | grep Z

Résultat attendu :

1234  Z    [python] <defunct>

Pourquoi existe-t-il ?

1. Cycle de vie normal d'un processus :

• Un processus enfant se termine (exit())
• Le noyau conserve certaines informations (code de sortie, statistiques d'utilisation)
• Ces informations doivent être lues par le parent via wait() ou waitpid()
• Une fois lues, le processus est complètement supprimé

2. Cas du zombie :

• L'enfant se termine
• Le parent ne récupère pas le code de sortie (n'appelle pas wait())
• L'enfant reste en état zombie en attendant que le parent le récupère

3. Caractéristiques d'un zombie :

• N'utilise aucune ressource CPU ou mémoire (sauf l'entrée dans la table)
• État : Z (Zombie) ou <defunct>
• Ne peut pas être tué avec kill (il est déjà mort !)
• Disparaît quand le parent appelle wait() ou se termine

Méthodes pour éliminer un zombie :

1. Solution propre : Le parent récupère l'enfant

Modifier le code pour que le parent appelle wait() :

import os
import sys

def main():
    pid = os.fork()
    
    if pid > 0:
        # Processus parent
        print(f"Parent (PID: {os.getpid()}) a créé l'enfant (PID: {pid})")
        # Attendre que l'enfant se termine et récupérer son état
        child_pid, status = os.wait()
        print(f"Enfant {child_pid} terminé avec le code {status}")
    else:
        # Processus enfant
        print(f"Enfant (PID: {os.getpid()}) se termine")
        sys.exit(0)

main()

2. Tuer le processus parent

# Trouver le PID du parent
$ ps -eo pid,ppid,stat,cmd | grep defunct

# Tuer le parent
$ kill PPID_du_parent

3. On ne peut PAS tuer directement un zombie

$ kill -9 PID_zombie     # ❌ Inefficace (déjà mort)
$ kill -15 PID_zombie    # ❌ Inefficace

Commandes à exécuter :

# Instance avec priorité basse (moins prioritaire)
$ nice -n 10 python infini.py &
[1] 2345

# Instance avec priorité haute (plus prioritaire - nécessite sudo)
$ sudo nice -n -5 python infini.py &
[2] 2346

# Afficher les priorités
$ ps -l

Résultat attendu avec ps -l :

F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY        TIME CMD
0 S  1000  2345  1234  0  90  10    -  123 -      pts/0   0:00 python infini.py
0 S  1000  2346  1234  0  75  -5    -  123 -      pts/0   0:00 python infini.py

Commande renice :

# Rendre un processus "plus gentil" (réduire sa priorité)
$ renice +10 -p 2345

# Augmenter la priorité (nécessite sudo)
$ sudo renice -10 -p 2346

Syntaxe générale :

renice [nouvelle_valeur_nice] -p [PID]
renice [nouvelle_valeur_nice] -u [utilisateur]
renice [nouvelle_valeur_nice] -g [groupe]

Exemples pratiques :

# Réduire la priorité de tous les processus d'un utilisateur
$ sudo renice +15 -u nomeleve

# Vérifier le changement
$ ps -l -u nomeleve

Cas d'usage réels :

• Compilation : nice -n 15 make (ne pas ralentir le système)
• Sauvegarde : nice -n 10 rsync ... (basse priorité)
• Serveur critique : sudo renice -10 -p PID_serveur (haute priorité)

Commande pour lister les démons :

$ ps aux | grep -E '^\w+\s+\d+.*\?'
# ou plus simple
$ ps aux | grep ' ?'

Signification :

• Le ? indique que le processus n'est pas attaché à un terminal
• Les démons tournent en arrière-plan sans interaction utilisateur
• Ils démarrent généralement au boot du système
• Exemples : serveurs web, bases de données, services système

Exemple de sortie :

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.1  0.4 168844 9256 ?        Ss   08:15   0:02 /sbin/init
root       385  0.0  0.2  29008  5284 ?        Ss   08:15   0:00 /lib/systemd/systemd-journald
root       425  0.0  0.1  20644  3156 ?        Ss   08:15   0:00 /lib/systemd/systemd-udevd
message+   632  0.0  0.1   7352  3524 ?        Ss   08:15   0:00 /usr/bin/dbus-daemon

Commande pour lister les services :

$ systemctl list-units --type=service --state=active

Pour voir les détails d'un service :

$ systemctl status nom_service

Exemples de services courants :

$ systemctl status ssh

$ systemctl status systemd-journald

$ systemctl status cron

Commandes utiles pour gérer les services :

# Démarrer un service
$ sudo systemctl start nom_service

# Arrêter un service
$ sudo systemctl stop nom_service

# Redémarrer un service
$ sudo systemctl restart nom_service

# Activer au démarrage
$ sudo systemctl enable nom_service

# Désactiver au démarrage
$ sudo systemctl disable nom_service

# Vérifier si un service est actif
$ systemctl is-active nom_service

# Voir les logs d'un service
$ journalctl -u nom_service -f