.. _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. Les entrées sont classées selon le terme le plus utilisé dans le cours (souvent le terme anglais, par exemple *stack* pour la pile) ; le synonyme est indiqué juste en dessous. 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 renvoie 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 (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`` ou la fin du programme. calloc *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 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 : ses 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) renvoyée par ``fgetc``, ``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_*`` renvoient 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``. faute de page page fault 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`` renvoie ``0`` à l'enfant et le PID de l'enfant au parent. gestionnaire de signal handler 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`). 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. malloc *memory allocation* : alloue un bloc de mémoire dans la heap, non initialisé. fuite mémoire memory leak Mémoire allouée qui n'est jamais libérée alors qu'elle n'est plus utilisée. ``valgrind`` ou AddressSanitizer permettent de les détecter. 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* : domaines d'exécution imposés par le processeur. 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 renvoient ``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 (````, type ``_Atomic``). 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``). 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. segfault *segmentation fault* : 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:`gestionnaire de signal` (plus fiable et portable que ``signal``). size_t Type entier non signé utilisé pour les tailles (renvoyé par ``sizeof`` et ``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 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``). TCP *Transmission Control Protocol* : protocole de transport avec connexion, qui garantit que les données arrivent toutes, dans l'ordre et sans doublon. 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. 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. 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 code de retour. zombie Processus terminé dont le parent n'a pas encore récupéré le code de retour avec ``wait``. Il n'occupe plus de mémoire mais reste dans la table des processus.