Public cible
Débutants, étudiants et professionnels qui souhaitent acquérir une pratique structurée dans ce domaine.
Relier les notions de processus, mémoire, fichiers et appels système à un programme C observé et testé.
Débutants, étudiants et professionnels qui souhaitent acquérir une pratique structurée dans ce domaine.
Comprendre les notions essentielles et les appliquer dans un projet vérifiable.
Aucune connaissance préalable n’est strictement obligatoire ; les prérequis détaillés sont précisés dans les ateliers.
Tous niveaux
La validation repose sur les évaluations actives et les livrables pratiques du cours.
Un ordinateur, un navigateur et les outils indiqués dans le premier atelier sont suffisants pour commencer.
Manipuler processus, mémoire et fichiers avec un programme C.
Obligatoire ConsulterÉvaluer les notions de processus, mémoire, fichiers et appels système.
Obligatoire ConsulterRéaliser un programme système robuste et documenté.
Livrables :
Manipuler processus, mémoire et fichiers avec un programme C.
Obligatoire ConsulterÉvaluer les notions de processus, mémoire, fichiers et appels système.
Obligatoire ConsulterRéaliser un programme système robuste et documenté.
Livrables :
Comprendre ce qu’un système d’exploitation fait pour un programme — noyau, processus, mémoire, fichiers, périphériques, journaux et réseau — puis relier chaque constat à la commande qui le prouve.
Le cours va du noyau vers l’observation : modes et appels système, processus, threads, mémoire, fichiers, périphériques, journaux, réseau, durcissement, puis méthode d’observation.
Prérequis : Bases de programmation C et de ligne de commande.
Le noyau est la seule partie du système qui parle directement au matériel : processeur, mémoire, disques, interfaces réseau. Il décide quel programme reçoit le processeur, à qui appartient une page mémoire, quel processus ouvre quel fichier. Tout ce qui vit au-dessus — interpréteur de commandes, applications, services — demande l’autorisation au lieu d’agir.
Deux modes d’exécution structurent cette séparation. En mode utilisateur, le code applicatif s’exécute sans accès direct au matériel : écrire dans la mémoire d’un autre programme ou piloter un disque déclenche une interception et l’arrêt du programme. En mode noyau, le code privilégié du noyau fait ce que l’application ne peut pas faire elle-même. C’est cette barrière qui empêche un programme défectueux de faire tomber la machine entière.
L’appel système est la porte entre les deux modes : le processus dépose un numéro d’appel et ses arguments, le processeur bascule en mode noyau, le noyau réalise l’opération pour le compte du processus puis rend la main avec un code de retour. Les fonctions open, read, write, fork, mmap ou socket franchissent cette porte ; printf ne la franchit pas, c’est une fonction de bibliothèque qui finira par demander un write.
La bascule n’est pas gratuite. Une boucle qui lit un octet à la fois paie deux changements de mode par octet, là où une lecture par bloc les amortit : un programme lent n’est donc pas toujours un programme qui calcule mal, c’est parfois un programme qui sollicite le noyau trop souvent.
| Appel système | Ce qu’il demande au noyau | Code d’erreur de retour fréquent |
|---|---|---|
| open | Ouvrir un fichier et obtenir un descripteur. | EACCES : droits insuffisants. ENOENT : chemin absent. |
| fork | Dupliquer le processus courant en un processus fils. | EAGAIN : limite de processus ou de mémoire atteinte. |
| read et write | Lire ou écrire des octets sur un descripteur. | EBADF : descripteur fermé. EINTR : appel interrompu par un signal. |
| mmap | Projeter un fichier ou une zone en mémoire. | ENOMEM : plus d’espace adressable disponible. |
| socket | Créer un point de communication réseau. | EMFILE : trop de descripteurs ouverts par le processus. |
Un programme qui échoue sans message utile se lit dans l’appel système fautif : l’outil de trace montre l’appel, ses arguments et le code de retour. Sans cette trace on devine, avec elle on sait — et la cause peut être citée dans un compte rendu.
Un processus est un programme en cours d’exécution, avec son espace d’adressage, ses descripteurs de fichiers, ses droits et son identifiant. Le noyau l’ordonnance : il lui donne le processeur, le lui retire, puis le lui rend, de sorte que plusieurs programmes semblent progresser en même temps.
Son cycle de vie comporte quatre moments. La création charge l’image du programme ou duplique le processus père. L’exécution alterne entre prêt et élu, selon la décision de l’ordonnanceur. L’attente endort le processus jusqu’à ce qu’une ressource soit disponible : lecture disque, réponse réseau, temporisation. La terminaison ferme les descripteurs et libère la mémoire, mais laisse un enregistrement zombie jusqu’à ce que le père lise le code de retour.
Deux situations reviennent souvent. Un processus qui occupe le processeur sans jamais le rendre affame tous les autres et fait grimper la charge ; un processus qui dort sur une ressource bloquée entraîne toute une chaîne derrière lui sans consommer de processeur. Un fils jamais attendu reste zombie, un fils orphelin est recueilli par le processus d’initialisation du système.
Les commandes de supervision répondent à deux questions différentes. ps donne une photographie datée : identifiant, état, temps consommé, ligne de commande. top montre le même tableau en évolution et permet de le trier par consommation. La première prouve un instant, la seconde une tendance ; aucune des deux ne donne la cause.
# Photographie : qui consomme, dans quel etat, depuis quand ?
ps aux --sort=-%cpu | head -n 15
ps -eo pid,ppid,stat,etime,time,comm --sort=-time | head -n 15
# Suivi continu, trie par processeur puis par memoire
top
# Un processus precis : etat, nombre de threads, memoire, commande
ps -o pid,ppid,stat,nlwp,rss,etime,cmd -p 1234
| État | Signification | Ce que l’intervenant en déduit |
|---|---|---|
| R ou S | En cours, ou en veille simple en attente d’un événement. | Un R permanent sur un service métier annonce une boucle sans issue. |
| D | Attente d’entrée-sortie non interruptible. | Suspicion immédiate sur le stockage ou un montage réseau bloqué. |
| Z | Terminé, mais le père n’a pas encore lu le code de retour. | Défaut de collecte dans le programme père, pas une fuite de mémoire. |
| T | Suspendu par un signal, en attente de reprise. | Intervention manuelle ou supervision : confirmer avant de le supprimer. |
| I | Thread du noyau en veille. | Normal en nombre limité ; une hausse brutale signale un module en défaut. |
Un processus à l’état D ne peut pas être réveillé : le supprimer ne libère pas toujours la ressource qu’il attend, et le redémarrage devient la seule sortie. C’est le seul état où le redémarrage se discute en premier, et il se documente comme tel.
Un thread est un fil d’exécution à l’intérieur d’un processus. Les threads d’un même processus partagent le même espace d’adressage : variables globales, allocations du tas, descripteurs de fichiers ouverts, bibliothèques chargées. Chaque thread possède en propre sa pile d’appels, ses registres et son compteur d’instruction.
Le partage est à la fois l’intérêt et le danger. Deux threads qui modifient la même variable sans coordination produisent une condition de course : le résultat dépend de l’ordre d’exécution, donc du hasard, et le défaut n’apparaît souvent qu’en charge. Un mécanisme de synchronisation rétablit un ordre ; l’oublier à la libération produit un interblocage, où deux threads s’attendent mutuellement et ne progressent plus.
Quatre règles évitent la majorité des cas : une seule ressource protégée par un seul verrou, un verrou pris et relâché dans la même fonction, jamais d’appel bloquant ou d’attente longue sous verrou, et un ordre de prise des verrous identique dans tout le programme. La dernière est celle qui supprime les interblocages circulaires.
Côté observation, un thread bloqué sur un verrou ne consomme pas de processeur : il est invisible dans un tableau trié par consommation. Il faut regarder les threads eux-mêmes, leur état et leur pile d’appels, puis la ressource qu’ils attendent.
# Les threads d un processus : etat et consommation
ps -T -p 1234
top -H -p 1234
# Un thread bloque : attente et pile d appels
pidstat -w -t -p 1234 1
| Ressource | Partagée entre threads ? | Conséquence |
|---|---|---|
| Variables globales et allocations du tas | Oui | Condition de course : à protéger par un verrou. |
| Pile d’appels, registres, compteur d’instruction | Non | Chaque thread exécute ses propres fonctions sans conflit. |
| Descripteurs de fichiers | Oui, table commune | Un octet lu par un thread est perdu pour l’autre : la position est partagée. |
| Signaux reçus par le processus | Oui | Un signal destiné au processus réveille un thread quelconque. |
| Nom, affinité et priorité | Non | Réglables par thread : utile pour repérer le thread fautif. |
Un interblocage ne se répare pas à chaud, il se prévient. Un verrou pris avec un délai maximal, une seule ressource protégée à la fois et un ordre de prise fixé à l’écriture du code suffisent à éliminer la plupart des cas rencontrés en pratique.
Chaque processus dispose d’un espace d’adressage virtuel que le noyau fait correspondre à la mémoire physique par pages. Le programme voit des adresses continues ; dessous, les pages sont en mémoire physique, absentes et rangées dans le fichier d’échange, ou partagées avec un autre processus. Une pagination légère est normale ; une pagination continue est un symptôme.
La pile croît vers le bas au fil des appels et porte les variables locales, les adresses de retour et le contexte d’appel. Le tas croît vers le haut et porte ce qui est alloué dynamiquement et doit survivre à la fonction qui l’a demandé. Retourner l’adresse d’une variable locale consiste donc à rendre une zone déjà réutilisable : la panne survient plus tard, loin de la cause, et devient difficile à reproduire.
Quand la mémoire physique manque, le noyau déplace des pages vers le fichier d’échange. La machine reste disponible mais tout ralentit, car chaque accès à une page sortie coûte une entrée-sortie. Un effondrement des performances sans saturation du processeur est presque toujours un problème de mémoire et non de calcul : le premier réflexe est de regarder l’usage du fichier d’échange.
Une erreur d’allocation se lit dans l’ordre : tester la valeur retournée avant de l’utiliser, consulter le code d’erreur associé, puis mesurer la mémoire disponible et la limite appliquée au processus. Une allocation qui échoue alors que la machine a encore de la mémoire libre désigne une limite de ressources ou une fragmentation, pas un manque global.
# Memoire disponible, utilisee, et usage du fichier d echange
free -h
vmstat 1 5
# Detail par processus : memoire residente et virtuelle
ps -eo pid,comm,rss,vsz --sort=-rss | head -n 15
# Limites appliquees a un processus
ulimit -a
| Zone mémoire | Ce qu’elle contient | Erreur typique |
|---|---|---|
| Pile | Variables locales, adresses de retour, cadres d’appels. | Dépassement par récursion sans condition d’arrêt : arrêt brutal du processus. |
| Tas | Allocations dynamiques, à libérer explicitement. | Fuite : mémoire allouée jamais rendue, consommation qui monte sans redescendre. |
| Données et code | Variables globales, constantes, instructions du programme. | Écriture dans une zone en lecture seule. |
| Bibliothèques partagées | Code commun chargé une fois pour tous les processus. | Version absente ou incompatible au démarrage. |
Une mesure prise une seule fois ne prouve rien en mémoire : consulter deux fois, à quelques secondes d’intervalle. Ce qui monte entre les deux lectures est une fuite, ce qui reste stable est un simple plateau d’utilisation.
Un chemin décrit l’emplacement logique d’une ressource : absolu depuis la racine de l’arborescence, relatif au répertoire courant. Le système le découpe en une suite de répertoires qu’il doit traverser. Cette traversée explique un accès refusé incompréhensible : sur un répertoire, le droit d’exécution n’autorise pas à lancer un programme, il autorise à franchir le répertoire pour atteindre ce qu’il contient.
Chaque fichier porte trois droits — lecture, écriture, exécution — pour trois catégories : le propriétaire, le groupe, les autres. Le masque de création, réglé par umask, retire des droits au moment de la création : avec un masque de 022, un fichier créé en 0666 arrive en 0644. Le masque se règle avant la création, jamais après, car corriger après coup laisse des fichiers déjà exposés.
Un lien physique est un second nom pour le même contenu : il partage droits, taille et données, et la suppression d’un nom ne supprime pas l’autre. Un lien symbolique est un raccourci qui contient un chemin : il peut pointer vers une cible absente, lien cassé, et il se résout vers ce que le chemin indique, ce qui autorise une sortie du répertoire prévu. Un service qui écrit ne doit jamais suivre un lien fourni de l’extérieur.
Les écritures sensibles se font en deux temps : écrire dans un fichier temporaire du même répertoire, puis renommer. Le renommage est atomique, donc un lecteur voit l’ancien contenu ou le nouveau, jamais un fichier à moitié écrit. C’est la seule façon d’éviter qu’une interruption laisse un fichier de configuration tronqué.
# Droits, proprietaire, groupe, taille, dates
ls -l /etc/app/config.txt
stat /etc/app/config.txt
# Appliquer des droits, un proprietaire et un groupe
chmod 640 /etc/app/config.txt
chown app:app /etc/app/config.txt
# Masque de creation, avant toute creation
umask 027
# Lien physique (meme contenu) et lien symbolique (raccourci)
ln /srv/data/base.db /srv/data/base.db.dur
ln -s /srv/data/base.db /srv/app/base.db
| Notation | Qui peut faire quoi | Emploi conseillé |
|---|---|---|
| r, w, x | Trois droits de base : 4 pour lire, 2 pour écrire, 1 pour exécuter. | Base de toute décision, à additionner par catégorie. |
| 644 | Le propriétaire lit et écrit ; le groupe et les autres lisent. | Contenu publié, jamais un secret. |
| 600 | Le propriétaire seul, personne d’autre. | Clé privée, fichier de secrets. |
| 640 | Le propriétaire lit et écrit ; le groupe lit ; les autres rien. | Configuration lue par un service dédié. |
| 750 | Le propriétaire fait tout ; le groupe lit et traverse ; les autres rien. | Répertoire applicatif. |
| 755 | Le propriétaire fait tout ; le groupe et les autres lisent et traversent. | Programme installé, accessible à tous. |
| umask 022 | Retire l’écriture au groupe et aux autres à la création. | Fichier en 644, répertoire en 755. |
| umask 077 | Retire tout au groupe et aux autres à la création. | Fichier en 600, répertoire en 700. |
Un fichier lisible dont le répertoire parent n’est pas traversable reste inaccessible : le test de droits porte sur chaque répertoire du chemin, pas seulement sur le fichier. C’est la première chose à vérifier quand la lecture échoue alors que les droits du fichier semblent corrects.
Dans un système de la famille Unix, un périphérique n’est pas un objet séparé : c’est un fichier. Disques, terminaux, ports série et pseudo-périphériques apparaissent dans l’arborescence, sous /dev, et se manipulent avec les mêmes appels système qu’un fichier ordinaire. Un programme n’a donc pas besoin de savoir s’il écrit sur un disque, sur un port ou sur un tube.
Le pilote est le code du noyau qui parle au matériel. Lorsqu’il manque ou qu’il échoue, le périphérique est simplement invisible : aucun fichier, aucune interface, aucun message côté application. Le diagnostic commence alors par le journal du noyau, jamais par l’application, car c’est le noyau qui a vu, ou non, le branchement.
Pour un disque qui n’apparaît pas, la méthode va du physique au logiciel et chaque étape élimine une cause : alimentation et câble, puis visibilité par le noyau, puis fichiers de périphérique, puis table des partitions, puis système de fichiers, enfin point de montage. Sauter une étape fait chercher une erreur de montage là où le câble est débranché.
Une panne silencieuse s’annonce avant de frapper : compteurs d’erreurs qui montent, secteurs réattribués, lectures qui ralentissent. Relever ces compteurs à intervalle régulier est la seule façon d’anticiper, et une sauvegarde ne se décide pas au moment de la panne.
# Le noyau a-t-il vu le peripherique et le pilote ?
dmesg | tail -n 30
# Les disques et partitions exposes
lsblk
ls -l /dev/sd*
# Table des partitions et systemes de fichiers
fdisk -l
blkid
# Ce qui est monte, et ou
mount | grep srv
| Étape | Commande ou observation | Ce qu’elle prouve |
|---|---|---|
| 1 Alimentation et câble | Voyant allumé, disque visible dans le microprogramme de la machine. | Le disque est alimenté et détecté avant tout logiciel. |
| 2 Noyau et pilote | dmesg, consultation du journal du noyau | Le noyau a vu le périphérique et le pilote s’est chargé. |
| 3 Fichiers de périphérique | lsblk, ls -l /dev/sd* | Le noyau expose le disque et ses partitions. |
| 4 Table des partitions | fdisk -l, parted -l | Une table est lisible et décrit les périmètres. |
| 5 Système de fichiers | blkid, fsck -n | Le système de fichiers est identifiable et sain. |
| 6 Montage | mount, /etc/fstab | Le système de fichiers est attaché à un répertoire. |
Ne jamais lancer une réparation de système de fichiers sur un volume monté : l’opération modifie les données pendant que le système les utilise, et une panne de disque devient une perte de données. Démonter, ou travailler sur une copie.
Un système en bonne santé parle peu dans ses journaux ; un système qui tombe y laisse tout. Les journaux locaux sont la mémoire des incidents et la première source à consulter, avant toute reproduction, parce qu’eux seuls datent les faits avec précision.
Les emplacements varient selon la distribution : fichiers texte sous /var/log pour les services classiques, journal binaire consulté avec journalctl quand le système est supervisé par systemd. Les deux cohabitent fréquemment ; savoir où chercher évite de perdre un temps précieux au mauvais endroit.
La rotation empêche les journaux de remplir le disque : ils sont découpés par taille ou par date, compressés, et un nombre limité de générations est conservé. Une rotation mal réglée produit l’un ou l’autre des deux excès : un journal presque vide qui ne prouve plus rien, ou un disque plein qui provoque une seconde panne.
Ce qu’on cherche en priorité, dans cet ordre : les erreurs et avertissements qui se répètent, la ligne qui précède immédiatement la première occurrence, les messages d’authentification avec leurs échecs, puis les événements de démarrage et d’arrêt des services. La première occurrence compte plus que la dernière, parce qu’elle précède la cause.
# Les cent dernieres lignes du systeme
tail -n 100 /var/log/syslog
# Un service precis, sur une fenetre de temps
journalctl -u nginx --since "2026-10-09 08:00" --until "2026-10-09 09:00"
# Les erreurs repetees et leur volume
journalctl -p err --since today
grep -c "echec" /var/log/auth.log
| Journal | Ce qu’il contient | Ce qu’on y cherche en priorité |
|---|---|---|
| /var/log/syslog ou /var/log/messages | Événements généraux du système et des services. | La première erreur de la série, pas la dernière. |
| /var/log/auth.log ou /var/log/secure | Connexions, échecs, élévations de droits. | Tentatives répétées, comptes inconnus, usage de sudo. |
| Journal du noyau | Pilotes, matériel, mémoire, stockage. | Erreurs de disque, périphérique non réclamé, mémoire insuffisante. |
| journalctl -u service | Toutes les lignes d’un service, redémarrages compris. | La date du dernier redémarrage et l’erreur qui l’a précédé. |
| Journal applicatif | Ce que le service a choisi de tracer. | L’exception complète et l’identifiant de la requête concernée. |
La rotation ne conserve qu’un nombre limité de générations : quelques jours plus tard, la preuve a disparu. Extraire immédiatement la fenêtre concernée avec son horodatage, dans un dossier d’incident, avant qu’elle ne soit compressée puis supprimée.
Du point de vue du système, le réseau est un ensemble d’interfaces, d’adresses, de routes, de règles de résolution et de règles de filtrage. Une application qui n’atteint pas une cible peut être en défaut, mais le système est interrogé d’abord : c’est lui qui détient l’état réel, là où l’application ne voit qu’un refus.
Les interfaces portent les adresses et leur état ; la table de routage décide par où sort un paquet ; le résolveur traduit un nom en adresse, aidé d’un cache local et d’un fichier de configuration. Un même symptôme — le service ne répond pas — a des causes différentes selon le maillon en défaut, et les commandes ne se remplacent pas.
Le pare-feu local ajoute une seconde barrière, distincte de celle posée par l’équipement d’interconnexion. Une règle locale trop stricte coupe un service pourtant fonctionnel ; un port ouvert à la hâte pour un test reste ouvert. Le diagnostic réseau compare donc toujours les deux côtés : ce que la machine autorise, et ce que le réseau laisse entrer.
Depuis le système, on prouve que l’interface est active, que la route existe, que le nom se résout et que le service écoute. Depuis l’extérieur, on prouve que la même cible répond sur le même port. Un test qui réussit d’un seul côté désigne le filtrage, sans qu’il soit nécessaire de tout réinstaller.
# Interfaces, adresses, etat
ip a
ip link
# Routes et passerelle par defaut
ip route
# Le nom se resout-il, et vers quelle adresse ?
getent hosts srv-app.test
cat /etc/resolv.conf
# Ports en ecoute, avec le processus
ss -tlnp
# Regles locales du pare-feu
iptables -L -n -v
| Maillon | Commande | Ce qu’elle prouve | Ce qu’elle ne prouve pas |
|---|---|---|---|
| Interface et adresse | ip a | L’interface existe, porte une adresse, son état est actif. | Que l’adresse est correcte pour le réseau. |
| Table de routage | ip route | Par où le système envoie ce qu’il ne sait pas router. | Que la passerelle accepte réellement le trafic. |
| Résolution de nom | getent hosts nom | Le résolveur configuré traduit le nom en adresse. | Que le service distant est joignable. |
| Port en écoute | ss -tlnp | Un service local attend sur une adresse et un port donnés. | Que le filtrage laisse entrer le trafic. |
| Règles de filtrage | iptables -L -n -v, nft list ruleset | Les règles appliquées et leur compteur d’utilisation. | Ce que laisse passer l’équipement en amont du poste. |
Un service qui écoute uniquement sur l’adresse de boucle locale est injoignable depuis le réseau, alors que tout paraît correct en local. Vérifier l’adresse d’écoute avant d’accuser le pare-feu : c’est une cause plus fréquente qu’une règle oubliée.
Durcir consiste à réduire la surface exposée : moins de services actifs, moins de comptes, moins de droits permanents. Un système qui n’exécute que ce dont il a besoin tombe moins souvent et se diagnostique plus vite, parce qu’il y a moins de journaux à lire et moins de causes possibles.
Les services inutiles se neutralisent en premier : chacun est un point d’entrée, un processus à maintenir et une source de bruit dans les journaux. Arrêter un service ne suffit pas, il faut aussi l’empêcher de repartir au prochain démarrage, sinon la mesure ne survit pas au redémarrage suivant.
Les mises à jour de sécurité s’appliquent tôt et se vérifient en trois temps : lister les correctifs disponibles, contrôler la version réellement installée, puis recharger le service concerné. Une mise à jour appliquée sans rechargement laisse l’ancien code en mémoire : la version installée prouve le fichier, pas le processus.
Les comptes se réduisent et se surveillent : pas de compte partagé, pas de mot de passe vide, pas de session ouverte directement avec le compte d’administration. Les tâches d’administration passent par sudo, qui conserve chaque commande et chaque compte : c’est une piste d’audit autant qu’un confort d’exécution.
# Services reellement actifs
systemctl list-units --type=service --state=running
# Ports en ecoute et processus associes
ss -tlnp
# Comptes disposant d un interpreteur de commandes
getent passwd | grep -v nologin
# Droits accordes a un compte
sudo -l
| Mesure | Effet attendu | Vérification |
|---|---|---|
| Arrêter et désactiver les services inutiles | Moins de points d’entrée et de processus à maintenir. | La liste des services actifs ne contient plus que le nécessaire, y compris après redémarrage. |
| Appliquer les mises à jour de sécurité | Correctifs connus appliqués au système. | La liste des mises à jour disponibles est vide. |
| Supprimer les comptes inutilisés | Moins de cibles et moins de mots de passe à tourner. | La liste des comptes ne contient que des comptes justifiés. |
| Interdire la connexion directe en administrateur | Toute élévation de droits passe par sudo et se trace. | Aucune session directe, chaque commande dans le journal d’audit. |
| Restreindre le pare-feu local | Seuls les ports utiles sont joignables. | Un balayage depuis l’extérieur ne voit que les ports attendus. |
Ouvrir un port « temporairement » sans date de retour est la faille la plus fréquente : la règle reste, et personne ne se souvient de son motif. Toute ouverture se note comme un contournement, avec son motif et sa date de retrait.
Une commande ne prouve que ce qu’elle mesure. ps montre un instant, top une tendance, ss un port en écoute, strace une séquence réelle d’appels, lsof un descripteur ouvert, journalctl un fait daté. Mélanger leurs conclusions produit un diagnostic flou que personne ne peut reproduire.
La méthode ne change pas : observer avant de modifier, changer une seule variable, reproduire, comparer. Un constat non reproductible n’est pas un diagnostic, c’est une coïncidence ; il ne peut ni être expliqué à un tiers ni servir de preuve.
Le laboratoire se prépare avec un programme aux entrées connues, des erreurs attendues et un protocole de compilation et d’exécution. Chaque observation est datée et recopiée telle quelle, sans correction après coup : la trace doit survivre à la rédaction du compte rendu.
# Protocole de laboratoire
# 1) Compilation avec tous les avertissements
cc -Wall -Wextra -O0 -g -o demo demo.c
# 2) Cas nominal : le programme donne son PID et son resultat
./demo data.txt
# 3) Erreurs provoquees : chemin absent, droits retires, allocation geante
./demo absent.txt
chmod 000 data.txt && ./demo data.txt ; chmod 644 data.txt
# 4) Observations pendant et apres l execution
ps -o pid,ppid,stat,rss,time,cmd -C demo
free -h
| Commande | Ce qu’elle prouve | Ce qu’elle ne prouve pas |
|---|---|---|
| ps aux --sort=-%cpu | La consommation et l’état des processus à un instant donné. | Rien sur l’évolution : un pic peut être déjà passé. |
| top | L’évolution du processeur, de la mémoire et de la charge. | La cause : il reste à croiser avec le journal ou la trace. |
| ps -eLf, top -H | Les threads, leur état et leur consommation. | Le verrou en cause : seulement le blocage apparent. |
| free -h, vmstat 1 | La mémoire disponible et l’usage du fichier d’échange. | Qui consomme : il faut croiser avec les processus. |
| ls -l, stat | Droits, propriétaire, groupe, taille et dates. | Le contenu du fichier ni son usage réel. |
| ss -tlnp | Les ports en écoute et le processus qui les détient. | Le filtrage en amont du poste. |
| journalctl -u service | Les faits datés d’un service, redémarrages compris. | Ce qui s’est passé hors du système : réseau, matériel. |
| strace | Les appels système réels, leurs arguments et leurs codes de retour. | Le comportement voulu : seulement le comportement observé. |
Le même scénario rejoué deux fois doit donner la même trace. S’il ne le fait pas, la cause est une variable non maîtrisée — environnement, minute de démarrage, ordre des threads — et le compte rendu doit le dire au lieu de cacher la différence.
Le livrable doit montrer une compréhension personnelle, des choix explicités et une vérification par un cas de test ou une procédure reproductible.
Publié le 09/05/2025