Ce travail de fin de cycle introduit les appels systèmes sous l'environnement GNU/Linux. L'objectif est de rendre le fonctionnement de ces appels plus transparent à l'intéressé. Le sujet est abordé tant de manière théorique que pratique.
La partie théorique permet d'identifier et comprendre les différents acteurs qui entrent en jeu lors d'un appel système. On part de l'architecture de l'ordinateur pour remonter jusqu'au système d'exploitation. Plus précisément, on démarre du niveau matériel pour atteindre la couche logicielle, ceci en abordant à chaque étape les éléments concernant un appel système.
La partie pratique présente dans un premier temps, les outils pouvant être utilisés pour l'analyse d'appels systèmes et ensuite, l'analyse de deux applications.
L'étude des applications aborde également la manière d'analyser des programmes en général, et ce notamment par l'utilisation d'un debugger.
Finalement, il est fait quelques implémentations d'appels systèmes en langage assembleur. Cela permet d'observer le lien entre la couche matérielle et logicielle via l'utilisation des registres CPU. Si l'on parle d'introduction au sujet, c'est que celui-ci est sufisamment complexe et prétendre couvrir l'entièreté du domaine serait illusoire.
Table des matières
1. Introduction
1.1 Motivations
2. Notions Théorique
2.1 Ecosystèmes
2.1.1 Définition d'un OS - Système d'exploitation
2.1.2 GNU/Linux
2.1.3 GNU
2.1.4 Linux
2.1.5 Les licences « Open Source »
2.2 Architecture d'un ordinateur
2.2.1 Modèle de von Neumann
2.2.2 Architecture CPU
2.2.3 Organisation CPU
2.2.3.1 Les registres
2.2.3.2 L'unité Arithmétique et Logique
2.2.3.3 Unité de Contrôle
2.2.4 Quelques extensions CPU
2.2.5 Mémoire sous GNU/Linux
2.2.5.1 Mémoire virtuelle
2.2.5.2 Processus en mémoire
2.3 Le noyau
2.3.1 Le système de fichier virtuel proc
2.3.2 L'organisation des processus
2.3.2.1 Les différents états d'un processus
2.4 Définition d'un appel système
2.4.1 Interruption
2.4.1.1 Trappe ou interruption logiciel
2.4.2 Gestionnaire d'interruptions
2.4.2.1 La table des appels systèmes
2.4.2.2 L'IDT ou la Table de Descripteurs d'Interruptions
2.4.3 Mécanismes d'invocation d'un appel système
2.4.4 La glibc
3. Méthodes et outils utilisés
3.1 Méthodes d'analyse
3.1.1 Traçage de l'application
3.1.2 Débogage
3.1.3 Code source
3.2 Les outils et langages de programmation utilisés
3.2.1 strace
3.2.2 Débogueur
3.2.3 Langage Python
3.2.4 Langage Bash
3.2.5 Langage C
3.2.6 Langage Assembleur
4. Etudes pratiques
4.1 Analyse du fonctionnement d'un éditeur de texte
4.2 Analyse de fonctionnalités d'un serveur FTP
5. Mise en pratique, implémentation
5.1 Effectuer un appel système en assembleur
6. Conclusion
Objectifs et champs d'étude
Ce travail académique a pour but d'apporter une compréhension approfondie du fonctionnement des appels système dans l'environnement GNU/Linux, en articulant les aspects théoriques de l'architecture matérielle avec une approche appliquée de traçage et de débogage.
- Analyse de l'architecture matérielle (CPU, modes de privilège, mémoire) liée aux systèmes d'exploitation.
- Étude approfondie du noyau Linux, des processus et des mécanismes d'interruption.
- Exploration technique des appels système, incluant leur invocation et les structures kernel associées (IDT, sys_call_table).
- Mise en pratique au travers de l'analyse dynamique d'applications (éditeur de texte, serveur FTP) avec des outils comme strace et GDB.
- Expérimentation directe par l'implémentation d'appels système bas niveau en langage assembleur.
Auszug aus dem Buch
2.4 Définition d'un appel système
L'objectif d'un appel système peut être résumé en quelques mots : il est un canal/moyen de communication entre les programmes en espace utilisateur et le noyau. Son rôle est de fournir au programmeur des fonctionnalités spécifiques en lui épargnant la « complexité » qui est derrière. Ils sont implémentés au niveau du noyau Linux. Un appel système est un point d'entrée dans le noyau, il permet au processus de formuler une requête au noyau pour que celui-ci accomplisse cette tâche pour lui[15]. (étant donné qu'une application en ring 3 ne peut exécuter directement du code en ring 0.).
Le noyau fournit une série de services aux programmes via l'API (Application Programming Interface) des appels systèmes. Il y a environ 300 appels systèmes.
Résumé des chapitres
1. Introduction: Ce chapitre d'introduction pose le cadre du travail, justifie le choix du sujet sur les appels système sous GNU/Linux et présente la méthodologie composée d'une approche théorique suivie d'une phase pratique.
2. Notions Théorique: Cette section détaille les fondamentaux de l'écosystème GNU/Linux, l'architecture des ordinateurs (modèle de von Neumann), la gestion de la mémoire, ainsi que le fonctionnement interne du noyau et les mécanismes complexes des appels système.
3. Méthodes et outils utilisés: Ce chapitre présente les outils d'analyse et de développement sélectionnés pour l'étude, incluant strace, GDB, Python, Bash, le langage C et l'assembleur.
4. Etudes pratiques: Une mise en application concrète est réalisée ici à travers deux cas d'études : l'observation des appels système d'un éditeur de texte (nano) et l'analyse du comportement d'un serveur FTP (ProFTPD).
5. Mise en pratique, implémentation: Cette partie est consacrée à la pratique pure avec l'implémentation directe d'appels système en langage assembleur, illustrant concrètement le lien avec les registres CPU.
6. Conclusion: Le dernier chapitre synthétise les apprentissages tirés de l'étude, confirmant la complexité des mécanismes explorés et l'intérêt de la démarche expérimentale entreprise.
Mots-clés
GNU/Linux, Appels système, Noyau, Architecture ordinateur, CPU, Interruption, Trappe, strace, GDB, Debugging, Assembleur, Processus, Mémoire virtuelle, ProFTPD, Identification
Foire aux questions
Quel est le sujet principal de ce travail ?
Ce travail porte sur la compréhension et l'analyse du fonctionnement des appels système dans l'environnement GNU/Linux, abordée sous des angles à la fois théoriques et pratiques.
Quels sont les domaines techniques abordés ?
Les principaux domaines incluent l'architecture informatique, le fonctionnement du noyau Linux (interruption, gestion des processus, mémoire) et les méthodologies de traçage et de débogage logiciel.
Quel était l'objectif initial de cette recherche ?
L'objectif était de rendre le fonctionnement des appels système plus transparent afin de mieux comprendre le lien entre la couche logicielle et la couche matérielle.
Quelle approche méthodologique a été privilégiée ?
L'approche est hybride : elle combine une partie théorique (architecture, systèmes d'exploitation) et une partie pratique (utilisation d'outils comme strace et GDB, et programmation assembleur).
Que traite la partie principale (le cœur) du document ?
Le corps du travail traite des mécanismes sous-jacents aux appels système, de l'IDT et la table des appels systèmes, jusqu'aux travaux pratiques consistant à analyser des logiciels tiers ou à coder ses propres appels en assembleur.
Quels mots-clés résument le mieux ce travail ?
Les termes essentiels sont GNU/Linux, Appels système, Noyau, strace, Débogage et Assembleur.
Comment le fonctionnement d'une commande (ex. 'ls') est-il analysé dans ce document ?
L'analyse repose sur l'utilisation du logiciel de traçage 'strace' combiné à un débogueur comme GDB, permettant d'intercepter les appels système en temps réel durant l'exécution de la commande au sein d'un serveur FTP.
Quel est le rôle du langage assembleur dans cette étude ?
L'assembleur est utilisé pour illustrer, par l'implémentation directe (ex. syscall exit, write, creat), comment un programme interagit précisément avec les registres du processeur pour solliciter les services du noyau.
- Quote paper
- Tolga Topal (Author), 2013, Introduction aux appels systèmes sous GNU/Linux, Munich, GRIN Verlag, https://www.grin.com/document/1441075
