.. _glossaire: Glossaire ========= Beaucoup de noms en programmation système sont des abréviations anglaises. Connaître le mot d'origine aide souvent à comprendre (et à retenir) ce que fait une fonction ou une constante. Chaque entrée porte en premier le terme anglais (par exemple *stack*), et son synonyme français juste en dessous (pile) ; les entrées sont triées par ordre alphabétique. Pour trouver un terme, utilisez la recherche de la page (``Ctrl+F``). .. glossary:: :sorted: accept Fonction qui, côté serveur, attend puis accepte une connexion d'un client sur un socket en écoute. Elle retourne un nouveau socket dédié à ce client (voir :ref:`Sockets `). AF_INET AF_INET6 *Address Family* : famille d'adresses utilisée par un socket, IPv4 (``AF_INET``) ou IPv6 (``AF_INET6``). API *Application Programming Interface* : ensemble de fonctions, types et constantes qu'une bibliothèque ou un système met à disposition des programmes. argc argv *argument count* / *argument vector* : nombre d'arguments de la ligne de commande et tableau de chaînes les contenant (``argv[0]`` est le nom du programme). appel système syscall *system call* : demande faite par un programme au noyau (ouvrir un fichier, créer un processus…). Les appels système sont documentés dans la section 2 du ``man``. backlog Deuxième argument de ``listen`` : taille maximale de la file des connexions en attente d'un ``accept``. BSS segment data segment text Segments mémoire d'un programme : *text* contient le code machine (lecture seule), *data* les variables globales et statiques initialisées, BSS (*Block Started by Symbol*) celles non initialisées ou initialisées à zéro (mises à zéro au lancement). bind *lier* : associe un socket à une adresse IP et un port local. buffer tampon Zone mémoire temporaire où les données sont accumulées avant d'être écrites ou après avoir été lues. Par exemple, ``printf`` n'écrit pas forcément tout de suite : le texte attend dans le buffer de ``stdout`` jusqu'à un ``\n`` (quand ``stdout`` est un terminal), un ``fflush``, le remplissage du buffer ou la fin du programme. calloc *clear allocation* (ou *contiguous allocation*) : alloue un tableau de ``n`` éléments dans la heap et initialise la mémoire à zéro. connect *connecter* : côté client, établit une connexion entre un socket et l'adresse (IP et port) d'un serveur en écoute. copy-on-write COW *copie à l'écriture* : après un ``fork``, les pages mémoire sont partagées entre parent et enfant, et une page n'est réellement copiée que lorsque l'un des deux la modifie. data race Accès concurrents non synchronisés à une même donnée par plusieurs threads, dont au moins une écriture. C'est un comportement indéfini en C, et un cas particulier de :term:`race condition`. dangling pointer *pointeur pendant* : pointeur qui contient encore l'adresse d'une zone devenue invalide, déjà libérée avec ``free`` ou appartenant à une fonction terminée (variable locale dont la stack frame a été dépilée). L'utiliser est un :term:`comportement indéfini` (voir :ref:`Mémoire `). deadlock interblocage Situation où plusieurs threads (ou processus) s'attendent mutuellement et restent bloqués indéfiniment, par exemple quand chacun détient un mutex dont l'autre a besoin. descripteur de fichier fd *file descriptor* : entier qui identifie une ressource ouverte par un processus (fichier, pipe, socket…). ``0``, ``1`` et ``2`` correspondent à l'entrée standard, la sortie standard et la sortie d'erreur. detach *détacher* : rend un thread indépendant, dont les ressources sont libérées automatiquement à sa fin, sans ``pthread_join``. endianness big-endian little-endian Ordre de stockage des octets d'un nombre en mémoire : octet de poids fort en premier (*big-endian*, utilisé sur le réseau) ou octet de poids faible en premier (*little-endian*, utilisé par les processeurs x86 et la plupart des processeurs ARM). ELF *Executable and Linkable Format* : format des exécutables, des fichiers objets et des bibliothèques sous Linux. EOF *End Of File* : indique qu'il n'y a plus rien à lire. ``EOF`` est aussi la valeur (négative) retournée par ``getchar``, ``scanf``… dans ce cas. errno *error number* : variable (propre à chaque thread) positionnée par la plupart des appels système et fonctions de la libc en cas d'erreur (les fonctions ``pthread_*`` retournent directement le code d'erreur). ``perror`` affiche le message correspondant. exec Famille de fonctions qui remplacent le programme du processus courant par un autre. Les suffixes indiquent la façon de passer les arguments : ``l`` (*list*, un par un), ``v`` (*vector*, un tableau), ``p`` (*path*, cherche le programme dans le ``PATH``), ``e`` (*environment*, environnement fourni). Par exemple ``execvp``. page fault faute de page Exception (interruption) déclenchée par la :term:`MMU` quand un programme accède à une page absente de la mémoire physique (ou interdite). Le noyau charge alors la page, ou envoie ``SIGSEGV`` si l'accès est invalide. FIFO pipe nommé *First In, First Out* : premier entré, premier sorti. Un pipe nommé (créé avec ``mkfifo``) est un pipe qui apparaît dans le système de fichiers, ce qui permet à des processus sans lien de parenté de communiquer. FILE Type de la bibliothèque standard (``FILE *``) représentant un :term:`flux` ouvert avec ``fopen``. Il contient un descripteur de fichier et un buffer. flux stream Suite d'octets lue ou écrite de façon séquentielle. En C, un flux est représenté par un ``FILE *`` (``stdin``, ``stdout``, fichier ouvert avec ``fopen``…). fork *fourche* : duplique le processus courant. Le processus enfant est une copie du parent ; ``fork`` retourne ``0`` à l'enfant et le PID de l'enfant au parent. handler gestionnaire de signal Fonction appelée à la réception d'un signal, installée avec ``sigaction`` (ou ``signal``). heap tas Zone mémoire où sont faites les allocations dynamiques (``malloc``, ``calloc``…). Chaque bloc alloué doit être libéré à la main avec ``free``. htons htonl ntohs ntohl *host to network short/long* et *network to host short/long* : convertissent un entier entre l'ordre des octets de la machine et l'ordre réseau (*big-endian*). ``short`` pour 16 bits (un port), ``long`` pour 32 bits (une adresse IPv4). *long* est un nom historique : ces fonctions manipulent des ``uint32_t`` (un ``long`` fait 64 bits sous Linux 64 bits). I/O E/S *Input/Output*, entrées/sorties : tout échange de données entre un programme et l'extérieur (clavier, écran, fichiers, réseau…). inode *index node* : structure qui décrit un fichier sur le disque (taille, droits, propriétaire, emplacement des données). Le nom du fichier est stocké à part, dans le répertoire. IP *Internet Protocol* : protocole qui achemine les paquets entre machines, identifiées par une adresse IP. IPC *Inter-Process Communication* : mécanismes de communication entre processus (pipes, signaux, mémoire partagée, sockets…). join *rejoindre* : ``pthread_join`` attend la fin d'un thread et récupère sa valeur de retour. joinable État par défaut d'un thread : un autre thread doit appeler ``pthread_join`` pour attendre sa fin et libérer ses ressources (voir :term:`detach`). hard link lien physique Nom supplémentaire pour un même fichier : deux entrées de répertoire désignent le même :term:`inode`. Le fichier n'est supprimé que lorsque son dernier nom l'est (``ln cible lien``). libc Bibliothèque standard du C (sur Linux, en général la *GNU C Library*, glibc). Elle fournit ``printf``, ``malloc``, ``fopen``… et les fonctions qui encapsulent les appels système. linker éditeur de liens Programme (``ld``) qui, lors de l'édition de liens, assemble les fichiers objets (``.o``) et les bibliothèques en un exécutable. listen *écouter* : met un socket serveur en attente de connexions entrantes. symbolic link lien symbolique Fichier spécial qui contient le chemin d'un autre fichier (``ln -s cible lien``). Si la cible est supprimée, le lien devient cassé. malloc *memory allocation* : alloue un bloc de mémoire dans la heap, non initialisé. memory leak fuite mémoire Mémoire allouée qui n'est jamais libérée alors qu'elle n'est plus utilisée. ``valgrind`` ou AddressSanitizer permettent de détecter les fuites mémoire. mémoire virtuelle Espace d'adressage propre à chaque processus. Les adresses manipulées par le programme sont virtuelles et traduites en adresses physiques par la :term:`MMU`, page par page. MMU *Memory Management Unit* : composant du processeur qui traduit les adresses virtuelles en adresses physiques, à partir des tables de pages gérées par le noyau. espace noyau espace utilisateur mode noyau mode utilisateur *kernel space* / *user space* : modes d'exécution du processeur (et zones de mémoire associées). En espace noyau (mode noyau), tout est permis (accès au matériel, à toute la mémoire) ; en espace utilisateur (mode utilisateur), un programme doit passer par un :term:`appel système` pour ces opérations (voir :ref:`Introduction `). mmap *memory map* : projette un fichier ou une zone de mémoire (éventuellement partagée entre processus) dans l'espace d'adressage du processus. mutex *mutual exclusion* : verrou qui garantit qu'un seul thread à la fois exécute une section critique. noyau kernel Cœur du système d'exploitation : il gère les processus, la mémoire, les fichiers et le matériel, et s'exécute en :term:`mode noyau`. NULL Valeur d'un pointeur qui ne pointe vers rien. Beaucoup de fonctions retournent ``NULL`` en cas d'échec (``malloc``, ``fopen``…). O_RDONLY O_WRONLY O_RDWR O_CREAT O_TRUNC O_APPEND Options de ``open`` : *read only*, *write only*, *read/write*, *create* (créer le fichier s'il n'existe pas), *truncate* (vider le fichier), *append* (écrire à la fin). opération atomique atomic Opération qui s'exécute en une seule fois, sans pouvoir être interrompue ou observée à moitié par un autre thread (````, ``atomic_int``…). orphelin Processus dont le parent s'est terminé avant lui. Il est alors rattaché à un autre processus (``init``/``systemd``) qui attendra sa fin. OS système d'exploitation *Operating System* : ensemble formé du noyau et des programmes de base qui gèrent la machine et offrent des services aux programmes (Linux, Windows, macOS…). page Bloc de mémoire de taille fixe (en général 4 Kio) : unité de base de la mémoire virtuelle, que la :term:`MMU` traduit en adresse physique. PCB *Process Control Block* : structure du noyau qui regroupe les informations d'un processus (PID, état, registres, mémoire, fichiers ouverts…). PID PPID *Process IDentifier* / *Parent Process IDentifier* : numéro unique d'un processus / de son parent (``getpid``, ``getppid``). program counter PC compteur ordinal Registre du processeur qui contient l'adresse de la prochaine instruction à exécuter : il indique où en est un processus (ou un thread) dans son code. Il fait partie du contexte sauvegardé dans le :term:`PCB`, et chaque thread a le sien (voir :ref:`Processus ` et :ref:`Threads `). pipe tube Canal de communication à sens unique entre deux processus : ce qui est écrit d'un côté est lu de l'autre. Créé avec ``pipe``, il est hérité lors d'un ``fork``. port Numéro (de 0 à 65535) qui identifie une application sur une machine, en complément de l'adresse IP. POSIX *Portable Operating System Interface* (le X rappelle UNIX) : norme qui définit l'interface des systèmes de type UNIX (appels système, ``pthread``, outils en ligne de commande…). préprocesseur Première étape de la compilation : traite les directives ``#include``, ``#define``, ``#ifdef``… et produit du C sans macros. pthread *POSIX threads* : bibliothèque de threads définie par la norme POSIX (``pthread_create``, ``pthread_join``, ``pthread_mutex_lock``…). race condition situation de compétition Bug où le résultat dépend de l'ordre (non maîtrisé) dans lequel des threads ou processus accèdent à une donnée partagée. realloc *re-allocation* : change la taille d'un bloc alloué dans la heap, en le déplaçant si nécessaire. sanitizer Option du compilateur qui ajoute des vérifications à l'exécution : AddressSanitizer (``-fsanitize=address``, accès mémoire invalides et fuites), UndefinedBehaviorSanitizer (``-fsanitize=undefined``), ThreadSanitizer (``-fsanitize=thread``, data races). scheduler ordonnanceur Partie du noyau qui choisit quel processus ou thread s'exécute sur le processeur, et pendant combien de temps. section critique Portion de code qui accède à une ressource partagée et ne doit être exécutée que par un seul thread à la fois. segmentation fault segfault Erreur provoquée par un accès à une zone mémoire interdite (causes possibles : pointeur ``NULL``, dépassement de tableau, mémoire déjà libérée… ; ces deux dernières ne provoquent pas toujours de segfault). Le processus est tué par le signal ``SIGSEGV``. sémaphore Compteur partagé qui limite le nombre de threads ou processus pouvant accéder simultanément à une ressource (``sem_wait`` décrémente, ``sem_post`` incrémente). shell Interpréteur de commandes (``bash``, ``zsh``…) : lit les commandes tapées dans le terminal et lance les programmes correspondants. shutdown Ferme une connexion socket dans un sens (lecture, écriture) ou les deux, sans libérer le descripteur (ce que fait ``close``). signal Notification asynchrone envoyée à un processus : ``SIGINT`` (*interrupt*, ``Ctrl+C``), ``SIGKILL`` (tuer, ne peut pas être intercepté), ``SIGTERM`` (*terminate*), ``SIGCHLD`` (*child*, un enfant s'est terminé), ``SIGSEGV`` (*segmentation violation*), ``SIGPIPE`` (écriture dans un pipe ou un socket fermé de l'autre côté)… sigaction Appel système qui installe un :term:`handler` (plus fiable et portable que ``signal``). size_t Type entier non signé utilisé pour les tailles (type du résultat de ``sizeof`` et de ``strlen``, attendu par ``malloc``…). sockaddr sockaddr_in Structures qui décrivent une adresse de socket : ``struct sockaddr`` est le type générique attendu par ``bind``, ``connect`` et ``accept`` ; ``struct sockaddr_in`` contient une adresse IPv4 et un port (``sin_addr``, ``sin_port``). socket *prise* : extrémité d'une communication, en général réseau. Il est manipulé par un descripteur de fichier, comme un fichier. SOCK_STREAM SOCK_DGRAM Types de socket : flux (*stream*, utilisé avec TCP) ou datagrammes (*datagram*, utilisé avec UDP). stack pile Zone mémoire où sont stockées les variables locales et les informations d'appel des fonctions. À chaque appel, une :term:`stack frame` y est empilée ; elle est libérée automatiquement à la sortie de la fonction. stack overflow débordement du stack Dépassement de la taille maximale du :term:`stack` (8 Mio par défaut sous Linux, ``ulimit -s``), en général à cause d'une récursion sans fin ou d'un très grand tableau local. Le processus est tué par ``SIGSEGV`` (voir :ref:`stack_pas_a_pas`). stack frame Zone du :term:`stack` réservée à un appel de fonction (adresse de retour, paramètres, variables locales). Elle est empilée à l'appel et dépilée (libérée) au retour de la fonction (voir :ref:`stack_pas_a_pas`). std *standard*. Se retrouve dans ``stdio.h`` (*standard input/output*), ``stdlib.h`` (*standard library*), ``stdint.h`` (*standard integers*), ``stdbool.h``… stdin stdout stderr *standard input / output / error* : entrée standard (clavier par défaut), sortie standard et sortie d'erreur (terminal par défaut). Ce sont des flux ``FILE *``, associés aux descripteurs ``0``, ``1`` et ``2`` (``STDIN_FILENO``, ``STDOUT_FILENO``, ``STDERR_FILENO``). swap Partie d'un disque utilisée comme extension de la RAM : le noyau y déplace les pages peu utilisées quand la mémoire manque. L'accès est beaucoup plus lent que la RAM (voir :ref:`Mémoire `). TCP *Transmission Control Protocol* : protocole de transport avec connexion, qui garantit que les données arrivent toutes, dans l'ordre et sans doublon. thread-safe Se dit d'une fonction qui peut être appelée en même temps par plusieurs threads sans erreur (par exemple ``ctime_r`` et ``rand_r``, contrairement à ``ctime`` et ``rand``). TID *Thread IDentifier* : identifiant attribué par le noyau à un thread, obtenu avec ``gettid`` (du même type qu'un PID). Pour le thread principal, TID = PID. À ne pas confondre avec le ``pthread_t`` rempli par ``pthread_create``. thread *fil (d'exécution)* : suite d'instructions exécutée à l'intérieur d'un processus. Les threads d'un même processus partagent sa mémoire (variables globales, heap) mais ont chacun leur stack. TLB *Translation Lookaside Buffer* : cache de la :term:`MMU` qui garde les traductions d'adresses virtuelles récentes, pour éviter de relire la table des pages à chaque accès. UB comportement indéfini *Undefined Behavior* : situation où la norme du C n'impose rien (dépassement de tableau, variable non initialisée, double ``free``…). Le programme peut sembler fonctionner, planter, ou faire n'importe quoi. UDP *User Datagram Protocol* : protocole de transport sans connexion, plus léger que TCP mais sans garantie de réception ni d'ordre. umask Masque des droits retirés à la création d'un fichier : les droits demandés à ``open`` (par exemple ``0666``) sont combinés avec le masque (par exemple ``0022``) pour donner ``0644``. C'est aussi le nom de la commande et de la fonction qui le modifient (voir :ref:`umask`). unistd.h *UNIX standard* : en-tête POSIX qui déclare notamment ``read``, ``write``, ``close``, ``fork``, ``pipe``, ``getpid``… variable de condition Mécanisme (``pthread_cond_t``) qui permet à un thread d'attendre qu'une condition soit remplie, en étant réveillé par un autre thread (``pthread_cond_wait`` / ``pthread_cond_signal``). wait waitpid Attendent la fin d'un processus enfant et récupèrent son état de fin (code de retour ou signal reçu). zombie Processus terminé dont le parent n'a pas encore récupéré le code de retour avec ``wait``. Sa mémoire a été libérée, mais il garde une entrée dans la table des processus (PID, code de retour).