SYSTEME D’EXPLOITATION II

LINUX AVANCÉ
Essaid EL HAJI

Université Abdelmalek Essaadi

Faculté Polydisciplinaire à Larache - Département Informatique
[email protected]
Qu’est-ce qu’un processus
1. Définition

Un processus est l’image en mémoire d’un programme en cours d’exécution.

Il a un cycle de vie : il naît, il meurt
Un même programme lancé deux fois génère deux processus différents

Sous Linux, chaque processus est identifié par un numéro appelé PID (Processus IDentifier).
À chaque processus est également associé :
l'identifiant de l'utilisateur pour le compte duquel il s'exécute (UID), qui détermine
les droits du processus ;
l'identifiant de son processus parent (PPID).

Ne pas confondre processus et processeur : Un processeur un composant physique, tandis qu’un

processus est un programme en exécution

Chapitre 1: Les processus 2

Qu’est-ce qu’un processus
1. Espace mémoire d'un processus (Segments)
• Utilisée pour les appels de fonctions et variables locales.
• C'est dans cette zone que le processus va stocker l'ensemble des variables
locales mais également les paramètres et les valeurs de retour de toutes les
fonctions qui sont appelées.
• Elle croit vers le bas!

0xffffffff (haut) • C'est une zone de mémoire virtuelle non allouée initialement.
• Permet au heap de s'agrandir vers le haut et à la pile de s'agrandir vers le bas
Stack (Pile)  ESP/RSP (pointeur actuel) sans se chevaucher.
• Si le heap et la pile viennent à se rencontrer (par manque d'espace), le
processus crash (segmentation fault).
…  Espace libre pour expansion
• Mémoire allouée dynamiquement (via malloc(), calloc(), new en C++).
• Il Commence juste après le segment BSS/Data (adresse basse) et croît vers le
Heap(Tas)  Brk/sbk (limite actuelle) haut (adresses croissantes).
Données non init → BSS • BSS (Block Started by Symbol) : Variables globales/statiques non initialisées
(ex: int y;), initialisées à zéro par le noyau.
Données init → Data
• Variables globales/statiques initialisées explicitement (ex: int x = 10;).
Code exécutable → Text
• Contient le code exécutable (instructions machine compilées).
0x00000000 (bas) • En lecture seule (read-only) pour éviter les modifications accidentelles.
• Partagé entre toutes les instances d'un même programme (économie de
mémoire).
Chapitre 1: Les processus 3
 Qu’est-ce qu’un processus?
2. Caractéristiques d’un processus sous Linux
Un processus possède des caractéristiques statiques (définies lors de sa création) et dynamiques
(évoluant pendant son exécution).

❑ Caractéristiques statiques : Ce sont des attributs qui ne changent pas pendant l'exécution du processus.

Caractéristique Description
PID (Process ID) Identifiant unique du processus.
PPID (Parent Process ID) Identifiant du processus parent.
UID (User ID) Identifiant de l'utilisateur propriétaire.
GID (Group ID) Identifiant du groupe propriétaire.
Nice Value (NI) Priorité du processus (valeurs négatives = plus prioritaire).
Groupe de processus (PGID) Groupe auquel appartient le processus.
Commande (CMD) Programme exécuté par le processus.

Chapitre 1: Les processus 4

 Qu’est-ce qu’un processus?
2. Caractéristiques d’un processus sous Linux

❑ Caractéristiques dynamiques: Ces attributs évoluent au fil du temps en fonction de l’état du

processus et des ressources système.

Caractéristique Description
État (S ou STAT) Indique si le processus est actif, suspendu, en veille, etc.
Temps CPU (TIME) Temps total CPU utilisé par le processus.
Mémoire utilisée (RSS, VSZ) Quantité de mémoire consommée (en RAM et virtuelle).
Priorité (PRI) Priorité effective du processus pour l’ordonnanceur.
Contexte d’exécution Registres, pile et état du processeur.
Nombre de threads Nombre de threads actifs dans le processus.

Chapitre 1: Les processus 5

Qu’est-ce qu’un processus?
2. Caractéristiques d’un processus sous Linux
La commande ps –l affiche les caractéristiques principales d’un processus sous Linux.

Colonne Nom Description Colonne Nom Description

Indicateurs de statut du processus (0x002 = Taille virtuelle du processus en pages
F Flags superutilisateur, 0x400 = processus en cours de SZ Size
mémoire.
swap).
Resident Set Quantité de mémoire physique utilisée (en
Identifiant de l'utilisateur propriétaire du RSS
UID User ID Size Ko).
processus.
Wait
PID Process ID Identifiant unique du processus. WCHAN Fonction noyau où le processus est en attente.
Channel
PPID Parent PID Identifiant du processus parent.
C CPU Usage Utilisation récente du CPU. État du processus (R = running, S = sleeping,
STAT State
Priorité du processus (valeur basse = plus Z = zombie, D = uninterruptible sleep, etc.).
PRI Priority
prioritaire).
TIME CPU Time Temps total CPU utilisé par le processus.
Facteur d'ajustement de la priorité (de -20 à 19,
NI Nice Value
plus bas = plus prioritaire). CMD Command Nom du programme exécuté.
Chapitre 1: Les processus 6
Hiérarchie des processus
Dans les systèmes Unix et Unix-like (Linux, BSD, macOS, etc.), les processus sont organisés selon une
structure arborescente (hiérarchie parent-enfant). Cette hiérarchie permet de gérer les dépendances, les
ressources et la communication entre les processus.

Un processus a un seul père et peut avoir 0 ou plusieurs fils.

Chaque processus (sauf INIT/systemd) a un parent.

La commande pstree donne une bonne illustration de la hiérarchie des processus parents et
fils (L’option -p affiche le PID des processus).

Chapitre 1: Les processus 7

Hiérarchie des processus

La commande pstree donne une bonne illustration de la hiérarchie des processus parents et fils.

Chaque processus possède un processus parent

Sauf le premier processus (systemd ou init,
PID=1)

Chapitre 1: Les processus 8

Hiérarchie des processus

Si un processus 1 lance un processus 2 :

❑ Processus 1 est appelé processus père
❑ Processus 2 est appelé processus fils.

Le Processus père fournit un environnement d'exécution aux processus fils qu’il

engendre :
❑ Ils héritent d’un certain nombre de ressources du processus père:
• Tables des fichiers ouverts.
• Identificateur de l’utilisateur du processus et de son groupe.
❑ La pile mémoire et le segment Données (variables du programme) sont dupliqués, le
segment code (instructions du programme) est partagé.

Chapitre 1: Les processus 9

Hiérarchie des processus

❑systemd (pid = 1) est le processus parent de tous es autres

▪ Il permet d'attribuer le nom de la machine, d'initialiser la date et l'heure et
de contrôler si le système a été bien arrêté.
▪ Il lance un processus de surveillance du réseau.
▪ Il lance tous les processus de démarrage de linux.
▪ Ne meurt qu’à l’arrêt du système.
❑Dans certaines distributions linux, notamment les anciennes versions, le
processus parent (pid = 1) s’appelle init

Chapitre 1: Les processus 10

Cycle de vie d’un processus

❑ Le cycle de vie d’un processus Linux passe par 4 états principaux :

Prêt (initial, transitoire) : le processus est nouvellement créé ou bien en interruption

(bascule CPU), il dispose de toutes les ressources nécessaires à son exécution à
l'exception du processeur
Actif (élu, en exécution) : le processus est en cours d'exécution
En attente (Bloqué) : le processus est suspendu, en attente qu’un événement
se produit ou bien une ressource pour pouvoir continuer
Terminé (zombie) : le processus a terminé son exécution, il attend la libération
de ses ressources (dispose toujours d'un PID)

Chapitre 1: Les processus 11

Cycle de vie d’un processus

Chapitre 1: Les processus 12

 Bloc de Contrôle de Processus (PCB)
Lorsqu’un processus est temporairement suspendu (Changement de contexte), l’OS doit être
capable de retrouver l’état du processus exactement au moment de sa suspension :
➔ Il faut que toutes les informations dont il a besoin soient sauvegardées pendant sa mise
en attente.

▪ Pour ce faire, Linux utilise une structure de donnée appelée Bloc de Contrôle de Processus (PCB)
Contenant toutes les informations sur un processus donnée (non détruit) :
▪ Etat du processus (prêt, suspendu, ..),
▪ quantité de mémoire,
▪ temps CPU (utilisé, restant),
▪ priorité, …

Le BCP est une structure de données qui permet au noyau de suivre l’état d’un processus. Il est
créé lors du lancement d’un processus et mis à jour tout au long de son cycle de vie (exécution,
suspension, terminaison)..

Chapitre 1: Les processus 13

Bloc de Contrôle de Processus (PCB)
Pour gérer les informations de tous les processus :

❑ Linux range les PCB de chaque processus dans une table appelée : Table des Processus
❑ La table se trouve dans la mémoire centrale du système

❑ Le PCB permet la sauvegarde et la restauration du contexte mémoire et du contexte

processeur lors des opérations de commutations d’état

Chapitre 1: Les processus 14

Classification des processus dans Linux

Classification des processus

Rôle du processus Mode d’exécution Relation entre processus

Processus Processus en
Parent-enfant
utilisateur avant plan

Processus Processus en
Orphelin
système arrière plan

Processus
démons Zombie
(Deamons)

Chapitre 1: Les processus 15

Classification des processus dans Linux
❑Classification selon le rôle du processus
▪ Processus utilisateur (User Process) : Processus lancés par un utilisateur à
partir d'un terminal ou d'une interface graphique. Ils s’exécutent généralement
avec les permissions de l'utilisateur qui les a démarrés.

▪ Processus système (System Process) : Processus gérés par le noyau Linux et

sont essentiels au fonctionnement du système d'exploitation. Ils incluent des
tâches comme la gestion de la mémoire, la planification des processus, ou la
gestion des périphériques. Ils fonctionnent souvent avec des privilèges élevés
(root).

▪ Démons (Daemons, for Disk And Execution MONitor): Processus système qui
fonctionnent en arrière-plan et fournissent des services spécifiques (par
exemple, un serveur web, un serveur SSH, ou un gestionnaire d'impression). Ils
sont généralement démarrés au boot du système et fonctionnent de manière
continue.
Chapitre 1: Les processus 16
Classification des processus dans Linux
❑Classification selon le rôle d’exécution
▪ Processus en avant-plan (Foreground Process): Processus directement lié à un
terminal et interagit avec l'utilisateur. Il occupe le terminal jusqu'à ce qu'il se
termine ou soit mis en pause.

o Par exemple, lorsque la commande ls est exécutée, elle s'exécute en

avant-plan.

▪ Processus en arrière-plan (Background Process) : Processus qui s'exécute

indépendamment du terminal, permettant à l'utilisateur de continuer à utiliser
le terminal pour d'autres tâches.

o Pour lancer un processus en arrière-plan, on ajoute & à la fin de la

commande

Chapitre 1: Les processus 17

Classification des processus dans Linux
❑Classification par relation entre processus
▪ Processus parent (Parent Process) : est celui qui crée un ou plusieurs processus
enfants en utilisant un appel système comme fork(). Le processus parent a
généralement la responsabilité de surveiller et de gérer ses processus enfants..

▪ Processus enfant (Child Process): Processus créé par un processus parent. Il

hérite de nombreuses propriétés de son parent, comme les variables
d'environnement et les descripteurs de fichiers.

▪ Processus orphelin (Orphan Process) : Processus enfant dont le processus

parent a terminé son exécution avant lui. Dans ce cas, le processus orphelin est
"adopté" par le processus init (ou systemd sur les systèmes modernes), qui
devient son nouveau parent. Cela garantit que le processus orphelin ne reste
pas bloqué et puisse terminer son exécution correctement..

Chapitre 1: Les processus 18

Création d’un processus

Il existe deux grandes approches pour créer un processus sous Linux :

1. Via le shell (exécution d'une commande)
❑ Lorsqu'on lance une commande (ls, sleep 300 &, etc.), le Shell crée un processus en arrière-plan.
▪ En interne, le Shell utilise les appels système:
o fork(), pour dupliquer le processus shell.
o exec(), pour remplacer l'image mémoire par le programme à exécuter.

Exemple: Quand vous exécuter la commande : ls -l

Le shell effectue en interne :
▪ fork() → duplique le processus shell.
▪ exec("ls") → remplace l'image mémoire du processus enfant par celle de ls.
▪ wait() → le shell attend la fin de l'exécution de ls avant de redonner la main (sinon, il devient un "zombie")

Chapitre 1: Les processus 19

Création d’un processus
2. Via la programmation système (en C par exemple)
❑ Un programme peut utiliser directement les appels système comme fork() pour créer un nouveau
processus.
▪ Souvent, fork() est suivi de exec() pour remplacer le code du processus enfant par un autre
programme.
Exemple

Chapitre 1: Les processus 20

Destruction d’un processus
❑ Un processus peut être arrêté de trois manière différentes:

▪ Arrêt normal : Le processus termine sans problème et demande à son père de nettoyer son état
(via wait()).
▪ Arrêt anormal : Une erreur imprévue survient (erreur système):
▪ mémoire demandée non disponible;
▪ temps d’exécution dépassé
▪ instruction invalide (division par 0 par exemple);
▪ fichier introuvable;
▪ etc..
▪ Arrêt par kill : Un processus est explicitement tué par un autre processus, généralement via l’envoi
d’un signal.

Chapitre 1: Les processus 21

Destruction d’un processus
Quand un processus se termine :

▪ Le noyau Linux conserve des informations sur lui (code de sortie, état…) jusqu’à ce que son parent
appelle wait() ou waitpid().
▪ Si le parent ne récupère pas l’état, l’enfant devient un zombie (Z dans ps aux).
▪ Si le parent meurt avant l’enfant, l’enfant devient orphelin et est adopté par init/systemd (PID 1).

❑ Processus Zombie :
▪ Un processus qui a terminé son exécution mais dont le parent n’a pas récupéré le statut (wait()
non appelé).
▪ Visible avec: ps aux | grep Z.
▪ Solution : forcer le parent à récupérer l’état de l’enfant avec wait().
Processus Orphelin :
▪ Un enfant dont le parent s'est terminé avant lui;
▪ Il est adopté par init/systemd (PID 1), qui s’occupera de sa terminaison
Chapitre 1: Les processus 22
Lister les processus
❑ La gestion des processus est un aspect fondamental des systèmes Unix/Linux.
❑ Il existe plusieurs commandes permettant d'afficher et d'analyser les processus en cours
d'exécution. Ces commandes offrent différentes perspectives selon les besoins :
▪ affichage basique,
▪ informations détaillées,
▪ filtrage avancé,
▪ surveillance en temps réel.
❑ Dans cette section, les commandes suivantes sont étudiées:
▪ ps
▪ pop
▪ jobs
▪ pgrep
▪ pidof

Chapitre 1: Les processus 23

Lister les processus
❑La commande ps : Process Status
▪ La commande ps permet d'obtenir la liste des processus qui tournent au moment où la commande
est lancée.
▪ Cette liste n'est pas actualisée en temps réel (contrairement à ce que fait top).

▪ PID : c'est le numéro d'identification du processus

▪ TTY : c'est le nom de la console depuis laquelle a été lancé le processus
▪ TIME : la durée d'exécution du processus (la durée pendant laquelle le processus a occupé le
processeur depuis son lancement.
▪ CMD : le programme qui a généré le processus?
Chapitre 1: Les processus 24
Lister les processus
❑ Quand on utilise ps sans argument :
▪ Seulement les processus lancés par le même utilisateur dans la même console
▪ Beaucoup de processus sont lancés par root et sur d’autres consoles
❑ La commande ps permet d'utiliser énormément d'options :
Options Fonctions
ps -a affiche les processus de tous les utilisateurs ayant une session active sur le système.
ps -u
affiche tous les processus d’un utilisateur.
username
active l'affichage en format long, qui fournit des informations supplémentaires comme le
ps -l
PID, le PPID, le PRI (priorité), le NICE et l'adresse mémoire du processus.
affiche les processus sous forme d'un arbre hiérarchique, en indiquant les relations
ps -f
parent-enfant entre les processus.
affiche tous les processus du système, même ceux qui ne sont pas associés à un terminal.
ps -e
C'est plus large que l'option a.

ps aux affiche tous les processus du système en détails (sans PPID, avec USERNAME)
Chapitre 1: Les processus 25
Lister les processus
❑Exemple

❑ S (statut) : l’état du processus au moment du lancement de la commande.

▪ R (Running) : le processus est en cours d’exécution.
▪ S (Sleeping) : le processus est actif et en attente d’être pris dans le processeur (prêt).
▪ T (Stopped/Traced) : le processus est stoppé (bloqué).
▪ Z (Zombie) : le processus est terminé en attente de libération de ressources (zombie).

Chapitre 1: Les processus 26

Lister les processus
❑La commande top (Surveillance en temps réel)
▪ La commande top est utilisée pour surveiller en temps réel l’utilisation du CPU et de la mémoire par
les processus.
▪ Par défaut, les processus sont triés par taux d'utilisation du processeur (colonne %CPU)
▪ Les processus tout en haut de la liste sont les plus gourmands en processeur!
▪ top ne peut pas afficher tous les processus à la fois, il ne conserve que les premiers pour qu'ils
tiennent sur une « page » de la console

On navigue à l'intérieur de top en appuyant sur certaines touches du clavier :

▪ q : ferme top.
▪ h : affiche l'aide, cad la liste des touches utilisables.
▪ s : change l'intervalle de temps entre chaque rafraîchissement de la liste (par défaut, c'est
toutes les 3 secondes).

Chapitre 1: Les processus 27

Lister les processus
❑La commande pgrep (Recherche de processus par nom)

▪ La commande pgrep permet d'afficher directement les PID des processus en fonction
de leur nom.
▪ Exemples:
o pgrep nginx
• renvoie les PID de tous les processus nginx.
o pgrep -u root,user1 sshd
• affiche seulement les PID des processus nommés sshd appartenant à root ou
à user1.
o ps -fp $(pgrep nginx)
• Afficher aussi les informations détaillées (ps combiné à pgrep)

Chapitre 1: Les processus 28

Lister les processus
❑La commande pidof

▪ Elle permet d’obtenir le PID d'un programme spécifique?

▪ Utile pour tuer un programme avec kill.
▪ Exemple:
▪ pidof firefox
▪ Renvoie le PID du processus firefox

❑La commande jobs

▪ Elle permet de lister les processus lancés en arrière plan (lacés avec &).
▪ Renvoie la liste des processus en arrière-plan associés à votre session.

Chapitre 1: Les processus 29

Arrêter un processus
Sous Linux, il existe plusieurs façons d'arrêter un processus, en fonction du
contexte et du niveau d'interruption souhaité:
1. Interruption avec le clavier (processus en avant-plan)
❑ Ctrl + C
▪ Envoie le signal SIGINT (Interruption) au processus en cours d'exécution dans le terminal.
▪ Typiquement utilisé pour arrêter un programme proprement.
❑ Ctrl + Z
▪ Met le processus en pause (signal SIGTSTP), mais ne le termine pas.
▪ Pour le reprendre :
o fg → Relance en avant-plan.
o bg → Relance en arrière-plan.

2. Utilisation de la commande kill (processus en arrière-plan ou spécifique)

La commande kill envoie des signaux aux processus en fonction de leur PID (Process ID).

Chapitre 1: Les processus 30

Arrêter un processus
❑ Commande kill :
Kill PID

❑ Par défaut, Kill envoie le signal SIGTERM (15) pour un arrêt propre du processus.
❑ Il faut récupérer le PID du processus à arrêter avant d’utiliser la commande kill, via :
▪ pidof nom_du_processus
▪ ps aux

❑ Forcer l'arrêt d'un processus

▪ Si SIGTERM ne suffit pas, on peut utiliser SIGKILL (9) pour forcer la fermeture :
o Kill – 9 PID
o Kill -SIGKILL PID

▪ Attention : SIGKILL ne permet pas au processus d'effectuer un nettoyage avant l'arrêt.

Chapitre 1: Les processus 31

Arrêter un processus
❑ Chaque processus peut recevoir des signaux
▪ Chaque signal a une signification particulière.
▪ Pour envoyer un signal on utilise la commande kill.
▪ kill -l : affiche tous les 64 signaux existants.

Nom du signal Numéro Description

SIGINT 2 touche Ctrl-C, termine le processus (dans la console)

SIGKILL 9 Arrêt brutal et immédiat du processus

Arrête le processus, mais permet d’effectuer des

SIGTERM 15
opérations avant l’arrêt (kill pid = kill -15 pid)

SIGCHLD 17 Informe le père de la mort de son fils

SIGCONT 18 Continue (in bg) executing, if stopped

SIGTSTP 20 Suspension temporaire d’un processus (ctrl-Z)

Chapitre 1: Les processus 32

Arrêter un processus
❑Utilisation de pkill et killall (basé sur le nom du processus)

▪ pkill : Arrêter un processus par son nom

▪ Exemple :
o c firefox # Ferme tous les processus Firefox
o pkill -9 firefox # Force la fermeture

❑ killall : Arrêter tous les processus portant un même nom

▪ Exemples:
o killall python
o killall -9 vlc

Chapitre 1: Les processus 33

Travaux Pratiques 1

Chapitre 1: Les processus 34

Exécuter un processus en arrière plan
❑ Pourquoi il est important dans certains cas de lancer des processus en
arrière-plan ? :
▪ Multitâche : Cela permet à l'utilisateur de continuer à utiliser le terminal pour
d'autres tâches pendant que le processus s'exécute en arrière-plan.
▪ Longues opérations : Pour les processus qui prennent beaucoup de temps
(comme des compilations, des téléchargements, ou des scripts longs), il est
pratique de les lancer en arrière-plan pour ne pas bloquer le terminal.
▪ Automatisation : Dans les scripts, il est souvent nécessaire de lancer des
processus en arrière-plan pour permettre l'exécution d'autres commandes en
parallèle.
▪ Services persistants : Certains services ou démons doivent tourner en arrière-
plan pour rester actifs en permanence, comme un serveur web ou une base de
données

Chapitre 1: Les processus 35

Exécuter un processus en arrière plan
❑ Comment exécuter un processus en arrière-plan ?
1. Utiliser le symbole & à la fin de la commande
▪ Exemple :

sleep 100 &

▪ Cette commande lance la commande sleep 100 en arrière-plan
➔ vous pouvez continuer à utiliser le terminal pendant que la commande s'exécute.

Deux informations sont renvoyées :

▪ [1] : c'est le numéro du processus en arrière-plan dans cette console.
Comme c'est le premier processus que nous envoyons en arrière-plan, il
prend le numéro 1.
▪ 388 : c'est le numéro d'identification général du processus (PID)
Chapitre 1: Les processus 36
Exécuter un processus en arrière plan
❑ Deux petits problèmes!!
1. Si le processus tourne en arrière-plan, il envoie toujours sa sortie sur le terminal.

Exemple!

Problème : Si le processus tourne en arrière-

plan, il envoie toujours sa sortie sur le
terminal.

Solution : Rediriger la sortie vers un fichier

Chapitre 1: Les processus 37

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

Solution : Rediriger la sortie vers un fichier

❑ Sous Linux, chaque programme génère trois flux standards :

▪ stdout (sortie standard) → Affiche les résultats normaux.
▪ stderr (sortie d'erreur standard) → Affiche les erreurs.
▪ stdin (entrée standard) → Utilisée pour l’entrée utilisateur (non concernée
ici).
❑ En redirigeant stdout et stderr, on empêche le processus en arrière-plan de
« polluer » le terminal.

Chapitre 1: Les processus 38

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

Solution : Rediriger la sortie vers un fichier

▪ Rediriger seulement la sortie normale (stdout):

Si on veut uniquement enregistrer les résultats de la commande sans afficher quoi que
ce soit dans le terminal :

Cette commande crée (ou écrase) resultats.txt et y stocke tout ce que find aurait
affiché normalement.

Chapitre 1: Les processus 39

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

Solution : Rediriger la sortie vers un fichier

▪ Rediriger seulement les erreurs (stderr)

Si on veut capturer les erreurs, par exemple : "Permission denied") :

2> signifie "rediriger stderr vers le fichier erreurs.txt".

Chapitre 1: Les processus 40

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

Solution : Rediriger la sortie vers un fichier

▪ Rediriger stdout et stderr ensemble:

Capturer les résultats ET les erreurs dans un même fichier

2>&1 signifie "rediriger stderr (2) vers le même fichier que stdout (1)".

▪ Autre option plus moderne (compatible avec Bash 4+)

Chapitre 1: Les processus 41

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

Résumé des options de redirection utiles

Commande Explication
cmd > fichier.txt & Rediriger stdout vers un fichier
cmd 2> erreurs.txt & Rediriger stderr vers un fichier
cmd > sortie.txt 2>&1 & Rediriger stdout et stderr dans un même fichier
cmd &> sortie.txt & Même chose que la ligne précédente (plus simple)
cmd > /dev/null 2>&1 & Exécuter sans afficher aucun résultat (mode "silencieux")

Chapitre 1: Les processus 42

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

2. Le processus est « attaché » à la console

▪ Si la console est fermée ou l'utilisateur se déconnecte le processus sera automatiquement
arrêté
Solution : Détacher la commande de la console

▪ Utiliser nohup : nohup (No Hang Up) permet d'exécuter un programme qui continue
même après la fermeture du terminal :

La sortie de la commande est par défaut redirigée vers un fichier nohup.out

▪ Aucun message ne risque donc d'apparaître dans la console.
▪ La commande continuera de fonctionner quoi qu'il arrive (sauf si on lui envoie un kill).
▪ nohup est très utile par exemple si se connecte à un serveur, et on veut lancer une
commande et se déconnecter (sans arrêter l’exécution de la commande).

Chapitre 1: Les processus 43

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!

Exemple :

elhaji@DESKTOP-TS4QND1:/mnt/c/Users/HP$ nohup wget http://example.com/largefile.iso > log.txt 2>&1 &

Chapitre 1: Les processus 44

Exécuter un processus en arrière plan
❑ Deux petits problèmes!!
❑ Utiliser disown
▪ Si un processus est déjà en arrière-plan mais attaché au terminal, vous pouvez l’en
détacher avec disown :

disown -h %1
▪ disown : Retire un processus de la liste des tâches gérées par le shell (il ne sera plus affecté par une
déconnexion).
▪ -h (hold) : Marque le processus comme "gardé" dans la table des tâches, ce qui signifie que le shell ne
l'oubliera pas complètement.
▪ %1 : Référence le numéro du job (donné par la commande jobs)

Chapitre 1: Les processus 45

Passer un processus en arrière plan

Pour des raisons différentes, on peut dans un certain cas préférer passer un
processus qui s’exécute en avant plan à l’arrière plan. Pour ce faire, on exécute
les commandes suivantes:
▪ Ctrl +Z : pour mettre en pause le programme et récupérer l'invite de
commandes
▪ bg : pour que le processus continue à tourner mais en arrière-plan

Chapitre 1: Les processus 46

Identifier les processus qui tournent en arrière plan

Pour lister uniquement les processus qui tournent en fond au sein d'une
même console, on utilise la commande
▪ jobs –l : pour voir les processus en arrière-plan de la session actuelle :

Chapitre 1: Les processus 47

Ramener un processus au avant plan

❑ La commande fg (foreground) renvoie un processus au premier plan.

elhaji@ubuntu:~$ fg
❑ Si vous avez un seul processus listé dans les jobs, c'est ce processus qui sera
remis au premier plan.

❑ Si, en revanche, vous avez plusieurs processus en arrière-plan

▪ il faudra préciser lequel vous voulez récupérer

elhaji@ubuntu:~$ fg %2

Chapitre 1: Les processus 48

Redémarrer un processus suspendu

❑ Si un processus a été suspendu avec Ctrl + Z, mais que vous voulez le

relancer :
▪ En avant-plan

fg

▪ En arrière-plan

bg

Chapitre 1: Les processus 49

Redémarrer un processus suspendu

Chapitre 1: Les processus 50

Exécution planifiée des processus

❑ L’exécution planifiée permet d’exécuter automatiquement des tâches à des

moments précis, que ce soit une seule fois ou de manière récurrente.
❑ Cela est particulièrement utile pour
▪ automatiser les sauvegardes,
▪ mises à jour,
▪ nettoyages,
▪ etc.

Chapitre 1: Les processus 51

Exécution planifiée des processus

❑ Exécution unique d’un processus à une heure donnée avec at:

❑ at permet d’exécuter une tâche une seule fois à un moment futur.
1. Lancer at avec l'heure souhaitée : at heure

2. Entrer la commande à exécuter :

3. Terminer avec Ctrl+D

Chapitre 1: Les processus 52
Exécution planifiée des processus

❑ Autre exemple : echo "sh script.sh" | at now + 5 minutes

▪ Lister les tâches planifiées : atq

▪ Supprimer une tâche planifiée : atrm num_tâche

▪ Autre exemple : echo "sh /chemin/vers/script.sh" | at 9:00 tomorrow

Chapitre 1: Les processus 53

Lancer un processus régulièrement
❑ La « crontab » constitue un incontournable sous Linux : cet outil permet de
programmer l'exécution régulière d'un programme.

❑Contrairement à at qui n'exécutera le programme qu'une seule fois, crontab

permet de faire en sorte que l'exécution soit répétée : toutes les heures,
toutes les minutes, tous les jours, tous les trois jours, etc.

❑ crontab est en fait une commande qui permet de lire et de modifier un

fichier appelé la « crontab ».

▪ Ce fichier contient la liste des programmes qu’on souhaite exécuter

régulièrement.
❑ Alors que le programme cron se charge d'exécuter les programmes de
crontab aux heures demandées.
Chapitre 1: Les processus 54
Lancer un processus régulièrement
❑ La « crontab » constitue un incontournable sous Linux : cet outil permet de
programmer l'exécution régulière d'un programme.

❑Contrairement à at qui n'exécutera le programme qu'une seule fois, crontab

permet de faire en sorte que l'exécution soit répétée : toutes les heures,
toutes les minutes, tous les jours, tous les trois jours, etc.

❑ crontab est en fait une commande qui permet de lire et de modifier un

fichier appelé la « crontab ».

▪ Ce fichier contient la liste des programmes qu’on souhaite exécuter

régulièrement.
❑ Alors que le programme cron se charge d'exécuter les programmes de
crontab aux heures demandées.
Chapitre 1: Les processus 55
Lancer un processus régulièrement
❑ crontab est un outil puissant sous Linux pour planifier l'exécution
automatique et répétée de commandes ou de scripts.
❑ Il est couramment utilisé pour automatiser des tâches telles que des
sauvegardes, des nettoyages de fichiers, ou des rapports périodiques.
❑ Chaque ligne d'un fichier crontab suit ce format :

Chaque champ est séparé par un espace.

Chaque champs peut être remplacé soit

par un nombre de l’intervalle équivalent,
soit par une étoile qui signifie « tous les
nombres de l’intervalle sont valables »

Chapitre 1: Les processus 56

Lancer un processus régulièrement

B. Exemples de planification

▪ Tous les jours à minuit :

▪ 0 0 * * * /chemin/vers/script.sh
▪ Toutes les 5 minutes :
▪ */5 * * * * /chemin/vers/ script.sh

▪ Chaque lundi à 8h :
▪ 0 8 * * 1 /chemin/vers/tache.sh
▪ Le 1er janvier à minuit :
▪ 0 0 1 1 * /chemin/vers/script.sh

Chapitre 1: Les processus 57

Lancer un processus régulièrement

C. Gestion des crontabs

▪ Éditer le crontab :
crontab -e
▪ Lister les tâches planifiées :
crontab -l

▪ Supprimer toutes les tâches : :

Crontab -r
▪ Charger un fichier crontab :
Crontab nom_fichier_crontab.txt

Chapitre 1: Les processus 58

Lancer un processus régulièrement

Chapitre 1: Les processus 59

Lancer un processus régulièrement

Chapitre 1: Les processus 60

Regroupement des processus
❑ Enchaînement de commandes sous Linux:
▪ Pour exécuter plusieurs commandes successivement, il est possible de les séparer par
des points-virgules ;
▪ Par exemple :elhaji@ubuntu:~$ touch fichier.txt ; rm fichier.txt
▪ Dans cet exemple, la commande touch est exécutée en premier pour créer un fichier
nommé fichier.txt.
▪ Une fois cette commande terminée, la commande rm s'exécute immédiatement après,
supprimant ainsi le fichier créé.
❑ Ajouter une pause entre les commandes
▪ Dans certains cas, il peut être nécessaire d'insérer une pause entre deux commandes.
▪ C'est là qu'intervient la commande sleep, qui permet de suspendre l'exécution
pendant un certain laps de temps.
▪ Par exemple : elhaji@ubuntu:~$ touch fichier.txt ; sleep 5 ; rm fichier.txt
▪ Ainsi, le fichier sera créé, puis supprimé après une attente de 5 secondes.
Chapitre 1: Les processus 61
Regroupement des processus
❑ Exécution conditionnelle en cas de réussite avec &&:
❑ Il est possible d'exécuter des commandes sous condition de réussite en utilisant
l'opérateur &&.
❑ Contrairement au point-virgule ;, qui exécute toutes les commandes indépendamment
de leur succès, && garantit que chaque commande n'est exécutée que si la précédente
s'est terminée avec succès.
❑ La syntaxe est la suivante :
cmd1 && cmd2 && cmd3 && ... && cmdN
▪ Si cmd1 s'exécute correctement, alors cmd2 sera lancée, et ainsi de suite.
▪ Si cmd1 échoue, aucune des commandes suivantes ne sera exécutée.
▪ Exemple : elhaji@ubuntu:~$ cat file.txt && echo "Fichier bien affiché !«
▪ Dans cet exemple :Si file.txt existe et est lisible, son contenu est affiché, puis
echo affiche le message "Fichier bien affiché !".
▪ Si file.txt n'existe pas ou ne peut être lu, echo ne sera pas exécuté.

Chapitre 1: Les processus 62

Regroupement des processus
❑ Exécution conditionnelle en cas d'erreur avec || :
❑ L'opérateur || permet d'exécuter une commande uniquement si la précédente échoue.
❑ Cela est utile pour définir un comportement de repli ou afficher un message d'erreur si
une commande ne s'exécute pas correctement.
❑ La syntaxe est la suivante :
cmd1 || cmd2 || cmd3 || ... || cmdN
❑ Si cmd1 échoue, alors cmd2 est exécutée, et ainsi de suite.
❑ Si cmd1 s'exécute correctement, les autres commandes ne seront pas exécutées.
Exemple :
elhaji@ubuntu:~$ cat file.txt 2> /dev/null || echo "Fichier non existant«
Dans cet exemple :
▪ Si file.txt existe et est lisible, son contenu est affiché et echo ne sera pas exécutée.
▪ Si file.txt n'existe pas ou ne peut être lu, l'erreur est redirigée vers /dev/null (donc non
affichée), et echo affiche "Fichier non existant".

Chapitre 1: Les processus 63

Gestion des services
❑La gestion des services sous Linux repose sur des systèmes d'initiation et de
supervision des processus, tel que Systemd,
❑La connaissance de ces outils est essentielle pour administrer un serveur Linux
et assurer la disponibilité des services critiques.
❑Utilisation de Systemd
▪ Systemd est le système d'init le plus répandu sur les distributions modernes
(Ubuntu, Debian, CentOS, Fedora, etc.).
▪ Il repose sur des unités décrites par des fichiers de configuration situés dans
o /etc/systemd/system/
o /usr/lib/systemd/system/

Chapitre 1: Les processus 64

Gestions des processus
❑Commandes essentielles avec Systemd:
Commande description
systemctl list-units --type=service Lister tous les services actifs
systemctl status <nom_du_service> Vérifier l’état d’un service
systemctl start <nom_du_service> Démarrer un service
systemctl stop <nom_du_service> Arrêter un service

systemctl restart <nom_du_service> Redémarrer un service

systemctl reload <nom_du_service> systemctl reload <nom_du_service>

systemctl enable <nom_du_service> Activer un service au démarrage
systemctl disable <nom_du_service> Désactiver un service au démarrage

systemctl mask <nom_du_service> Masquer un service pour empêcher son exécution

systemctl unmask <nom_du_service> Démasquer un service

Chapitre 1: Les processus 65
Gestions des processus
❑Création d’un service personnalisé avec Systemd
Étapes de création d’un service personnalisé
1. Créer un script exécuté par le service sudo nano /usr/local/bin/monservice.sh

Rendre le script exécutable :

chmod +x /usr/local/bin/mon_service.sh

2. Créer un fichier de service Systemd sudo nano /etc/systemd/system/mon_service.service

3. Recharger Systemd et activer le service

• sudo systemctl daemon-reload
• sudo systemctl enable mon_service
• sudo systemctl start mon_service
Chapitre 1: Les processus 66
Gestions des processus
❑ Vérifier le fonctionnement du service:
sudo systemctl status mon_service

❑ Arrêter et désactiver le service:

▪ Arrêter le service : sudo systemctl stop mon_service
▪ Désactiver le service au démarrage : sudo systemctl disable mon_service
▪ Supprimer le fichier de service :
o sudo rm /etc/systemd/system/mon_service.service
o sudo systemctl daemon-reload
Chapitre 1: Les processus 67
Gestions des processus

TP - guidé

Chapitre 1: Les processus 68