Aller au contenu principal

Systèmes d’exploitation

Progression

#Systèmes d’exploitation

À quoi ça sert ?

À quoi ça sert: partager le matériel entre programmes, fournir des abstractions sûres (fichiers, processus, sockets) et faire respecter l’isolation. Comment: le noyau arbitre CPU, mémoire et E/S et expose des appels système.

#Services offerts

Le noyau maintient une couche de fichiers virtuelle (VFS) qui uniformise les systèmes de fichiers et expose des opérations simples (open, read, write). Il fournit des API réseau via les sockets, crée et planifie les processus ou threads, et expose des horloges/timers pour cadencer les tâches. La mémoire virtuelle repose sur la MMU : pages, tables multi-niveaux et mmap pour partager des segments ou mapper un fichier. Côté sécurité, le noyau gère permissions, utilisateurs/groupes, mécanismes d’isolation (cgroups, namespaces) et, selon les distributions, des politiques renforcées (SELinux, AppArmor).

Outils à expérimenter
  • strace pour observer les appels système d’un programme.
  • lsof pour lister les fichiers/sockets ouverts et comprendre qui consomme les ressources.
  • htop / btop pour visualiser la planification et les priorités.
  • perf stat pour corréler événements matériels et comportement applicatif.
Espace noyau vs espace utilisateur

Un appel système passe en mode noyau (privilèges élevés) pour accéder aux ressources protégées, puis revient en espace utilisateur. Les libc enveloppent ces primitives pour un usage portable.

#Boot & userland

Au démarrage, le bootloader charge le noyau en mémoire puis lui passe la main. Le noyau initialise les pilotes essentiels, monte le système de fichiers racine et lance init (ou systemd). Ce dernier démarre les services, monte les volumes restants et, en bout de chaîne, offre un shell ou un environnement graphique à l’utilisateur.

#Appels système (exemples)

Le noyau expose un catalogue d’appels système: open/read/write/close pour manipuler des fichiers, fork/exec/wait pour créer des processus, socket/connect/accept pour établir des connexions réseau, ou encore clone, sendfile, mmap, ioctl pour des scénarios spécifiques.

Exemple minimaliste (C) lecture d’un fichier:

cc
1#include <fcntl.h>2#include <unistd.h>3#include <stdio.h>4 5int main() {6  int fd = open("/etc/hostname", O_RDONLY); // syscall via libc7  if (fd < 0) return 1;8  char buf[128];9  ssize_t n = read(fd, buf, sizeof(buf)-1);10  if (n > 0) { buf[n] = '\0'; printf("%s\n", buf); }11  close(fd);12}

#Parcours interactif d’un syscall

Parcours d’un appel noyau

Choisissez un scénario pour voir comment la requête traverse l’espace utilisateur, le noyau et le matériel, avec la part de latence associée à chaque phase.

Lecture auto

Un appel read() classique depuis un programme utilisateur. On suit la traversée user → noyau → contrôleur NVMe, puis la remontée des données.

Progression cumulative : 30 µs / 5.43 ms
Étape actuelle
Appel read(fd, buf, size)

Libc vérifie les paramètres et prépare le tampon utilisateur.

Espace utilisateur

Répartition des durées
Espace utilisateur1.7 % (90 µs)
Noyau2.6 % (140 µs)
Matériel95.8 % (5.20 ms)
À retenir
  • Les accès NVMe dominent la latence totale : la phase matérielle représente > 90 % du temps.
  • La copie mémoire peut être remplacée par mmap pour éviter un aller-retour supplémentaire.

#Planification (ordonnancement)

Les politiques courantes incluent Round-Robin, les priorités statiques ou dynamiques, et les files multi-niveaux à rétroaction (MLFQ). Un ordonnanceur préemptif interrompt un processus à l’expiration de son quantum pour donner la main à un autre, ce qui réduit la latence mais nécessite de surveiller la famine (starvation) via des mécanismes de vieillissement. Les métriques suivies sont la latence de réponse, le débit global, l’équité et, pour certaines charges, les garanties temps réel (classes SCHED_FIFO, SCHED_RR).

#Mémoire virtuelle

Les espaces d’adressage sont découpés en pages (souvent 4 KiB) référencées par des tables multi-niveaux. La TLB accélère les traductions, et une faute de page déclenche le chargement ou l’allocation du bloc manquant. Les processus peuvent obtenir de la mémoire via brk/sbrk ou mmap; le noyau sur-alloue et ne réserve réellement qu’au premier accès (copy-on-write après fork). La protection repose sur des bits d’exécution (NX/DEP), l’aléa ASLR et la distinction entre segments privés ou partagés, anonymes ou mappés sur fichier.

#Systèmes de fichiers

Les systèmes de fichiers stockent des inodes (métadonnées) et des répertoires, gèrent liens durs et symboliques et choisissent un mode de protection: journalisation (ext4, XFS) ou copy-on-write (btrfs, ZFS). Le cache page/buffer évite de toucher le disque pour chaque écriture; fsync ou les barrières de mémoire forcent la persistance. Les permissions POSIX et les ACLs raffinent le contrôle d’accès, tandis que les namespaces permettent de monter des environnements isolés (mount, pid, net).

Points surveillés en production
  • Saturation des inodes (beaucoup de petits fichiers) : surveillez df -i.
  • Latence disque élevée : activer le journal écrit en différé peut masquer des pertes; ajustez commit= sur ext4.
  • Contention sur le répertoire /tmp partagé : privilégiez des répertoires isolés avec PrivateTmp (systemd) ou des volumes dédiés.

#Quiz

Quelle séquence crée un nouveau processus et remplace son image par un programme ?
Quelle séquence crée un nouveau processus et remplace son image par un programme ?
Quel mécanisme permet d’éviter l’HoL blocking TCP pour HTTP ?
Quel mécanisme permet d’éviter l’HoL blocking TCP pour HTTP ?