Cours Processus en PDF (Intermédiaire)

Tutoriel programmation système concis et ciblé : ce support PDF de 17 pages explique les mécanismes essentiels des processus sous Linux — appels système, ordonnancement, et gestion de la mémoire — pour un usage pédagogique et opérationnel en BTS/LP ou en développement système.

Programmation Système : les processus — points essentiels.

  • Processus : exécution dynamique d'une image mémoire regroupant code, zones de données, stack et heap, identifié par un PID géré par le noyau.
  • Connaissances clés : multiprogrammation, commutation de contexte (Process Control Block), et appels systèmes fork, exec, wait, kill, nice.
  • Objectif : comprendre l'ordonnancement, la gestion des ressources et les interactions père/fils en environnement Unix/Linux.
  • Usage pédagogique : fiche synthétique avec définitions et exemples pratiques pour l'apprentissage et le diagnostic système.

Objectifs pédagogiques

  • Notions de base : distinguer programme (statique), image et processus (dynamique). Expliquer l'illusion de simultanéité créée par la multiprogrammation et le rôle du swapping pour déplacer des images entre mémoire centrale et secondaire.
  • Contexte de processus (PCB) : comprendre les éléments sauvegardés/restaurés lors d'une commutation de contexte et pourquoi les threads sont des processus légers. Le Process Control Block (PCB) stocke l'état d'exécution (registres, compteur ordinal), les pointeurs de pile, les tables de pages et les descripteurs de fichiers ; il permet au noyau de sauvegarder et restaurer l'environnement d'un processus lors de la commutation de contexte.
  • Création et exécution : savoir décrire les effets de fork (duplication) et des variantes de exec (execl, execv, etc.) sur l'image mémoire et les descripteurs hérités.
  • Attributs et identité : rôle de PID, PPID, UID, EUID, GID, EGID pour la gestion des droits et des relations père-fils (ex. rôle d'init PID 1).
  • États et ordonnanceur : cartographier états (exécuté, prêt, bloqué), comprendre la préemption et l'impact des politiques d'ordonnancement et des priorités (nice).
  • Processus vs Threads : comprendre la notion de processus léger et le partage de mémoire.

📑 Sommaire du document

Concepts clés abordés

Principaux repères et notions présentes dans le support pour orienter l'étude et la pratique : la Table des processus comme index central du noyau, les segments mémoire détaillant code, données, pile et tas, et les mécanismes d'initialisation illustrés par le processus 0. D'autres éléments traités incluent les structures du PCB, les politiques d'ordonnancement et les primitives de synchronisation utilisées en programmation système.

  • Table des processus
  • Segments mémoire (code, données, pile)
  • Processus 0 et initialisation

Structure mémoire et table des processus

Un processus possède plusieurs segments mémoire distincts : le segment code (instructions), le segment données (variables globales), la pile (stack) pour les appels et variables locales, et le tas (heap) pour l'allocation dynamique. Ces segments déterminent la mise en place des tables de pages et les protections mémoire. La table des processus, gérée par le noyau, contient les entrées associées à chaque PID : pointeurs vers le PCB, informations d'ordonnancement, descripteurs de fichiers, et références aux tables de pages. Dans un tutoriel programmation système orienté C, comprendre cette structure facilite l'analyse des effets de fork et exec, la gestion des partages de mémoire et le diagnostic des problèmes liés aux segments mémoire et à la cohérence des données.

Pourquoi choisir ce cours ?

Fiche signée Thierry VAIRA — enseignant, La Salle Avignon (BTS IRIS). Contenu synthétique et technique centré sur le cycle de vie des processus en environnement Unix/Linux : définitions, comparaisons API (WIN32 vs UNIX) et repères opérationnels (commandes et primitives) utiles pour concevoir ou diagnostiquer du code système. Le cours s'appuie sur une approche pratique adaptée aux étudiants de BTS/LP et aux développeurs systèmes souhaitant un support de référence.

À qui s'adresse ce cours ?

  • Public cible : étudiants en BTS/LP et développeurs systèmes débutants en environnement Unix/Linux souhaitant maîtriser la gestion des processus et les appels système.
  • Prérequis : bases de programmation (langage C recommandé), familiarité avec la ligne de commande Unix/Linux et notions d'architecture mémoire (pile/tas).

Foire Aux Questions (FAQ)

Que copie exactement fork lors de la création d'un processus fils ? Le noyau crée un nouveau processus avec une image initiale reprenant le code, les données et la pile du père ; les fichiers ouverts sont hérités et un nouveau PID est assigné.

Comment la primitive wait résout-elle la synchronisation des terminaisons ? wait suspend le processus appelant jusqu'à la terminaison d'un fils, permettant de récupérer son statut de sortie et de libérer proprement les ressources associées.

Exemples pratiques de programmation système

Extraits et notions à garder pour la programmation système C et l'analyse de comportements : exemples d'utilisation de l'appel système fork, gestion des processus sous Linux et interactions avec l'ordonnanceur.

  • Champs critiques d'une entrée Table des processus (PCB) :
    • PID, PPID — identifiants du processus et de son parent;
    • État du processus (exécuté, prêt, bloqué);
    • Registres CPU et compteur ordinal (program counter);
    • Pile utilisateur / pile noyau et pointeurs de pile;
    • Descripteurs de fichiers ouverts (tableaux de pointeurs);
    • Informations mémoire : tables de pages, limites d'adresses;
    • Informations d'ordonnancement : priorité, valeur nice;
    • Identifiants de sécurité : UID, EUID, GID, EGID;
    • Gestion des signaux et handlers;
    • Comptabilité CPU et statistiques d'exécution.
  • Termes intégrés naturellement : programmation système C, appel système fork, gestion des processus Linux, ordonnanceur.

Exemple pratique : Création de processus avec fork() et wait()


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(void) {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return EXIT_FAILURE;
    } else if (pid == 0) {
        /* Processus fils */
        printf("Fils: PID=%d, PPID=%d\n", getpid(), getppid());
        /* Exemple: remplacer l'image par un autre binaire (commentaire) */
        /* execlp("ls", "ls", "-l", (char *)NULL); */
        _exit(0);
    } else {
        /* Processus parent */
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {
            printf("Parent: fils %d terminé, code=%d\n", pid, WEXITSTATUS(status));
        }
    }
    return EXIT_SUCCESS;
}

Différences entre processus et threads

Processus et threads diffèrent par leur isolation et leur gestion des ressources : un processus possède son espace d'adressage propre, tandis que les threads d'un même processus partagent la mémoire et les descripteurs, ce qui réduit le coût de création et de communication. Le partage de données facilite la conception d'applications concurrentes mais impose des mécanismes de synchronisation (mutex, sémaphores) pour éviter les conditions de concurrence. Pour aller plus loin, consultez le Cours Référence Debian en PDF pour approfondir vos connaissances système.