Cours de programmation système Linux

Leçon 1 • Introduction aux appels système

Montre comment les programmes utilisateur invoquent les services du noyau via des appels système en utilisant les wrappers glibc et l'appel système brut. Relie les fonctions de la bibliothèque C à leurs opérations sous-jacentes dans le noyau.

Leçon 2 • Architecture Linux et aperçu du noyau

Couvre l'espace noyau par rapport à l'espace utilisateur, la conception de noyau monolithique et l'abstraction matérielle. Établit le cadre conceptuel dont dépendent tous les sujets de programmation ultérieurs.

Leçon 3 • Compilation, édition de liens et chargement

Explique le pipeline complet de la chaîne d'outils, du code source à l'exécutable, y compris l'édition de liens statique et dynamique. Prépare les étudiants à diagnostiquer les erreurs de construction et à comprendre la structure binaire.

Leçon 4 • Essentiels du langage C pour le travail système

Passe en revue les pointeurs, la disposition de la mémoire, les structures et les opérations binaires essentielles pour le code système. Fait le pont entre les connaissances générales en C et les modèles de bas niveau utilisés tout au long du cours.

Leçon 1 • Opérations sur les répertoires et les métadonnées

Enseigne les fonctions stat(), le parcours de répertoires et la gestion des liens, y compris les liens physiques et symboliques. Permet aux programmes d'inspecter et de manipuler la structure du système de fichiers par programmation.

Leçon 2 • Opérations sur les fichiers POSIX

Couvre les fonctions open(), read(), write(), lseek() et close() avec tous les indicateurs et modes pertinents. Enseigne les modèles d'utilisation corrects et les pièges courants tels que les lectures et écritures partielles.

Leçon 3 • Fichiers mappés en mémoire

Montre mmap() pour mapper des fichiers dans l'espace d'adressage d'un processus pour des E/S rapides et des données partagées. Relie les E/S de fichier aux concepts de mémoire virtuelle introduits dans les chapitres ultérieurs.

Leçon 4 • Descripteurs de fichiers et fichiers ouverts

Explique la table des fichiers ouverts, les entiers descripteurs de fichier et les structures de données du noyau qui les sous-tendent. Ancre tout le travail ultérieur d'E/S dans un modèle précis de la façon dont le noyau suit les fichiers ouverts.

Leçon 1 • Internes et attributs des processus

Examine le PID, le PPID, l'UID, le GID et les champs du descripteur de processus que le noyau maintient. Fournit le vocabulaire et le modèle de données nécessaires pour contrôler les processus par programmation.

Leçon 2 • Attente et récupération des enfants

Enseigne les fonctions wait(), waitpid() et waitid() pour collecter le statut de sortie des enfants et empêcher les zombies. Garantit que les étudiants écrivent des programmes multi-processus sans fuite.

Leçon 3 • Exécution de programmes avec exec()

Explique la famille exec, le passage d'arguments et d'environnement, et ce qui est préservé lors d'un exec. Permet aux étudiants de construire des shells et des lanceurs de processus qui remplacent correctement les images de processus.

Leçon 4 • Création de processus avec fork()

Couvre la sémantique de copie sur écriture, la gestion des valeurs de retour et l'héritage des ressources après fork(). Construit la base de tous les modèles de programmation multi-processus du cours.

Leçon 1 • Concepts de signaux et signaux standards

Introduit les numéros de signaux, les dispositions par défaut et le mécanisme d'envoi du noyau. Établit le modèle conceptuel requis avant d'écrire du code de gestion de signaux.

Leçon 2 • Masques de signaux et blocage

Enseigne sigprocmask(), la manipulation de sigset_t et la protection des sections critiques par blocage. Permet aux étudiants d'éviter les courses de signaux dans les opérations multi-étapes.

Leçon 3 • Programmation async-signal-safe

Identifie les fonctions async-signal-safe et les modèles pour écrire des gestionnaires corrects et réentrants. Empêche les bogues subtils qui surviennent lors de l'appel de fonctions non sécurisées dans les gestionnaires.

Leçon 4 • Signaux temps réel et signalfd

Couvre les signaux temps réel POSIX, les garanties de mise en file d'attente et l'interface signalfd() pour une gestion synchrone. Étend les compétences en matière de signaux aux architectures haute fiabilité et pilotées par événements.

Leçon 1 • Files de messages POSIX

Enseigne mq_open(), mq_send(), mq_receive() et la livraison de messages basée sur la priorité. Offre une alternative structurée et typée aux pipes de flux d'octets pour l'IPC orienté message.

Leçon 2 • Comparaison et sélection des mécanismes IPC

Analyse les compromis de débit, de latence, de complexité et de persistance pour tous les types d'IPC. Permet aux étudiants de prendre des décisions architecturales éclairées dans des conceptions système réelles.

Leçon 3 • Sémaphores POSIX

Couvre les sémaphores nommés et non nommés, sem_wait/sem_post et les modèles d'exclusion mutuelle. Fournit la couche de synchronisation nécessaire pour utiliser la mémoire partagée en toute sécurité.

Leçon 4 • Pipes et FIFOs

Couvre les pipes anonymes, la création de FIFO et le modèle producteur-consommateur pour les processus apparentés et non apparentés. Introduit l'IPC de flux d'octets unidirectionnel comme primitive de coordination la plus simple.

Leçon 1 • Utilisation avancée de mmap()

Montre MAP_ANONYMOUS, MAP_FIXED, les pages géantes et madvise() pour le réglage des performances. Étend les compétences en mmap() des E/S de fichier à la gestion de mémoire générale.

Leçon 2 • Allocation de tas et allocateur

Couvre malloc(), calloc(), realloc(), free() et les internes de l'allocateur glibc, y compris les arènes. Enseigne les modèles d'allocation corrects et comment éviter la corruption du tas.

Leçon 3 • Protection et permissions de la mémoire

Enseigne mprotect() pour changer les permissions des pages et les pages de garde pour la détection des débordements de tampon. Permet aux étudiants de mettre en œuvre des techniques de durcissement de la sécurité au niveau mémoire.

Leçon 4 • Architecture de la mémoire virtuelle

Explique les tables de pages, la disposition de l'espace d'adressage virtuel et l'interface /proc/pid/maps. Fournit le modèle mental nécessaire pour comprendre le comportement de l'allocateur et la sémantique de mmap().

Leçon 1 • Création et cycle de vie des threads

Couvre pthread_create(), les attributs de thread, l'état de détachement et pthread_join(). Établit le modèle de cycle de vie des threads sur lequel reposent tous les sujets de synchronisation.

Leçon 2 • Verrous de lecture-écriture et barrières

Couvre le rwlock pour les charges de travail à lecture intensive et pthread_barrier pour la synchronisation de phase. Étend la boîte à outils de synchronisation à des modèles où le verrouillage exclusif est trop grossier.

Leçon 3 • Variables de condition

Montre pthread_cond_wait(), les réveils intempestifs et le modèle de boucle de prédicat. Permet aux threads d'attendre efficacement les changements d'état sans attente active.

Leçon 4 • Mutex et sections critiques

Enseigne l'initialisation du mutex, la discipline de verrouillage/déverrouillage et les types de mutex avec vérification d'erreur. Fournit l'outil principal pour protéger les données partagées des modifications concurrentes.

Leçon 1 • E/S non bloquantes et epoll

Met en œuvre un serveur piloté par événements utilisant des sockets non bloquants, epoll_create() et le mode déclenché par front. Fait évoluer la gestion des connexions au-delà du modèle un-thread-par-connexion.

Leçon 2 • Principes fondamentaux de l'API socket

Couvre socket(), bind(), listen(), accept(), connect() et les structures d'adresse pour IPv4 et IPv6. Établit la surface d'API de base sur laquelle repose toute la programmation réseau.

Leçon 3 • UDP et sockets datagramme

Couvre sendto(), recvfrom() et les modèles de communication sans connexion pour UDP. Compare la livraison non fiable d'UDP avec TCP et identifie les cas d'utilisation appropriés.

Leçon 4 • Options de socket et fonctionnalités avancées

Enseigne getsockopt()/setsockopt() pour le réglage des tampons, du keepalive et du contrôle de l'algorithme de Nagle. Permet un réglage fin des performances et de la fiabilité des connexions réseau.