Cours Processus en PDF (Intermédiaire)

Programmation Système : les processus — éléments essentiels. Un processus correspond à l'exécution d'une image mémoire d'un programme : code exécutable, segments de données, pile (stack) et tas (heap). Il est identifié par un PID, suivi via la table des processus et le Process Control Block (PCB). La maîtrise des appels système POSIX (fork, exec, wait), des états de processus et des politiques d'ordonnancement est cruciale pour le développement et le diagnostic sous Unix/Linux ; ce PDF de 17 pages rassemble ces notions pour une révision ciblée ou un support de cours.

🎯 Ce que vous allez apprendre

• Multiprogrammation et swapping — définitions techniques et conséquences sur la gestion mémoire et le découpage temporel du processeur ; impact sur performance et concurrence.
• Structure d'un processus et PCB — composants d'un processus (code, données, stack, heap) et éléments du contexte d'exécution (registres, compteur ordinal, piles user/system) ; mécanisme de changement de contexte côté noyau.
• Création et remplacement d'image : fork et exec — comportement de fork et rôle des variantes de exec pour remplacer une image mémoire ; héritage des descripteurs de fichiers.
• Attributs et identité — PID, PPID, UID, EUID, GID, EGID : usage pour contrôle d'accès et traçabilité, et interprétation dans ps et top.
• Synchronisation et ordonnancement — usage de wait, gestion des signaux (kill, Ctrl+C), suspension/résumé (Ctrl+Z, fg/bg) et modification de priorité avec nice. Le document précise les risques de processus zombies et orphelins, leurs causes et les stratégies de collecte via wait ou handlers de signaux.

Cycle de vie et états d'un processus Linux

Le cycle de vie d'un processus décrit ses transitions entre états gérés par le noyau et l'ordonnanceur. Après création (souvent via fork), un processus entre en état prêt, puis peut être choisi par l'ordonnanceur pour l'état d'exécution. Des événements matériels ou logiciels (I/O, attente de sémaphore) le placent en état bloqué ; au retour de l'événement il redevient prêt. À la terminaison, l'entrée reste brièvement sous forme de zombie jusqu'à ce que le parent récupère le statut. Ces transitions sont au cœur des notions d'ordonnancement préemptif, de changement de contexte et de gestion de l'espace d'adressage.

Les différents états d'un processus

• Nouveau
• Prêt (Ready)
• Élu (Running)
• Bloqué (Blocked)
• Terminé (Zombie / Exit)

Exemple pratique de programmation système en C

Un exemple minimal illustre la création d'un fils, l'exécution d'un nouveau programme dans ce fils et la synchronisation côté parent. Le code ci‑dessous montre l'usage de fork, d'un exec simple et de waitpid pour éviter les zombies. Cet extrait est conçu pour être compilé et testé sur une machine Linux avec les outils standards.

Exemple de code C : fork()

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

int main(void) {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    }
    if (pid == 0) {
        /* processus fils */
        printf("Fils PID=%d\n", getpid());
        execlp("ls", "ls", "-l", (char *)NULL);
        _exit(127); /* si exec échoue */
    } else {
        /* processus père */
        int status;
        if (waitpid(pid, &status, 0) < 0) {
            perror("waitpid");
            return 1;
        }
        if (WIFEXITED(status)) {
            printf("Fils terminé, code=%d\n", WEXITSTATUS(status));
        }
    }
    return 0;
}

📑 Sommaire du document

Remarque sur les exercices pratiques : la présence et le format des exercices corrigés ne sont pas explicités dans ce résumé ; consultez le PDF pour vérifier si des corrigés sont fournis ou si seuls des exercices d'application sont proposés.

💡 Pourquoi choisir ce cours ?

Document concis (17 pages) rédigé par Thierry VAIRA et utilisé dans le cadre pédagogique LT La Salle Avignon – BTS IRIS. Approche pragmatique : contraste API Win32 / appels système Unix, rappel des primitives POSIX (fork, exec, wait) et diagramme d'états pour visualiser la préemption et l'ordonnancement. Le support met l'accent sur l'attributs des processus et les commandes système utiles pour le diagnostic.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en BTS/LICENCE technique, développeurs systèmes ou administrateurs débutants souhaitant consolider les concepts fondamentaux de gestion des processus sous Unix/Linux.
• Prérequis : connaissances de base en programmation (notamment en C et appels système), familiarité avec la ligne de commande Unix (ps, top, shell) et notions élémentaires de systèmes d'exploitation (fichiers, permissions, processus).

❓ Foire Aux Questions (FAQ)

Quelle est la différence fonctionnelle entre fork() et exec() ?

fork() crée un nouveau processus fils en dupliquant l'image mémoire du parent (code, données, piles). Après fork, deux processus distincts continuent l'exécution. exec (famille d'appels execl, execv, etc.) remplace l'image mémoire du processus courant par un nouveau programme : le PID reste le même mais l'espace d'adressage change.

Comment wait() évite-t-il les problèmes de synchronisation entre parent et fils ?

wait() suspend le processus appelant jusqu'à la terminaison d'un de ses fils et permet de récupérer son statut de sortie, évitant ainsi l'accumulation de processus zombies. Associé à des handlers de signaux ou à waitpid, il facilite la coordination des terminaisons et la gestion correcte des PID/PPID.