Architecture du système GNU/Linux

Vue d’ensemble

Il est important de bien connaître l’architecture et le fonctionnement du système d’exploitation pour en assurer l’installation, la configuration, l’exploitation et la maintenance.

Ce chapitre vous permettra d’étudier les différentes couches qui constituent le système GNU/Linux, de donner une définition aux termes et également de décrire leurs rôles respectifs.

Identifier la distribution

Nous allons parler des deux principales distributions du marché : Debian et Red Hat.

Anneaux de protection

Les systèmes d’exploitation utilisent généralement aujourd’hui des anneaux de protection (protection rings) qui offrent plusieurs niveaux de privilèges : du plus faible au plus élevé. Ces derniers sont créés par le processeur et non par le système d’exploitation.

Quand un programme s’exécute, le système d’exploitation lui attribue une zone de mémoire vive qui est affectée à un anneau de protection. L’intérêt est de faire une séparation entre les programmes sensibles, comme le noyau du système, et les programmes du ou des utilisateurs.

Noyau Linux

Un noyau (kernel) est un composant majeur au sein du système d’exploitation qui gère les ressources de l’ordinateur et sert d’interface entre le matériel et les programmes.

1. Composants du noyau

Le noyau Linux s’exécute dans l’anneau de protection 0 :

Le noyau Linux est composé de six principaux sous-systèmes :

• Le Process Management (PM) qui est chargé de répartir de façon équitable les accès au processeur entre toutes les applications actives.

• Le Memory Management (MM) qui est chargé d’affecter à chaque programme une zone mémoire qui ne doit pas être lue ou modifiée par un autre processus.

• Le Virtual File System (VFS) qui garantit une gestion correcte des fichiers et un contrôle des droits d’accès (ACL - Access Control List). Pour limiter la complexité liée aux nombreux systèmes de fichiers existants, il utilise des appels système identiques quel que soit le système de fichiers choisi. Le noyau Linux détourne les appels standards vers les appels spécifiques au système de fichiers.

• L’Inter-Process Communication (IPC) permet à des applications de communiquer entre elles du fait qu’un processus ne peut accéder qu’à la zone mémoire qui lui a été allouée.

• Le Device Driver (DD) gère les ressources matérielles avec des pilotes de périphériques (device drivers) et fournit aux programmes une interface uniforme pour l’accès à ces ressources.

• Le Network Stack (NET) permet de se connecter à d’autres systèmes à travers un réseau informatique. De nombreux périphériques matériels sont supportés. Plusieurs protocoles réseau peuvent être utilisés comme IPX/SPX, TCP/IP version 4 ou 6...

Pilotes de périphériques

Un pilote de périphérique (device driver ou plus simplement driver) est un programme qui permet aux autres programmes du système de communiquer avec un périphérique.

GNU/Linux dispose de trois classes de pilotes :

ls <option> <fichiers> 

[root@system2 ~]# ls -l /dev 
total 0 
crw-------. 1 root root     10, 235 24 oct.   21:46 autofs 
drwxr-xr-x. 2 root root         260 24 oct.   21:46 block 
drwxr-xr-x. 2 root root         120 24 oct.   21:46 bsg 
crw-------. 1 root root     10, 234 24 oct.   21:46 btrfs-control 
drwxr-xr-x. 3 root root          60 24 oct.   21:47 bus 
lrwxrwxrwx. 1 root root           3 24 oct.   21:46 cdrom -> sr0 
drwxr-xr-x. 2 root root        2800 24 oct.   21:47 char 
crw-------. 1 root root      5,   1 24 oct.   21:46 console 
lrwxrwxrwx. 1 root root          11 24 oct.   21:46 core -> /proc/kcore 
drwxr-xr-x. 3 root root          80 24 oct.   21:47 cpu 
crw-------. 1 root root     10,  61 24 oct.   21:46 cpu_dma_latency 
crw-------. 1...

Bibliothèques

Les programmes du système Linux sont principalement écrits en langage C. Ils sont composés de plusieurs fichiers de code source. La compilation produit un programme exécutable au format binaire. En vérité, nous avons quatre étapes :

1. La précompilation (pre-processing). Cette étape réalise plusieurs opérations de substitution sur le code source telles que la suppression des commentaires, l’inclusion des fichiers d’en-têtes *.h  dans chaque fichier source .c et le traitement des directives de compilation (#define, #ifdef, #pragma…).

2. La compilation (compiling). Le code source est transformé en assembleur, un langage machine qui reste lisible par un humain. Les fichiers ont une extension .s.

3. L’assemblage (assembling). Le code assembleur est ensuite transformé en code machine binaire qui ne peut pas être lu par un humain. Il faut prendre des outils pour désassembler. Les fichiers dits « objets » ont une extension .o.

4. L’édition des liens (linking). Le fichier objet produit par l’étape 3 demeure incomplet, il ne contient pas le code des fonctions telles que printf()... Ce code est présent dans une bibliothèque (library). L’édition des liens va réunir le fichier objet et les fonctions contenues dans les bibliothèques pour produire le programme complet, soit l’exécutable.

Les développeurs peuvent concevoir des routines (fonctions du langage C ou des méthodes et des classes du langage C++ par exemple) qu’ils vont invoquer plusieurs fois dans un ou plusieurs programmes. Ils vont donc compiler ces dernières dans des fichiers objets et les intégrer dans une bibliothèque logicielle. Les bibliothèques sont exécutées dans l’anneau de protection 3.

Nous avons deux types de bibliothèques :

Appels système

Les applications communiquent avec le noyau par le biais des appels système (system calls ou syscalls).

Une application appelle des fonctions provenant d’une bibliothèque telle que la glibc qui, à leur tour via l’interface des appels système (SCI, System Calls Interface), demandent au noyau d’effectuer des tâches pour le compte de l’application. 

Le système Linux offre un peu plus de 350 appels système qui sont regroupés par catégories :

Lorsqu’une application utilise, par exemple, la fonction printf() pour afficher une chaîne de caractères formatée dans une console, elle invoque la fonction write().

La section 2 des pages de manuel fournit la description des appels système :

[root@system2: ~]# man 2 intro 

Voici le résultat à l’écran :

Concernant Debian, les pages de manuel pour le développement ne sont pas forcément installées. Il faut installer le paquet manpages-dev ou pour la version française manpages-fr-dev :

root@system1:~# apt-get install manpages-dev 
Lecture des listes de paquets... Fait 
Construction de l'arbre des dépendances 
Lecture des informations d'état......

Gestion des services

Un service (dæmon ou démon) est un programme qui démarre lors du chargement du système d’exploitation et qui s’exécute en arrière-plan. Ces programmes peuvent être des serveurs web, de messagerie, de base de données, un pare-feu, entre autres...

Historiquement, les services étaient démarrés par le programme /sbin/init (System V initialization ou sysVinit) qui avait un fichier de configuration /etc/inittab. Nous disposions de plusieurs niveaux d’exécution.

Scott James Remnant de Canonical Ltd a, par la suite, développé upstart pour remplacer le dæmon sysVinit. Il est nativement intégré depuis la distribution Ubuntu 9.10 (Karmic Koala). Nous disposons également de plusieurs niveaux d’exécution.

Lennart Poettering a initié en 2010 le projet systemd ou « system dæmon » (le dæmon du système). Ce projet a suscité de vives controverses chez les développeurs Linux. L’objectif est de mieux appréhender la gestion d’un système multitâche, de gérer les dépendances entre les différents services lancés au démarrage avec comme intention d’optimiser les performances système. Il devient peu à peu le gestionnaire des services dans la plupart des distributions Linux.

À partir de Debian 8 (Jessie), systemd est le gestionnaire de service par défaut. L’adoption de ce dernier a provoqué une prise de position d’une partie des développeurs et utilisateurs de la communauté Debian. Ils partent du principe que systemd ne respecte pas le principe KISS (Keep It Simple and Stupid)... Donc, une distribution dérivée (fork) est née en novembre 2014 : Devuan. Elle propose par défaut sysVinit.

Red Hat proposait sysVinit par défaut dans ces distributions jusqu’à la version 5. La version 6 utilisait upstart pour la partie système. Cependant, les services ajoutés depuis les dépôts étaient gérés par sysVinit. Red Hat 7 contient de base systemd.

En conclusion, Debian 9 et Red Hat 7 utilisent tous deux systemd avec une prise en charge de sysVinit pour assurer une compatibilité.

Journaux système

Les journaux système de Debian 9 et de Red Hat Enterprise Linux 7 sont gérés par le service systemd-journald qui retransmet les événements au service rsyslogd pour assurer une compatibilité antérieure. Nous pouvons donc nous attendre à la disparition de rsyslogd dans de prochaines versions de Debian ou Red Hat.

Shell

Un shell est un programme qui sert d’interface entre l’utilisateur et le système d’exploitation. Il existe deux formes distinctes :

#ls -l $(which sh) 
lrwxrwxrwx 1 root root 4 janv. 24 2017 /bin/sh -> dash 

#ls -l $(which sh)  
lrwxrwxrwx 1 root root 4 25 oct. 13:57 /bin/sh -> bash 

Applications

Les programmes compilés sont écrits dans un langage de programmation C, C++, Java, FreePascal, etc. Les programmes interprétés sont écrits en TCL/TK, Perl, Python, Ruby...

Le développement d’une application graphique est basé sur une bibliothèque comme GTK+ (The Gimp ToolKit) qui a permis de développer les bureaux gnome, xfce... ou Qt (prononcez « cute » et non la lettre Q puis la lettre T) qui a permis de développer le bureau KDE. Sur les serveurs, il est rare de voir une interface graphique. Ceci est plutôt réservé aux stations de travail.

Des applications console peuvent, quant à elles, utiliser la bibliothèque ncurses (New Curses) qui propose principalement la gestion de fenêtres, huit couleurs différentes, la gestion de la souris et la gestion des touches de fonction du clavier. On peut penser aux programmes htop, Midnight commander...

Bien sûr, il existe d’autres bibliothèques comme Newt (Not Erik’s Windowing Toolkit), développée par Erik Troan, qui sont utilisées pour écrire le programme whiptail, ou les outils TUI (Text-based User Interface) comme nmtui.

Les programmes binaires sont sur 32 bits ou 64 bits. La commande file permet d’identifier son modèle de compilation.

Syntaxe

file <chemin/nom_du_fichier> 

Exemple

Savoir si le programme ls est 32 ou 64 bits.

[root@system2 ~]# file /bin/ls 
/bin/ls: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), 
dynamically linked (uses shared libs), for GNU/Linux 2.6.32,  
BuildID[sha1]=c5ad78cfc1de12b9bb6829207cececb990b3e987, stripped 

Vous lisez « ELF 64-bit LSB executable, x86-64 » dans le résultat.